duckdb 0.9.3-dev2.0 → 0.10.0

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

@@ -0,0 +1,226 @@
+#include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast/default_casts.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
+
+namespace duckdb {
+
+unique_ptr<BoundCastData> ArrayBoundCastData::BindArrayToArrayCast(BindCastInput &input, const LogicalType &source,
+                                                                   const LogicalType &target) {
+	vector<BoundCastInfo> child_cast_info;
+	auto &source_child_type = ArrayType::GetChildType(source);
+	auto &result_child_type = ArrayType::GetChildType(target);
+	auto child_cast = input.GetCastFunction(source_child_type, result_child_type);
+	return make_uniq<ArrayBoundCastData>(std::move(child_cast));
+}
+
+static unique_ptr<BoundCastData> BindArrayToListCast(BindCastInput &input, const LogicalType &source,
+                                                     const LogicalType &target) {
+	D_ASSERT(source.id() == LogicalTypeId::ARRAY);
+	D_ASSERT(target.id() == LogicalTypeId::LIST);
+
+	vector<BoundCastInfo> child_cast_info;
+	auto &source_child_type = ArrayType::GetChildType(source);
+	auto &result_child_type = ListType::GetChildType(target);
+	auto child_cast = input.GetCastFunction(source_child_type, result_child_type);
+	return make_uniq<ArrayBoundCastData>(std::move(child_cast));
+}
+
+unique_ptr<FunctionLocalState> ArrayBoundCastData::InitArrayLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = parameters.cast_data->Cast<ArrayBoundCastData>();
+	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);
+}
+
+//------------------------------------------------------------------------------
+// ARRAY -> ARRAY
+//------------------------------------------------------------------------------
+static bool ArrayToArrayCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+
+	auto source_array_size = ArrayType::GetSize(source.GetType());
+	auto target_array_size = ArrayType::GetSize(result.GetType());
+	if (source_array_size != target_array_size) {
+		// Cant cast between arrays of different sizes
+		auto msg = StringUtil::Format("Cannot cast array of size %u to array of size %u", source_array_size,
+		                              target_array_size);
+		HandleCastError::AssignError(msg, parameters.error_message);
+		if (!parameters.strict) {
+			// if this was a TRY_CAST, we know every row will fail, so just return null
+			result.SetVectorType(VectorType::CONSTANT_VECTOR);
+			ConstantVector::SetNull(result, true);
+			return false;
+		}
+	}
+
+	auto &cast_data = parameters.cast_data->Cast<ArrayBoundCastData>();
+	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+
+		if (ConstantVector::IsNull(source)) {
+			ConstantVector::SetNull(result, true);
+		}
+
+		auto &source_cc = ArrayVector::GetEntry(source);
+		auto &result_cc = ArrayVector::GetEntry(result);
+
+		// If the array vector is constant, the child vector must be flat (or constant if array size is 1)
+		D_ASSERT(source_cc.GetVectorType() == VectorType::FLAT_VECTOR || source_array_size == 1);
+
+		CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
+		bool all_ok = cast_data.child_cast_info.function(source_cc, result_cc, source_array_size, child_parameters);
+		return all_ok;
+	} else {
+		// Flatten if not constant
+		source.Flatten(count);
+		result.SetVectorType(VectorType::FLAT_VECTOR);
+
+		FlatVector::SetValidity(result, FlatVector::Validity(source));
+		auto &source_cc = ArrayVector::GetEntry(source);
+		auto &result_cc = ArrayVector::GetEntry(result);
+
+		CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
+		bool all_ok =
+		    cast_data.child_cast_info.function(source_cc, result_cc, count * source_array_size, child_parameters);
+		return all_ok;
+	}
+}
+
+//------------------------------------------------------------------------------
+// ARRAY -> VARCHAR
+//------------------------------------------------------------------------------
+static bool ArrayToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+	auto is_constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
+
+	auto size = ArrayType::GetSize(source.GetType());
+	Vector varchar_list(LogicalType::ARRAY(LogicalType::VARCHAR, size), count);
+	ArrayToArrayCast(source, varchar_list, count, parameters);
+
+	varchar_list.Flatten(count);
+	auto &validity = FlatVector::Validity(varchar_list);
+	auto &child = ArrayVector::GetEntry(varchar_list);
+
+	child.Flatten(count);
+	auto &child_validity = FlatVector::Validity(child);
+
+	auto in_data = FlatVector::GetData<string_t>(child);
+	auto out_data = FlatVector::GetData<string_t>(result);
+
+	static constexpr const idx_t SEP_LENGTH = 2;
+	static constexpr const idx_t NULL_LENGTH = 4;
+
+	for (idx_t i = 0; i < count; i++) {
+		if (!validity.RowIsValid(i)) {
+			FlatVector::SetNull(result, i, true);
+			continue;
+		}
+
+		// First pass, compute the length
+		idx_t array_varchar_length = 2;
+		for (idx_t j = 0; j < size; j++) {
+			auto elem_idx = (i * size) + j;
+			auto elem = in_data[elem_idx];
+			if (j > 0) {
+				array_varchar_length += SEP_LENGTH;
+			}
+			array_varchar_length += child_validity.RowIsValid(elem_idx) ? elem.GetSize() : NULL_LENGTH;
+		}
+
+		out_data[i] = StringVector::EmptyString(result, array_varchar_length);
+		auto dataptr = out_data[i].GetDataWriteable();
+		idx_t offset = 0;
+		dataptr[offset++] = '[';
+
+		// Second pass, write the actual data
+		for (idx_t j = 0; j < size; j++) {
+			auto elem_idx = (i * size) + j;
+			auto elem = in_data[elem_idx];
+			if (j > 0) {
+				memcpy(dataptr + offset, ", ", SEP_LENGTH);
+				offset += SEP_LENGTH;
+			}
+			if (child_validity.RowIsValid(elem_idx)) {
+				auto len = elem.GetSize();
+				memcpy(dataptr + offset, elem.GetData(), len);
+				offset += len;
+			} else {
+				memcpy(dataptr + offset, "NULL", NULL_LENGTH);
+				offset += NULL_LENGTH;
+			}
+		}
+		dataptr[offset++] = ']';
+		out_data[i].Finalize();
+	}
+
+	if (is_constant) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+
+	return true;
+}
+
+//------------------------------------------------------------------------------
+// ARRAY -> LIST
+//------------------------------------------------------------------------------
+static bool ArrayToListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+	auto &cast_data = parameters.cast_data->Cast<ArrayBoundCastData>();
+
+	// FIXME: dont flatten
+	source.Flatten(count);
+	if (count == 1) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+	auto array_size = ArrayType::GetSize(source.GetType());
+	auto child_count = count * array_size;
+
+	ListVector::Reserve(result, child_count);
+	ListVector::SetListSize(result, child_count);
+
+	auto &source_child = ArrayVector::GetEntry(source);
+	auto &result_child = ListVector::GetEntry(result);
+
+	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
+	bool all_ok = cast_data.child_cast_info.function(source_child, result_child, child_count, child_parameters);
+
+	auto list_data = ListVector::GetData(result);
+	for (idx_t i = 0; i < count; i++) {
+		if (FlatVector::IsNull(source, i)) {
+			FlatVector::SetNull(result, i, true);
+			continue;
+		}
+
+		list_data[i].offset = i * array_size;
+		list_data[i].length = array_size;
+	}
+
+	if (count == 1) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+
+	return all_ok;
+}
+
+BoundCastInfo DefaultCasts::ArrayCastSwitch(BindCastInput &input, const LogicalType &source,
+                                            const LogicalType &target) {
+	switch (target.id()) {
+	case LogicalTypeId::VARCHAR: {
+		auto size = ArrayType::GetSize(source);
+		return BoundCastInfo(
+		    ArrayToVarcharCast,
+		    ArrayBoundCastData::BindArrayToArrayCast(input, source, LogicalType::ARRAY(LogicalType::VARCHAR, size)),
+		    ArrayBoundCastData::InitArrayLocalState);
+	}
+	case LogicalTypeId::ARRAY:
+		return BoundCastInfo(ArrayToArrayCast, ArrayBoundCastData::BindArrayToArrayCast(input, source, target),
+		                     ArrayBoundCastData::InitArrayLocalState);
+	case LogicalTypeId::LIST:
+		return BoundCastInfo(ArrayToListCast, BindArrayToListCast(input, source, target),
+		                     ArrayBoundCastData::InitArrayLocalState);
+	default:
+		return DefaultCasts::TryVectorNullCast;
+	};
+}
+
+} // namespace duckdb

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

@@ -30,6 +30,8 @@ BoundCastInfo DefaultCasts::BitCastSwitch(BindCastInput &input, const LogicalTyp
 		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint64_t, CastFromBitToNumeric>);
 	case LogicalTypeId::HUGEINT:
 		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, hugeint_t, CastFromBitToNumeric>);
+	case LogicalTypeId::UHUGEINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uhugeint_t, CastFromBitToNumeric>);
 	case LogicalTypeId::FLOAT:
 		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, float, CastFromBitToNumeric>);
 	case LogicalTypeId::DOUBLE:

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

@@ -1,4 +1,3 @@
-
 #include "duckdb/function/cast/cast_function_set.hpp"
 
 #include "duckdb/common/pair.hpp"
@@ -26,6 +25,10 @@ CastFunctionSet::CastFunctionSet() : map_info(nullptr) {
 	bind_functions.emplace_back(DefaultCasts::GetDefaultCastFunction);
 }
 
+CastFunctionSet::CastFunctionSet(DBConfig &config_p) : CastFunctionSet() {
+	this->config = &config_p;
+}
+
 CastFunctionSet &CastFunctionSet::Get(ClientContext &context) {
 	return DBConfig::GetConfig(context).GetCastFunctions();
 }
@@ -91,6 +94,8 @@ static auto RelaxedTypeMatch(type_map_t<MAP_VALUE_TYPE> &map, const LogicalType
 		return map.end();
 	case LogicalTypeId::UNION:
 		return map.find(LogicalType::UNION({{"any", LogicalType::ANY}}));
+	case LogicalTypeId::ARRAY:
+		return map.find(LogicalType::ARRAY(LogicalType::ANY));
 	default:
 		return map.find(LogicalType::ANY);
 	}
@@ -154,7 +159,13 @@ int64_t CastFunctionSet::ImplicitCastCost(const LogicalType &source, const Logic
 		}
 	}
 	// if not, fallback to the default implicit cast rules
-	return CastRules::ImplicitCast(source, target);
+	auto score = CastRules::ImplicitCast(source, target);
+	if (score < 0 && config && config->options.old_implicit_casting) {
+		if (source.id() != LogicalTypeId::BLOB && target.id() == LogicalTypeId::VARCHAR) {
+			score = 149;
+		}
+	}
+	return score;
 }
 
 BoundCastInfo MapCastFunction(BindCastInput &input, const LogicalType &source, const LogicalType &target) {

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

@@ -247,6 +247,8 @@ BoundCastInfo DefaultCasts::DecimalCastSwitch(BindCastInput &input, const Logica
 		return FromDecimalCast<uint64_t>;
 	case LogicalTypeId::HUGEINT:
 		return FromDecimalCast<hugeint_t>;
+	case LogicalTypeId::UHUGEINT:
+		return FromDecimalCast<uhugeint_t>;
 	case LogicalTypeId::DECIMAL: {
 		// decimal to decimal cast
 		// first we need to figure out the source and target internal types

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

@@ -5,7 +5,7 @@
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/types/chunk_collection.hpp"
+
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/cast/vector_cast_helpers.hpp"
@@ -91,6 +91,7 @@ BoundCastInfo DefaultCasts::GetDefaultCastFunction(BindCastInput &input, const L
 	case LogicalTypeId::USMALLINT:
 	case LogicalTypeId::UINTEGER:
 	case LogicalTypeId::UBIGINT:
+	case LogicalTypeId::UHUGEINT:
 	case LogicalTypeId::HUGEINT:
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
@@ -137,6 +138,8 @@ BoundCastInfo DefaultCasts::GetDefaultCastFunction(BindCastInput &input, const L
 		return UnionCastSwitch(input, source, target);
 	case LogicalTypeId::ENUM:
 		return EnumCastSwitch(input, source, target);
+	case LogicalTypeId::ARRAY:
+		return ArrayCastSwitch(input, source, target);
 	case LogicalTypeId::AGGREGATE_STATE:
 		return AggregateStateToBlobCast;
 	default:

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

@@ -1,6 +1,7 @@
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/function/cast/bound_cast_data.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
 
 namespace duckdb {
 
@@ -13,6 +14,15 @@ unique_ptr<BoundCastData> ListBoundCastData::BindListToListCast(BindCastInput &i
 	return make_uniq<ListBoundCastData>(std::move(child_cast));
 }
 
+static unique_ptr<BoundCastData> BindListToArrayCast(BindCastInput &input, const LogicalType &source,
+                                                     const LogicalType &target) {
+	vector<BoundCastInfo> child_cast_info;
+	auto &source_child_type = ListType::GetChildType(source);
+	auto &result_child_type = ArrayType::GetChildType(target);
+	auto child_cast = input.GetCastFunction(source_child_type, result_child_type);
+	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) {
@@ -28,11 +38,14 @@ bool ListCast::ListToListCast(Vector &source, Vector &result, idx_t count, CastP
 	// only handle constant and flat vectors here for now
 	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 		result.SetVectorType(source.GetVectorType());
-		ConstantVector::SetNull(result, ConstantVector::IsNull(source));
+		const bool is_null = ConstantVector::IsNull(source);
+		ConstantVector::SetNull(result, is_null);
 
-		auto ldata = ConstantVector::GetData<list_entry_t>(source);
-		auto tdata = ConstantVector::GetData<list_entry_t>(result);
-		*tdata = *ldata;
+		if (!is_null) {
+			auto ldata = ConstantVector::GetData<list_entry_t>(source);
+			auto tdata = ConstantVector::GetData<list_entry_t>(result);
+			*tdata = *ldata;
+		}
 	} else {
 		source.Flatten(count);
 		result.SetVectorType(VectorType::FLAT_VECTOR);
@@ -69,7 +82,7 @@ static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastP
 	auto list_data = FlatVector::GetData<list_entry_t>(varchar_list);
 	auto &validity = FlatVector::Validity(varchar_list);
 
-	child.Flatten(count);
+	child.Flatten(ListVector::GetListSize(varchar_list));
 	auto child_data = FlatVector::GetData<string_t>(child);
 	auto &child_validity = FlatVector::Validity(child);
 
@@ -94,7 +107,7 @@ static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastP
 		}
 		result_data[i] = StringVector::EmptyString(result, list_length);
 		auto dataptr = result_data[i].GetDataWriteable();
-		auto offset = 0;
+		idx_t offset = 0;
 		dataptr[offset++] = '[';
 		for (idx_t list_idx = 0; list_idx < list.length; list_idx++) {
 			auto idx = list.offset + list_idx;
@@ -121,6 +134,131 @@ static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastP
 	return true;
 }
 
+static bool ListToArrayCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+	auto &cast_data = parameters.cast_data->Cast<ListBoundCastData>();
+	auto array_size = ArrayType::GetSize(result.GetType());
+
+	// only handle constant and flat vectors here for now
+	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		result.SetVectorType(source.GetVectorType());
+		if (ConstantVector::IsNull(source)) {
+			ConstantVector::SetNull(result, true);
+			return true;
+		}
+
+		auto ldata = ConstantVector::GetData<list_entry_t>(source)[0];
+		if (!ConstantVector::IsNull(source) && ldata.length != array_size) {
+			// Cant cast to array, list size mismatch
+			auto msg = StringUtil::Format("Cannot cast list with length %llu to array with length %u", ldata.length,
+			                              array_size);
+			HandleCastError::AssignError(msg, parameters.error_message);
+			ConstantVector::SetNull(result, true);
+			return false;
+		}
+
+		auto &source_cc = ListVector::GetEntry(source);
+		auto &result_cc = ArrayVector::GetEntry(result);
+
+		// Since the list was constant, there can only be one sequence of data in the child vector
+		CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
+		bool all_succeeded = cast_data.child_cast_info.function(source_cc, result_cc, array_size, child_parameters);
+		return all_succeeded;
+	} else {
+		source.Flatten(count);
+		result.SetVectorType(VectorType::FLAT_VECTOR);
+
+		auto child_type = ArrayType::GetChildType(result.GetType());
+		auto &source_cc = ListVector::GetEntry(source);
+		auto &result_cc = ArrayVector::GetEntry(result);
+		auto ldata = FlatVector::GetData<list_entry_t>(source);
+
+		auto child_count = array_size * count;
+		SelectionVector child_sel(child_count);
+
+		bool all_ok = true;
+
+		for (idx_t i = 0; i < count; i++) {
+			if (FlatVector::IsNull(source, i)) {
+				FlatVector::SetNull(result, i, true);
+				for (idx_t array_elem = 0; array_elem < array_size; array_elem++) {
+					FlatVector::SetNull(result_cc, i * array_size + array_elem, true);
+					child_sel.set_index(i * array_size + array_elem, 0);
+				}
+			} else if (ldata[i].length != array_size) {
+				if (all_ok) {
+					all_ok = false;
+					auto msg = StringUtil::Format("Cannot cast list with length %llu to array with length %u",
+					                              ldata[i].length, array_size);
+					HandleCastError::AssignError(msg, parameters.error_message);
+				}
+				FlatVector::SetNull(result, i, true);
+				for (idx_t array_elem = 0; array_elem < array_size; array_elem++) {
+					FlatVector::SetNull(result_cc, i * array_size + array_elem, true);
+					child_sel.set_index(i * array_size + array_elem, 0);
+				}
+			} else {
+				for (idx_t array_elem = 0; array_elem < array_size; array_elem++) {
+					child_sel.set_index(i * array_size + array_elem, ldata[i].offset + array_elem);
+				}
+			}
+		}
+
+		CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
+
+		// Fast path: No lists are null
+		// We can just cast the child vector directly
+		// Note: Its worth doing a CheckAllValid here, the slow path is significantly more expensive
+		if (FlatVector::Validity(source).CheckAllValid(count)) {
+			Vector payload_vector(result_cc.GetType(), child_count);
+
+			bool ok = cast_data.child_cast_info.function(source_cc, payload_vector, child_count, child_parameters);
+			if (all_ok && !ok) {
+				all_ok = false;
+				HandleCastError::AssignError(*child_parameters.error_message, parameters.error_message);
+			}
+			// Now do the actual copy onto the result vector, making sure to slice properly in case the lists are out of
+			// order
+			VectorOperations::Copy(payload_vector, result_cc, child_sel, child_count, 0, 0);
+			return all_ok;
+		}
+
+		// Slow path: Some lists are null, so we need to copy the data list by list to the right place
+		auto list_data = FlatVector::GetData<list_entry_t>(source);
+		DataChunk cast_chunk;
+		cast_chunk.Initialize(Allocator::DefaultAllocator(), {source_cc.GetType(), result_cc.GetType()}, array_size);
+
+		for (idx_t i = 0; i < count; i++) {
+			if (FlatVector::IsNull(source, i)) {
+				FlatVector::SetNull(result, i, true);
+				// Also null the array children
+				for (idx_t array_elem = 0; array_elem < array_size; array_elem++) {
+					FlatVector::SetNull(result_cc, i * array_size + array_elem, true);
+				}
+			} else {
+				auto &list_cast_input = cast_chunk.data[0];
+				auto &list_cast_output = cast_chunk.data[1];
+				auto list_entry = list_data[i];
+
+				VectorOperations::Copy(source_cc, list_cast_input, list_entry.offset + array_size, list_entry.offset,
+				                       0);
+
+				bool ok =
+				    cast_data.child_cast_info.function(list_cast_input, list_cast_output, array_size, child_parameters);
+				if (all_ok && !ok) {
+					all_ok = false;
+					HandleCastError::AssignError(*child_parameters.error_message, parameters.error_message);
+				}
+				VectorOperations::Copy(list_cast_output, result_cc, array_size, 0, i * array_size);
+
+				// Reset the cast_chunk
+				cast_chunk.Reset();
+			}
+		}
+
+		return all_ok;
+	}
+}
+
 BoundCastInfo DefaultCasts::ListCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	switch (target.id()) {
 	case LogicalTypeId::LIST:
@@ -131,9 +269,16 @@ BoundCastInfo DefaultCasts::ListCastSwitch(BindCastInput &input, const LogicalTy
 		    ListToVarcharCast,
 		    ListBoundCastData::BindListToListCast(input, source, LogicalType::LIST(LogicalType::VARCHAR)),
 		    ListBoundCastData::InitListLocalState);
+	case LogicalTypeId::ARRAY:
+		return BoundCastInfo(ListToArrayCast, BindListToArrayCast(input, source, target),
+		                     ListBoundCastData::InitListLocalState);
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}
 }
 
+/*
+
+ */
+
 } // namespace duckdb

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

@@ -29,6 +29,8 @@ static BoundCastInfo InternalNumericCastSwitch(const LogicalType &source, const
 		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, uint64_t, duckdb::NumericTryCast>);
 	case LogicalTypeId::HUGEINT:
 		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, hugeint_t, duckdb::NumericTryCast>);
+	case LogicalTypeId::UHUGEINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, uhugeint_t, duckdb::NumericTryCast>);
 	case LogicalTypeId::FLOAT:
 		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<SRC, float, duckdb::NumericTryCast>);
 	case LogicalTypeId::DOUBLE:
@@ -67,6 +69,8 @@ BoundCastInfo DefaultCasts::NumericCastSwitch(BindCastInput &input, const Logica
 		return InternalNumericCastSwitch<uint64_t>(source, target);
 	case LogicalTypeId::HUGEINT:
 		return InternalNumericCastSwitch<hugeint_t>(source, target);
+	case LogicalTypeId::UHUGEINT:
+		return InternalNumericCastSwitch<uhugeint_t>(source, target);
 	case LogicalTypeId::FLOAT:
 		return InternalNumericCastSwitch<float>(source, target);
 	case LogicalTypeId::DOUBLE:

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

@@ -1,5 +1,6 @@
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/vector_cast_helpers.hpp"
+#include "duckdb/common/exception/conversion_exception.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
@@ -102,6 +103,8 @@ static BoundCastInfo VectorStringCastNumericSwitch(BindCastInput &input, const L
 		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, uint64_t, duckdb::TryCast>);
 	case LogicalTypeId::HUGEINT:
 		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, hugeint_t, duckdb::TryCast>);
+	case LogicalTypeId::UHUGEINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, uhugeint_t, duckdb::TryCast>);
 	case LogicalTypeId::FLOAT:
 		return BoundCastInfo(&VectorCastHelpers::TryCastStrictLoop<string_t, float, duckdb::TryCast>);
 	case LogicalTypeId::DOUBLE:
@@ -189,13 +192,16 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(const string_t *source_dat
 	Vector varchar_vector(varchar_struct_type, count);
 	auto &child_vectors = StructVector::GetEntries(varchar_vector);
 	auto &result_children = StructVector::GetEntries(result);
+	auto is_unnamed = StructType::IsUnnamed(result.GetType());
 
 	string_map_t<idx_t> child_names;
-	vector<ValidityMask *> child_masks;
+	vector<reference<ValidityMask>> child_masks;
 	for (idx_t child_idx = 0; child_idx < result_children.size(); child_idx++) {
-		child_names.insert({StructType::GetChildName(result.GetType(), child_idx), child_idx});
-		child_masks.emplace_back(&FlatVector::Validity(*child_vectors[child_idx]));
-		child_masks[child_idx]->SetAllInvalid(count);
+		if (!is_unnamed) {
+			child_names.insert({StructType::GetChildName(result.GetType(), child_idx), child_idx});
+		}
+		child_masks.emplace_back(FlatVector::Validity(*child_vectors[child_idx]));
+		child_masks[child_idx].get().SetAllInvalid(count);
 	}
 
 	bool all_converted = true;
@@ -208,11 +214,14 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(const string_t *source_dat
 			result_mask.SetInvalid(i);
 			continue;
 		}
+		if (is_unnamed) {
+			throw ConversionException("Casting strings to unnamed structs is unsupported");
+		}
 		if (!VectorStringToStruct::SplitStruct(source_data[idx], child_vectors, i, child_names, child_masks)) {
 			string text = "Type VARCHAR with value '" + source_data[idx].GetString() +
 			              "' can't be cast to the destination type STRUCT";
 			for (auto &child_mask : child_masks) {
-				child_mask->SetInvalid(idx); // some values may have already been found and set valid
+				child_mask.get().SetInvalid(idx); // some values may have already been found and set valid
 			}
 			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, parameters.error_message, all_converted);
 		}
@@ -333,6 +342,81 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data,
 	return all_converted;
 }
 
+//===--------------------------------------------------------------------===//
+// string -> array casting
+//===--------------------------------------------------------------------===//
+bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask,
+                                                     Vector &result, ValidityMask &result_mask, idx_t count,
+                                                     CastParameters &parameters, const SelectionVector *sel) {
+	idx_t array_size = ArrayType::GetSize(result.GetType());
+	bool all_lengths_match = true;
+
+	for (idx_t i = 0; i < count; i++) {
+		idx_t idx = i;
+		if (sel) {
+			idx = sel->get_index(i);
+		}
+		if (!source_mask.RowIsValid(idx)) {
+			continue;
+		}
+		auto str_array_size = VectorStringToList::CountPartsList(source_data[idx]);
+		if (array_size != str_array_size) {
+			if (all_lengths_match) {
+				all_lengths_match = false;
+				auto msg =
+				    StringUtil::Format("Type VARCHAR with value '%s' can't be cast to the destination type ARRAY[%u]"
+				                       ", the size of the array must match the destination type",
+				                       source_data[idx].GetString(), array_size);
+				if (parameters.strict) {
+					throw ConversionException(msg);
+				}
+				HandleCastError::AssignError(msg, parameters.error_message);
+			}
+			result_mask.SetInvalid(i);
+		}
+	}
+
+	auto child_count = array_size * count;
+	Vector varchar_vector(LogicalType::VARCHAR, child_count);
+	auto child_data = FlatVector::GetData<string_t>(varchar_vector);
+
+	bool all_converted = true;
+	idx_t total = 0;
+	for (idx_t i = 0; i < count; i++) {
+		idx_t idx = i;
+		if (sel) {
+			idx = sel->get_index(i);
+		}
+
+		if (!source_mask.RowIsValid(idx) || !result_mask.RowIsValid(i)) {
+			// The source is null, or there was a size-mismatch above, so dont try to split the string
+			result_mask.SetInvalid(i);
+
+			// Null the entire array
+			for (idx_t j = 0; j < array_size; j++) {
+				FlatVector::SetNull(varchar_vector, idx * array_size + j, true);
+			}
+
+			total += array_size;
+			continue;
+		}
+
+		if (!VectorStringToList::SplitStringList(source_data[idx], child_data, total, varchar_vector)) {
+			auto text = StringUtil::Format("Type VARCHAR with value '%s' can't be cast to the destination type ARRAY",
+			                               source_data[idx].GetString());
+			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, parameters.error_message, all_converted);
+		}
+	}
+	D_ASSERT(total == child_count);
+
+	auto &result_child = ArrayVector::GetEntry(result);
+	auto &cast_data = parameters.cast_data->Cast<ArrayBoundCastData>();
+	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
+	bool cast_result = cast_data.child_cast_info.function(varchar_vector, result_child, child_count, child_parameters);
+
+	return all_lengths_match && cast_result && all_converted;
+}
+
 template <class T>
 bool StringToNestedTypeCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	D_ASSERT(source.GetType().id() == LogicalTypeId::VARCHAR);
@@ -398,6 +482,12 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 		    &StringToNestedTypeCast<VectorStringToList>,
 		    ListBoundCastData::BindListToListCast(input, LogicalType::LIST(LogicalType::VARCHAR), target),
 		    ListBoundCastData::InitListLocalState);
+	case LogicalTypeId::ARRAY:
+		// the second argument allows for a secondary casting function to be passed in the CastParameters
+		return BoundCastInfo(
+		    &StringToNestedTypeCast<VectorStringToArray>,
+		    ArrayBoundCastData::BindArrayToArrayCast(input, LogicalType::ARRAY(LogicalType::VARCHAR), target),
+		    ArrayBoundCastData::InitArrayLocalState);
 	case LogicalTypeId::STRUCT:
 		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToStruct>,
 		                     StructBoundCastData::BindStructToStructCast(input, InitVarcharStructType(target), target),