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

package/binding.gyp

@@ -224,18 +224,18 @@
                 "src/duckdb/third_party/zstd/compress/zstd_lazy.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
-                "src/duckdb/extension/icu/./icu-table-range.cpp", 
-                "src/duckdb/extension/icu/./icu-datepart.cpp", 
-                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
-                "src/duckdb/extension/icu/./icu-timezone.cpp", 
-                "src/duckdb/extension/icu/./icu-datesub.cpp", 
-                "src/duckdb/extension/icu/./icu-list-range.cpp", 
                 "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
-                "src/duckdb/extension/icu/./icu-extension.cpp", 
                 "src/duckdb/extension/icu/./icu-strptime.cpp", 
+                "src/duckdb/extension/icu/./icu-timezone.cpp", 
+                "src/duckdb/extension/icu/./icu-extension.cpp", 
+                "src/duckdb/extension/icu/./icu-datepart.cpp", 
                 "src/duckdb/extension/icu/./icu-dateadd.cpp", 
-                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
+                "src/duckdb/extension/icu/./icu-list-range.cpp", 
+                "src/duckdb/extension/icu/./icu-table-range.cpp", 
+                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
                 "src/duckdb/extension/icu/./icu-makedate.cpp", 
+                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
+                "src/duckdb/extension/icu/./icu-datesub.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_common.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp", 
                 "src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev1457.0",
+  "version": "0.7.2-dev1533.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/icu/icu-dateadd.cpp

@@ -197,7 +197,7 @@ struct ICUDateAdd : public ICUDateFunc {
 	static void ExecuteUnary(DataChunk &args, ExpressionState &state, Vector &result) {
 		D_ASSERT(args.ColumnCount() == 1);
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar(info.calendar->clone());
 
@@ -217,7 +217,7 @@ struct ICUDateAdd : public ICUDateFunc {
 	static void ExecuteBinary(DataChunk &args, ExpressionState &state, Vector &result) {
 		D_ASSERT(args.ColumnCount() == 2);
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar(info.calendar->clone());
 

package/src/duckdb/extension/icu/icu-datepart.cpp

@@ -234,7 +234,7 @@ struct ICUDatePart : public ICUDateFunc {
 		D_ASSERT(args.ColumnCount() == 1);
 		auto &date_arg = args.data[0];
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BIND_TYPE &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
@@ -258,7 +258,7 @@ struct ICUDatePart : public ICUDateFunc {
 		auto &part_arg = args.data[0];
 		auto &date_arg = args.data[1];
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BIND_TYPE &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
@@ -280,7 +280,7 @@ struct ICUDatePart : public ICUDateFunc {
 	template <typename INPUT_TYPE>
 	static void StructFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 		using BIND_TYPE = BindAdapterData<int64_t>;
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BIND_TYPE &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();

package/src/duckdb/extension/icu/icu-datesub.cpp

@@ -95,7 +95,7 @@ struct ICUCalendarSub : public ICUDateFunc {
 		auto &startdate_arg = args.data[1];
 		auto &enddate_arg = args.data[2];
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar(info.calendar->clone());
 
@@ -217,7 +217,7 @@ struct ICUCalendarDiff : public ICUDateFunc {
 		auto &startdate_arg = args.data[1];
 		auto &enddate_arg = args.data[2];
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();

package/src/duckdb/extension/icu/icu-datetrunc.cpp

@@ -98,7 +98,7 @@ struct ICUDateTrunc : public ICUDateFunc {
 		auto &part_arg = args.data[0];
 		auto &date_arg = args.data[1];
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar(info.calendar->clone());
 

package/src/duckdb/extension/icu/icu-extension.cpp

@@ -61,7 +61,7 @@ struct IcuBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (IcuBindData &)other_p;
+		auto &other = other_p.Cast<IcuBindData>();
 		return language == other.language && country == other.country;
 	}
 };
@@ -86,8 +86,8 @@ static int32_t ICUGetSortKey(icu::Collator &collator, string_t input, duckdb::un
 static void ICUCollateFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	const char HEX_TABLE[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
 
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (IcuBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<IcuBindData>();
 	auto &collator = *info.collator;
 
 	duckdb::unique_ptr<char[]> buffer;

package/src/duckdb/extension/icu/icu-list-range.cpp

@@ -127,7 +127,7 @@ struct ICUListRange : public ICUDateFunc {
 		D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
 		D_ASSERT(args.ColumnCount() == 3);
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &bind_info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(bind_info.calendar->clone());
 		auto calendar = calendar_ptr.get();

package/src/duckdb/extension/icu/icu-makedate.cpp

@@ -35,7 +35,7 @@ struct ICUMakeTimestampTZFunc : public ICUDateFunc {
 
 	template <typename T>
 	static void Execute(DataChunk &input, ExpressionState &state, Vector &result) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();

package/src/duckdb/extension/icu/icu-strptime.cpp

@@ -28,7 +28,7 @@ struct ICUStrptime : public ICUDateFunc {
 		StrpTimeFormat format;
 
 		bool Equals(const FunctionData &other_p) const override {
-			auto &other = (ICUStrptimeBindData &)other_p;
+			auto &other = other_p.Cast<ICUStrptimeBindData>();
 			return format.format_specifier == other.format.format_specifier;
 		}
 		duckdb::unique_ptr<FunctionData> Copy() const override {
@@ -91,8 +91,8 @@ struct ICUStrptime : public ICUDateFunc {
 		auto &str_arg = args.data[0];
 		auto &fmt_arg = args.data[1];
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
-		auto &info = (ICUStrptimeBindData &)*func_expr.bind_info;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+		auto &info = func_expr.bind_info->Cast<ICUStrptimeBindData>();
 		CalendarPtr calendar(info.calendar->clone());
 		auto &format = info.format;
 
@@ -145,7 +145,7 @@ struct ICUStrptime : public ICUDateFunc {
 		auto &catalog = Catalog::GetSystemCatalog(context);
 		auto entry = catalog.GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, DEFAULT_SCHEMA, name);
 		D_ASSERT(entry && entry->type == CatalogType::SCALAR_FUNCTION_ENTRY);
-		auto &func = (ScalarFunctionCatalogEntry &)*entry;
+		auto &func = entry->Cast<ScalarFunctionCatalogEntry>();
 		vector<LogicalType> types {LogicalType::VARCHAR, LogicalType::VARCHAR};
 		string error;
 
@@ -162,7 +162,7 @@ struct ICUStrptime : public ICUDateFunc {
 	}
 
 	static bool CastFromVarchar(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		auto &cast_data = (CastData &)*parameters.cast_data;
+		auto &cast_data = parameters.cast_data->Cast<CastData>();
 		auto info = (BindData *)cast_data.info.get();
 		CalendarPtr cal(info->calendar->clone());
 
@@ -283,7 +283,7 @@ struct ICUStrftime : public ICUDateFunc {
 		auto &src_arg = args.data[0];
 		auto &fmt_arg = args.data[1];
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar(info.calendar->clone());
 		const auto tz_name = info.tz_setting.c_str();
@@ -389,7 +389,7 @@ struct ICUStrftime : public ICUDateFunc {
 	}
 
 	static bool CastToVarchar(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		auto &cast_data = (CastData &)*parameters.cast_data;
+		auto &cast_data = parameters.cast_data->Cast<CastData>();
 		auto info = (BindData *)cast_data.info.get();
 		CalendarPtr calendar(info->calendar->clone());
 

package/src/duckdb/extension/icu/icu-timebucket.cpp

@@ -125,7 +125,7 @@ struct ICUTimeBucket : public ICUDateFunc {
 	static void ExecuteBinary(DataChunk &args, ExpressionState &state, Vector &result) {
 		D_ASSERT(args.ColumnCount() == 2);
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar(info.calendar->clone());
 
@@ -138,7 +138,7 @@ struct ICUTimeBucket : public ICUDateFunc {
 	static void ExecuteTernary(DataChunk &args, ExpressionState &state, Vector &result) {
 		D_ASSERT(args.ColumnCount() == 3);
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar(info.calendar->clone());
 
@@ -357,7 +357,7 @@ struct ICUTimeBucket : public ICUDateFunc {
 	static void ICUTimeBucketFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 		D_ASSERT(args.ColumnCount() == 2);
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
@@ -413,7 +413,7 @@ struct ICUTimeBucket : public ICUDateFunc {
 	static void ICUTimeBucketOffsetFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 		D_ASSERT(args.ColumnCount() == 3);
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
@@ -478,7 +478,7 @@ struct ICUTimeBucket : public ICUDateFunc {
 	static void ICUTimeBucketOriginFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 		D_ASSERT(args.ColumnCount() == 3);
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
@@ -546,7 +546,7 @@ struct ICUTimeBucket : public ICUDateFunc {
 	static void ICUTimeBucketTimeZoneFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 		D_ASSERT(args.ColumnCount() == 3);
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();

package/src/duckdb/extension/icu/icu-timezone.cpp

@@ -124,7 +124,7 @@ struct ICUFromNaiveTimestamp : public ICUDateFunc {
 	}
 
 	static bool CastFromNaive(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		auto &cast_data = (CastData &)*parameters.cast_data;
+		auto &cast_data = parameters.cast_data->Cast<CastData>();
 		auto info = (BindData *)cast_data.info.get();
 		CalendarPtr calendar(info->calendar->clone());
 
@@ -187,7 +187,7 @@ struct ICUToNaiveTimestamp : public ICUDateFunc {
 	}
 
 	static bool CastToNaive(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		auto &cast_data = (CastData &)*parameters.cast_data;
+		auto &cast_data = parameters.cast_data->Cast<CastData>();
 		auto info = (BindData *)cast_data.info.get();
 		CalendarPtr calendar(info->calendar->clone());
 
@@ -246,7 +246,7 @@ struct ICULocalTimestampFunc : public ICUDateFunc {
 	}
 
 	static timestamp_t GetLocalTimestamp(ExpressionState &state) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindDataNow &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
@@ -295,7 +295,7 @@ struct ICULocalTimeFunc : public ICUDateFunc {
 struct ICUTimeZoneFunc : public ICUDateFunc {
 	template <typename OP>
 	static void Execute(DataChunk &input, ExpressionState &state, Vector &result) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();

package/src/duckdb/extension/json/include/json_executors.hpp

@@ -33,7 +33,7 @@ public:
 	template <class T>
 	static void BinaryExecute(DataChunk &args, ExpressionState &state, Vector &result,
 	                          std::function<T(yyjson_val *, yyjson_alc *, Vector &)> fun) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		const auto &info = (JSONReadFunctionData &)*func_expr.bind_info;
 		auto &lstate = JSONFunctionLocalState::ResetAndGet(state);
 		auto alc = lstate.json_allocator.GetYYJSONAllocator();
@@ -80,7 +80,7 @@ public:
 	template <class T>
 	static void ExecuteMany(DataChunk &args, ExpressionState &state, Vector &result,
 	                        std::function<T(yyjson_val *, yyjson_alc *, Vector &)> fun) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		const auto &info = (JSONReadManyFunctionData &)*func_expr.bind_info;
 		auto &lstate = JSONFunctionLocalState::ResetAndGet(state);
 		auto alc = lstate.json_allocator.GetYYJSONAllocator();

package/src/duckdb/extension/json/json_functions/copy_json.cpp

@@ -13,7 +13,7 @@ namespace duckdb {
 
 static BoundStatement CopyToJSONPlan(Binder &binder, CopyStatement &stmt) {
 	auto stmt_copy = stmt.Copy();
-	auto &copy = (CopyStatement &)*stmt_copy;
+	auto &copy = stmt_copy->Cast<CopyStatement>();
 	auto &info = *copy.info;
 
 	// Bind the select statement of the original to resolve the types
@@ -25,7 +25,7 @@ static BoundStatement CopyToJSONPlan(Binder &binder, CopyStatement &stmt) {
 	select_stmt->node = std::move(copy.select_statement);
 	auto subquery_ref = make_uniq<SubqueryRef>(std::move(select_stmt));
 	copy.select_statement = make_uniq_base<QueryNode, SelectNode>();
-	auto &new_select_node = (SelectNode &)*copy.select_statement;
+	auto &new_select_node = copy.select_statement->Cast<SelectNode>();
 	new_select_node.from_table = std::move(subquery_ref);
 
 	// Create new select list
@@ -56,8 +56,8 @@ static BoundStatement CopyToJSONPlan(Binder &binder, CopyStatement &stmt) {
 	}
 
 	// Now create the struct_pack/to_json to create a JSON object per row
-	auto &select_node = (SelectNode &)*copy.select_statement;
-	vector<duckdb::unique_ptr<ParsedExpression>> struct_pack_child;
+	auto &select_node = copy.select_statement->Cast<SelectNode>();
+	vector<unique_ptr<ParsedExpression>> struct_pack_child;
 	struct_pack_child.emplace_back(make_uniq<FunctionExpression>("struct_pack", std::move(select_list)));
 	select_node.select_list.emplace_back(make_uniq<FunctionExpression>("to_json", std::move(struct_pack_child)));
 

package/src/duckdb/extension/json/json_functions/json_create.cpp

@@ -421,7 +421,7 @@ static void CreateValues(const JSONCreateFunctionData &info, yyjson_mut_doc *doc
 }
 
 static void ObjectFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	const auto &info = (JSONCreateFunctionData &)*func_expr.bind_info;
 	auto &lstate = JSONFunctionLocalState::ResetAndGet(state);
 	auto alc = lstate.json_allocator.GetYYJSONAllocator();
@@ -453,7 +453,7 @@ static void ObjectFunction(DataChunk &args, ExpressionState &state, Vector &resu
 }
 
 static void ArrayFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	const auto &info = (JSONCreateFunctionData &)*func_expr.bind_info;
 	auto &lstate = JSONFunctionLocalState::ResetAndGet(state);
 	auto alc = lstate.json_allocator.GetYYJSONAllocator();
@@ -486,7 +486,7 @@ static void ArrayFunction(DataChunk &args, ExpressionState &state, Vector &resul
 }
 
 static void ToJSONFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	const auto &info = (JSONCreateFunctionData &)*func_expr.bind_info;
 	auto &lstate = JSONFunctionLocalState::ResetAndGet(state);
 	auto alc = lstate.json_allocator.GetYYJSONAllocator();

package/src/duckdb/extension/json/json_functions/json_serialize_sql.cpp

@@ -74,8 +74,8 @@ static void JsonSerializeFunction(DataChunk &args, ExpressionState &state, Vecto
 	auto alc = local_state.json_allocator.GetYYJSONAllocator();
 	auto &inputs = args.data[0];
 
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	const auto &info = (JsonSerializeBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	const auto &info = func_expr.bind_info->Cast<JsonSerializeBindData>();
 
 	UnaryExecutor::Execute<string_t, string_t>(inputs, result, args.size(), [&](string_t input) {
 		auto doc = JSONCommon::CreateDocument(alc);
@@ -92,7 +92,7 @@ static void JsonSerializeFunction(DataChunk &args, ExpressionState &state, Vecto
 				if (statement->type != StatementType::SELECT_STATEMENT) {
 					throw NotImplementedException("Only SELECT statements can be serialized to json!");
 				}
-				auto &select = (SelectStatement &)*statement;
+				auto &select = statement->Cast<SelectStatement>();
 				auto serializer = JsonSerializer(doc, info.skip_if_null, info.skip_if_empty);
 				select.FormatSerialize(serializer);
 				auto json = serializer.GetRootObject();

package/src/duckdb/extension/json/json_functions.cpp

@@ -115,7 +115,7 @@ unique_ptr<FunctionLocalState> JSONFunctionLocalState::Init(ExpressionState &sta
 }
 
 JSONFunctionLocalState &JSONFunctionLocalState::ResetAndGet(ExpressionState &state) {
-	auto &lstate = (JSONFunctionLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<JSONFunctionLocalState>();
 	lstate.json_allocator.Reset();
 	return lstate;
 }
@@ -197,7 +197,7 @@ static duckdb::unique_ptr<FunctionLocalState> InitJSONCastLocalState(CastLocalSt
 }
 
 static bool CastVarcharToJSON(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &lstate = (JSONFunctionLocalState &)*parameters.local_state;
+	auto &lstate = parameters.local_state->Cast<JSONFunctionLocalState>();
 	lstate.json_allocator.Reset();
 	auto alc = lstate.json_allocator.GetYYJSONAllocator();
 

package/src/duckdb/extension/parquet/parquet-extension.cpp

@@ -143,15 +143,15 @@ void ParquetOptions::Deserialize(FieldReader &reader) {
 
 BindInfo ParquetGetBatchInfo(const FunctionData *bind_data) {
 	auto bind_info = BindInfo(ScanType::PARQUET);
-	auto parquet_bind = (ParquetReadBindData *)bind_data;
+	auto &parquet_bind = bind_data->Cast<ParquetReadBindData>();
 	vector<Value> file_path;
-	for (auto &path : parquet_bind->files) {
+	for (auto &path : parquet_bind.files) {
 		file_path.emplace_back(path);
 	}
 	bind_info.InsertOption("file_path", Value::LIST(LogicalType::VARCHAR, file_path));
-	bind_info.InsertOption("binary_as_string", Value::BOOLEAN(parquet_bind->parquet_options.binary_as_string));
-	bind_info.InsertOption("file_row_number", Value::BOOLEAN(parquet_bind->parquet_options.file_row_number));
-	parquet_bind->parquet_options.file_options.AddBatchInfo(bind_info);
+	bind_info.InsertOption("binary_as_string", Value::BOOLEAN(parquet_bind.parquet_options.binary_as_string));
+	bind_info.InsertOption("file_row_number", Value::BOOLEAN(parquet_bind.parquet_options.file_row_number));
+	parquet_bind.parquet_options.file_options.AddBatchInfo(bind_info);
 	return bind_info;
 }
 
@@ -205,7 +205,7 @@ public:
 
 	static unique_ptr<BaseStatistics> ParquetScanStats(ClientContext &context, const FunctionData *bind_data_p,
 	                                                   column_t column_index) {
-		auto &bind_data = (ParquetReadBindData &)*bind_data_p;
+		auto &bind_data = bind_data_p->Cast<ParquetReadBindData>();
 
 		if (IsRowIdColumnId(column_index)) {
 			return nullptr;
@@ -308,7 +308,7 @@ public:
 
 	static double ParquetProgress(ClientContext &context, const FunctionData *bind_data_p,
 	                              const GlobalTableFunctionState *global_state) {
-		auto &bind_data = (ParquetReadBindData &)*bind_data_p;
+		auto &bind_data = bind_data_p->Cast<ParquetReadBindData>();
 		if (bind_data.files.empty()) {
 			return 100.0;
 		}
@@ -323,8 +323,8 @@ public:
 
 	static unique_ptr<LocalTableFunctionState>
 	ParquetScanInitLocal(ExecutionContext &context, TableFunctionInitInput &input, GlobalTableFunctionState *gstate_p) {
-		auto &bind_data = (ParquetReadBindData &)*input.bind_data;
-		auto &gstate = (ParquetReadGlobalState &)*gstate_p;
+		auto &bind_data = input.bind_data->Cast<ParquetReadBindData>();
+		auto &gstate = gstate_p->Cast<ParquetReadGlobalState>();
 
 		auto result = make_uniq<ParquetReadLocalState>();
 		result->is_parallel = true;
@@ -394,13 +394,13 @@ public:
 	static idx_t ParquetScanGetBatchIndex(ClientContext &context, const FunctionData *bind_data_p,
 	                                      LocalTableFunctionState *local_state,
 	                                      GlobalTableFunctionState *global_state) {
-		auto &data = (ParquetReadLocalState &)*local_state;
+		auto &data = local_state->Cast<ParquetReadLocalState>();
 		return data.batch_index;
 	}
 
 	static void ParquetScanSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
 	                                 const TableFunction &function) {
-		auto &bind_data = (ParquetReadBindData &)*bind_data_p;
+		auto &bind_data = bind_data_p->Cast<ParquetReadBindData>();
 		writer.WriteList<string>(bind_data.files);
 		writer.WriteRegularSerializableList(bind_data.types);
 		writer.WriteList<string>(bind_data.names);
@@ -422,9 +422,9 @@ public:
 		if (!data_p.local_state) {
 			return;
 		}
-		auto &data = (ParquetReadLocalState &)*data_p.local_state;
-		auto &gstate = (ParquetReadGlobalState &)*data_p.global_state;
-		auto &bind_data = (ParquetReadBindData &)*data_p.bind_data;
+		auto &data = data_p.local_state->Cast<ParquetReadLocalState>();
+		auto &gstate = data_p.global_state->Cast<ParquetReadGlobalState>();
+		auto &bind_data = data_p.bind_data->CastNoConst<ParquetReadBindData>();
 
 		do {
 			if (gstate.CanRemoveFilterColumns()) {
@@ -448,12 +448,12 @@ public:
 	}
 
 	static unique_ptr<NodeStatistics> ParquetCardinality(ClientContext &context, const FunctionData *bind_data) {
-		auto &data = (ParquetReadBindData &)*bind_data;
+		auto &data = bind_data->Cast<ParquetReadBindData>();
 		return make_uniq<NodeStatistics>(data.initial_file_cardinality * data.files.size());
 	}
 
 	static idx_t ParquetScanMaxThreads(ClientContext &context, const FunctionData *bind_data) {
-		auto &data = (ParquetReadBindData &)*bind_data;
+		auto &data = bind_data->Cast<ParquetReadBindData>();
 		return data.initial_file_row_groups * data.files.size();
 	}
 
@@ -513,11 +513,11 @@ public:
 
 	static void ParquetComplexFilterPushdown(ClientContext &context, LogicalGet &get, FunctionData *bind_data_p,
 	                                         vector<unique_ptr<Expression>> &filters) {
-		auto data = (ParquetReadBindData *)bind_data_p;
-		auto reset_reader = MultiFileReader::ComplexFilterPushdown(context, data->files,
-		                                                           data->parquet_options.file_options, get, filters);
+		auto &data = bind_data_p->Cast<ParquetReadBindData>();
+		auto reset_reader = MultiFileReader::ComplexFilterPushdown(context, data.files,
+		                                                           data.parquet_options.file_options, get, filters);
 		if (reset_reader) {
-			MultiFileReader::PruneReaders(*data);
+			MultiFileReader::PruneReaders(data);
 		}
 	}
 
@@ -618,7 +618,7 @@ unique_ptr<FunctionData> ParquetWriteBind(ClientContext &context, CopyInfo &info
 unique_ptr<GlobalFunctionData> ParquetWriteInitializeGlobal(ClientContext &context, FunctionData &bind_data,
                                                             const string &file_path) {
 	auto global_state = make_uniq<ParquetWriteGlobalState>();
-	auto &parquet_bind = (ParquetWriteBindData &)bind_data;
+	auto &parquet_bind = bind_data.Cast<ParquetWriteBindData>();
 
 	auto &fs = FileSystem::GetFileSystem(context);
 	global_state->writer =
@@ -629,9 +629,9 @@ unique_ptr<GlobalFunctionData> ParquetWriteInitializeGlobal(ClientContext &conte
 
 void ParquetWriteSink(ExecutionContext &context, FunctionData &bind_data_p, GlobalFunctionData &gstate,
                       LocalFunctionData &lstate, DataChunk &input) {
-	auto &bind_data = (ParquetWriteBindData &)bind_data_p;
-	auto &global_state = (ParquetWriteGlobalState &)gstate;
-	auto &local_state = (ParquetWriteLocalState &)lstate;
+	auto &bind_data = bind_data_p.Cast<ParquetWriteBindData>();
+	auto &global_state = gstate.Cast<ParquetWriteGlobalState>();
+	auto &local_state = lstate.Cast<ParquetWriteLocalState>();
 
 	// append data to the local (buffered) chunk collection
 	local_state.buffer.Append(input);
@@ -645,20 +645,20 @@ void ParquetWriteSink(ExecutionContext &context, FunctionData &bind_data_p, Glob
 
 void ParquetWriteCombine(ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
                          LocalFunctionData &lstate) {
-	auto &global_state = (ParquetWriteGlobalState &)gstate;
-	auto &local_state = (ParquetWriteLocalState &)lstate;
+	auto &global_state = gstate.Cast<ParquetWriteGlobalState>();
+	auto &local_state = lstate.Cast<ParquetWriteLocalState>();
 	// flush any data left in the local state to the file
 	global_state.writer->Flush(local_state.buffer);
 }
 
 void ParquetWriteFinalize(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate) {
-	auto &global_state = (ParquetWriteGlobalState &)gstate;
+	auto &global_state = gstate.Cast<ParquetWriteGlobalState>();
 	// finalize: write any additional metadata to the file here
 	global_state.writer->Finalize();
 }
 
 unique_ptr<LocalFunctionData> ParquetWriteInitializeLocal(ExecutionContext &context, FunctionData &bind_data_p) {
-	auto &bind_data = (ParquetWriteBindData &)bind_data_p;
+	auto &bind_data = bind_data_p.Cast<ParquetWriteBindData>();
 	return make_uniq<ParquetWriteLocalState>(context.client, bind_data.sql_types);
 }
 

package/src/duckdb/extension/parquet/parquet_metadata.cpp

@@ -418,7 +418,7 @@ unique_ptr<FunctionData> ParquetMetaDataBind(ClientContext &context, TableFuncti
 
 template <bool SCHEMA>
 unique_ptr<GlobalTableFunctionState> ParquetMetaDataInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = (ParquetMetaDataBindData &)*input.bind_data;
+	auto &bind_data = input.bind_data->Cast<ParquetMetaDataBindData>();
 	D_ASSERT(!bind_data.files.empty());
 
 	auto result = make_uniq<ParquetMetaDataOperatorData>(context, bind_data.return_types);
@@ -433,8 +433,8 @@ unique_ptr<GlobalTableFunctionState> ParquetMetaDataInit(ClientContext &context,
 
 template <bool SCHEMA>
 void ParquetMetaDataImplementation(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (ParquetMetaDataOperatorData &)*data_p.global_state;
-	auto &bind_data = (ParquetMetaDataBindData &)*data_p.bind_data;
+	auto &data = data_p.global_state->Cast<ParquetMetaDataOperatorData>();
+	auto &bind_data = data_p.bind_data->Cast<ParquetMetaDataBindData>();
 
 	while (true) {
 		if (!data.collection.Scan(data.scan_state, output)) {

package/src/duckdb/src/catalog/catalog_entry/duck_index_entry.cpp

@@ -16,11 +16,11 @@ DuckIndexEntry::~DuckIndexEntry() {
 	info->indexes.RemoveIndex(index);
 }
 
-string DuckIndexEntry::GetSchemaName() {
+string DuckIndexEntry::GetSchemaName() const {
 	return info->schema;
 }
 
-string DuckIndexEntry::GetTableName() {
+string DuckIndexEntry::GetTableName() const {
 	return info->table;
 }