duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

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

@@ -21,37 +21,37 @@ void BuiltinFunctions::AddCollation(string name, ScalarFunction function, bool c
                                     bool not_required_for_equality) {
 	CreateCollationInfo info(std::move(name), std::move(function), combinable, not_required_for_equality);
 	info.internal = true;
-	catalog.CreateCollation(transaction, &info);
+	catalog.CreateCollation(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(AggregateFunctionSet set) {
 	CreateAggregateFunctionInfo info(std::move(set));
 	info.internal = true;
-	catalog.CreateFunction(transaction, &info);
+	catalog.CreateFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(AggregateFunction function) {
 	CreateAggregateFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreateFunction(transaction, &info);
+	catalog.CreateFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(PragmaFunction function) {
 	CreatePragmaFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreatePragmaFunction(transaction, &info);
+	catalog.CreatePragmaFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(const string &name, PragmaFunctionSet functions) {
 	CreatePragmaFunctionInfo info(name, std::move(functions));
 	info.internal = true;
-	catalog.CreatePragmaFunction(transaction, &info);
+	catalog.CreatePragmaFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(ScalarFunction function) {
 	CreateScalarFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreateFunction(transaction, &info);
+	catalog.CreateFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(const vector<string> &names, ScalarFunction function) { // NOLINT: false positive
@@ -64,25 +64,25 @@ void BuiltinFunctions::AddFunction(const vector<string> &names, ScalarFunction f
 void BuiltinFunctions::AddFunction(ScalarFunctionSet set) {
 	CreateScalarFunctionInfo info(std::move(set));
 	info.internal = true;
-	catalog.CreateFunction(transaction, &info);
+	catalog.CreateFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(TableFunction function) {
 	CreateTableFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreateTableFunction(transaction, &info);
+	catalog.CreateTableFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(TableFunctionSet set) {
 	CreateTableFunctionInfo info(std::move(set));
 	info.internal = true;
-	catalog.CreateTableFunction(transaction, &info);
+	catalog.CreateTableFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(CopyFunction function) {
 	CreateCopyFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreateCopyFunction(transaction, &info);
+	catalog.CreateCopyFunction(transaction, info);
 }
 
 } // namespace duckdb

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

@@ -6,7 +6,8 @@
 
 namespace duckdb {
 
-BindCastInput::BindCastInput(CastFunctionSet &function_set, BindCastInfo *info, ClientContext *context)
+BindCastInput::BindCastInput(CastFunctionSet &function_set, optional_ptr<BindCastInfo> info,
+                             optional_ptr<ClientContext> context)
     : function_set(function_set), info(info), context(context) {
 }
 
@@ -117,7 +118,7 @@ void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const Logi
 void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const LogicalType &target, MapCastNode node) {
 	if (!map_info) {
 		// create the cast map and the cast map function
-		auto info = make_unique<MapCastInfo>();
+		auto info = make_uniq<MapCastInfo>();
 		map_info = info.get();
 		bind_functions.emplace_back(MapCastFunction, std::move(info));
 	}

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

@@ -99,27 +99,49 @@ struct EnumBoundCastData : public BoundCastData {
 
 public:
 	unique_ptr<BoundCastData> Copy() const override {
-		return make_unique<EnumBoundCastData>(to_varchar_cast.Copy(), from_varchar_cast.Copy());
+		return make_uniq<EnumBoundCastData>(to_varchar_cast.Copy(), from_varchar_cast.Copy());
 	}
 };
 
 unique_ptr<BoundCastData> BindEnumCast(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	auto to_varchar_cast = input.GetCastFunction(source, LogicalType::VARCHAR);
 	auto from_varchar_cast = input.GetCastFunction(LogicalType::VARCHAR, target);
-	return make_unique<EnumBoundCastData>(std::move(to_varchar_cast), std::move(from_varchar_cast));
+	return make_uniq<EnumBoundCastData>(std::move(to_varchar_cast), std::move(from_varchar_cast));
+}
+
+struct EnumCastLocalState : public FunctionLocalState {
+public:
+	unique_ptr<FunctionLocalState> to_varchar_local;
+	unique_ptr<FunctionLocalState> from_varchar_local;
+};
+
+static unique_ptr<FunctionLocalState> InitEnumCastLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = parameters.cast_data->Cast<EnumBoundCastData>();
+	auto result = make_uniq<EnumCastLocalState>();
+
+	if (cast_data.from_varchar_cast.init_local_state) {
+		CastLocalStateParameters from_varchar_params(parameters, cast_data.from_varchar_cast.cast_data);
+		result->from_varchar_local = cast_data.from_varchar_cast.init_local_state(from_varchar_params);
+	}
+	if (cast_data.to_varchar_cast.init_local_state) {
+		CastLocalStateParameters from_varchar_params(parameters, cast_data.to_varchar_cast.cast_data);
+		result->from_varchar_local = cast_data.to_varchar_cast.init_local_state(from_varchar_params);
+	}
+	return std::move(result);
 }
 
 static bool EnumToAnyCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = (EnumBoundCastData &)*parameters.cast_data;
+	auto &cast_data = parameters.cast_data->Cast<EnumBoundCastData>();
+	auto &lstate = parameters.local_state->Cast<EnumCastLocalState>();
 
 	Vector varchar_cast(LogicalType::VARCHAR, count);
 
 	// cast to varchar
-	CastParameters to_varchar_params(parameters, cast_data.to_varchar_cast.cast_data.get());
+	CastParameters to_varchar_params(parameters, cast_data.to_varchar_cast.cast_data, lstate.to_varchar_local);
 	cast_data.to_varchar_cast.function(source, varchar_cast, count, to_varchar_params);
 
 	// cast from varchar to the target
-	CastParameters from_varchar_params(parameters, cast_data.from_varchar_cast.cast_data.get());
+	CastParameters from_varchar_params(parameters, cast_data.from_varchar_cast.cast_data, lstate.from_varchar_local);
 	cast_data.from_varchar_cast.function(varchar_cast, result, count, from_varchar_params);
 	return true;
 }
@@ -152,7 +174,7 @@ BoundCastInfo DefaultCasts::EnumCastSwitch(BindCastInput &input, const LogicalTy
 			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
 		}
 	default: {
-		return BoundCastInfo(EnumToAnyCast, BindEnumCast(input, source, target));
+		return BoundCastInfo(EnumToAnyCast, BindEnumCast(input, source, target), InitEnumCastLocalState);
 	}
 	}
 }

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

@@ -1,5 +1,6 @@
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
 
 namespace duckdb {
 
@@ -9,11 +10,20 @@ unique_ptr<BoundCastData> ListBoundCastData::BindListToListCast(BindCastInput &i
 	auto &source_child_type = ListType::GetChildType(source);
 	auto &result_child_type = ListType::GetChildType(target);
 	auto child_cast = input.GetCastFunction(source_child_type, result_child_type);
-	return make_unique<ListBoundCastData>(std::move(child_cast));
+	return make_uniq<ListBoundCastData>(std::move(child_cast));
+}
+
+unique_ptr<FunctionLocalState> ListBoundCastData::InitListLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = parameters.cast_data->Cast<ListBoundCastData>();
+	if (!cast_data.child_cast_info.init_local_state) {
+		return nullptr;
+	}
+	CastLocalStateParameters child_parameters(parameters, cast_data.child_cast_info.cast_data);
+	return cast_data.child_cast_info.init_local_state(child_parameters);
 }
 
 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) {
@@ -40,7 +50,7 @@ bool ListCast::ListToListCast(Vector &source, Vector &result, idx_t count, CastP
 	ListVector::Reserve(result, source_size);
 	auto &append_vector = ListVector::GetEntry(result);
 
-	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data.get());
+	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
 	if (!cast_data.child_cast_info.function(source_cc, append_vector, source_size, child_parameters)) {
 		return false;
 	}
@@ -96,7 +106,7 @@ static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastP
 			}
 			if (child_validity.RowIsValid(idx)) {
 				auto len = child_data[idx].GetSize();
-				memcpy(dataptr + offset, child_data[idx].GetDataUnsafe(), len);
+				memcpy(dataptr + offset, child_data[idx].GetData(), len);
 				offset += len;
 			} else {
 				memcpy(dataptr + offset, "NULL", NULL_LENGTH);
@@ -116,10 +126,13 @@ static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastP
 BoundCastInfo DefaultCasts::ListCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	switch (target.id()) {
 	case LogicalTypeId::LIST:
-		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target));
+		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target),
+		                     ListBoundCastData::InitListLocalState);
 	case LogicalTypeId::VARCHAR:
-		return BoundCastInfo(ListToVarcharCast, ListBoundCastData::BindListToListCast(
-		                                            input, source, LogicalType::LIST(LogicalType::VARCHAR)));
+		return BoundCastInfo(
+		    ListToVarcharCast,
+		    ListBoundCastData::BindListToListCast(input, source, LogicalType::LIST(LogicalType::VARCHAR)),
+		    ListBoundCastData::InitListLocalState);
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

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

@@ -1,5 +1,6 @@
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
 
 namespace duckdb {
 
@@ -12,7 +13,7 @@ unique_ptr<BoundCastData> MapBoundCastData::BindMapToMapCast(BindCastInput &inpu
 	auto target_val = MapType::ValueType(target);
 	auto key_cast = input.GetCastFunction(source_key, target_key);
 	auto value_cast = input.GetCastFunction(source_val, target_val);
-	return make_unique<MapBoundCastData>(std::move(key_cast), std::move(value_cast));
+	return make_uniq<MapBoundCastData>(std::move(key_cast), std::move(value_cast));
 }
 
 static bool MapToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
@@ -78,10 +79,12 @@ static bool MapToVarcharCast(Vector &source, Vector &result, idx_t count, CastPa
 BoundCastInfo DefaultCasts::MapCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	switch (target.id()) {
 	case LogicalTypeId::MAP:
-		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target));
+		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target),
+		                     ListBoundCastData::InitListLocalState);
 	case LogicalTypeId::VARCHAR: {
 		auto varchar_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-		return BoundCastInfo(MapToVarcharCast, ListBoundCastData::BindListToListCast(input, source, varchar_type));
+		return BoundCastInfo(MapToVarcharCast, ListBoundCastData::BindListToListCast(input, source, varchar_type),
+		                     ListBoundCastData::InitListLocalState);
 	}
 	default:
 		return TryVectorNullCast;

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

@@ -3,6 +3,7 @@
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
 
 namespace duckdb {
 
@@ -115,7 +116,9 @@ static BoundCastInfo VectorStringCastNumericSwitch(BindCastInput &input, const L
 	}
 }
 
+//===--------------------------------------------------------------------===//
 // string -> list casting
+//===--------------------------------------------------------------------===//
 bool VectorStringToList::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
                                                     ValidityMask &result_mask, idx_t count, CastParameters &parameters,
                                                     const SelectionVector *sel) {
@@ -162,8 +165,8 @@ 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;
-	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data.get());
+	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;
 }
@@ -177,11 +180,12 @@ static LogicalType InitVarcharStructType(const LogicalType &target) {
 	return LogicalType::STRUCT(child_types);
 }
 
+//===--------------------------------------------------------------------===//
 // string -> struct casting
+//===--------------------------------------------------------------------===//
 bool VectorStringToStruct::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
                                                       ValidityMask &result_mask, idx_t count,
                                                       CastParameters &parameters, const SelectionVector *sel) {
-
 	auto varchar_struct_type = InitVarcharStructType(result.GetType());
 	Vector varchar_vector(varchar_struct_type, count);
 	auto &child_vectors = StructVector::GetEntries(varchar_vector);
@@ -215,22 +219,40 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(string_t *source_data, Val
 		}
 	}
 
-	auto &cast_data = (StructBoundCastData &)*parameters.cast_data;
+	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++) {
-		auto &varchar_vector = *child_vectors[child_idx];
+		auto &child_varchar_vector = *child_vectors[child_idx];
 		auto &result_child_vector = *result_children[child_idx];
 		auto &child_cast_info = cast_data.child_cast_info[child_idx];
-		CastParameters child_parameters(parameters, child_cast_info.cast_data.get());
-		if (!child_cast_info.function(varchar_vector, result_child_vector, count, child_parameters)) {
+		CastParameters child_parameters(parameters, child_cast_info.cast_data, lstate.local_states[child_idx]);
+		if (!child_cast_info.function(child_varchar_vector, result_child_vector, count, child_parameters)) {
 			all_converted = false;
 		}
 	}
 	return all_converted;
 }
 
+//===--------------------------------------------------------------------===//
 // string -> map casting
+//===--------------------------------------------------------------------===//
+unique_ptr<FunctionLocalState> InitMapCastLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = parameters.cast_data->Cast<MapBoundCastData>();
+	auto result = make_uniq<MapCastLocalState>();
+
+	if (cast_data.key_cast.init_local_state) {
+		CastLocalStateParameters child_params(parameters, cast_data.key_cast.cast_data);
+		result->key_state = cast_data.key_cast.init_local_state(child_params);
+	}
+	if (cast_data.value_cast.init_local_state) {
+		CastLocalStateParameters child_params(parameters, cast_data.value_cast.cast_data);
+		result->value_state = cast_data.value_cast.init_local_state(child_params);
+	}
+	return std::move(result);
+}
+
 bool VectorStringToMap::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
                                                    ValidityMask &result_mask, idx_t count, CastParameters &parameters,
                                                    const SelectionVector *sel) {
@@ -281,13 +303,14 @@ 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 &cast_data = parameters.cast_data->Cast<MapBoundCastData>();
+	auto &lstate = parameters.local_state->Cast<MapCastLocalState>();
 
-	CastParameters key_params(parameters, cast_data.key_cast.cast_data.get());
+	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)) {
 		all_converted = false;
 	}
-	CastParameters val_params(parameters, cast_data.value_cast.cast_data.get());
+	CastParameters val_params(parameters, cast_data.value_cast.cast_data, lstate.value_state);
 	if (!cast_data.value_cast.function(varchar_val_vector, result_val_child, total_elements, val_params)) {
 		all_converted = false;
 	}
@@ -307,7 +330,7 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(string_t *source_data, Validi
 			}
 		}
 	}
-	MapConversionVerify(result, count);
+	MapVector::MapConversionVerify(result, count);
 	return all_converted;
 }
 
@@ -373,14 +396,17 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 		// the second argument allows for a secondary casting function to be passed in the CastParameters
 		return BoundCastInfo(
 		    &StringToNestedTypeCast<VectorStringToList>,
-		    ListBoundCastData::BindListToListCast(input, LogicalType::LIST(LogicalType::VARCHAR), target));
+		    ListBoundCastData::BindListToListCast(input, LogicalType::LIST(LogicalType::VARCHAR), target),
+		    ListBoundCastData::InitListLocalState);
 	case LogicalTypeId::STRUCT:
 		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToStruct>,
-		                     StructBoundCastData::BindStructToStructCast(input, InitVarcharStructType(target), target));
+		                     StructBoundCastData::BindStructToStructCast(input, InitVarcharStructType(target), target),
+		                     StructBoundCastData::InitStructCastLocalState);
 	case LogicalTypeId::MAP:
 		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToMap>,
 		                     MapBoundCastData::BindMapToMapCast(
-		                         input, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR), target));
+		                         input, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR), target),
+		                     InitMapCastLocalState);
 	default:
 		return VectorStringCastNumericSwitch(input, source, target);
 	}

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

@@ -1,5 +1,6 @@
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
 
 namespace duckdb {
 
@@ -15,11 +16,27 @@ unique_ptr<BoundCastData> StructBoundCastData::BindStructToStructCast(BindCastIn
 		auto child_cast = input.GetCastFunction(source_child_types[i].second, result_child_types[i].second);
 		child_cast_info.push_back(std::move(child_cast));
 	}
-	return make_unique<StructBoundCastData>(std::move(child_cast_info), target);
+	return make_uniq<StructBoundCastData>(std::move(child_cast_info), target);
+}
+
+unique_ptr<FunctionLocalState> StructBoundCastData::InitStructCastLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = parameters.cast_data->Cast<StructBoundCastData>();
+	auto result = make_uniq<StructCastLocalState>();
+
+	for (auto &entry : cast_data.child_cast_info) {
+		unique_ptr<FunctionLocalState> child_state;
+		if (entry.init_local_state) {
+			CastLocalStateParameters child_params(parameters, entry.cast_data);
+			child_state = entry.init_local_state(child_params);
+		}
+		result->local_states.push_back(std::move(child_state));
+	}
+	return std::move(result);
 }
 
 static bool StructToStructCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = (StructBoundCastData &)*parameters.cast_data;
+	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());
@@ -29,7 +46,8 @@ static bool StructToStructCast(Vector &source, Vector &result, idx_t count, Cast
 	for (idx_t c_idx = 0; c_idx < source_child_types.size(); c_idx++) {
 		auto &result_child_vector = *result_children[c_idx];
 		auto &source_child_vector = *source_children[c_idx];
-		CastParameters child_parameters(parameters, cast_data.child_cast_info[c_idx].cast_data.get());
+		CastParameters child_parameters(parameters, cast_data.child_cast_info[c_idx].cast_data,
+		                                lstate.local_states[c_idx]);
 		if (!cast_data.child_cast_info[c_idx].function(source_child_vector, result_child_vector, count,
 		                                               child_parameters)) {
 			all_converted = false;
@@ -48,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);
 
@@ -100,7 +118,7 @@ static bool StructToVarcharCast(Vector &source, Vector &result, idx_t count, Cas
 			// value
 			if (child_validity.RowIsValid(i)) {
 				auto len = data[i].GetSize();
-				memcpy(dataptr + offset, data[i].GetDataUnsafe(), len);
+				memcpy(dataptr + offset, data[i].GetData(), len);
 				offset += len;
 			} else {
 				memcpy(dataptr + offset, "NULL", NULL_LENGTH);
@@ -121,7 +139,8 @@ BoundCastInfo DefaultCasts::StructCastSwitch(BindCastInput &input, const Logical
                                              const LogicalType &target) {
 	switch (target.id()) {
 	case LogicalTypeId::STRUCT:
-		return BoundCastInfo(StructToStructCast, StructBoundCastData::BindStructToStructCast(input, source, target));
+		return BoundCastInfo(StructToStructCast, StructBoundCastData::BindStructToStructCast(input, source, target),
+		                     StructBoundCastData::InitStructCastLocalState);
 	case LogicalTypeId::VARCHAR: {
 		// bind a cast in which we convert all child entries to VARCHAR entries
 		auto &struct_children = StructType::GetChildTypes(source);
@@ -129,9 +148,10 @@ BoundCastInfo DefaultCasts::StructCastSwitch(BindCastInput &input, const Logical
 		for (auto &child_entry : struct_children) {
 			varchar_children.push_back(make_pair(child_entry.first, LogicalType::VARCHAR));
 		}
-		auto varchar_type = LogicalType::STRUCT(std::move(varchar_children));
+		auto varchar_type = LogicalType::STRUCT(varchar_children);
 		return BoundCastInfo(StructToVarcharCast,
-		                     StructBoundCastData::BindStructToStructCast(input, source, varchar_type));
+		                     StructBoundCastData::BindStructToStructCast(input, source, varchar_type),
+		                     StructBoundCastData::InitStructCastLocalState);
 	}
 	default:
 		return TryVectorNullCast;

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

@@ -69,7 +69,7 @@ BoundCastInfo DefaultCasts::TimestampCastSwitch(BindCastInput &input, const Logi
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
 	case LogicalTypeId::TIMESTAMP_TZ:
 		// timestamp (us) to timestamp with time zone
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::Cast>);
+		return ReinterpretCast;
 	case LogicalTypeId::TIMESTAMP_NS:
 		// timestamp (us) to timestamp (ns)
 		return BoundCastInfo(
@@ -100,7 +100,7 @@ BoundCastInfo DefaultCasts::TimestampTzCastSwitch(BindCastInput &input, const Lo
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
 	case LogicalTypeId::TIMESTAMP:
 		// timestamp with time zone to timestamp (us)
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::Cast>);
+		return ReinterpretCast;
 	default:
 		return TryVectorNullCast;
 	}

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

@@ -1,6 +1,6 @@
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
 
 #include <algorithm> // for std::sort
 
@@ -26,7 +26,7 @@ struct ToUnionBoundCastData : public BoundCastData {
 
 public:
 	unique_ptr<BoundCastData> Copy() const override {
-		return make_unique<ToUnionBoundCastData>(tag, name, type, cost, member_cast_info.Copy());
+		return make_uniq<ToUnionBoundCastData>(tag, name, type, cost, member_cast_info.Copy());
 	}
 
 	static bool SortByCostAscending(const ToUnionBoundCastData &left, const ToUnionBoundCastData &right) {
@@ -95,15 +95,24 @@ unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalTyp
 	}
 
 	// otherwise, return the selected cast
-	return make_unique<ToUnionBoundCastData>(std::move(selected_cast));
+	return make_uniq<ToUnionBoundCastData>(std::move(selected_cast));
+}
+
+unique_ptr<FunctionLocalState> InitToUnionLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = parameters.cast_data->Cast<ToUnionBoundCastData>();
+	if (!cast_data.member_cast_info.init_local_state) {
+		return nullptr;
+	}
+	CastLocalStateParameters child_parameters(parameters, cast_data.member_cast_info.cast_data);
+	return cast_data.member_cast_info.init_local_state(child_parameters);
 }
 
 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.get());
+	CastParameters child_parameters(parameters, cast_data.member_cast_info.cast_data, parameters.local_state);
 	if (!cast_data.member_cast_info.function(source, selected_member_vector, count, child_parameters)) {
 		return false;
 	}
@@ -118,7 +127,7 @@ static bool ToUnionCast(Vector &source, Vector &result, idx_t count, CastParamet
 
 BoundCastInfo DefaultCasts::ImplicitToUnionCast(BindCastInput &input, const LogicalType &source,
                                                 const LogicalType &target) {
-	return BoundCastInfo(&ToUnionCast, BindToUnionCast(input, source, target));
+	return BoundCastInfo(&ToUnionCast, BindToUnionCast(input, source, target), InitToUnionLocalState);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -154,7 +163,7 @@ public:
 		for (auto &member_cast : member_casts) {
 			member_casts_copy.push_back(member_cast.Copy());
 		}
-		return make_unique<UnionToUnionBoundCastData>(tag_map, std::move(member_casts_copy), target_type);
+		return make_uniq<UnionToUnionBoundCastData>(tag_map, std::move(member_casts_copy), target_type);
 	}
 };
 
@@ -194,11 +203,27 @@ unique_ptr<BoundCastData> BindUnionToUnionCast(BindCastInput &input, const Logic
 		}
 	}
 
-	return make_unique<UnionToUnionBoundCastData>(tag_map, std::move(member_casts), target);
+	return make_uniq<UnionToUnionBoundCastData>(tag_map, std::move(member_casts), target);
+}
+
+unique_ptr<FunctionLocalState> InitUnionToUnionLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = parameters.cast_data->Cast<UnionToUnionBoundCastData>();
+	auto result = make_uniq<StructCastLocalState>();
+
+	for (auto &entry : cast_data.member_casts) {
+		unique_ptr<FunctionLocalState> child_state;
+		if (entry.init_local_state) {
+			CastLocalStateParameters child_params(parameters, entry.cast_data);
+			child_state = entry.init_local_state(child_params);
+		}
+		result->local_states.push_back(std::move(child_state));
+	}
+	return std::move(result);
 }
 
 static bool UnionToUnionCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = (UnionToUnionBoundCastData &)*parameters.cast_data;
+	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());
@@ -213,7 +238,7 @@ static bool UnionToUnionCast(Vector &source, Vector &result, idx_t count, CastPa
 		auto &target_member_vector = UnionVector::GetMember(result, target_member_idx);
 		auto &member_cast = cast_data.member_casts[member_idx];
 
-		CastParameters child_parameters(parameters, member_cast.cast_data.get());
+		CastParameters child_parameters(parameters, member_cast.cast_data, lstate.local_states[member_idx]);
 		if (!member_cast.function(source_member_vector, target_member_vector, count, child_parameters)) {
 			return false;
 		}
@@ -288,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);
@@ -339,10 +364,11 @@ BoundCastInfo DefaultCasts::UnionCastSwitch(BindCastInput &input, const LogicalT
 			varchar_members.push_back(make_pair(UnionType::GetMemberName(source, member_idx), LogicalType::VARCHAR));
 		}
 		auto varchar_type = LogicalType::UNION(std::move(varchar_members));
-		return BoundCastInfo(UnionToVarcharCast, BindUnionToUnionCast(input, source, varchar_type));
-	} break;
+		return BoundCastInfo(UnionToVarcharCast, BindUnionToUnionCast(input, source, varchar_type),
+		                     InitUnionToUnionLocalState);
+	}
 	case LogicalTypeId::UNION:
-		return BoundCastInfo(UnionToUnionCast, BindUnionToUnionCast(input, source, target));
+		return BoundCastInfo(UnionToUnionCast, BindUnionToUnionCast(input, source, target), InitUnionToUnionLocalState);
 	default:
 		return TryVectorNullCast;
 	}

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

@@ -105,7 +105,7 @@ struct SplitStringListOperation {
 
 template <class OP>
 static bool SplitStringListInternal(const string_t &input, OP &state) {
-	const char *buf = input.GetDataUnsafe();
+	const char *buf = input.GetData();
 	idx_t len = input.GetSize();
 	idx_t lvl = 1;
 	idx_t pos = 0;
@@ -221,7 +221,7 @@ static bool FindKeyOrValueMap(const char *buf, idx_t len, idx_t &pos, OP &state,
 
 template <class OP>
 static bool SplitStringMapInternal(const string_t &input, OP &state) {
-	const char *buf = input.GetDataUnsafe();
+	const char *buf = input.GetData();
 	idx_t len = input.GetSize();
 	idx_t pos = 0;
 
@@ -299,10 +299,9 @@ static bool FindValueStruct(const char *buf, idx_t len, idx_t &pos, Vector &varc
 	return false;
 }
 
-bool VectorStringToStruct::SplitStruct(string_t &input, std::vector<std::unique_ptr<Vector>> &varchar_vectors,
-                                       idx_t &row_idx, string_map_t<idx_t> &child_names,
-                                       std::vector<ValidityMask *> &child_masks) {
-	const char *buf = input.GetDataUnsafe();
+bool VectorStringToStruct::SplitStruct(string_t &input, vector<unique_ptr<Vector>> &varchar_vectors, idx_t &row_idx,
+                                       string_map_t<idx_t> &child_names, vector<ValidityMask *> &child_masks) {
+	const char *buf = input.GetData();
 	idx_t len = input.GetSize();
 	idx_t pos = 0;
 	idx_t child_idx;