duckdb 0.9.3-dev0.0 → 0.9.3-dev3.0

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

@@ -16,15 +16,42 @@ unique_ptr<BoundCastData> StructBoundCastData::BindStructToStructCast(BindCastIn
 	if (source_child_types.size() != result_child_types.size()) {
 		throw TypeMismatchException(source, target, "Cannot cast STRUCTs of different size");
 	}
-	for (idx_t i = 0; i < source_child_types.size(); i++) {
-		if (!target_is_unnamed && !source_is_unnamed &&
-		    !StringUtil::CIEquals(source_child_types[i].first, result_child_types[i].first)) {
-			throw TypeMismatchException(source, target, "Cannot cast STRUCTs with different names");
+	bool named_struct_cast = !source_is_unnamed && !target_is_unnamed;
+	case_insensitive_map_t<idx_t> target_members;
+	if (named_struct_cast) {
+		for (idx_t i = 0; i < result_child_types.size(); i++) {
+			auto &target_name = result_child_types[i].first;
+			if (target_members.find(target_name) != target_members.end()) {
+				throw NotImplementedException("Error while casting - duplicate name \"%s\" in struct", target_name);
+			}
+			target_members[target_name] = i;
+		}
+	}
+	vector<idx_t> child_member_map;
+	child_member_map.reserve(source_child_types.size());
+	for (idx_t source_idx = 0; source_idx < source_child_types.size(); source_idx++) {
+		auto &source_child = source_child_types[source_idx];
+		idx_t target_idx;
+		if (named_struct_cast) {
+			// named struct cast - find corresponding member in target
+			auto entry = target_members.find(source_child.first);
+			if (entry == target_members.end()) {
+				throw TypeMismatchException(source, target,
+				                            "Cannot cast STRUCTs - element \"" + source_child.first +
+				                                "\" in source struct was not found in target struct");
+			}
+			target_idx = entry->second;
+			target_members.erase(entry);
+		} else {
+			// unnamed struct cast - positionally cast elements
+			target_idx = source_idx;
 		}
-		auto child_cast = input.GetCastFunction(source_child_types[i].second, result_child_types[i].second);
+		child_member_map.push_back(target_idx);
+		auto child_cast = input.GetCastFunction(source_child.second, result_child_types[target_idx].second);
 		child_cast_info.push_back(std::move(child_cast));
 	}
-	return make_uniq<StructBoundCastData>(std::move(child_cast_info), target);
+	D_ASSERT(child_member_map.size() == source_child_types.size());
+	return make_uniq<StructBoundCastData>(std::move(child_cast_info), target, std::move(child_member_map));
 }
 
 unique_ptr<FunctionLocalState> StructBoundCastData::InitStructCastLocalState(CastLocalStateParameters &parameters) {
@@ -52,8 +79,10 @@ static bool StructToStructCast(Vector &source, Vector &result, idx_t count, Cast
 	auto &result_children = StructVector::GetEntries(result);
 	bool all_converted = true;
 	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];
+		auto source_idx = c_idx;
+		auto target_idx = cast_data.child_member_map[source_idx];
+		auto &source_child_vector = *source_children[source_idx];
+		auto &result_child_vector = *result_children[target_idx];
 		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,
@@ -80,6 +109,7 @@ static bool StructToVarcharCast(Vector &source, Vector &result, idx_t count, Cas
 
 	// now construct the actual varchar vector
 	varchar_struct.Flatten(count);
+	bool is_unnamed = StructType::IsUnnamed(source.GetType());
 	auto &child_types = StructType::GetChildTypes(source.GetType());
 	auto &children = StructVector::GetEntries(varchar_struct);
 	auto &validity = FlatVector::Validity(varchar_struct);
@@ -101,13 +131,15 @@ static bool StructToVarcharCast(Vector &source, Vector &result, idx_t count, Cas
 			auto &child_validity = FlatVector::Validity(*children[c]);
 			auto data = FlatVector::GetData<string_t>(*children[c]);
 			auto &name = child_types[c].first;
-			string_length += name.size() + NAME_SEP_LENGTH; // "'{name}': "
+			if (!is_unnamed) {
+				string_length += name.size() + NAME_SEP_LENGTH; // "'{name}': "
+			}
 			string_length += child_validity.RowIsValid(i) ? data[i].GetSize() : NULL_LENGTH;
 		}
 		result_data[i] = StringVector::EmptyString(result, string_length);
 		auto dataptr = result_data[i].GetDataWriteable();
 		idx_t offset = 0;
-		dataptr[offset++] = '{';
+		dataptr[offset++] = is_unnamed ? '(' : '{';
 		for (idx_t c = 0; c < children.size(); c++) {
 			if (c > 0) {
 				memcpy(dataptr + offset, ", ", SEP_LENGTH);
@@ -115,14 +147,16 @@ static bool StructToVarcharCast(Vector &source, Vector &result, idx_t count, Cas
 			}
 			auto &child_validity = FlatVector::Validity(*children[c]);
 			auto data = FlatVector::GetData<string_t>(*children[c]);
-			auto &name = child_types[c].first;
-			// "'{name}': "
-			dataptr[offset++] = '\'';
-			memcpy(dataptr + offset, name.c_str(), name.size());
-			offset += name.size();
-			dataptr[offset++] = '\'';
-			dataptr[offset++] = ':';
-			dataptr[offset++] = ' ';
+			if (!is_unnamed) {
+				auto &name = child_types[c].first;
+				// "'{name}': "
+				dataptr[offset++] = '\'';
+				memcpy(dataptr + offset, name.c_str(), name.size());
+				offset += name.size();
+				dataptr[offset++] = '\'';
+				dataptr[offset++] = ':';
+				dataptr[offset++] = ' ';
+			}
 			// value
 			if (child_validity.RowIsValid(i)) {
 				auto len = data[i].GetSize();
@@ -133,7 +167,7 @@ static bool StructToVarcharCast(Vector &source, Vector &result, idx_t count, Cas
 				offset += NULL_LENGTH;
 			}
 		}
-		dataptr[offset++] = '}';
+		dataptr[offset++] = is_unnamed ? ')' : '}';
 		result_data[i].Finalize();
 	}
 

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

@@ -114,6 +114,13 @@ BoundCastInfo DefaultCasts::TimestampNsCastSwitch(BindCastInput &input, const Lo
 	case LogicalTypeId::VARCHAR:
 		// timestamp (ns) to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::CastFromTimestampNS>);
+	case LogicalTypeId::DATE:
+		// timestamp (ns) to date
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, date_t, duckdb::CastTimestampNsToDate>);
+	case LogicalTypeId::TIME:
+		// timestamp (ns) to time
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::CastTimestampNsToTime>);
 	case LogicalTypeId::TIMESTAMP:
 		// timestamp (ns) to timestamp (us)
 		return BoundCastInfo(
@@ -130,6 +137,13 @@ BoundCastInfo DefaultCasts::TimestampMsCastSwitch(BindCastInput &input, const Lo
 	case LogicalTypeId::VARCHAR:
 		// timestamp (ms) to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::CastFromTimestampMS>);
+	case LogicalTypeId::DATE:
+		// timestamp (ms) to date
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, date_t, duckdb::CastTimestampMsToDate>);
+	case LogicalTypeId::TIME:
+		// timestamp (ms) to time
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::CastTimestampMsToTime>);
 	case LogicalTypeId::TIMESTAMP:
 		// timestamp (ms) to timestamp (us)
 		return BoundCastInfo(
@@ -148,8 +162,16 @@ BoundCastInfo DefaultCasts::TimestampSecCastSwitch(BindCastInput &input, const L
 	// now switch on the result type
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
-		// timestamp (sec) to varchar
+		// timestamp (s) to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::CastFromTimestampSec>);
+	case LogicalTypeId::DATE:
+		// timestamp (s) to date
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, date_t, duckdb::CastTimestampSecToDate>);
+	case LogicalTypeId::TIME:
+		// timestamp (s) to time
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::CastTimestampSecToTime>);
 	case LogicalTypeId::TIMESTAMP_MS:
 		// timestamp (s) to timestamp (ms)
 		return BoundCastInfo(

package/src/duckdb/src/function/cast/union/from_struct.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/function/cast/bound_cast_data.hpp"
+#include "duckdb/common/exception/conversion_exception.hpp"
 
 namespace duckdb {
 

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

@@ -1,6 +1,7 @@
 #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/exception/conversion_exception.hpp"
 
 #include <algorithm> // for std::sort
 
@@ -41,7 +42,7 @@ unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalTyp
 				message += ", ";
 			}
 		}
-		throw CastException(message);
+		throw ConversionException(message);
 	}
 
 	// sort the candidate casts by cost
@@ -68,7 +69,7 @@ unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalTyp
 		}
 		message += ". Disambiguate the target type by using the 'union_value(<tag> := <arg>)' function to promote the "
 		           "source value to a single member union before casting.";
-		throw CastException(message);
+		throw ConversionException(message);
 	}
 
 	// otherwise, return the selected cast
@@ -182,7 +183,7 @@ unique_ptr<BoundCastData> BindUnionToUnionCast(BindCastInput &input, const Logic
 			auto message =
 			    StringUtil::Format("Type %s can't be cast as %s. The member '%s' is not present in target union",
 			                       source.ToString(), target.ToString(), source_member_name);
-			throw CastException(message);
+			throw ConversionException(message);
 		}
 	}
 

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

@@ -285,7 +285,7 @@ static bool FindKeyStruct(const char *buf, idx_t len, idx_t &pos) {
 }
 
 static bool FindValueStruct(const char *buf, idx_t len, idx_t &pos, Vector &varchar_child, idx_t &row_idx,
-                            ValidityMask *child_mask) {
+                            ValidityMask &child_mask) {
 	auto start_pos = pos;
 	idx_t lvl = 0;
 	while (pos < len) {
@@ -302,7 +302,7 @@ static bool FindValueStruct(const char *buf, idx_t len, idx_t &pos, Vector &varc
 			}
 			FlatVector::GetData<string_t>(varchar_child)[row_idx] =
 			    StringVector::AddString(varchar_child, buf + start_pos, end_pos - start_pos);
-			child_mask->SetValid(row_idx); // any child not set to valid will remain invalid
+			child_mask.SetValid(row_idx); // any child not set to valid will remain invalid
 			return true;
 		}
 		pos++;
@@ -312,7 +312,7 @@ static bool FindValueStruct(const char *buf, idx_t len, idx_t &pos, Vector &varc
 
 bool VectorStringToStruct::SplitStruct(const string_t &input, vector<unique_ptr<Vector>> &varchar_vectors,
                                        idx_t &row_idx, string_map_t<idx_t> &child_names,
-                                       vector<ValidityMask *> &child_masks) {
+                                       vector<reference<ValidityMask>> &child_masks) {
 	const char *buf = input.GetData();
 	idx_t len = input.GetSize();
 	idx_t pos = 0;
@@ -332,6 +332,10 @@ bool VectorStringToStruct::SplitStruct(const string_t &input, vector<unique_ptr<
 				return false;
 			}
 			auto key_end = StringTrim(buf, key_start, pos);
+			if (key_start >= key_end) {
+				// empty key name unsupported
+				return false;
+			}
 			string_t found_key(buf + key_start, key_end - key_start);
 
 			auto it = child_names.find(found_key);
@@ -340,7 +344,7 @@ bool VectorStringToStruct::SplitStruct(const string_t &input, vector<unique_ptr<
 			}
 			child_idx = it->second;
 			SkipWhitespace(buf, ++pos, len);
-			if (!FindValueStruct(buf, len, pos, *varchar_vectors[child_idx], row_idx, child_masks[child_idx])) {
+			if (!FindValueStruct(buf, len, pos, *varchar_vectors[child_idx], row_idx, child_masks[child_idx].get())) {
 				return false;
 			}
 			SkipWhitespace(buf, ++pos, len);

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

@@ -5,25 +5,34 @@ namespace duckdb {
 //! The target type determines the preferred implicit casts
 static int64_t TargetTypeCost(const LogicalType &type) {
 	switch (type.id()) {
-	case LogicalTypeId::INTEGER:
-		return 103;
 	case LogicalTypeId::BIGINT:
 		return 101;
-	case LogicalTypeId::DOUBLE:
+	case LogicalTypeId::INTEGER:
 		return 102;
 	case LogicalTypeId::HUGEINT:
-		return 120;
+		return 103;
+	case LogicalTypeId::DOUBLE:
+		return 104;
+	case LogicalTypeId::DECIMAL:
+		return 105;
+	case LogicalTypeId::TIMESTAMP_NS:
+		return 119;
 	case LogicalTypeId::TIMESTAMP:
 		return 120;
+	case LogicalTypeId::TIMESTAMP_MS:
+		return 121;
+	case LogicalTypeId::TIMESTAMP_SEC:
+		return 122;
 	case LogicalTypeId::VARCHAR:
 		return 149;
-	case LogicalTypeId::DECIMAL:
-		return 104;
 	case LogicalTypeId::STRUCT:
 	case LogicalTypeId::MAP:
 	case LogicalTypeId::LIST:
 	case LogicalTypeId::UNION:
+	case LogicalTypeId::ARRAY:
 		return 160;
+	case LogicalTypeId::ANY:
+		return int64_t(AnyType::GetCastScore(type));
 	default:
 		return 110;
 	}
@@ -92,6 +101,7 @@ static int64_t ImplicitCastUTinyint(const LogicalType &to) {
 	case LogicalTypeId::INTEGER:
 	case LogicalTypeId::BIGINT:
 	case LogicalTypeId::HUGEINT:
+	case LogicalTypeId::UHUGEINT:
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::DECIMAL:
@@ -108,6 +118,7 @@ static int64_t ImplicitCastUSmallint(const LogicalType &to) {
 	case LogicalTypeId::INTEGER:
 	case LogicalTypeId::BIGINT:
 	case LogicalTypeId::HUGEINT:
+	case LogicalTypeId::UHUGEINT:
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::DECIMAL:
@@ -122,6 +133,7 @@ static int64_t ImplicitCastUInteger(const LogicalType &to) {
 
 	case LogicalTypeId::UBIGINT:
 	case LogicalTypeId::BIGINT:
+	case LogicalTypeId::UHUGEINT:
 	case LogicalTypeId::HUGEINT:
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
@@ -136,6 +148,7 @@ static int64_t ImplicitCastUBigint(const LogicalType &to) {
 	switch (to.id()) {
 	case LogicalTypeId::FLOAT:
 	case LogicalTypeId::DOUBLE:
+	case LogicalTypeId::UHUGEINT:
 	case LogicalTypeId::HUGEINT:
 	case LogicalTypeId::DECIMAL:
 		return TargetTypeCost(to);
@@ -181,6 +194,17 @@ static int64_t ImplicitCastHugeint(const LogicalType &to) {
 	}
 }
 
+static int64_t ImplicitCastUhugeint(const LogicalType &to) {
+	switch (to.id()) {
+	case LogicalTypeId::FLOAT:
+	case LogicalTypeId::DOUBLE:
+	case LogicalTypeId::DECIMAL:
+		return TargetTypeCost(to);
+	default:
+		return -1;
+	}
+}
+
 static int64_t ImplicitCastDate(const LogicalType &to) {
 	switch (to.id()) {
 	case LogicalTypeId::TIMESTAMP:
@@ -190,8 +214,106 @@ static int64_t ImplicitCastDate(const LogicalType &to) {
 	}
 }
 
+static int64_t ImplicitCastEnum(const LogicalType &to) {
+	switch (to.id()) {
+	case LogicalTypeId::VARCHAR:
+		return TargetTypeCost(to);
+	default:
+		return -1;
+	}
+}
+
+static int64_t ImplicitCastTimestampSec(const LogicalType &to) {
+	switch (to.id()) {
+	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_MS:
+	case LogicalTypeId::TIMESTAMP_NS:
+		return TargetTypeCost(to);
+	default:
+		return -1;
+	}
+}
+
+static int64_t ImplicitCastTimestampMS(const LogicalType &to) {
+	switch (to.id()) {
+	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_NS:
+		return TargetTypeCost(to);
+	default:
+		return -1;
+	}
+}
+
+static int64_t ImplicitCastTimestampNS(const LogicalType &to) {
+	switch (to.id()) {
+	case LogicalTypeId::TIMESTAMP:
+		// we allow casting ALL timestamps, including nanosecond ones, to TimestampNS
+		return TargetTypeCost(to);
+	default:
+		return -1;
+	}
+}
+
+static int64_t ImplicitCastTimestamp(const LogicalType &to) {
+	switch (to.id()) {
+	case LogicalTypeId::TIMESTAMP_NS:
+		return TargetTypeCost(to);
+	default:
+		return -1;
+	}
+}
+
+bool LogicalTypeIsValid(const LogicalType &type) {
+	switch (type.id()) {
+	case LogicalTypeId::STRUCT:
+	case LogicalTypeId::UNION:
+	case LogicalTypeId::LIST:
+	case LogicalTypeId::MAP:
+	case LogicalTypeId::ARRAY:
+	case LogicalTypeId::DECIMAL:
+		// these types are only valid with auxiliary info
+		if (!type.AuxInfo()) {
+			return false;
+		}
+		break;
+	default:
+		break;
+	}
+	switch (type.id()) {
+	case LogicalTypeId::ANY:
+	case LogicalTypeId::INVALID:
+	case LogicalTypeId::UNKNOWN:
+		return false;
+	case LogicalTypeId::STRUCT: {
+		auto child_count = StructType::GetChildCount(type);
+		for (idx_t i = 0; i < child_count; i++) {
+			if (!LogicalTypeIsValid(StructType::GetChildType(type, i))) {
+				return false;
+			}
+		}
+		return true;
+	}
+	case LogicalTypeId::UNION: {
+		auto member_count = UnionType::GetMemberCount(type);
+		for (idx_t i = 0; i < member_count; i++) {
+			if (!LogicalTypeIsValid(UnionType::GetMemberType(type, i))) {
+				return false;
+			}
+		}
+		return true;
+	}
+	case LogicalTypeId::LIST:
+	case LogicalTypeId::MAP:
+		return LogicalTypeIsValid(ListType::GetChildType(type));
+	case LogicalTypeId::ARRAY:
+		return LogicalTypeIsValid(ArrayType::GetChildType(type));
+	default:
+		return true;
+	}
+}
+
 int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to) {
-	if (from.id() == LogicalTypeId::SQLNULL) {
+	if (from.id() == LogicalTypeId::SQLNULL || to.id() == LogicalTypeId::ANY) {
 		// NULL expression can be cast to anything
 		return TargetTypeCost(to);
 	}
@@ -199,9 +321,34 @@ int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to)
 		// parameter expression can be cast to anything for no cost
 		return 0;
 	}
-	if (to.id() == LogicalTypeId::ANY) {
-		// anything can be cast to ANY type for (almost no) cost
-		return 1;
+	if (from.id() == LogicalTypeId::STRING_LITERAL) {
+		// string literals can be cast to any type for low cost as long as the type is valid
+		// i.e. we cannot cast to LIST(ANY) as we don't know what "ANY" should be
+		// we cannot cast to DECIMAL without precision/width specified
+		if (!LogicalTypeIsValid(to)) {
+			return -1;
+		}
+		if (to.id() == LogicalTypeId::VARCHAR && to.GetAlias().empty()) {
+			return 1;
+		}
+		return 20;
+	}
+	if (from.id() == LogicalTypeId::INTEGER_LITERAL) {
+		// the integer literal has an underlying type - this type always matches
+		if (IntegerLiteral::GetType(from).id() == to.id()) {
+			return 0;
+		}
+		// integer literals can be cast to any other integer type for a low cost, but only if the literal fits
+		if (IntegerLiteral::FitsInType(from, to)) {
+			// to avoid ties we prefer BIGINT, INT, ...
+			auto target_cost = TargetTypeCost(to);
+			if (target_cost < 100) {
+				throw InternalException("Integer literal implicit cast - TargetTypeCost should be >= 100");
+			}
+			return target_cost - 90;
+		}
+		// in any other case we use the casting rules of the preferred type of the literal
+		return CastRules::ImplicitCast(IntegerLiteral::GetType(from), to);
 	}
 	if (from.GetAlias() != to.GetAlias()) {
 		// if aliases are different, an implicit cast is not possible
@@ -210,24 +357,43 @@ int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to)
 	if (from.id() == LogicalTypeId::LIST && to.id() == LogicalTypeId::LIST) {
 		// Lists can be cast if their child types can be cast
 		auto child_cost = ImplicitCast(ListType::GetChildType(from), ListType::GetChildType(to));
-		if (child_cost >= 100) {
+		if (child_cost >= 1) {
 			// subtract one from the cost because we prefer LIST[X] -> LIST[VARCHAR] over LIST[X] -> VARCHAR
 			child_cost--;
 		}
 		return child_cost;
 	}
+	if (from.id() == LogicalTypeId::ARRAY && to.id() == LogicalTypeId::ARRAY) {
+		// Arrays can be cast if their child types can be cast and the source and target has the same size
+		// or the target type has a unknown (any) size.
+		auto from_size = ArrayType::GetSize(from);
+		auto to_size = ArrayType::GetSize(to);
+		auto to_is_any_size = ArrayType::IsAnySize(to);
+		if (from_size == to_size || to_is_any_size) {
+			auto child_cost = ImplicitCast(ArrayType::GetChildType(from), ArrayType::GetChildType(to));
+			if (child_cost >= 100) {
+				// subtract one from the cost because we prefer ARRAY[X] -> ARRAY[VARCHAR] over ARRAY[X] -> VARCHAR
+				child_cost--;
+			}
+			return child_cost;
+		}
+		return -1; // Not possible if the sizes are different
+	}
+	if (from.id() == LogicalTypeId::ARRAY && to.id() == LogicalTypeId::LIST) {
+		// Arrays can be cast to lists for the cost of casting the child type
+		// add 1 because we prefer ARRAY->ARRAY casts over ARRAY->LIST casts
+		return ImplicitCast(ArrayType::GetChildType(from), ListType::GetChildType(to)) + 1;
+	}
+	if (from.id() == LogicalTypeId::LIST && (to.id() == LogicalTypeId::ARRAY && !ArrayType::IsAnySize(to))) {
+		// Lists can be cast to arrays for the cost of casting the child type, if the target size is known
+		// there is no way for us to resolve the size at bind-time without inspecting the list values.
+		// TODO: if we can access the expression we could resolve the size if the list is constant.
+		return ImplicitCast(ListType::GetChildType(from), ArrayType::GetChildType(to));
+	}
 	if (from.id() == to.id()) {
 		// arguments match: do nothing
 		return 0;
 	}
-	if (from.id() == LogicalTypeId::BLOB && to.id() == LogicalTypeId::VARCHAR) {
-		// Implicit cast not allowed from BLOB to VARCHAR
-		return -1;
-	}
-	if (to.id() == LogicalTypeId::VARCHAR) {
-		// everything can be cast to VARCHAR, but this cast has a high cost
-		return TargetTypeCost(to);
-	}
 
 	if (from.id() == LogicalTypeId::UNION && to.id() == LogicalTypeId::UNION) {
 		// Unions can be cast if the source tags are a subset of the target tags
@@ -273,18 +439,6 @@ int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to)
 		}
 	}
 
-	if ((from.id() == LogicalTypeId::TIMESTAMP_SEC || from.id() == LogicalTypeId::TIMESTAMP_MS ||
-	     from.id() == LogicalTypeId::TIMESTAMP_NS) &&
-	    to.id() == LogicalTypeId::TIMESTAMP) {
-		//! Any timestamp type can be converted to the default (us) type at low cost
-		return 101;
-	}
-	if ((to.id() == LogicalTypeId::TIMESTAMP_SEC || to.id() == LogicalTypeId::TIMESTAMP_MS ||
-	     to.id() == LogicalTypeId::TIMESTAMP_NS) &&
-	    from.id() == LogicalTypeId::TIMESTAMP) {
-		//! Any timestamp type can be converted to the default (us) type at low cost
-		return 100;
-	}
 	switch (from.id()) {
 	case LogicalTypeId::TINYINT:
 		return ImplicitCastTinyint(to);
@@ -304,6 +458,8 @@ int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to)
 		return ImplicitCastUBigint(to);
 	case LogicalTypeId::HUGEINT:
 		return ImplicitCastHugeint(to);
+	case LogicalTypeId::UHUGEINT:
+		return ImplicitCastUhugeint(to);
 	case LogicalTypeId::FLOAT:
 		return ImplicitCastFloat(to);
 	case LogicalTypeId::DOUBLE:
@@ -312,6 +468,16 @@ int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to)
 		return ImplicitCastDate(to);
 	case LogicalTypeId::DECIMAL:
 		return ImplicitCastDecimal(to);
+	case LogicalTypeId::ENUM:
+		return ImplicitCastEnum(to);
+	case LogicalTypeId::TIMESTAMP_SEC:
+		return ImplicitCastTimestampSec(to);
+	case LogicalTypeId::TIMESTAMP_MS:
+		return ImplicitCastTimestampMS(to);
+	case LogicalTypeId::TIMESTAMP_NS:
+		return ImplicitCastTimestampNS(to);
+	case LogicalTypeId::TIMESTAMP:
+		return ImplicitCastTimestamp(to);
 	default:
 		return -1;
 	}

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

@@ -23,6 +23,8 @@ static DefaultCompressionMethod internal_compression_methods[] = {
      DictionaryCompressionFun::TypeIsSupported},
     {CompressionType::COMPRESSION_CHIMP, ChimpCompressionFun::GetFunction, ChimpCompressionFun::TypeIsSupported},
     {CompressionType::COMPRESSION_PATAS, PatasCompressionFun::GetFunction, PatasCompressionFun::TypeIsSupported},
+    {CompressionType::COMPRESSION_ALP, AlpCompressionFun::GetFunction, AlpCompressionFun::TypeIsSupported},
+    {CompressionType::COMPRESSION_ALPRD, AlpRDCompressionFun::GetFunction, AlpRDCompressionFun::TypeIsSupported},
     {CompressionType::COMPRESSION_FSST, FSSTFun::GetFunction, FSSTFun::TypeIsSupported},
     {CompressionType::COMPRESSION_AUTO, nullptr, nullptr}};
 
@@ -76,6 +78,8 @@ vector<reference<CompressionFunction>> DBConfig::GetCompressionFunctions(Physica
 	TryLoadCompression(*this, result, CompressionType::COMPRESSION_DICTIONARY, data_type);
 	TryLoadCompression(*this, result, CompressionType::COMPRESSION_CHIMP, data_type);
 	TryLoadCompression(*this, result, CompressionType::COMPRESSION_PATAS, data_type);
+	TryLoadCompression(*this, result, CompressionType::COMPRESSION_ALP, data_type);
+	TryLoadCompression(*this, result, CompressionType::COMPRESSION_ALPRD, data_type);
 	TryLoadCompression(*this, result, CompressionType::COMPRESSION_FSST, data_type);
 	return result;
 }

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

@@ -47,7 +47,7 @@ SimpleFunction::~SimpleFunction() {
 }
 
 string SimpleFunction::ToString() const {
-	return Function::CallToString(name, arguments);
+	return Function::CallToString(name, arguments, varargs);
 }
 
 bool SimpleFunction::HasVarArgs() const {
@@ -71,17 +71,17 @@ bool SimpleNamedParameterFunction::HasNamedParameters() const {
 }
 
 BaseScalarFunction::BaseScalarFunction(string name_p, vector<LogicalType> arguments_p, LogicalType return_type_p,
-                                       FunctionSideEffects side_effects, LogicalType varargs_p,
+                                       FunctionStability stability, LogicalType varargs_p,
                                        FunctionNullHandling null_handling)
     : SimpleFunction(std::move(name_p), std::move(arguments_p), std::move(varargs_p)),
-      return_type(std::move(return_type_p)), side_effects(side_effects), null_handling(null_handling) {
+      return_type(std::move(return_type_p)), stability(stability), null_handling(null_handling) {
 }
 
 BaseScalarFunction::~BaseScalarFunction() {
 }
 
 string BaseScalarFunction::ToString() const {
-	return Function::CallToString(name, arguments, return_type);
+	return Function::CallToString(name, arguments, varargs, return_type);
 }
 
 // add your initializer for new functions here
@@ -118,16 +118,22 @@ hash_t BaseScalarFunction::Hash() const {
 	return hash;
 }
 
-string Function::CallToString(const string &name, const vector<LogicalType> &arguments) {
+string Function::CallToString(const string &name, const vector<LogicalType> &arguments, const LogicalType &varargs) {
 	string result = name + "(";
-	result += StringUtil::Join(arguments, arguments.size(), ", ",
-	                           [](const LogicalType &argument) { return argument.ToString(); });
+	vector<string> string_arguments;
+	for (auto &arg : arguments) {
+		string_arguments.push_back(arg.ToString());
+	}
+	if (varargs.IsValid()) {
+		string_arguments.push_back("[" + varargs.ToString() + "...]");
+	}
+	result += StringUtil::Join(string_arguments, ", ");
 	return result + ")";
 }
 
-string Function::CallToString(const string &name, const vector<LogicalType> &arguments,
+string Function::CallToString(const string &name, const vector<LogicalType> &arguments, const LogicalType &varargs,
                               const LogicalType &return_type) {
-	string result = CallToString(name, arguments);
+	string result = CallToString(name, arguments, varargs);
 	result += " -> " + return_type.ToString();
 	return result;
 }