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

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

@@ -25,7 +25,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDistinct &
 	for (idx_t i = 0; i < distinct_targets.size(); i++) {
 		auto &target = distinct_targets[i];
 		if (target->type == ExpressionType::BOUND_REF) {
-			auto &bound_ref = (BoundReferenceExpression &)*target;
+			auto &bound_ref = target->Cast<BoundReferenceExpression>();
 			group_by_references[bound_ref.index] = i;
 		}
 		aggregate_types.push_back(target->return_type);
@@ -49,6 +49,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDistinct &
 				requires_projection = true;
 			}
 		} else {
+			if (op.distinct_type == DistinctType::DISTINCT && op.order_by) {
+				throw InternalException("Entry that is not a group, but not a DISTINCT ON aggregate");
+			}
 			// entry is not one of the groups: need to push a FIRST aggregate
 			auto bound = make_uniq<BoundReferenceExpression>(logical_type, i);
 			vector<unique_ptr<Expression>> first_children;

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

@@ -0,0 +1,14 @@
+#include "duckdb/execution/operator/projection/physical_pivot.hpp"
+#include "duckdb/execution/physical_plan_generator.hpp"
+#include "duckdb/planner/operator/logical_pivot.hpp"
+
+namespace duckdb {
+
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalPivot &op) {
+	D_ASSERT(op.children.size() == 1);
+	auto child_plan = CreatePlan(*op.children[0]);
+	auto pivot = make_uniq<PhysicalPivot>(std::move(op.types), std::move(child_plan), std::move(op.bound_pivot));
+	return std::move(pivot);
+}
+
+} // namespace duckdb

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

@@ -22,7 +22,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalProjection
 		bool omit_projection = true;
 		for (idx_t i = 0; i < op.types.size(); i++) {
 			if (op.expressions[i]->type == ExpressionType::BOUND_REF) {
-				auto &bound_ref = (BoundReferenceExpression &)*op.expressions[i];
+				auto &bound_ref = op.expressions[i]->Cast<BoundReferenceExpression>();
 				if (bound_ref.index == i) {
 					continue;
 				}

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

@@ -11,16 +11,16 @@
 namespace duckdb {
 
 static bool IsStreamingWindow(unique_ptr<Expression> &expr) {
-	auto wexpr = reinterpret_cast<BoundWindowExpression *>(expr.get());
-	if (!wexpr->partitions.empty() || !wexpr->orders.empty() || wexpr->ignore_nulls) {
+	auto &wexpr = expr->Cast<BoundWindowExpression>();
+	if (!wexpr.partitions.empty() || !wexpr.orders.empty() || wexpr.ignore_nulls) {
 		return false;
 	}
-	switch (wexpr->type) {
+	switch (wexpr.type) {
 	// TODO: add more expression types here?
 	case ExpressionType::WINDOW_AGGREGATE:
 		// We can stream aggregates if they are "running totals" and don't use filters
-		return wexpr->start == WindowBoundary::UNBOUNDED_PRECEDING && wexpr->end == WindowBoundary::CURRENT_ROW_ROWS &&
-		       !wexpr->filter_expr;
+		return wexpr.start == WindowBoundary::UNBOUNDED_PRECEDING && wexpr.end == WindowBoundary::CURRENT_ROW_ROWS &&
+		       !wexpr.filter_expr;
 	case ExpressionType::WINDOW_FIRST_VALUE:
 	case ExpressionType::WINDOW_PERCENT_RANK:
 	case ExpressionType::WINDOW_RANK:
@@ -68,14 +68,14 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op
 
 		// Find all functions that share the partitioning of the first remaining expression
 		const auto over_idx = remaining[0];
-		auto over_expr = reinterpret_cast<BoundWindowExpression *>(op.expressions[over_idx].get());
+		auto &over_expr = op.expressions[over_idx]->Cast<BoundWindowExpression>();
 
 		vector<idx_t> matching;
 		vector<idx_t> unprocessed;
 		for (const auto &expr_idx : remaining) {
 			D_ASSERT(op.expressions[expr_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
-			auto wexpr = reinterpret_cast<BoundWindowExpression *>(op.expressions[expr_idx].get());
-			if (over_expr->KeysAreCompatible(wexpr)) {
+			auto &wexpr = op.expressions[expr_idx]->Cast<BoundWindowExpression>();
+			if (over_expr.KeysAreCompatible(wexpr)) {
 				matching.emplace_back(expr_idx);
 			} else {
 				unprocessed.emplace_back(expr_idx);

package/src/duckdb/src/execution/physical_plan_generator.cpp

@@ -8,6 +8,7 @@
 #include "duckdb/main/query_profiler.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/operator/logical_extension_operator.hpp"
+#include "duckdb/planner/operator/list.hpp"
 
 namespace duckdb {
 
@@ -68,118 +69,118 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 
 	switch (op.type) {
 	case LogicalOperatorType::LOGICAL_GET:
-		plan = CreatePlan((LogicalGet &)op);
+		plan = CreatePlan(op.Cast<LogicalGet>());
 		break;
 	case LogicalOperatorType::LOGICAL_PROJECTION:
-		plan = CreatePlan((LogicalProjection &)op);
+		plan = CreatePlan(op.Cast<LogicalProjection>());
 		break;
 	case LogicalOperatorType::LOGICAL_EMPTY_RESULT:
-		plan = CreatePlan((LogicalEmptyResult &)op);
+		plan = CreatePlan(op.Cast<LogicalEmptyResult>());
 		break;
 	case LogicalOperatorType::LOGICAL_FILTER:
-		plan = CreatePlan((LogicalFilter &)op);
+		plan = CreatePlan(op.Cast<LogicalFilter>());
 		break;
 	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		plan = CreatePlan((LogicalAggregate &)op);
+		plan = CreatePlan(op.Cast<LogicalAggregate>());
 		break;
 	case LogicalOperatorType::LOGICAL_WINDOW:
-		plan = CreatePlan((LogicalWindow &)op);
+		plan = CreatePlan(op.Cast<LogicalWindow>());
 		break;
 	case LogicalOperatorType::LOGICAL_UNNEST:
-		plan = CreatePlan((LogicalUnnest &)op);
+		plan = CreatePlan(op.Cast<LogicalUnnest>());
 		break;
 	case LogicalOperatorType::LOGICAL_LIMIT:
-		plan = CreatePlan((LogicalLimit &)op);
+		plan = CreatePlan(op.Cast<LogicalLimit>());
 		break;
 	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT:
-		plan = CreatePlan((LogicalLimitPercent &)op);
+		plan = CreatePlan(op.Cast<LogicalLimitPercent>());
 		break;
 	case LogicalOperatorType::LOGICAL_SAMPLE:
-		plan = CreatePlan((LogicalSample &)op);
+		plan = CreatePlan(op.Cast<LogicalSample>());
 		break;
 	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		plan = CreatePlan((LogicalOrder &)op);
+		plan = CreatePlan(op.Cast<LogicalOrder>());
 		break;
 	case LogicalOperatorType::LOGICAL_TOP_N:
-		plan = CreatePlan((LogicalTopN &)op);
+		plan = CreatePlan(op.Cast<LogicalTopN>());
 		break;
 	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-		plan = CreatePlan((LogicalCopyToFile &)op);
+		plan = CreatePlan(op.Cast<LogicalCopyToFile>());
 		break;
 	case LogicalOperatorType::LOGICAL_DUMMY_SCAN:
-		plan = CreatePlan((LogicalDummyScan &)op);
+		plan = CreatePlan(op.Cast<LogicalDummyScan>());
 		break;
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		plan = CreatePlan((LogicalAnyJoin &)op);
+		plan = CreatePlan(op.Cast<LogicalAnyJoin>());
 		break;
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		plan = CreatePlan((LogicalDelimJoin &)op);
+		plan = CreatePlan(op.Cast<LogicalDelimJoin>());
 		break;
 	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		plan = CreatePlan((LogicalAsOfJoin &)op);
+		plan = CreatePlan(op.Cast<LogicalAsOfJoin>());
 		break;
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		plan = CreatePlan((LogicalComparisonJoin &)op);
+		plan = CreatePlan(op.Cast<LogicalComparisonJoin>());
 		break;
 	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		plan = CreatePlan((LogicalCrossProduct &)op);
+		plan = CreatePlan(op.Cast<LogicalCrossProduct>());
 		break;
 	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
-		plan = CreatePlan((LogicalPositionalJoin &)op);
+		plan = CreatePlan(op.Cast<LogicalPositionalJoin>());
 		break;
 	case LogicalOperatorType::LOGICAL_UNION:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
 	case LogicalOperatorType::LOGICAL_INTERSECT:
-		plan = CreatePlan((LogicalSetOperation &)op);
+		plan = CreatePlan(op.Cast<LogicalSetOperation>());
 		break;
 	case LogicalOperatorType::LOGICAL_INSERT:
-		plan = CreatePlan((LogicalInsert &)op);
+		plan = CreatePlan(op.Cast<LogicalInsert>());
 		break;
 	case LogicalOperatorType::LOGICAL_DELETE:
-		plan = CreatePlan((LogicalDelete &)op);
+		plan = CreatePlan(op.Cast<LogicalDelete>());
 		break;
 	case LogicalOperatorType::LOGICAL_CHUNK_GET:
-		plan = CreatePlan((LogicalColumnDataGet &)op);
+		plan = CreatePlan(op.Cast<LogicalColumnDataGet>());
 		break;
 	case LogicalOperatorType::LOGICAL_DELIM_GET:
-		plan = CreatePlan((LogicalDelimGet &)op);
+		plan = CreatePlan(op.Cast<LogicalDelimGet>());
 		break;
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
-		plan = CreatePlan((LogicalExpressionGet &)op);
+		plan = CreatePlan(op.Cast<LogicalExpressionGet>());
 		break;
 	case LogicalOperatorType::LOGICAL_UPDATE:
-		plan = CreatePlan((LogicalUpdate &)op);
+		plan = CreatePlan(op.Cast<LogicalUpdate>());
 		break;
 	case LogicalOperatorType::LOGICAL_CREATE_TABLE:
-		plan = CreatePlan((LogicalCreateTable &)op);
+		plan = CreatePlan(op.Cast<LogicalCreateTable>());
 		break;
 	case LogicalOperatorType::LOGICAL_CREATE_INDEX:
-		plan = CreatePlan((LogicalCreateIndex &)op);
+		plan = CreatePlan(op.Cast<LogicalCreateIndex>());
 		break;
 	case LogicalOperatorType::LOGICAL_EXPLAIN:
-		plan = CreatePlan((LogicalExplain &)op);
+		plan = CreatePlan(op.Cast<LogicalExplain>());
 		break;
 	case LogicalOperatorType::LOGICAL_SHOW:
-		plan = CreatePlan((LogicalShow &)op);
+		plan = CreatePlan(op.Cast<LogicalShow>());
 		break;
 	case LogicalOperatorType::LOGICAL_DISTINCT:
-		plan = CreatePlan((LogicalDistinct &)op);
+		plan = CreatePlan(op.Cast<LogicalDistinct>());
 		break;
 	case LogicalOperatorType::LOGICAL_PREPARE:
-		plan = CreatePlan((LogicalPrepare &)op);
+		plan = CreatePlan(op.Cast<LogicalPrepare>());
 		break;
 	case LogicalOperatorType::LOGICAL_EXECUTE:
-		plan = CreatePlan((LogicalExecute &)op);
+		plan = CreatePlan(op.Cast<LogicalExecute>());
 		break;
 	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
 	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
 	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
 	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
 	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
-		plan = CreatePlan((LogicalCreate &)op);
+		plan = CreatePlan(op.Cast<LogicalCreate>());
 		break;
 	case LogicalOperatorType::LOGICAL_PRAGMA:
-		plan = CreatePlan((LogicalPragma &)op);
+		plan = CreatePlan(op.Cast<LogicalPragma>());
 		break;
 	case LogicalOperatorType::LOGICAL_TRANSACTION:
 	case LogicalOperatorType::LOGICAL_ALTER:
@@ -188,22 +189,25 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 	case LogicalOperatorType::LOGICAL_LOAD:
 	case LogicalOperatorType::LOGICAL_ATTACH:
 	case LogicalOperatorType::LOGICAL_DETACH:
-		plan = CreatePlan((LogicalSimple &)op);
+		plan = CreatePlan(op.Cast<LogicalSimple>());
 		break;
 	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
-		plan = CreatePlan((LogicalRecursiveCTE &)op);
+		plan = CreatePlan(op.Cast<LogicalRecursiveCTE>());
 		break;
 	case LogicalOperatorType::LOGICAL_CTE_REF:
-		plan = CreatePlan((LogicalCTERef &)op);
+		plan = CreatePlan(op.Cast<LogicalCTERef>());
 		break;
 	case LogicalOperatorType::LOGICAL_EXPORT:
-		plan = CreatePlan((LogicalExport &)op);
+		plan = CreatePlan(op.Cast<LogicalExport>());
 		break;
 	case LogicalOperatorType::LOGICAL_SET:
-		plan = CreatePlan((LogicalSet &)op);
+		plan = CreatePlan(op.Cast<LogicalSet>());
 		break;
 	case LogicalOperatorType::LOGICAL_RESET:
-		plan = CreatePlan((LogicalReset &)op);
+		plan = CreatePlan(op.Cast<LogicalReset>());
+		break;
+	case LogicalOperatorType::LOGICAL_PIVOT:
+		plan = CreatePlan((LogicalPivot &)op);
 		break;
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
 		plan = ((LogicalExtensionOperator &)op).CreatePlan(context, *this);
@@ -217,6 +221,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 		throw NotImplementedException("Unimplemented logical operator type!");
 	}
 	}
+	if (!plan) {
+		throw InternalException("Physical plan generator - no plan generated");
+	}
 
 	if (op.estimated_props) {
 		plan->estimated_cardinality = op.estimated_props->GetCardinality<idx_t>();

package/src/duckdb/src/execution/radix_partitioned_hashtable.cpp

@@ -102,7 +102,7 @@ public:
 };
 
 void RadixPartitionedHashTable::SetMultiScan(GlobalSinkState &state) {
-	auto &gstate = (RadixHTGlobalState &)state;
+	auto &gstate = state.Cast<RadixHTGlobalState>();
 	gstate.multi_scan = true;
 }
 
@@ -121,7 +121,7 @@ void RadixPartitionedHashTable::PopulateGroupChunk(DataChunk &group_chunk, DataC
 		// Retrieve the expression containing the index in the input chunk
 		auto &group = op.groups[group_idx];
 		D_ASSERT(group->type == ExpressionType::BOUND_REF);
-		auto &bound_ref_expr = (BoundReferenceExpression &)*group;
+		auto &bound_ref_expr = group->Cast<BoundReferenceExpression>();
 		// Reference from input_chunk[group.index] -> group_chunk[chunk_index]
 		group_chunk.data[chunk_index++].Reference(input_chunk.data[bound_ref_expr.index]);
 	}
@@ -132,8 +132,8 @@ void RadixPartitionedHashTable::PopulateGroupChunk(DataChunk &group_chunk, DataC
 void RadixPartitionedHashTable::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                      DataChunk &groups_input, DataChunk &payload_input,
                                      const vector<idx_t> &filter) const {
-	auto &llstate = (RadixHTLocalState &)lstate;
-	auto &gstate = (RadixHTGlobalState &)state;
+	auto &llstate = lstate.Cast<RadixHTLocalState>();
+	auto &gstate = state.Cast<RadixHTGlobalState>();
 	D_ASSERT(!gstate.is_finalized);
 
 	DataChunk &group_chunk = llstate.group_chunk;
@@ -176,8 +176,8 @@ void RadixPartitionedHashTable::Sink(ExecutionContext &context, GlobalSinkState
 
 void RadixPartitionedHashTable::Combine(ExecutionContext &context, GlobalSinkState &state,
                                         LocalSinkState &lstate) const {
-	auto &llstate = (RadixHTLocalState &)lstate;
-	auto &gstate = (RadixHTGlobalState &)state;
+	auto &llstate = lstate.Cast<RadixHTLocalState>();
+	auto &gstate = state.Cast<RadixHTGlobalState>();
 	D_ASSERT(!gstate.is_finalized);
 
 	// this actually does not do a lot but just pushes the local HTs into the global state so we can later combine them
@@ -208,7 +208,7 @@ void RadixPartitionedHashTable::Combine(ExecutionContext &context, GlobalSinkSta
 }
 
 bool RadixPartitionedHashTable::Finalize(ClientContext &context, GlobalSinkState &gstate_p) const {
-	auto &gstate = (RadixHTGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<RadixHTGlobalState>();
 	D_ASSERT(!gstate.is_finalized);
 	gstate.is_finalized = true;
 
@@ -304,7 +304,7 @@ private:
 
 void RadixPartitionedHashTable::ScheduleTasks(Executor &executor, const shared_ptr<Event> &event,
                                               GlobalSinkState &state, vector<unique_ptr<Task>> &tasks) const {
-	auto &gstate = (RadixHTGlobalState &)state;
+	auto &gstate = state.Cast<RadixHTGlobalState>();
 	if (!gstate.is_partitioned) {
 		return;
 	}
@@ -316,7 +316,7 @@ void RadixPartitionedHashTable::ScheduleTasks(Executor &executor, const shared_p
 }
 
 bool RadixPartitionedHashTable::ForceSingleHT(GlobalSinkState &state) const {
-	auto &gstate = (RadixHTGlobalState &)state;
+	auto &gstate = state.Cast<RadixHTGlobalState>();
 	return gstate.partition_info.n_partitions < 2;
 }
 
@@ -365,7 +365,7 @@ unique_ptr<LocalSourceState> RadixPartitionedHashTable::GetLocalSourceState(Exec
 }
 
 idx_t RadixPartitionedHashTable::Size(GlobalSinkState &sink_state) const {
-	auto &gstate = (RadixHTGlobalState &)sink_state;
+	auto &gstate = sink_state.Cast<RadixHTGlobalState>();
 	if (gstate.is_empty && grouping_set.empty()) {
 		return 1;
 	}
@@ -379,9 +379,9 @@ idx_t RadixPartitionedHashTable::Size(GlobalSinkState &sink_state) const {
 
 void RadixPartitionedHashTable::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSinkState &sink_state,
                                         GlobalSourceState &gsstate, LocalSourceState &lsstate) const {
-	auto &gstate = (RadixHTGlobalState &)sink_state;
-	auto &state = (RadixHTGlobalSourceState &)gsstate;
-	auto &lstate = (RadixHTLocalSourceState &)lsstate;
+	auto &gstate = sink_state.Cast<RadixHTGlobalState>();
+	auto &state = gsstate.Cast<RadixHTGlobalSourceState>();
+	auto &lstate = lsstate.Cast<RadixHTLocalSourceState>();
 	D_ASSERT(gstate.is_finalized);
 	if (state.finished) {
 		return;
@@ -399,7 +399,7 @@ void RadixPartitionedHashTable::GetData(ExecutionContext &context, DataChunk &ch
 		}
 		for (idx_t i = 0; i < op.aggregates.size(); i++) {
 			D_ASSERT(op.aggregates[i]->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-			auto &aggr = (BoundAggregateExpression &)*op.aggregates[i];
+			auto &aggr = op.aggregates[i]->Cast<BoundAggregateExpression>();
 			auto aggr_state = unique_ptr<data_t[]>(new data_t[aggr.function.state_size()]);
 			aggr.function.initialize(aggr_state.get());
 

package/src/duckdb/src/function/aggregate/algebraic/avg.cpp

@@ -52,7 +52,7 @@ public:
 	};
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (AverageDecimalBindData &)other_p;
+		auto &other = other_p.Cast<AverageDecimalBindData>();
 		return scale == other.scale;
 	}
 };
@@ -76,7 +76,7 @@ template <class T>
 static T GetAverageDivident(uint64_t count, FunctionData *bind_data) {
 	T divident = T(count);
 	if (bind_data) {
-		auto &avg_bind_data = (AverageDecimalBindData &)*bind_data;
+		auto &avg_bind_data = bind_data->Cast<AverageDecimalBindData>();
 		divident *= avg_bind_data.scale;
 	}
 	return divident;

package/src/duckdb/src/function/aggregate/distributive/bitstring_agg.cpp

@@ -33,7 +33,7 @@ struct BitstringAggBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (BitstringAggBindData &)other_p;
+		auto &other = other_p.Cast<BitstringAggBindData>();
 		if (min.IsNull() && other.min.IsNull() && max.IsNull() && other.max.IsNull()) {
 			return true;
 		}

package/src/duckdb/src/function/aggregate/distributive/string_agg.cpp

@@ -25,7 +25,7 @@ struct StringAggBindData : public FunctionData {
 		return make_uniq<StringAggBindData>(sep);
 	}
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (StringAggBindData &)other_p;
+		auto &other = other_p.Cast<StringAggBindData>();
 		return sep == other.sep;
 	}
 };
@@ -89,7 +89,7 @@ struct StringAggFunction {
 	}
 
 	static inline void PerformOperation(StringAggState *state, string_t str, FunctionData *data_p) {
-		auto &data = (StringAggBindData &)*data_p;
+		auto &data = data_p->Cast<StringAggBindData>();
 		PerformOperation(state, str.GetDataUnsafe(), data.sep.c_str(), str.GetSize(), data.sep.size());
 	}
 

package/src/duckdb/src/function/aggregate/holistic/approximate_quantile.cpp

@@ -28,7 +28,7 @@ struct ApproximateQuantileBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (ApproximateQuantileBindData &)other_p;
+		auto &other = other_p.Cast<ApproximateQuantileBindData>();
 		//		return quantiles == other.quantiles;
 		if (quantiles != other.quantiles) {
 			return false;

package/src/duckdb/src/function/aggregate/holistic/quantile.cpp

@@ -440,7 +440,7 @@ struct QuantileBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (QuantileBindData &)other_p;
+		auto &other = other_p.Cast<QuantileBindData>();
 		return desc == other.desc && quantiles == other.quantiles && order == other.order;
 	}
 

package/src/duckdb/src/function/aggregate/holistic/reservoir_quantile.cpp

@@ -60,7 +60,7 @@ struct ReservoirQuantileBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (ReservoirQuantileBindData &)other_p;
+		auto &other = other_p.Cast<ReservoirQuantileBindData>();
 		return quantiles == other.quantiles && sample_size == other.sample_size;
 	}
 

package/src/duckdb/src/function/aggregate/nested/list.cpp

@@ -118,7 +118,7 @@ static void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_d
 	auto states = (ListAggState **)sdata.data;
 	RecursiveFlatten(input, count);
 
-	auto &list_bind_data = (ListBindData &)*aggr_input_data.bind_data;
+	auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
 
 	for (idx_t i = 0; i < count; i++) {
 		auto state = states[sdata.sel->get_index(i)];
@@ -138,7 +138,7 @@ static void ListCombineFunction(Vector &state, Vector &combined, AggregateInputD
 	state.ToUnifiedFormat(count, sdata);
 	auto states_ptr = (ListAggState **)sdata.data;
 
-	auto &list_bind_data = (ListBindData &)*aggr_input_data.bind_data;
+	auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
 
 	auto combined_ptr = FlatVector::GetData<ListAggState *>(combined);
 	for (idx_t i = 0; i < count; i++) {
@@ -185,7 +185,7 @@ static void ListFinalize(Vector &state_vector, AggregateInputData &aggr_input_da
 	auto result_data = FlatVector::GetData<list_entry_t>(result);
 	size_t total_len = ListVector::GetListSize(result);
 
-	auto &list_bind_data = (ListBindData &)*aggr_input_data.bind_data;
+	auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
 
 	for (idx_t i = 0; i < count; i++) {
 

package/src/duckdb/src/function/cast/enum_casts.cpp

@@ -116,7 +116,7 @@ public:
 };
 
 static unique_ptr<FunctionLocalState> InitEnumCastLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = (EnumBoundCastData &)*parameters.cast_data;
+	auto &cast_data = parameters.cast_data->Cast<EnumBoundCastData>();
 	auto result = make_uniq<EnumCastLocalState>();
 
 	if (cast_data.from_varchar_cast.init_local_state) {
@@ -131,8 +131,8 @@ static unique_ptr<FunctionLocalState> InitEnumCastLocalState(CastLocalStateParam
 }
 
 static bool EnumToAnyCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = (EnumBoundCastData &)*parameters.cast_data;
-	auto &lstate = (EnumCastLocalState &)*parameters.local_state;
+	auto &cast_data = parameters.cast_data->Cast<EnumBoundCastData>();
+	auto &lstate = parameters.local_state->Cast<EnumCastLocalState>();
 
 	Vector varchar_cast(LogicalType::VARCHAR, count);
 

package/src/duckdb/src/function/cast/list_casts.cpp

@@ -14,7 +14,7 @@ unique_ptr<BoundCastData> ListBoundCastData::BindListToListCast(BindCastInput &i
 }
 
 unique_ptr<FunctionLocalState> ListBoundCastData::InitListLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = (ListBoundCastData &)*parameters.cast_data;
+	auto &cast_data = parameters.cast_data->Cast<ListBoundCastData>();
 	if (!cast_data.child_cast_info.init_local_state) {
 		return nullptr;
 	}
@@ -23,7 +23,7 @@ unique_ptr<FunctionLocalState> ListBoundCastData::InitListLocalState(CastLocalSt
 }
 
 bool ListCast::ListToListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = (ListBoundCastData &)*parameters.cast_data;
+	auto &cast_data = parameters.cast_data->Cast<ListBoundCastData>();
 
 	// only handle constant and flat vectors here for now
 	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {

package/src/duckdb/src/function/cast/string_cast.cpp

@@ -165,7 +165,7 @@ bool VectorStringToList::StringToNestedTypeCastLoop(string_t *source_data, Valid
 	D_ASSERT(total_list_size == total);
 
 	auto &result_child = ListVector::GetEntry(result);
-	auto &cast_data = (ListBoundCastData &)*parameters.cast_data;
+	auto &cast_data = parameters.cast_data->Cast<ListBoundCastData>();
 	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
 	return cast_data.child_cast_info.function(varchar_vector, result_child, total_list_size, child_parameters) &&
 	       all_converted;
@@ -219,8 +219,8 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(string_t *source_data, Val
 		}
 	}
 
-	auto &cast_data = (StructBoundCastData &)*parameters.cast_data;
-	auto &lstate = (StructCastLocalState &)*parameters.local_state;
+	auto &cast_data = parameters.cast_data->Cast<StructBoundCastData>();
+	auto &lstate = parameters.local_state->Cast<StructCastLocalState>();
 	D_ASSERT(cast_data.child_cast_info.size() == result_children.size());
 
 	for (idx_t child_idx = 0; child_idx < result_children.size(); child_idx++) {
@@ -239,7 +239,7 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(string_t *source_data, Val
 // string -> map casting
 //===--------------------------------------------------------------------===//
 unique_ptr<FunctionLocalState> InitMapCastLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = (MapBoundCastData &)*parameters.cast_data;
+	auto &cast_data = parameters.cast_data->Cast<MapBoundCastData>();
 	auto result = make_uniq<MapCastLocalState>();
 
 	if (cast_data.key_cast.init_local_state) {
@@ -303,8 +303,8 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(string_t *source_data, Validi
 
 	auto &result_key_child = MapVector::GetKeys(result);
 	auto &result_val_child = MapVector::GetValues(result);
-	auto &cast_data = (MapBoundCastData &)*parameters.cast_data;
-	auto &lstate = (MapCastLocalState &)*parameters.local_state;
+	auto &cast_data = parameters.cast_data->Cast<MapBoundCastData>();
+	auto &lstate = parameters.local_state->Cast<MapCastLocalState>();
 
 	CastParameters key_params(parameters, cast_data.key_cast.cast_data, lstate.key_state);
 	if (!cast_data.key_cast.function(varchar_key_vector, result_key_child, total_elements, key_params)) {

package/src/duckdb/src/function/cast/struct_cast.cpp

@@ -20,7 +20,7 @@ unique_ptr<BoundCastData> StructBoundCastData::BindStructToStructCast(BindCastIn
 }
 
 unique_ptr<FunctionLocalState> StructBoundCastData::InitStructCastLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = (StructBoundCastData &)*parameters.cast_data;
+	auto &cast_data = parameters.cast_data->Cast<StructBoundCastData>();
 	auto result = make_uniq<StructCastLocalState>();
 
 	for (auto &entry : cast_data.child_cast_info) {
@@ -35,8 +35,8 @@ unique_ptr<FunctionLocalState> StructBoundCastData::InitStructCastLocalState(Cas
 }
 
 static bool StructToStructCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = (StructBoundCastData &)*parameters.cast_data;
-	auto &lstate = (StructCastLocalState &)*parameters.local_state;
+	auto &cast_data = parameters.cast_data->Cast<StructBoundCastData>();
+	auto &lstate = parameters.local_state->Cast<StructCastLocalState>();
 	auto &source_child_types = StructType::GetChildTypes(source.GetType());
 	auto &source_children = StructVector::GetEntries(source);
 	D_ASSERT(source_children.size() == StructType::GetChildTypes(result.GetType()).size());
@@ -66,7 +66,7 @@ static bool StructToStructCast(Vector &source, Vector &result, idx_t count, Cast
 static bool StructToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
 	// first cast all child elements to varchar
-	auto &cast_data = (StructBoundCastData &)*parameters.cast_data;
+	auto &cast_data = parameters.cast_data->Cast<StructBoundCastData>();
 	Vector varchar_struct(cast_data.target, count);
 	StructToStructCast(source, varchar_struct, count, parameters);
 

package/src/duckdb/src/function/cast/union_casts.cpp

@@ -99,7 +99,7 @@ unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalTyp
 }
 
 unique_ptr<FunctionLocalState> InitToUnionLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = (ToUnionBoundCastData &)*parameters.cast_data;
+	auto &cast_data = parameters.cast_data->Cast<ToUnionBoundCastData>();
 	if (!cast_data.member_cast_info.init_local_state) {
 		return nullptr;
 	}
@@ -109,7 +109,7 @@ unique_ptr<FunctionLocalState> InitToUnionLocalState(CastLocalStateParameters &p
 
 static bool ToUnionCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	D_ASSERT(result.GetType().id() == LogicalTypeId::UNION);
-	auto &cast_data = (ToUnionBoundCastData &)*parameters.cast_data;
+	auto &cast_data = parameters.cast_data->Cast<ToUnionBoundCastData>();
 	auto &selected_member_vector = UnionVector::GetMember(result, cast_data.tag);
 
 	CastParameters child_parameters(parameters, cast_data.member_cast_info.cast_data, parameters.local_state);
@@ -207,7 +207,7 @@ unique_ptr<BoundCastData> BindUnionToUnionCast(BindCastInput &input, const Logic
 }
 
 unique_ptr<FunctionLocalState> InitUnionToUnionLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = (UnionToUnionBoundCastData &)*parameters.cast_data;
+	auto &cast_data = parameters.cast_data->Cast<UnionToUnionBoundCastData>();
 	auto result = make_uniq<StructCastLocalState>();
 
 	for (auto &entry : cast_data.member_casts) {
@@ -222,8 +222,8 @@ unique_ptr<FunctionLocalState> InitUnionToUnionLocalState(CastLocalStateParamete
 }
 
 static bool UnionToUnionCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = (UnionToUnionBoundCastData &)*parameters.cast_data;
-	auto &lstate = (StructCastLocalState &)*parameters.local_state;
+	auto &cast_data = parameters.cast_data->Cast<UnionToUnionBoundCastData>();
+	auto &lstate = parameters.local_state->Cast<StructCastLocalState>();
 
 	auto source_member_count = UnionType::GetMemberCount(source.GetType());
 	auto target_member_count = UnionType::GetMemberCount(result.GetType());
@@ -313,7 +313,7 @@ static bool UnionToUnionCast(Vector &source, Vector &result, idx_t count, CastPa
 static bool UnionToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
 	// first cast all union members to varchar
-	auto &cast_data = (UnionToUnionBoundCastData &)*parameters.cast_data;
+	auto &cast_data = parameters.cast_data->Cast<UnionToUnionBoundCastData>();
 	Vector varchar_union(cast_data.target_type, count);
 
 	UnionToUnionCast(source, varchar_union, count, parameters);