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

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

@@ -354,8 +354,8 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionConte
 
 SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p,
                                     DataChunk &chunk) const {
-	auto &gstate = (InsertGlobalState &)state;
-	auto &lstate = (InsertLocalState &)lstate_p;
+	auto &gstate = state.Cast<InsertGlobalState>();
+	auto &lstate = lstate_p.Cast<InsertLocalState>();
 
 	auto table = gstate.table;
 	auto &storage = table->GetStorage();
@@ -398,8 +398,8 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 }
 
 void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (InsertGlobalState &)gstate_p;
-	auto &lstate = (InsertLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<InsertGlobalState>();
+	auto &lstate = lstate_p.Cast<InsertLocalState>();
 	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(this, &lstate.default_executor, "default_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
@@ -443,7 +443,7 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 
 SinkFinalizeType PhysicalInsert::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                           GlobalSinkState &state) const {
-	auto &gstate = (InsertGlobalState &)state;
+	auto &gstate = state.Cast<InsertGlobalState>();
 	if (!parallel && gstate.initialized) {
 		auto table = gstate.table;
 		auto &storage = table->GetStorage();
@@ -460,7 +460,7 @@ public:
 	explicit InsertSourceState(const PhysicalInsert &op) : finished(false) {
 		if (op.return_chunk) {
 			D_ASSERT(op.sink_state);
-			auto &g = (InsertGlobalState &)*op.sink_state;
+			auto &g = op.sink_state->Cast<InsertGlobalState>();
 			g.return_collection.InitializeScan(scan_state);
 		}
 	}
@@ -475,8 +475,8 @@ unique_ptr<GlobalSourceState> PhysicalInsert::GetGlobalSourceState(ClientContext
 
 void PhysicalInsert::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                              LocalSourceState &lstate) const {
-	auto &state = (InsertSourceState &)gstate;
-	auto &insert_gstate = (InsertGlobalState &)*sink_state;
+	auto &state = gstate.Cast<InsertSourceState>();
+	auto &insert_gstate = sink_state->Cast<InsertGlobalState>();
 	if (state.finished) {
 		return;
 	}

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

@@ -58,8 +58,8 @@ public:
 
 SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                     DataChunk &chunk) const {
-	auto &gstate = (UpdateGlobalState &)state;
-	auto &ustate = (UpdateLocalState &)lstate;
+	auto &gstate = state.Cast<UpdateGlobalState>();
+	auto &ustate = lstate.Cast<UpdateLocalState>();
 
 	DataChunk &update_chunk = ustate.update_chunk;
 	DataChunk &mock_chunk = ustate.mock_chunk;
@@ -80,7 +80,7 @@ SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, GlobalSinkState &
 		} else {
 			D_ASSERT(expressions[i]->type == ExpressionType::BOUND_REF);
 			// index into child chunk
-			auto &binding = (BoundReferenceExpression &)*expressions[i];
+			auto &binding = expressions[i]->Cast<BoundReferenceExpression>();
 			update_chunk.data[i].Reference(chunk.data[binding.index]);
 		}
 	}
@@ -141,7 +141,7 @@ unique_ptr<LocalSinkState> PhysicalUpdate::GetLocalSinkState(ExecutionContext &c
 }
 
 void PhysicalUpdate::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
-	auto &state = (UpdateLocalState &)lstate;
+	auto &state = lstate.Cast<UpdateLocalState>();
 	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(this, &state.default_executor, "default_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
@@ -155,7 +155,7 @@ public:
 	explicit UpdateSourceState(const PhysicalUpdate &op) : finished(false) {
 		if (op.return_chunk) {
 			D_ASSERT(op.sink_state);
-			auto &g = (UpdateGlobalState &)*op.sink_state;
+			auto &g = op.sink_state->Cast<UpdateGlobalState>();
 			g.return_collection.InitializeScan(scan_state);
 		}
 	}
@@ -170,8 +170,8 @@ unique_ptr<GlobalSourceState> PhysicalUpdate::GetGlobalSourceState(ClientContext
 
 void PhysicalUpdate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                              LocalSourceState &lstate) const {
-	auto &state = (UpdateSourceState &)gstate;
-	auto &g = (UpdateGlobalState &)*sink_state;
+	auto &state = gstate.Cast<UpdateSourceState>();
+	auto &g = sink_state->Cast<UpdateGlobalState>();
 	if (state.finished) {
 		return;
 	}

package/src/duckdb/src/execution/operator/projection/physical_pivot.cpp

@@ -0,0 +1,81 @@
+#include "duckdb/execution/operator/projection/physical_pivot.hpp"
+#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+
+namespace duckdb {
+
+PhysicalPivot::PhysicalPivot(vector<LogicalType> types_p, unique_ptr<PhysicalOperator> child,
+                             BoundPivotInfo bound_pivot_p)
+    : PhysicalOperator(PhysicalOperatorType::PIVOT, std::move(types_p), child->estimated_cardinality),
+      bound_pivot(std::move(bound_pivot_p)) {
+	children.push_back(std::move(child));
+	for (idx_t p = 0; p < bound_pivot.pivot_values.size(); p++) {
+		auto entry = pivot_map.find(bound_pivot.pivot_values[p]);
+		if (entry != pivot_map.end()) {
+			continue;
+		}
+		pivot_map[bound_pivot.pivot_values[p]] = bound_pivot.group_count + p;
+	}
+	// extract the empty aggregate expressions
+	for (auto &aggr_expr : bound_pivot.aggregates) {
+		auto &aggr = (BoundAggregateExpression &)*aggr_expr;
+		// for each aggregate, initialize an empty aggregate state and finalize it immediately
+		auto state = unique_ptr<data_t[]>(new data_t[aggr.function.state_size()]);
+		aggr.function.initialize(state.get());
+		Vector state_vector(Value::POINTER((uintptr_t)state.get()));
+		Vector result_vector(aggr_expr->return_type);
+		AggregateInputData aggr_input_data(aggr.bind_info.get(), Allocator::DefaultAllocator());
+		aggr.function.finalize(state_vector, aggr_input_data, result_vector, 1, 0);
+		empty_aggregates.push_back(result_vector.GetValue(0));
+	}
+}
+
+OperatorResultType PhysicalPivot::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+                                          GlobalOperatorState &gstate, OperatorState &state) const {
+	// copy the groups as-is
+	for (idx_t i = 0; i < bound_pivot.group_count; i++) {
+		chunk.data[i].Reference(input.data[i]);
+	}
+	auto pivot_column_lists = FlatVector::GetData<list_entry_t>(input.data.back());
+	auto &pivot_column_values = ListVector::GetEntry(input.data.back());
+	auto pivot_columns = FlatVector::GetData<string_t>(pivot_column_values);
+
+	// initialize all aggregate columns with the empty aggregate value
+	// if there are multiple aggregates the columns are in order of [AGGR1][AGGR2][AGGR1][AGGR2]
+	// so we need to alternate the empty_aggregate that we use
+	idx_t aggregate = 0;
+	for (idx_t c = bound_pivot.group_count; c < chunk.ColumnCount(); c++) {
+		chunk.data[c].Reference(empty_aggregates[aggregate]);
+		chunk.data[c].Flatten(input.size());
+		aggregate++;
+		if (aggregate >= empty_aggregates.size()) {
+			aggregate = 0;
+		}
+	}
+
+	// move the pivots to the given columns
+	for (idx_t r = 0; r < input.size(); r++) {
+		auto list = pivot_column_lists[r];
+		for (idx_t l = 0; l < list.length; l++) {
+			// figure out the column value number of this list
+			auto &column_name = pivot_columns[list.offset + l];
+			auto entry = pivot_map.find(column_name);
+			if (entry == pivot_map.end()) {
+				// column entry not found in map - that means this element is explicitly excluded from the pivot list
+				continue;
+			}
+			auto column_idx = entry->second;
+			for (idx_t aggr = 0; aggr < empty_aggregates.size(); aggr++) {
+				auto pivot_value_lists = FlatVector::GetData<list_entry_t>(input.data[bound_pivot.group_count + aggr]);
+				auto &pivot_value_child = ListVector::GetEntry(input.data[bound_pivot.group_count + aggr]);
+				if (list.offset != pivot_value_lists[r].offset || list.length != pivot_value_lists[r].length) {
+					throw InternalException("Pivot - unaligned lists between values and columns!?");
+				}
+				chunk.data[column_idx + aggr].SetValue(r, pivot_value_child.GetValue(list.offset + l));
+			}
+		}
+	}
+	chunk.SetCardinality(input.size());
+	return OperatorResultType::NEED_MORE_INPUT;
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/operator/projection/physical_tableinout_function.cpp

@@ -31,7 +31,7 @@ PhysicalTableInOutFunction::PhysicalTableInOutFunction(vector<LogicalType> types
 }
 
 unique_ptr<OperatorState> PhysicalTableInOutFunction::GetOperatorState(ExecutionContext &context) const {
-	auto &gstate = (TableInOutGlobalState &)*op_state;
+	auto &gstate = op_state->Cast<TableInOutGlobalState>();
 	auto result = make_uniq<TableInOutLocalState>();
 	if (function.init_local) {
 		TableFunctionInitInput input(bind_data.get(), column_ids, vector<idx_t>(), nullptr);
@@ -54,8 +54,8 @@ unique_ptr<GlobalOperatorState> PhysicalTableInOutFunction::GetGlobalOperatorSta
 
 OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                        GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = (TableInOutGlobalState &)gstate_p;
-	auto &state = (TableInOutLocalState &)state_p;
+	auto &gstate = gstate_p.Cast<TableInOutGlobalState>();
+	auto &state = state_p.Cast<TableInOutLocalState>();
 	TableFunctionInput data(bind_data.get(), state.local_state.get(), gstate.global_state.get());
 	if (projected_input.empty()) {
 		// straightforward case - no need to project input
@@ -102,8 +102,8 @@ OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context
 OperatorFinalizeResultType PhysicalTableInOutFunction::FinalExecute(ExecutionContext &context, DataChunk &chunk,
                                                                     GlobalOperatorState &gstate_p,
                                                                     OperatorState &state_p) const {
-	auto &gstate = (TableInOutGlobalState &)gstate_p;
-	auto &state = (TableInOutLocalState &)state_p;
+	auto &gstate = gstate_p.Cast<TableInOutGlobalState>();
+	auto &state = state_p.Cast<TableInOutLocalState>();
 	if (!projected_input.empty()) {
 		throw InternalException("FinalExecute not supported for project_input");
 	}

package/src/duckdb/src/execution/operator/projection/physical_unnest.cpp

@@ -19,9 +19,9 @@ public:
 		vector<LogicalType> list_data_types;
 		for (auto &exp : select_list) {
 			D_ASSERT(exp->type == ExpressionType::BOUND_UNNEST);
-			auto bue = (BoundUnnestExpression *)exp.get();
-			list_data_types.push_back(bue->child->return_type);
-			executor.AddExpression(*bue->child.get());
+			auto &bue = exp->Cast<BoundUnnestExpression>();
+			list_data_types.push_back(bue.child->return_type);
+			executor.AddExpression(*bue.child.get());
 		}
 
 		auto &allocator = Allocator::Get(context);
@@ -56,7 +56,6 @@ void UnnestOperatorState::Reset() {
 }
 
 void UnnestOperatorState::SetLongestListLength() {
-
 	longest_list_length = 0;
 	for (idx_t col_idx = 0; col_idx < list_data.ColumnCount(); col_idx++) {
 
@@ -257,7 +256,7 @@ OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, Da
                                                    const vector<unique_ptr<Expression>> &select_list,
                                                    bool include_input) {
 
-	auto &state = (UnnestOperatorState &)state_p;
+	auto &state = state_p.Cast<UnnestOperatorState>();
 
 	do {
 		// prepare the input data by executing any expressions and getting the

package/src/duckdb/src/execution/operator/scan/physical_column_data_scan.cpp

@@ -22,7 +22,7 @@ unique_ptr<GlobalSourceState> PhysicalColumnDataScan::GetGlobalSourceState(Clien
 
 void PhysicalColumnDataScan::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                                      LocalSourceState &lstate) const {
-	auto &state = (PhysicalColumnDataScanState &)gstate;
+	auto &state = gstate.Cast<PhysicalColumnDataScanState>();
 	D_ASSERT(collection);
 	if (collection->Count() == 0) {
 		return;

package/src/duckdb/src/execution/operator/scan/physical_positional_scan.cpp

@@ -139,7 +139,7 @@ public:
 
 unique_ptr<LocalSourceState> PhysicalPositionalScan::GetLocalSourceState(ExecutionContext &context,
                                                                          GlobalSourceState &gstate) const {
-	return make_uniq<PositionalScanLocalSourceState>(context, (PositionalScanGlobalSourceState &)gstate, *this);
+	return make_uniq<PositionalScanLocalSourceState>(context, gstate.Cast<PositionalScanGlobalSourceState>(), *this);
 }
 
 unique_ptr<GlobalSourceState> PhysicalPositionalScan::GetGlobalSourceState(ClientContext &context) const {
@@ -148,7 +148,7 @@ unique_ptr<GlobalSourceState> PhysicalPositionalScan::GetGlobalSourceState(Clien
 
 void PhysicalPositionalScan::GetData(ExecutionContext &context, DataChunk &output, GlobalSourceState &gstate_p,
                                      LocalSourceState &lstate_p) const {
-	auto &lstate = (PositionalScanLocalSourceState &)lstate_p;
+	auto &lstate = lstate_p.Cast<PositionalScanLocalSourceState>();
 
 	// Find the longest source block
 	idx_t count = 0;
@@ -171,7 +171,7 @@ void PhysicalPositionalScan::GetData(ExecutionContext &context, DataChunk &outpu
 }
 
 double PhysicalPositionalScan::GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const {
-	auto &gstate = (PositionalScanGlobalSourceState &)gstate_p;
+	auto &gstate = gstate_p.Cast<PositionalScanGlobalSourceState>();
 
 	double result = child_tables[0]->GetProgress(context, *gstate.global_states[0]);
 	for (size_t t = 1; t < child_tables.size(); ++t) {
@@ -186,7 +186,7 @@ bool PhysicalPositionalScan::Equals(const PhysicalOperator &other_p) const {
 		return false;
 	}
 
-	auto &other = (PhysicalPositionalScan &)other_p;
+	auto &other = other_p.Cast<PhysicalPositionalScan>();
 	if (child_tables.size() != other.child_tables.size()) {
 		return false;
 	}

package/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp

@@ -66,7 +66,7 @@ public:
 
 unique_ptr<LocalSourceState> PhysicalTableScan::GetLocalSourceState(ExecutionContext &context,
                                                                     GlobalSourceState &gstate) const {
-	return make_uniq<TableScanLocalSourceState>(context, (TableScanGlobalSourceState &)gstate, *this);
+	return make_uniq<TableScanLocalSourceState>(context, gstate.Cast<TableScanGlobalSourceState>(), *this);
 }
 
 unique_ptr<GlobalSourceState> PhysicalTableScan::GetGlobalSourceState(ClientContext &context) const {
@@ -76,15 +76,15 @@ unique_ptr<GlobalSourceState> PhysicalTableScan::GetGlobalSourceState(ClientCont
 void PhysicalTableScan::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                                 LocalSourceState &lstate) const {
 	D_ASSERT(!column_ids.empty());
-	auto &gstate = (TableScanGlobalSourceState &)gstate_p;
-	auto &state = (TableScanLocalSourceState &)lstate;
+	auto &gstate = gstate_p.Cast<TableScanGlobalSourceState>();
+	auto &state = lstate.Cast<TableScanLocalSourceState>();
 
 	TableFunctionInput data(bind_data.get(), state.local_state.get(), gstate.global_state.get());
 	function.function(context.client, data, chunk);
 }
 
 double PhysicalTableScan::GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const {
-	auto &gstate = (TableScanGlobalSourceState &)gstate_p;
+	auto &gstate = gstate_p.Cast<TableScanGlobalSourceState>();
 	if (function.table_scan_progress) {
 		return function.table_scan_progress(context, bind_data.get(), gstate.global_state.get());
 	}
@@ -96,8 +96,8 @@ idx_t PhysicalTableScan::GetBatchIndex(ExecutionContext &context, DataChunk &chu
                                        LocalSourceState &lstate) const {
 	D_ASSERT(SupportsBatchIndex());
 	D_ASSERT(function.get_batch_index);
-	auto &gstate = (TableScanGlobalSourceState &)gstate_p;
-	auto &state = (TableScanLocalSourceState &)lstate;
+	auto &gstate = gstate_p.Cast<TableScanGlobalSourceState>();
+	auto &state = lstate.Cast<TableScanLocalSourceState>();
 	return function.get_batch_index(context.client, bind_data.get(), state.local_state.get(),
 	                                gstate.global_state.get());
 }
@@ -156,7 +156,7 @@ bool PhysicalTableScan::Equals(const PhysicalOperator &other_p) const {
 	if (type != other_p.type) {
 		return false;
 	}
-	auto &other = (PhysicalTableScan &)other_p;
+	auto &other = other_p.Cast<PhysicalTableScan>();
 	if (function.function != other.function.function) {
 		return false;
 	}

package/src/duckdb/src/execution/operator/schema/physical_alter.cpp

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

package/src/duckdb/src/execution/operator/schema/physical_attach.cpp

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

package/src/duckdb/src/execution/operator/schema/physical_create_function.cpp

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

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -14,7 +14,8 @@ PhysicalCreateIndex::PhysicalCreateIndex(LogicalOperator &op, TableCatalogEntry
                                          vector<unique_ptr<Expression>> unbound_expressions,
                                          idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::CREATE_INDEX, op.types, estimated_cardinality),
-      table((DuckTableEntry &)table_p), info(std::move(info)), unbound_expressions(std::move(unbound_expressions)) {
+      table(table_p.Cast<DuckTableEntry>()), info(std::move(info)),
+      unbound_expressions(std::move(unbound_expressions)) {
 	D_ASSERT(table_p.IsDuckTable());
 	// convert virtual column ids to storage column ids
 	for (auto &column_id : column_ids) {
@@ -87,7 +88,7 @@ SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, GlobalSinkSt
                                          DataChunk &input) const {
 
 	D_ASSERT(input.ColumnCount() >= 2);
-	auto &lstate = (CreateIndexLocalSinkState &)lstate_p;
+	auto &lstate = lstate_p.Cast<CreateIndexLocalSinkState>();
 	auto &row_identifiers = input.data[input.ColumnCount() - 1];
 
 	// generate the keys for the given input
@@ -104,7 +105,7 @@ SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, GlobalSinkSt
 	}
 
 	// merge into the local ART
-	if (!lstate.local_index->MergeIndexes(art.get())) {
+	if (!lstate.local_index->MergeIndexes(*art)) {
 		throw ConstraintException("Data contains duplicates on indexed column(s)");
 	}
 	return SinkResultType::NEED_MORE_INPUT;
@@ -113,11 +114,11 @@ SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, GlobalSinkSt
 void PhysicalCreateIndex::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
                                   LocalSinkState &lstate_p) const {
 
-	auto &gstate = (CreateIndexGlobalSinkState &)gstate_p;
-	auto &lstate = (CreateIndexLocalSinkState &)lstate_p;
+	auto &gstate = gstate_p.Cast<CreateIndexGlobalSinkState>();
+	auto &lstate = lstate_p.Cast<CreateIndexLocalSinkState>();
 
 	// merge the local index into the global index
-	if (!gstate.global_index->MergeIndexes(lstate.local_index.get())) {
+	if (!gstate.global_index->MergeIndexes(*lstate.local_index)) {
 		throw ConstraintException("Data contains duplicates on indexed column(s)");
 	}
 }
@@ -127,7 +128,7 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 
 	// here, we just set the resulting global index as the newly created index of the table
 
-	auto &state = (CreateIndexGlobalSinkState &)gstate_p;
+	auto &state = gstate_p.Cast<CreateIndexGlobalSinkState>();
 	auto &storage = table.GetStorage();
 	if (!storage.IsRoot()) {
 		throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");

package/src/duckdb/src/execution/operator/schema/physical_create_schema.cpp

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

package/src/duckdb/src/execution/operator/schema/physical_create_sequence.cpp

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

package/src/duckdb/src/execution/operator/schema/physical_create_table.cpp

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

package/src/duckdb/src/execution/operator/schema/physical_create_type.cpp

@@ -28,7 +28,7 @@ unique_ptr<GlobalSinkState> PhysicalCreateType::GetGlobalSinkState(ClientContext
 
 SinkResultType PhysicalCreateType::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
                                         DataChunk &input) const {
-	auto &gstate = (CreateTypeGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<CreateTypeGlobalState>();
 	idx_t total_row_count = gstate.size + input.size();
 	if (total_row_count > NumericLimits<uint32_t>::Maximum()) {
 		throw InvalidInputException("Attempted to create ENUM of size %llu, which exceeds the maximum size of %llu",
@@ -74,14 +74,14 @@ unique_ptr<GlobalSourceState> PhysicalCreateType::GetGlobalSourceState(ClientCon
 
 void PhysicalCreateType::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                                  LocalSourceState &lstate) const {
-	auto &state = (CreateTypeSourceState &)gstate;
+	auto &state = gstate.Cast<CreateTypeSourceState>();
 	if (state.finished) {
 		return;
 	}
 
 	if (IsSink()) {
 		D_ASSERT(info->type == LogicalType::INVALID);
-		auto &g_sink_state = (CreateTypeGlobalState &)*sink_state;
+		auto &g_sink_state = sink_state->Cast<CreateTypeGlobalState>();
 		info->type = LogicalType::ENUM(info->name, g_sink_state.result, g_sink_state.size);
 	}
 

package/src/duckdb/src/execution/operator/schema/physical_create_view.cpp

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

package/src/duckdb/src/execution/operator/schema/physical_detach.cpp

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

package/src/duckdb/src/execution/operator/schema/physical_drop.cpp

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

package/src/duckdb/src/execution/operator/set/physical_recursive_cte.cpp

@@ -63,7 +63,7 @@ idx_t PhysicalRecursiveCTE::ProbeHT(DataChunk &chunk, RecursiveCTEState &state)
 
 SinkResultType PhysicalRecursiveCTE::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                           DataChunk &input) const {
-	auto &gstate = (RecursiveCTEState &)state;
+	auto &gstate = state.Cast<RecursiveCTEState>();
 	if (!union_all) {
 		idx_t match_count = ProbeHT(input, gstate);
 		if (match_count > 0) {
@@ -80,7 +80,7 @@ SinkResultType PhysicalRecursiveCTE::Sink(ExecutionContext &context, GlobalSinkS
 //===--------------------------------------------------------------------===//
 void PhysicalRecursiveCTE::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                                    LocalSourceState &lstate) const {
-	auto &gstate = (RecursiveCTEState &)*sink_state;
+	auto &gstate = sink_state->Cast<RecursiveCTEState>();
 	if (!gstate.initialized) {
 		gstate.intermediate_table.InitializeScan(gstate.scan_state);
 		gstate.finished_scan = false;

package/src/duckdb/src/execution/physical_operator.cpp

@@ -243,7 +243,7 @@ CachingPhysicalOperator::CachingPhysicalOperator(PhysicalOperatorType type, vect
 
 OperatorResultType CachingPhysicalOperator::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                     GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (CachingOperatorState &)state_p;
+	auto &state = state_p.Cast<CachingOperatorState>();
 
 	// Execute child operator
 	auto child_result = ExecuteInternal(context, input, chunk, gstate, state);
@@ -297,7 +297,7 @@ OperatorResultType CachingPhysicalOperator::Execute(ExecutionContext &context, D
 OperatorFinalizeResultType CachingPhysicalOperator::FinalExecute(ExecutionContext &context, DataChunk &chunk,
                                                                  GlobalOperatorState &gstate,
                                                                  OperatorState &state_p) const {
-	auto &state = (CachingOperatorState &)state_p;
+	auto &state = state_p.Cast<CachingOperatorState>();
 	if (state.cached_chunk) {
 		chunk.Move(*state.cached_chunk);
 		state.cached_chunk.reset();

package/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp

@@ -107,7 +107,7 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 		}
 	}
 	for (auto &expression : op.expressions) {
-		auto &aggregate = (BoundAggregateExpression &)*expression;
+		auto &aggregate = expression->Cast<BoundAggregateExpression>();
 		if (aggregate.IsDistinct() || !aggregate.function.combine) {
 			// distinct aggregates are not supported in perfect hash aggregates
 			return false;
@@ -129,7 +129,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAggregate
 		// special case: aggregate entire columns together
 		bool use_simple_aggregation = true;
 		for (auto &expression : op.expressions) {
-			auto &aggregate = (BoundAggregateExpression &)*expression;
+			auto &aggregate = expression->Cast<BoundAggregateExpression>();
 			if (!aggregate.function.simple_update) {
 				// unsupported aggregate for simple aggregation: use hash aggregation
 				use_simple_aggregation = false;
@@ -170,7 +170,7 @@ PhysicalPlanGenerator::ExtractAggregateExpressions(unique_ptr<PhysicalOperator>
 
 	// bind sorted aggregates
 	for (auto &aggr : aggregates) {
-		auto &bound_aggr = (BoundAggregateExpression &)*aggr;
+		auto &bound_aggr = aggr->Cast<BoundAggregateExpression>();
 		if (bound_aggr.order_bys) {
 			// sorted aggregate!
 			FunctionBinder::BindSortedAggregate(context, bound_aggr, groups);
@@ -183,7 +183,7 @@ PhysicalPlanGenerator::ExtractAggregateExpressions(unique_ptr<PhysicalOperator>
 		group = std::move(ref);
 	}
 	for (auto &aggr : aggregates) {
-		auto &bound_aggr = (BoundAggregateExpression &)*aggr;
+		auto &bound_aggr = aggr->Cast<BoundAggregateExpression>();
 		for (auto &child : bound_aggr.children) {
 			auto ref = make_uniq<BoundReferenceExpression>(child->return_type, expressions.size());
 			types.push_back(child->return_type);

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -168,7 +168,7 @@ Index *CheckIndexJoin(ClientContext &context, LogicalComparisonJoin &op, Physica
 	if (plan.type != PhysicalOperatorType::TABLE_SCAN) {
 		return nullptr;
 	}
-	auto &tbl_scan = (PhysicalTableScan &)plan;
+	auto &tbl_scan = plan.Cast<PhysicalTableScan>();
 	auto tbl = dynamic_cast<TableScanBindData *>(tbl_scan.bind_data.get());
 	Index *result = nullptr;
 	if (CanPlanIndexJoin(context, tbl, tbl_scan)) {
@@ -230,7 +230,7 @@ static bool PlanIndexJoin(ClientContext &context, LogicalComparisonJoin &op, uni
 
 static void RewriteJoinCondition(Expression &expr, idx_t offset) {
 	if (expr.type == ExpressionType::BOUND_REF) {
-		auto &ref = (BoundReferenceExpression &)expr;
+		auto &ref = expr.Cast<BoundReferenceExpression>();
 		ref.index += offset;
 	}
 	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { RewriteJoinCondition(child, offset); });

package/src/duckdb/src/execution/physical_plan/plan_create_index.cpp

@@ -36,7 +36,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	unique_ptr<TableFilterSet> table_filters;
 	op.info->column_ids.emplace_back(COLUMN_IDENTIFIER_ROW_ID);
 
-	auto &bind_data = (TableScanBindData &)*op.bind_data;
+	auto &bind_data = op.bind_data->Cast<TableScanBindData>();
 	bind_data.is_create_index = true;
 
 	auto table_scan =

package/src/duckdb/src/execution/physical_plan/plan_delete.cpp

@@ -10,7 +10,7 @@ namespace duckdb {
 unique_ptr<PhysicalOperator> DuckCatalog::PlanDelete(ClientContext &context, LogicalDelete &op,
                                                      unique_ptr<PhysicalOperator> plan) {
 	// get the index of the row_id column
-	auto &bound_ref = (BoundReferenceExpression &)*op.expressions[0];
+	auto &bound_ref = op.expressions[0]->Cast<BoundReferenceExpression>();
 
 	auto del = make_uniq<PhysicalDelete>(op.types, *op.table, op.table->GetStorage(), bound_ref.index,
 	                                     op.estimated_cardinality, op.return_chunk);

package/src/duckdb/src/execution/physical_plan/plan_delim_join.cpp

@@ -22,7 +22,7 @@ static void GatherDelimScans(PhysicalOperator *op, vector<PhysicalOperator *> &d
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelimJoin &op) {
 	// first create the underlying join
-	auto plan = CreatePlan((LogicalComparisonJoin &)op);
+	auto plan = CreatePlan(op.Cast<LogicalComparisonJoin>());
 	// this should create a join, not a cross product
 	D_ASSERT(plan && plan->type != PhysicalOperatorType::CROSS_PRODUCT);
 	// duplicate eliminated join
@@ -39,7 +39,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelimJoin
 	vector<unique_ptr<Expression>> distinct_groups, distinct_expressions;
 	for (auto &delim_expr : op.duplicate_eliminated_columns) {
 		D_ASSERT(delim_expr->type == ExpressionType::BOUND_REF);
-		auto &bound_ref = (BoundReferenceExpression &)*delim_expr;
+		auto &bound_ref = delim_expr->Cast<BoundReferenceExpression>();
 		delim_types.push_back(bound_ref.return_type);
 		distinct_groups.push_back(make_uniq<BoundReferenceExpression>(bound_ref.return_type, bound_ref.index));
 	}