duckdb 0.8.1-dev31.0 → 0.8.1-dev341.0

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

@@ -427,6 +427,7 @@ void Prefix::Vacuum(ART &art) {
 	auto &allocator = Node::GetAllocator(art, NType::PREFIX_SEGMENT);
 	if (allocator.NeedsVacuum(data.ptr)) {
 		data.ptr.SetPtr(allocator.VacuumPointer(data.ptr));
+		data.ptr.type = (uint8_t)NType::PREFIX_SEGMENT;
 	}
 
 	auto ptr = data.ptr;
@@ -435,6 +436,7 @@ void Prefix::Vacuum(ART &art) {
 		ptr = segment.next;
 		if (ptr.IsSet() && allocator.NeedsVacuum(ptr)) {
 			segment.next.SetPtr(allocator.VacuumPointer(ptr));
+			segment.next.type = (uint8_t)NType::PREFIX_SEGMENT;
 			ptr = segment.next;
 		}
 	}

package/src/duckdb/src/execution/join_hashtable.cpp

@@ -102,9 +102,9 @@ void JoinHashTable::ApplyBitmask(Vector &hashes, const SelectionVector &sel, idx
 	UnifiedVectorFormat hdata;
 	hashes.ToUnifiedFormat(count, hdata);
 
-	auto hash_data = (hash_t *)hdata.data;
+	auto hash_data = UnifiedVectorFormat::GetData<hash_t>(hdata);
 	auto result_data = FlatVector::GetData<data_ptr_t *>(pointers);
-	auto main_ht = (data_ptr_t *)hash_map.get();
+	auto main_ht = reinterpret_cast<data_ptr_t *>(hash_map.get());
 	for (idx_t i = 0; i < count; i++) {
 		auto rindex = sel.get_index(i);
 		auto hindex = hdata.sel->get_index(rindex);
@@ -269,7 +269,7 @@ void JoinHashTable::InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_loc
 	hashes.Flatten(count);
 	D_ASSERT(hashes.GetVectorType() == VectorType::FLAT_VECTOR);
 
-	auto pointers = (atomic<data_ptr_t> *)hash_map.get();
+	auto pointers = reinterpret_cast<atomic<data_ptr_t> *>(hash_map.get());
 	auto indices = FlatVector::GetData<hash_t>(hashes);
 
 	if (parallel) {
@@ -300,7 +300,7 @@ void JoinHashTable::InitializePointerTable() {
 	D_ASSERT(hash_map.GetSize() == capacity * sizeof(data_ptr_t));
 
 	// initialize HT with all-zero entries
-	std::fill_n((data_ptr_t *)hash_map.get(), capacity, nullptr);
+	std::fill_n(reinterpret_cast<data_ptr_t *>(hash_map.get()), capacity, nullptr);
 
 	bitmask = capacity - 1;
 }

package/src/duckdb/src/execution/nested_loop_join/nested_loop_join_inner.cpp

@@ -24,8 +24,8 @@ struct InitialNestedLoopJoin {
 		left.ToUnifiedFormat(left_size, left_data);
 		right.ToUnifiedFormat(right_size, right_data);
 
-		auto ldata = (T *)left_data.data;
-		auto rdata = (T *)right_data.data;
+		auto ldata = UnifiedVectorFormat::GetData<T>(left_data);
+		auto rdata = UnifiedVectorFormat::GetData<T>(right_data);
 		idx_t result_count = 0;
 		for (; rpos < right_size; rpos++) {
 			idx_t right_position = right_data.sel->get_index(rpos);
@@ -62,8 +62,8 @@ struct RefineNestedLoopJoin {
 		// refine lvector and rvector based on matches of subsequent conditions (in case there are multiple conditions
 		// in the join)
 		D_ASSERT(current_match_count > 0);
-		auto ldata = (T *)left_data.data;
-		auto rdata = (T *)right_data.data;
+		auto ldata = UnifiedVectorFormat::GetData<T>(left_data);
+		auto rdata = UnifiedVectorFormat::GetData<T>(right_data);
 		idx_t result_count = 0;
 		for (idx_t i = 0; i < current_match_count; i++) {
 			auto lidx = lvector.get_index(i);

package/src/duckdb/src/execution/nested_loop_join/nested_loop_join_mark.cpp

@@ -10,8 +10,8 @@ static void TemplatedMarkJoin(Vector &left, Vector &right, idx_t lcount, idx_t r
 	left.ToUnifiedFormat(lcount, left_data);
 	right.ToUnifiedFormat(rcount, right_data);
 
-	auto ldata = (T *)left_data.data;
-	auto rdata = (T *)right_data.data;
+	auto ldata = UnifiedVectorFormat::GetData<T>(left_data);
+	auto rdata = UnifiedVectorFormat::GetData<T>(right_data);
 	for (idx_t i = 0; i < lcount; i++) {
 		if (found_match[i]) {
 			continue;

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

@@ -124,7 +124,7 @@ struct FindMatchingAggregate {
 		if (other.children.size() != aggr.children.size()) {
 			return false;
 		}
-		if (!Expression::Equals(aggr.filter.get(), other.filter.get())) {
+		if (!Expression::Equals(aggr.filter, other.filter)) {
 			return false;
 		}
 		for (idx_t i = 0; i < aggr.children.size(); i++) {

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

@@ -186,7 +186,7 @@ unique_ptr<GlobalSourceState> PhysicalPerfectHashAggregate::GetGlobalSourceState
 
 SourceResultType PhysicalPerfectHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk,
                                                        OperatorSourceInput &input) const {
-	auto &state = (PerfectHashAggregateState &)input.global_state;
+	auto &state = input.global_state.Cast<PerfectHashAggregateState>();
 	auto &gstate = sink_state->Cast<PerfectHashAggregateGlobalState>();
 
 	gstate.ht->Scan(state.ht_scan_position, chunk);

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

@@ -26,7 +26,7 @@ class StreamingWindowState : public OperatorState {
 public:
 	using StateBuffer = vector<data_t>;
 
-	StreamingWindowState() : initialized(false), statev(LogicalType::POINTER, (data_ptr_t)&state_ptr) {
+	StreamingWindowState() : initialized(false), statev(LogicalType::POINTER, data_ptr_cast(&state_ptr)) {
 	}
 
 	~StreamingWindowState() override {
@@ -109,7 +109,7 @@ unique_ptr<OperatorState> PhysicalStreamingWindow::GetOperatorState(ExecutionCon
 OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                     GlobalOperatorState &gstate_p, OperatorState &state_p) const {
 	auto &gstate = gstate_p.Cast<StreamingWindowGlobalState>();
-	auto &state = (StreamingWindowState &)state_p;
+	auto &state = state_p.Cast<StreamingWindowState>();
 	if (!state.initialized) {
 		state.Initialize(context.client, input, select_list);
 	}

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

@@ -55,7 +55,7 @@ struct AggregateState {
 			if (!destructors[i]) {
 				continue;
 			}
-			Vector state_vector(Value::POINTER((uintptr_t)aggregates[i].get()));
+			Vector state_vector(Value::POINTER(CastPointerToValue(aggregates[i].get())));
 			state_vector.SetVectorType(VectorType::FLAT_VECTOR);
 
 			AggregateInputData aggr_input_data(bind_data[i], Allocator::DefaultAllocator());
@@ -332,8 +332,8 @@ void PhysicalUngroupedAggregate::Combine(ExecutionContext &context, GlobalSinkSt
 			continue;
 		}
 
-		Vector source_state(Value::POINTER((uintptr_t)source.state.aggregates[aggr_idx].get()));
-		Vector dest_state(Value::POINTER((uintptr_t)gstate.state.aggregates[aggr_idx].get()));
+		Vector source_state(Value::POINTER(CastPointerToValue(source.state.aggregates[aggr_idx].get())));
+		Vector dest_state(Value::POINTER(CastPointerToValue(gstate.state.aggregates[aggr_idx].get())));
 
 		AggregateInputData aggr_input_data(aggregate.bind_info.get(), Allocator::DefaultAllocator());
 		aggregate.function.combine(source_state, dest_state, aggr_input_data, 1);
@@ -565,7 +565,7 @@ SourceResultType PhysicalUngroupedAggregate::GetData(ExecutionContext &context,
 	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
 		auto &aggregate = aggregates[aggr_idx]->Cast<BoundAggregateExpression>();
 
-		Vector state_vector(Value::POINTER((uintptr_t)gstate.state.aggregates[aggr_idx].get()));
+		Vector state_vector(Value::POINTER(CastPointerToValue(gstate.state.aggregates[aggr_idx].get())));
 		AggregateInputData aggr_input_data(aggregate.bind_info.get(), Allocator::DefaultAllocator());
 		aggregate.function.finalize(state_vector, aggr_input_data, chunk.data[aggr_idx], 1, 0);
 	}

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

@@ -1,7 +1,9 @@
 #include "duckdb/execution/operator/aggregate/physical_window.hpp"
 
+#include "duckdb/common/operator/add.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/operator/subtract.hpp"
 #include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/radix_partitioning.hpp"
 #include "duckdb/common/row_operations/row_operations.hpp"
@@ -224,12 +226,14 @@ struct WindowInputColumn {
 	}
 
 	void Append(DataChunk &input_chunk) {
-		if (input_expr.expr && (!input_expr.scalar || !count)) {
-			input_expr.Execute(input_chunk);
-			auto &source = input_expr.chunk.data[0];
-			const auto source_count = input_expr.chunk.size();
+		if (input_expr.expr) {
+			const auto source_count = input_chunk.size();
 			D_ASSERT(count + source_count <= capacity);
-			VectorOperations::Copy(source, *target, source_count, 0, count);
+			if (!input_expr.scalar || !count) {
+				input_expr.Execute(input_chunk);
+				auto &source = input_expr.chunk.data[0];
+				VectorOperations::Copy(source, *target, source_count, 0, count);
+			}
 			count += source_count;
 		}
 	}
@@ -527,11 +531,17 @@ void WindowBoundariesState::Update(const idx_t row_idx, WindowInputColumn &range
 		bounds.window_start = bounds.peer_start;
 		break;
 	case WindowBoundary::EXPR_PRECEDING_ROWS: {
-		bounds.window_start = (int64_t)row_idx - boundary_start.GetCell<int64_t>(expr_idx);
+		if (!TrySubtractOperator::Operation(int64_t(row_idx), boundary_start.GetCell<int64_t>(expr_idx),
+		                                    bounds.window_start)) {
+			throw OutOfRangeException("Overflow computing ROWS PRECEDING start");
+		}
 		break;
 	}
 	case WindowBoundary::EXPR_FOLLOWING_ROWS: {
-		bounds.window_start = row_idx + boundary_start.GetCell<int64_t>(expr_idx);
+		if (!TryAddOperator::Operation(int64_t(row_idx), boundary_start.GetCell<int64_t>(expr_idx),
+		                               bounds.window_start)) {
+			throw OutOfRangeException("Overflow computing ROWS FOLLOWING start");
+		}
 		break;
 	}
 	case WindowBoundary::EXPR_PRECEDING_RANGE: {
@@ -567,10 +577,16 @@ void WindowBoundariesState::Update(const idx_t row_idx, WindowInputColumn &range
 		bounds.window_end = bounds.partition_end;
 		break;
 	case WindowBoundary::EXPR_PRECEDING_ROWS:
-		bounds.window_end = (int64_t)row_idx - boundary_end.GetCell<int64_t>(expr_idx) + 1;
+		if (!TrySubtractOperator::Operation(int64_t(row_idx + 1), boundary_end.GetCell<int64_t>(expr_idx),
+		                                    bounds.window_end)) {
+			throw OutOfRangeException("Overflow computing ROWS PRECEDING end");
+		}
 		break;
 	case WindowBoundary::EXPR_FOLLOWING_ROWS:
-		bounds.window_end = row_idx + boundary_end.GetCell<int64_t>(expr_idx) + 1;
+		if (!TryAddOperator::Operation(int64_t(row_idx + 1), boundary_end.GetCell<int64_t>(expr_idx),
+		                               bounds.window_end)) {
+			throw OutOfRangeException("Overflow computing ROWS FOLLOWING end");
+		}
 		break;
 	case WindowBoundary::EXPR_PRECEDING_RANGE: {
 		if (boundary_end.CellIsNull(expr_idx)) {
@@ -1254,6 +1270,7 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 		// Overwrite the collections with the sorted data
 		hash_group = std::move(gsink.hash_groups[hash_bin]);
 		hash_group->ComputeMasks(partition_mask, order_mask);
+		external = hash_group->global_sort->external;
 		MaterializeSortedData();
 	} else {
 		return;

package/src/duckdb/src/execution/operator/filter/physical_filter.cpp

@@ -41,7 +41,7 @@ unique_ptr<OperatorState> PhysicalFilter::GetOperatorState(ExecutionContext &con
 
 OperatorResultType PhysicalFilter::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                    GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (FilterState &)state_p;
+	auto &state = state_p.Cast<FilterState>();
 	idx_t result_count = state.executor.SelectExpression(input, state.sel);
 	if (result_count == input.size()) {
 		// nothing was filtered: skip adding any selection vectors

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

@@ -20,10 +20,14 @@ void PhysicalReset::ResetExtensionVariable(ExecutionContext &context, DBConfig &
 }
 
 SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
+	auto &config = DBConfig::GetConfig(context.client);
+	if (config.options.lock_configuration) {
+		throw InvalidInputException("Cannot reset configuration option \"%s\" - the configuration has been locked",
+		                            name);
+	}
 	auto option = DBConfig::GetOptionByName(name);
 	if (!option) {
 		// check if this is an extra extension variable
-		auto &config = DBConfig::GetConfig(context.client);
 		auto entry = config.extension_parameters.find(name);
 		if (entry == config.extension_parameters.end()) {
 			throw Catalog::UnrecognizedConfigurationError(context.client, name);
@@ -49,7 +53,6 @@ SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &ch
 			throw CatalogException("option \"%s\" cannot be reset globally", name);
 		}
 		auto &db = DatabaseInstance::GetDatabase(context.client);
-		auto &config = DBConfig::GetConfig(context.client);
 		config.ResetOption(&db, *option);
 		break;
 	}

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

@@ -23,10 +23,14 @@ void PhysicalSet::SetExtensionVariable(ClientContext &context, ExtensionOption &
 }
 
 SourceResultType PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
+	auto &config = DBConfig::GetConfig(context.client);
+	if (config.options.lock_configuration) {
+		throw InvalidInputException("Cannot change configuration option \"%s\" - the configuration has been locked",
+		                            name);
+	}
 	auto option = DBConfig::GetOptionByName(name);
 	if (!option) {
 		// check if this is an extra extension variable
-		auto &config = DBConfig::GetConfig(context.client);
 		auto entry = config.extension_parameters.find(name);
 		if (entry == config.extension_parameters.end()) {
 			throw Catalog::UnrecognizedConfigurationError(context.client, name);

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

@@ -63,7 +63,7 @@ void OuterJoinMarker::ConstructLeftJoinResult(DataChunk &left, DataChunk &result
 }
 
 idx_t OuterJoinMarker::MaxThreads() const {
-	return count / (STANDARD_VECTOR_SIZE * 10);
+	return count / (STANDARD_VECTOR_SIZE * 10ULL);
 }
 
 void OuterJoinMarker::InitializeScan(ColumnDataCollection &data, OuterJoinGlobalScanState &gstate) {

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

@@ -168,7 +168,7 @@ unique_ptr<OperatorState> PerfectHashJoinExecutor::GetOperatorState(ExecutionCon
 
 OperatorResultType PerfectHashJoinExecutor::ProbePerfectHashTable(ExecutionContext &context, DataChunk &input,
                                                                   DataChunk &result, OperatorState &state_p) {
-	auto &state = (PerfectHashJoinState &)state_p;
+	auto &state = state_p.Cast<PerfectHashJoinState>();
 	// keeps track of how many probe keys have a match
 	idx_t probe_sel_count = 0;
 

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

@@ -305,7 +305,7 @@ void AsOfLocalState::ResolveJoinKeys(DataChunk &input) {
 
 	DataChunk payload_chunk;
 	payload_chunk.InitializeEmpty({LogicalType::UINTEGER});
-	FlatVector::SetData(payload_chunk.data[0], (data_ptr_t)lhs_sel.data());
+	FlatVector::SetData(payload_chunk.data[0], data_ptr_cast(lhs_sel.data()));
 	payload_chunk.SetCardinality(lhs_valid);
 	local_sort.SinkChunk(lhs_keys, payload_chunk);
 
@@ -338,7 +338,7 @@ void AsOfLocalState::ResolveJoin(DataChunk &input, bool *found_match, std::pair<
 	// But they may be constant, so unify.
 	UnifiedVectorFormat bin_unified;
 	bin_vector.ToUnifiedFormat(lhs_valid, bin_unified);
-	const auto bins = (hash_t *)bin_unified.data;
+	const auto bins = UnifiedVectorFormat::GetData<hash_t>(bin_unified);
 
 	hash_t prev_bin = global_partition.bin_groups.size();
 	optional_ptr<PartitionGlobalHashGroup> hash_group;

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

@@ -111,7 +111,7 @@ OperatorResultType PhysicalBlockwiseNLJoin::ExecuteInternal(ExecutionContext &co
                                                             DataChunk &chunk, GlobalOperatorState &gstate_p,
                                                             OperatorState &state_p) const {
 	D_ASSERT(input.size() > 0);
-	auto &state = (BlockwiseNLJoinState &)state_p;
+	auto &state = state_p.Cast<BlockwiseNLJoinState>();
 	auto &gstate = sink_state->Cast<BlockwiseNLJoinGlobalState>();
 
 	if (gstate.right_chunks.Count() == 0) {
@@ -244,7 +244,7 @@ unique_ptr<GlobalSourceState> PhysicalBlockwiseNLJoin::GetGlobalSourceState(Clie
 
 unique_ptr<LocalSourceState> PhysicalBlockwiseNLJoin::GetLocalSourceState(ExecutionContext &context,
                                                                           GlobalSourceState &gstate) const {
-	return make_uniq<BlockwiseNLJoinLocalScanState>(*this, (BlockwiseNLJoinGlobalScanState &)gstate);
+	return make_uniq<BlockwiseNLJoinLocalScanState>(*this, gstate.Cast<BlockwiseNLJoinGlobalScanState>());
 }
 
 SourceResultType PhysicalBlockwiseNLJoin::GetData(ExecutionContext &context, DataChunk &chunk,
@@ -252,8 +252,8 @@ SourceResultType PhysicalBlockwiseNLJoin::GetData(ExecutionContext &context, Dat
 	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 = sink_state->Cast<BlockwiseNLJoinGlobalState>();
-	auto &gstate = (BlockwiseNLJoinGlobalScanState &)input.global_state;
-	auto &lstate = (BlockwiseNLJoinLocalScanState &)input.local_state;
+	auto &gstate = input.global_state.Cast<BlockwiseNLJoinGlobalScanState>();
+	auto &lstate = input.local_state.Cast<BlockwiseNLJoinLocalScanState>();
 
 	// if the LHS is exhausted in a FULL/RIGHT OUTER JOIN, we scan chunks we still need to output
 	sink.right_outer.Scan(gstate.scan_state, lstate.scan_state, chunk);

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

@@ -67,7 +67,7 @@ PhysicalIndexJoin::PhysicalIndexJoin(LogicalOperator &op, unique_ptr<PhysicalOpe
       left_projection_map(left_projection_map_p), right_projection_map(std::move(right_projection_map_p)),
       index(index_p), conditions(std::move(cond)), join_type(join_type), lhs_first(lhs_first) {
 	D_ASSERT(right->type == PhysicalOperatorType::TABLE_SCAN);
-	auto &tbl_scan = (PhysicalTableScan &)*right;
+	auto &tbl_scan = right->Cast<PhysicalTableScan>();
 	column_ids = std::move(column_ids_p);
 	children.push_back(std::move(left));
 	children.push_back(std::move(right));
@@ -109,7 +109,7 @@ 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 &phy_tbl_scan = children[1]->Cast<PhysicalTableScan>();
 	auto &bind_tbl = phy_tbl_scan.bind_data->Cast<TableScanBindData>();
 	auto &transaction = DuckTransaction::Get(context.client, bind_tbl.table.catalog);
 	auto &state = state_p.Cast<IndexJoinOperatorState>();
@@ -139,7 +139,7 @@ void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, Data
 		}
 		state.rhs_chunk.Reset();
 		state.fetch_state = make_uniq<ColumnFetchState>();
-		Vector row_ids(LogicalType::ROW_TYPE, (data_ptr_t)&fetch_rows[0]);
+		Vector row_ids(LogicalType::ROW_TYPE, data_ptr_cast(&fetch_rows[0]));
 		tbl.Fetch(transaction, state.rhs_chunk, fetch_ids, row_ids, output_sel_idx, *state.fetch_state);
 	}
 

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

@@ -443,7 +443,7 @@ unique_ptr<GlobalSourceState> PhysicalNestedLoopJoin::GetGlobalSourceState(Clien
 
 unique_ptr<LocalSourceState> PhysicalNestedLoopJoin::GetLocalSourceState(ExecutionContext &context,
                                                                          GlobalSourceState &gstate) const {
-	return make_uniq<NestedLoopJoinLocalScanState>(*this, (NestedLoopJoinGlobalScanState &)gstate);
+	return make_uniq<NestedLoopJoinLocalScanState>(*this, gstate.Cast<NestedLoopJoinGlobalScanState>());
 }
 
 SourceResultType PhysicalNestedLoopJoin::GetData(ExecutionContext &context, DataChunk &chunk,
@@ -451,8 +451,8 @@ SourceResultType PhysicalNestedLoopJoin::GetData(ExecutionContext &context, Data
 	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 = sink_state->Cast<NestedLoopJoinGlobalState>();
-	auto &gstate = (NestedLoopJoinGlobalScanState &)input.global_state;
-	auto &lstate = (NestedLoopJoinLocalScanState &)input.local_state;
+	auto &gstate = input.global_state.Cast<NestedLoopJoinGlobalScanState>();
+	auto &lstate = input.local_state.Cast<NestedLoopJoinLocalScanState>();
 
 	// if the LHS is exhausted in a FULL/RIGHT OUTER JOIN, we scan chunks we still need to output
 	sink.right_outer.Scan(gstate.scan_state, lstate.scan_state, chunk);

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

@@ -385,7 +385,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 &state = state_p.Cast<PiecewiseMergeJoinState>();
 	auto &gstate = sink_state->Cast<MergeJoinGlobalState>();
 
 	state.ResolveJoinKeys(input);
@@ -507,7 +507,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 &state = state_p.Cast<PiecewiseMergeJoinState>();
 	auto &gstate = sink_state->Cast<MergeJoinGlobalState>();
 	auto &rsorted = *gstate.table->global_sort_state.sorted_blocks[0];
 	const auto left_cols = input.ColumnCount();
@@ -682,7 +682,7 @@ SourceResultType PhysicalPiecewiseMergeJoin::GetData(ExecutionContext &context,
 	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 = sink_state->Cast<MergeJoinGlobalState>();
-	auto &state = (PiecewiseJoinScanState &)input.global_state;
+	auto &state = input.global_state.Cast<PiecewiseJoinScanState>();
 
 	lock_guard<mutex> l(state.lock);
 	if (!state.scanner) {

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

@@ -276,7 +276,7 @@ void TopNHeap::Finalize() {
 }
 
 void TopNHeap::Reduce() {
-	idx_t min_sort_threshold = MaxValue<idx_t>(STANDARD_VECTOR_SIZE * 5, 2 * (limit + offset));
+	idx_t min_sort_threshold = MaxValue<idx_t>(STANDARD_VECTOR_SIZE * 5ULL, 2ULL * (limit + offset));
 	if (sort_state.count < min_sort_threshold) {
 		// only reduce when we pass two times the limit + offset, or 5 vectors (whichever comes first)
 		return;

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

@@ -186,8 +186,8 @@ static string TrimWhitespace(const string &col_name) {
 
 static string NormalizeColumnName(const string &col_name) {
 	// normalize UTF8 characters to NFKD
-	auto nfkd = utf8proc_NFKD((const utf8proc_uint8_t *)col_name.c_str(), col_name.size());
-	const string col_name_nfkd = string((const char *)nfkd, strlen((const char *)nfkd));
+	auto nfkd = utf8proc_NFKD(reinterpret_cast<const utf8proc_uint8_t *>(col_name.c_str()), col_name.size());
+	const string col_name_nfkd = string(const_char_ptr_cast(nfkd), strlen(const_char_ptr_cast(nfkd)));
 	free(nfkd);
 
 	// only keep ASCII characters 0-9 a-z A-Z and replace spaces with regular whitespace

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

@@ -99,7 +99,7 @@ idx_t CSVFileHandle::Read(void *buffer, idx_t nr_bytes) {
 	}
 	// we have data left to read from the file
 	// read directly into the buffer
-	auto bytes_read = file_handle->Read((char *)buffer + result_offset, nr_bytes - result_offset);
+	auto bytes_read = file_handle->Read(char_ptr_cast(buffer) + result_offset, nr_bytes - result_offset);
 	file_size = file_handle->GetFileSize();
 	read_position += bytes_read;
 	if (reset_enabled) {
@@ -114,7 +114,7 @@ idx_t CSVFileHandle::Read(void *buffer, idx_t nr_bytes) {
 			}
 			cached_buffer = std::move(new_buffer);
 		}
-		memcpy(cached_buffer.get() + buffer_size, (char *)buffer + result_offset, bytes_read);
+		memcpy(cached_buffer.get() + buffer_size, char_ptr_cast(buffer) + result_offset, bytes_read);
 		buffer_size += bytes_read;
 	}
 

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

@@ -279,9 +279,8 @@ unique_ptr<GlobalSinkState> PhysicalBatchInsert::GetGlobalSinkState(ClientContex
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
 		auto &catalog = schema->catalog;
-		table = (TableCatalogEntry *)catalog
-		            .CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(), *info)
-		            .get();
+		auto created_table = catalog.CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(), *info);
+		table = &created_table->Cast<TableCatalogEntry>();
 	} else {
 		D_ASSERT(insert_table);
 		D_ASSERT(insert_table->IsDuckTable());

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

@@ -63,7 +63,7 @@ PhysicalInsert::PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry &schema,
 
 void PhysicalInsert::GetInsertInfo(const BoundCreateTableInfo &info, vector<LogicalType> &insert_types,
                                    vector<unique_ptr<Expression>> &bound_defaults) {
-	auto &create_info = (CreateTableInfo &)*info.base;
+	auto &create_info = info.base->Cast<CreateTableInfo>();
 	for (auto &col : create_info.columns.Physical()) {
 		insert_types.push_back(col.GetType());
 		bound_defaults.push_back(make_uniq<BoundConstantExpression>(Value(col.GetType())));

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

@@ -17,11 +17,11 @@ PhysicalPivot::PhysicalPivot(vector<LogicalType> types_p, unique_ptr<PhysicalOpe
 	}
 	// extract the empty aggregate expressions
 	for (auto &aggr_expr : bound_pivot.aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggr_expr;
+		auto &aggr = aggr_expr->Cast<BoundAggregateExpression>();
 		// for each aggregate, initialize an empty aggregate state and finalize it immediately
 		auto state = make_unsafe_uniq_array<data_t>(aggr.function.state_size());
 		aggr.function.initialize(state.get());
-		Vector state_vector(Value::POINTER((uintptr_t)state.get()));
+		Vector state_vector(Value::POINTER(CastPointerToValue(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);

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

@@ -27,7 +27,7 @@ PhysicalProjection::PhysicalProjection(vector<LogicalType> types, vector<unique_
 
 OperatorResultType PhysicalProjection::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (ProjectionState &)state_p;
+	auto &state = state_p.Cast<ProjectionState>();
 	state.executor.Execute(input, chunk);
 	return OperatorResultType::NEED_MORE_INPUT;
 }

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

@@ -65,7 +65,7 @@ void UnnestOperatorState::SetLongestListLength() {
 		if (vector_data.validity.RowIsValid(current_idx)) {
 
 			// check if this list is longer
-			auto list_data = (list_entry_t *)vector_data.data;
+			auto list_data = UnifiedVectorFormat::GetData<list_entry_t>(vector_data);
 			auto list_entry = list_data[current_idx];
 			if (list_entry.length > longest_list_length) {
 				longest_list_length = list_entry.length;
@@ -98,7 +98,7 @@ static void UnnestNull(idx_t start, idx_t end, Vector &result) {
 template <class T>
 static void TemplatedUnnest(UnifiedVectorFormat &vector_data, idx_t start, idx_t end, Vector &result) {
 
-	auto source_data = (T *)vector_data.data;
+	auto source_data = UnifiedVectorFormat::GetData<T>(vector_data);
 	auto &source_mask = vector_data.validity;
 
 	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
@@ -314,7 +314,7 @@ OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, Da
 
 				} else {
 
-					auto list_data = (list_entry_t *)vector_data.data;
+					auto list_data = UnifiedVectorFormat::GetData<list_entry_t>(vector_data);
 					auto list_entry = list_data[current_idx];
 
 					idx_t list_count = 0;

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

@@ -1,6 +1,7 @@
 #include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
 
 #include "duckdb/execution/operator/join/physical_delim_join.hpp"
+#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
 #include "duckdb/parallel/meta_pipeline.hpp"
 #include "duckdb/parallel/pipeline.hpp"
 
@@ -60,7 +61,7 @@ void PhysicalColumnDataScan::BuildPipelines(Pipeline &current, MetaPipeline &met
 		D_ASSERT(delim_sink->type == PhysicalOperatorType::DELIM_JOIN);
 		auto &delim_join = delim_sink->Cast<PhysicalDelimJoin>();
 		current.AddDependency(delim_dependency);
-		state.SetPipelineSource(current, (PhysicalOperator &)*delim_join.distinct);
+		state.SetPipelineSource(current, delim_join.distinct->Cast<PhysicalOperator>());
 		return;
 	}
 	case PhysicalOperatorType::RECURSIVE_CTE_SCAN:

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

@@ -22,7 +22,7 @@ unique_ptr<OperatorState> PhysicalExpressionScan::GetOperatorState(ExecutionCont
 
 OperatorResultType PhysicalExpressionScan::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                    GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (ExpressionScanState &)state_p;
+	auto &state = state_p.Cast<ExpressionScanState>();
 
 	for (; chunk.size() + input.size() <= STANDARD_VECTOR_SIZE && state.expression_index < expressions.size();
 	     state.expression_index++) {

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

@@ -19,7 +19,7 @@ PhysicalPositionalScan::PhysicalPositionalScan(vector<LogicalType> types, unique
 	if (left->type == PhysicalOperatorType::TABLE_SCAN) {
 		child_tables.emplace_back(std::move(left));
 	} else if (left->type == PhysicalOperatorType::POSITIONAL_SCAN) {
-		auto &left_scan = (PhysicalPositionalScan &)*left;
+		auto &left_scan = left->Cast<PhysicalPositionalScan>();
 		child_tables = std::move(left_scan.child_tables);
 	} else {
 		throw InternalException("Invalid left input for PhysicalPositionalScan");
@@ -28,7 +28,7 @@ PhysicalPositionalScan::PhysicalPositionalScan(vector<LogicalType> types, unique
 	if (right->type == PhysicalOperatorType::TABLE_SCAN) {
 		child_tables.emplace_back(std::move(right));
 	} else if (right->type == PhysicalOperatorType::POSITIONAL_SCAN) {
-		auto &right_scan = (PhysicalPositionalScan &)*right;
+		auto &right_scan = right->Cast<PhysicalPositionalScan>();
 		auto &right_tables = right_scan.child_tables;
 		child_tables.reserve(child_tables.size() + right_tables.size());
 		std::move(right_tables.begin(), right_tables.end(), std::back_inserter(child_tables));