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

package/src/duckdb/src/function/function.cpp

@@ -46,7 +46,7 @@ SimpleFunction::SimpleFunction(string name_p, vector<LogicalType> arguments_p, L
 SimpleFunction::~SimpleFunction() {
 }
 
-string SimpleFunction::ToString() {
+string SimpleFunction::ToString() const {
 	return Function::CallToString(name, arguments);
 }
 
@@ -62,11 +62,11 @@ SimpleNamedParameterFunction::SimpleNamedParameterFunction(string name_p, vector
 SimpleNamedParameterFunction::~SimpleNamedParameterFunction() {
 }
 
-string SimpleNamedParameterFunction::ToString() {
+string SimpleNamedParameterFunction::ToString() const {
 	return Function::CallToString(name, arguments, named_parameters);
 }
 
-bool SimpleNamedParameterFunction::HasNamedParameters() {
+bool SimpleNamedParameterFunction::HasNamedParameters() const {
 	return !named_parameters.empty();
 }
 
@@ -80,7 +80,7 @@ BaseScalarFunction::BaseScalarFunction(string name_p, vector<LogicalType> argume
 BaseScalarFunction::~BaseScalarFunction() {
 }
 
-string BaseScalarFunction::ToString() {
+string BaseScalarFunction::ToString() const {
 	return Function::CallToString(name, arguments, return_type);
 }
 

package/src/duckdb/src/function/function_binder.cpp

@@ -250,7 +250,8 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(const string &schema,
 	auto function =
 	    Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, schema, name);
 	D_ASSERT(function && function->type == CatalogType::SCALAR_FUNCTION_ENTRY);
-	return BindScalarFunction((ScalarFunctionCatalogEntry &)*function, std::move(children), error, is_operator, binder);
+	return BindScalarFunction(function->Cast<ScalarFunctionCatalogEntry>(), std::move(children), error, is_operator,
+	                          binder);
 }
 
 unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogEntry &func,

package/src/duckdb/src/function/macro_function.cpp

@@ -45,7 +45,7 @@ string MacroFunction::ValidateArguments(MacroFunction &macro_def, const string &
 		error = StringUtil::Format(
 		    "Macro function '%s(%s)' requires ", name,
 		    StringUtil::Join(parameters, parameters.size(), ", ", [](const unique_ptr<ParsedExpression> &p) {
-			    return ((ColumnRefExpression &)*p).column_names[0];
+			    return (p->Cast<ColumnRefExpression>()).column_names[0];
 		    }));
 		error += parameters.size() == 1 ? "a single positional argument"
 		                                : StringUtil::Format("%i positional arguments", parameters.size());
@@ -69,7 +69,7 @@ string MacroFunction::ValidateArguments(MacroFunction &macro_def, const string &
 	return error;
 }
 
-void MacroFunction::CopyProperties(MacroFunction &other) {
+void MacroFunction::CopyProperties(MacroFunction &other) const {
 	other.type = type;
 	for (auto &param : parameters) {
 		other.parameters.push_back(param->Copy());
@@ -79,7 +79,7 @@ void MacroFunction::CopyProperties(MacroFunction &other) {
 	}
 }
 
-string MacroFunction::ToSQL(const string &schema, const string &name) {
+string MacroFunction::ToSQL(const string &schema, const string &name) const {
 	vector<string> param_strings;
 	for (auto &param : parameters) {
 		param_strings.push_back(param->ToString());

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -145,7 +145,7 @@ string PragmaImportDatabase(ClientContext &context, const FunctionParameters &pa
 			query.clear();
 			for (auto &statement_p : copy_statements) {
 				D_ASSERT(statement_p->type == StatementType::COPY_STATEMENT);
-				auto &statement = (CopyStatement &)*statement_p;
+				auto &statement = statement_p->Cast<CopyStatement>();
 				auto &info = *statement.info;
 				auto file_name = fs.ExtractName(info.file_path);
 				info.file_path = fs.JoinPath(parameters.values[0].ToString(), file_name);

package/src/duckdb/src/function/pragma_function.cpp

@@ -30,7 +30,7 @@ PragmaFunction PragmaFunction::PragmaStatement(const string &name, pragma_functi
 	                      LogicalType::INVALID);
 }
 
-string PragmaFunction::ToString() {
+string PragmaFunction::ToString() const {
 	switch (type) {
 	case PragmaType::PRAGMA_STATEMENT:
 		return StringUtil::Format("PRAGMA %s", name);

package/src/duckdb/src/function/scalar/date/date_part.cpp

@@ -1338,7 +1338,7 @@ struct StructDatePart {
 
 	template <typename INPUT_TYPE>
 	static void Function(DataChunk &args, ExpressionState &state, Vector &result) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		D_ASSERT(args.ColumnCount() == 1);
 

package/src/duckdb/src/function/scalar/date/strftime.cpp

@@ -657,8 +657,8 @@ void StrfTimeFormat::ConvertDateVector(Vector &input, Vector &result, idx_t coun
 
 template <bool REVERSED>
 static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StrfTimeBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<StrfTimeBindData>();
 
 	if (info.is_null) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -691,8 +691,8 @@ void StrfTimeFormat::ConvertTimestampVector(Vector &input, Vector &result, idx_t
 
 template <bool REVERSED>
 static void StrfTimeFunctionTimestamp(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StrfTimeBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<StrfTimeBindData>();
 
 	if (info.is_null) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -1307,8 +1307,8 @@ timestamp_t StrpTimeFormat::ParseTimestamp(string_t input) {
 }
 
 static void StrpTimeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StrpTimeBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<StrpTimeBindData>();
 
 	if (ConstantVector::IsNull(args.data[1])) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);

package/src/duckdb/src/function/scalar/generic/alias.cpp

@@ -4,7 +4,7 @@
 namespace duckdb {
 
 static void AliasFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	Value v(state.expr.alias.empty() ? func_expr.children[0]->GetName() : state.expr.alias);
 	result.Reference(v);
 }

package/src/duckdb/src/function/scalar/generic/constant_or_null.cpp

@@ -23,8 +23,8 @@ public:
 };
 
 static void ConstantOrNullFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (ConstantOrNullBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<ConstantOrNullBindData>();
 	result.Reference(info.value);
 	for (idx_t idx = 1; idx < args.ColumnCount(); idx++) {
 		switch (args.data[idx].GetVectorType()) {
@@ -78,7 +78,7 @@ bool ConstantOrNull::IsConstantOrNull(BoundFunctionExpression &expr, const Value
 		return false;
 	}
 	D_ASSERT(expr.bind_info);
-	auto &bind_data = (ConstantOrNullBindData &)*expr.bind_info;
+	auto &bind_data = expr.bind_info->Cast<ConstantOrNullBindData>();
 	D_ASSERT(bind_data.value.type() == val.type());
 	return bind_data.value == val;
 }

package/src/duckdb/src/function/scalar/generic/current_setting.cpp

@@ -25,8 +25,8 @@ public:
 };
 
 static void CurrentSettingFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (CurrentSettingBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<CurrentSettingBindData>();
 	result.Reference(info.value);
 }
 

package/src/duckdb/src/function/scalar/generic/stats.cpp

@@ -21,8 +21,8 @@ public:
 };
 
 static void StatsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StatsBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<StatsBindData>();
 	if (info.stats.empty()) {
 		info.stats = "No statistics";
 	}
@@ -38,7 +38,7 @@ unique_ptr<FunctionData> StatsBind(ClientContext &context, ScalarFunction &bound
 static unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &bind_data = input.bind_data;
-	auto &info = (StatsBindData &)*bind_data;
+	auto &info = bind_data->Cast<StatsBindData>();
 	info.stats = child_stats[0].ToString();
 	return nullptr;
 }

package/src/duckdb/src/function/scalar/list/list_aggregates.cpp

@@ -50,9 +50,9 @@ struct StateVector {
 	    : count(count_p), aggr_expr(std::move(aggr_expr_p)), state_vector(Vector(LogicalType::POINTER, count_p)) {
 	}
 
-	~StateVector() {
+	~StateVector() { // NOLINT
 		// destroy objects within the aggregate states
-		auto &aggr = (BoundAggregateExpression &)*aggr_expr;
+		auto &aggr = aggr_expr->Cast<BoundAggregateExpression>();
 		if (aggr.function.destructor) {
 			aggr.function.destructor(state_vector, count);
 		}
@@ -157,9 +157,9 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 	}
 
 	// get the aggregate function
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (ListAggregatesBindData &)*func_expr.bind_info;
-	auto &aggr = (BoundAggregateExpression &)*info.aggr_expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<ListAggregatesBindData>();
+	auto &aggr = info.aggr_expr->Cast<BoundAggregateExpression>();
 	AggregateInputData aggr_input_data(aggr.bind_info.get(), Allocator::DefaultAllocator());
 
 	D_ASSERT(aggr.function.update);

package/src/duckdb/src/function/scalar/list/list_lambdas.cpp

@@ -38,7 +38,7 @@ unique_ptr<FunctionData> ListLambdaBindData::Copy() const {
 }
 
 bool ListLambdaBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (ListLambdaBindData &)other_p;
+	auto &other = other_p.Cast<ListLambdaBindData>();
 	return lambda_expr->Equals(other.lambda_expr.get()) && stype == other.stype;
 }
 
@@ -166,8 +166,8 @@ static void ListLambdaFunction(DataChunk &args, ExpressionState &state, Vector &
 	auto list_entries = (list_entry_t *)lists_data.data;
 
 	// get the lambda expression
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (ListLambdaBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<ListLambdaBindData>();
 	auto &lambda_expr = info.lambda_expr;
 
 	// get the child vector and child data

package/src/duckdb/src/function/scalar/list/list_sort.cpp

@@ -62,7 +62,7 @@ unique_ptr<FunctionData> ListSortBindData::Copy() const {
 }
 
 bool ListSortBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (ListSortBindData &)other_p;
+	auto &other = other_p.Cast<ListSortBindData>();
 	return order_type == other.order_type && null_order == other.null_order;
 }
 
@@ -112,8 +112,8 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 		return;
 	}
 
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (ListSortBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<ListSortBindData>();
 
 	// initialize the global and local sorting state
 	auto &buffer_manager = BufferManager::GetBufferManager(info.context);

package/src/duckdb/src/function/scalar/math/numeric.cpp

@@ -310,7 +310,7 @@ struct CeilOperator {
 
 template <class T, class POWERS_OF_TEN, class OP>
 static void GenericRoundFunctionDecimal(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	OP::template Operation<T, POWERS_OF_TEN>(input, DecimalType::GetScale(func_expr.children[0]->return_type), result);
 }
 
@@ -519,7 +519,7 @@ struct RoundPrecisionFunctionData : public FunctionData {
 
 template <class T, class POWERS_OF_TEN_CLASS>
 static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = (RoundPrecisionFunctionData &)*func_expr.bind_info;
 	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
 	auto width = DecimalType::GetWidth(func_expr.children[0]->return_type);
@@ -545,7 +545,7 @@ static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionSt
 
 template <class T, class POWERS_OF_TEN_CLASS>
 static void DecimalRoundPositivePrecisionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = (RoundPrecisionFunctionData &)*func_expr.bind_info;
 	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
 	T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[source_scale - info.target_scale];

package/src/duckdb/src/function/scalar/math/random.cpp

@@ -18,7 +18,7 @@ struct RandomLocalState : public FunctionLocalState {
 
 static void RandomFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 0);
-	auto &lstate = (RandomLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RandomLocalState>();
 
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<double>(result);
@@ -43,7 +43,7 @@ void RandomFun::RegisterFunction(BuiltinFunctions &set) {
 
 static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 0);
-	auto &lstate = (RandomLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RandomLocalState>();
 
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<hugeint_t>(result);

package/src/duckdb/src/function/scalar/math/setseed.cpp

@@ -26,8 +26,8 @@ struct SetseedBindData : public FunctionData {
 };
 
 static void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (SetseedBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<SetseedBindData>();
 	auto &input = args.data[0];
 	input.Flatten(args.size());
 

package/src/duckdb/src/function/scalar/operators/arithmetic.cpp

@@ -122,7 +122,7 @@ struct DecimalArithmeticBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto other = (DecimalArithmeticBindData &)other_p;
+		auto other = other_p.Cast<DecimalArithmeticBindData>();
 		return other.check_overflow == check_overflow;
 	}
 
@@ -456,7 +456,7 @@ struct DecimalNegateBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto other = (DecimalNegateBindData &)other_p;
+		auto other = other_p.Cast<DecimalNegateBindData>();
 		return other.bound_type == bound_type;
 	}
 

package/src/duckdb/src/function/scalar/sequence/nextval.cpp

@@ -26,7 +26,7 @@ struct NextvalBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (NextvalBindData &)other_p;
+		auto &other = other_p.Cast<NextvalBindData>();
 		return sequence == other.sequence;
 	}
 };
@@ -85,8 +85,8 @@ SequenceCatalogEntry *BindSequence(ClientContext &context, const string &name) {
 
 template <class OP>
 static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (NextvalBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<NextvalBindData>();
 	auto &input = args.data[0];
 
 	auto &context = state.GetContext();
@@ -127,7 +127,7 @@ static unique_ptr<FunctionData> NextValBind(ClientContext &context, ScalarFuncti
 }
 
 static void NextValDependency(BoundFunctionExpression &expr, DependencyList &dependencies) {
-	auto &info = (NextvalBindData &)*expr.bind_info;
+	auto &info = expr.bind_info->Cast<NextvalBindData>();
 	if (info.sequence) {
 		dependencies.AddDependency(info.sequence);
 	}

package/src/duckdb/src/function/scalar/string/like.cpp

@@ -490,7 +490,7 @@ static unique_ptr<BaseStatistics> ILikePropagateStats(ClientContext &context, Fu
 
 template <class OP, bool INVERT>
 static void RegularLikeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	if (func_expr.bind_info) {
 		auto &matcher = (LikeMatcher &)*func_expr.bind_info;
 		// use fast like matcher

package/src/duckdb/src/function/scalar/string/regexp/regexp_extract_all.cpp

@@ -13,7 +13,7 @@ using regexp_util::TryParseConstantPattern;
 
 unique_ptr<FunctionLocalState>
 RegexpExtractAll::InitLocalState(ExpressionState &state, const BoundFunctionExpression &expr, FunctionData *bind_data) {
-	auto &info = (RegexpBaseBindData &)*bind_data;
+	auto &info = bind_data->Cast<RegexpBaseBindData>();
 	if (info.constant_pattern) {
 		return make_uniq<RegexLocalState>(info, true);
 	}
@@ -126,7 +126,7 @@ int32_t GetGroupIndex(DataChunk &args, idx_t row, int32_t &result) {
 duckdb_re2::RE2 &GetPattern(const RegexpBaseBindData &info, ExpressionState &state,
                             unique_ptr<duckdb_re2::RE2> &pattern_p) {
 	if (info.constant_pattern) {
-		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
 		return lstate.constant_pattern;
 	}
 	D_ASSERT(pattern_p);
@@ -136,7 +136,7 @@ duckdb_re2::RE2 &GetPattern(const RegexpBaseBindData &info, ExpressionState &sta
 RegexStringPieceArgs &GetGroupsBuffer(const RegexpBaseBindData &info, ExpressionState &state,
                                       unique_ptr<RegexStringPieceArgs> &groups_p) {
 	if (info.constant_pattern) {
-		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
 		return lstate.group_buffer;
 	}
 	D_ASSERT(groups_p);
@@ -144,8 +144,8 @@ RegexStringPieceArgs &GetGroupsBuffer(const RegexpBaseBindData &info, Expression
 }
 
 void RegexpExtractAll::Execute(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	const auto &info = (RegexpBaseBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	const auto &info = func_expr.bind_info->Cast<RegexpBaseBindData>();
 
 	auto &strings = args.data[0];
 	auto &patterns = args.data[1];

package/src/duckdb/src/function/scalar/string/regexp.cpp

@@ -32,14 +32,14 @@ RegexpBaseBindData::~RegexpBaseBindData() {
 }
 
 bool RegexpBaseBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (RegexpBaseBindData &)other_p;
+	auto &other = other_p.Cast<RegexpBaseBindData>();
 	return constant_pattern == other.constant_pattern && constant_string == other.constant_string &&
 	       RegexOptionsEquals(options, other.options);
 }
 
 unique_ptr<FunctionLocalState> RegexInitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
                                                    FunctionData *bind_data) {
-	auto &info = (RegexpBaseBindData &)*bind_data;
+	auto &info = bind_data->Cast<RegexpBaseBindData>();
 	if (info.constant_pattern) {
 		return make_uniq<RegexLocalState>(info);
 	}
@@ -109,11 +109,11 @@ static void RegexpMatchesFunction(DataChunk &args, ExpressionState &state, Vecto
 	auto &strings = args.data[0];
 	auto &patterns = args.data[1];
 
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (RegexpMatchesBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<RegexpMatchesBindData>();
 
 	if (info.constant_pattern) {
-		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
 		UnaryExecutor::Execute<string_t, bool>(strings, result, args.size(), [&](string_t input) {
 			return OP::Operation(CreateStringPiece(input), lstate.constant_pattern);
 		});
@@ -163,15 +163,15 @@ static unique_ptr<FunctionData> RegexReplaceBind(ClientContext &context, ScalarF
 }
 
 static void RegexReplaceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (RegexpReplaceBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<RegexpReplaceBindData>();
 
 	auto &strings = args.data[0];
 	auto &patterns = args.data[1];
 	auto &replaces = args.data[2];
 
 	if (info.constant_pattern) {
-		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
 		BinaryExecutor::Execute<string_t, string_t, string_t>(
 		    strings, replaces, result, args.size(), [&](string_t input, string_t replace) {
 			    std::string sstring = input.GetString();
@@ -254,13 +254,13 @@ static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarF
 }
 
 static void RegexExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	const auto &info = (RegexpExtractBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	const auto &info = func_expr.bind_info->Cast<RegexpExtractBindData>();
 
 	auto &strings = args.data[0];
 	auto &patterns = args.data[1];
 	if (info.constant_pattern) {
-		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
 		UnaryExecutor::Execute<string_t, string_t>(strings, result, args.size(), [&](string_t input) {
 			return Extract(input, result, lstate.constant_pattern, info.rewrite);
 		});

package/src/duckdb/src/function/scalar/string/string_split.cpp

@@ -159,11 +159,11 @@ static void StringSplitFunction(DataChunk &args, ExpressionState &state, Vector
 }
 
 static void StringSplitRegexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (RegexpMatchesBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<RegexpMatchesBindData>();
 	if (info.constant_pattern) {
 		// fast path: pre-compiled regex
-		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
 		StringSplitExecutor<ConstantRegexpStringSplit>(args, state, result, &lstate.constant_pattern);
 	} else {
 		// slow path: have to re-compile regex for every row

package/src/duckdb/src/function/scalar/struct/struct_extract.cpp

@@ -27,8 +27,8 @@ public:
 };
 
 static void StructExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StructExtractBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<StructExtractBindData>();
 
 	// this should be guaranteed by the binder
 	auto &vec = args.data[0];
@@ -103,7 +103,7 @@ static unique_ptr<BaseStatistics> PropagateStructExtractStats(ClientContext &con
 	auto &child_stats = input.child_stats;
 	auto &bind_data = input.bind_data;
 
-	auto &info = (StructExtractBindData &)*bind_data;
+	auto &info = bind_data->Cast<StructExtractBindData>();
 	auto struct_child_stats = StructStats::GetChildStats(child_stats[0]);
 	return struct_child_stats[info.index].ToUnique();
 }

package/src/duckdb/src/function/scalar/struct/struct_pack.cpp

@@ -10,8 +10,8 @@ namespace duckdb {
 
 static void StructPackFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 #ifdef DEBUG
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (VariableReturnBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<VariableReturnBindData>();
 	// this should never happen if the binder below is sane
 	D_ASSERT(args.ColumnCount() == StructType::GetChildTypes(info.stype).size());
 #endif

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -28,8 +28,8 @@ struct ExportAggregateBindData : public FunctionData {
 	}
 
 	static ExportAggregateBindData &GetFrom(ExpressionState &state) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
-		return (ExportAggregateBindData &)*func_expr.bind_info;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+		return func_expr.bind_info->Cast<ExportAggregateBindData>();
 	}
 };
 

package/src/duckdb/src/function/scalar/union/union_extract.cpp

@@ -26,8 +26,8 @@ public:
 };
 
 static void UnionExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (UnionExtractBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<UnionExtractBindData>();
 
 	// this should be guaranteed by the binder
 	auto &vec = args.data[0];

package/src/duckdb/src/function/scalar_macro_function.cpp

@@ -21,7 +21,7 @@ ScalarMacroFunction::ScalarMacroFunction(unique_ptr<ParsedExpression> expression
 ScalarMacroFunction::ScalarMacroFunction(void) : MacroFunction(MacroType::SCALAR_MACRO) {
 }
 
-unique_ptr<MacroFunction> ScalarMacroFunction::Copy() {
+unique_ptr<MacroFunction> ScalarMacroFunction::Copy() const {
 	auto result = make_uniq<ScalarMacroFunction>();
 	result->expression = expression->Copy();
 	CopyProperties(*result);
@@ -31,7 +31,7 @@ unique_ptr<MacroFunction> ScalarMacroFunction::Copy() {
 
 void RemoveQualificationRecursive(unique_ptr<ParsedExpression> &expr) {
 	if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &col_ref = (ColumnRefExpression &)*expr;
+		auto &col_ref = expr->Cast<ColumnRefExpression>();
 		auto &col_names = col_ref.column_names;
 		if (col_names.size() == 2 && col_names[0].find(DummyBinding::DUMMY_NAME) != string::npos) {
 			col_names.erase(col_names.begin());
@@ -42,7 +42,7 @@ void RemoveQualificationRecursive(unique_ptr<ParsedExpression> &expr) {
 	}
 }
 
-string ScalarMacroFunction::ToSQL(const string &schema, const string &name) {
+string ScalarMacroFunction::ToSQL(const string &schema, const string &name) const {
 	// In case of nested macro's we need to fix it a bit
 	auto expression_copy = expression->Copy();
 	RemoveQualificationRecursive(expression_copy);

package/src/duckdb/src/function/table/arrow.cpp

@@ -288,13 +288,13 @@ unique_ptr<GlobalTableFunctionState> ArrowTableFunction::ArrowScanInitGlobal(Cli
 unique_ptr<LocalTableFunctionState> ArrowTableFunction::ArrowScanInitLocal(ExecutionContext &context,
                                                                            TableFunctionInitInput &input,
                                                                            GlobalTableFunctionState *global_state_p) {
-	auto &global_state = (ArrowScanGlobalState &)*global_state_p;
+	auto &global_state = global_state_p->Cast<ArrowScanGlobalState>();
 	auto current_chunk = make_uniq<ArrowArrayWrapper>();
 	auto result = make_uniq<ArrowScanLocalState>(std::move(current_chunk));
 	result->column_ids = input.column_ids;
 	result->filters = input.filters;
 	if (input.CanRemoveFilterColumns()) {
-		auto &asgs = (ArrowScanGlobalState &)*global_state_p;
+		auto &asgs = global_state_p->Cast<ArrowScanGlobalState>();
 		result->all_columns.Initialize(context.client, asgs.scanned_types);
 	}
 	if (!ArrowScanParallelStateNext(context.client, input.bind_data, *result, global_state)) {
@@ -308,8 +308,8 @@ void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunction
 		return;
 	}
 	auto &data = (ArrowScanFunctionData &)*data_p.bind_data;
-	auto &state = (ArrowScanLocalState &)*data_p.local_state;
-	auto &global_state = (ArrowScanGlobalState &)*data_p.global_state;
+	auto &state = data_p.local_state->Cast<ArrowScanLocalState>();
+	auto &global_state = data_p.global_state->Cast<ArrowScanGlobalState>();
 
 	//! Out of tuples in this chunk
 	if (state.chunk_offset >= (idx_t)state.chunk->arrow_array.length) {
@@ -340,7 +340,7 @@ unique_ptr<NodeStatistics> ArrowTableFunction::ArrowScanCardinality(ClientContex
 idx_t ArrowTableFunction::ArrowGetBatchIndex(ClientContext &context, const FunctionData *bind_data_p,
                                              LocalTableFunctionState *local_state,
                                              GlobalTableFunctionState *global_state) {
-	auto &state = (ArrowScanLocalState &)*local_state;
+	auto &state = local_state->Cast<ArrowScanLocalState>();
 	return state.batch_index;
 }
 

package/src/duckdb/src/function/table/checkpoint.cpp

@@ -45,7 +45,7 @@ static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunc
 
 template <bool FORCE>
 static void TemplatedCheckpointFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (CheckpointBindData &)*data_p.bind_data;
+	auto &bind_data = data_p.bind_data->Cast<CheckpointBindData>();
 	auto &transaction_manager = TransactionManager::Get(*bind_data.db);
 	transaction_manager.Checkpoint(context, FORCE);
 }