duckdb 0.8.2-dev87.0 → 0.9.0

package/src/duckdb/src/function/aggregate/distributive/count.cpp

@@ -39,8 +39,8 @@ struct CountStarFunction : public BaseCountFunction {
 	                   Vector &result, idx_t rid, idx_t bias) {
 		D_ASSERT(input_count == 0);
 		auto data = FlatVector::GetData<RESULT_TYPE>(result);
-		const auto begin = frame.first;
-		const auto end = frame.second;
+		const auto begin = frame.start;
+		const auto end = frame.end;
 		// Slice to any filtered rows
 		if (!filter_mask.AllValid()) {
 			RESULT_TYPE filtered = 0;
@@ -218,22 +218,11 @@ AggregateFunction CountFun::GetFunction() {
 	return fun;
 }
 
-static void CountStarSerialize(FieldWriter &writer, const FunctionData *bind_data, const AggregateFunction &function) {
-}
-
-static unique_ptr<FunctionData> CountStarDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                     AggregateFunction &function) {
-	return nullptr;
-}
-
 AggregateFunction CountStarFun::GetFunction() {
 	auto fun = AggregateFunction::NullaryAggregate<int64_t, int64_t, CountStarFunction>(LogicalType::BIGINT);
 	fun.name = "count_star";
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.window = CountStarFunction::Window<int64_t>;
-	// TODO is there a better way to set those?
-	fun.serialize = CountStarSerialize;
-	fun.deserialize = CountStarDeserialize;
 	return fun;
 }
 

package/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp

@@ -374,7 +374,8 @@ struct SortedAggregateFunction {
 
 		// State variables
 		auto bind_info = order_bind.bind_info.get();
-		AggregateInputData aggr_bind_info(bind_info, Allocator::DefaultAllocator());
+		ArenaAllocator allocator(Allocator::DefaultAllocator());
+		AggregateInputData aggr_bind_info(bind_info, allocator);
 
 		// Inner aggregate APIs
 		auto initialize = order_bind.function.initialize;
@@ -467,11 +468,12 @@ struct SortedAggregateFunction {
 
 					// These are all simple updates, so use it if available
 					if (simple_update) {
-						simple_update(sliced.data.data(), aggr_bind_info, 1, agg_state.data(), sliced.size());
+						simple_update(sliced.data.data(), aggr_bind_info, sliced.data.size(), agg_state.data(),
+						              sliced.size());
 					} else {
 						// We are only updating a constant state
 						agg_state_vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-						update(sliced.data.data(), aggr_bind_info, 1, agg_state_vec, sliced.size());
+						update(sliced.data.data(), aggr_bind_info, sliced.data.size(), agg_state_vec, sliced.size());
 					}
 
 					consumed += input_count;
@@ -515,14 +517,6 @@ struct SortedAggregateFunction {
 
 		result.Verify(count);
 	}
-
-	static void Serialize(FieldWriter &writer, const FunctionData *bind_data, const AggregateFunction &function) {
-		throw NotImplementedException("FIXME: serialize sorted aggregate not supported");
-	}
-	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
-	                                            AggregateFunction &function) {
-		throw NotImplementedException("FIXME: deserialize sorted aggregate not supported");
-	}
 };
 
 void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundAggregateExpression &expr,
@@ -581,7 +575,7 @@ void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundAggregateE
 	    AggregateFunction::StateCombine<SortedAggregateState, SortedAggregateFunction>,
 	    SortedAggregateFunction::Finalize, bound_function.null_handling, SortedAggregateFunction::SimpleUpdate, nullptr,
 	    AggregateFunction::StateDestroy<SortedAggregateState, SortedAggregateFunction>, nullptr,
-	    SortedAggregateFunction::Window, SortedAggregateFunction::Serialize, SortedAggregateFunction::Deserialize);
+	    SortedAggregateFunction::Window);
 
 	expr.function = std::move(ordered_aggregate);
 	expr.bind_info = std::move(sorted_bind);

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

@@ -1,3 +1,6 @@
+#include "duckdb/common/hugeint.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/types.hpp"
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/vector_cast_helpers.hpp"
 
@@ -6,9 +9,38 @@ namespace duckdb {
 BoundCastInfo DefaultCasts::BitCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	// now switch on the result type
 	switch (target.id()) {
+	// Numerics
+	case LogicalTypeId::BOOLEAN:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, bool, CastFromBitToNumeric>);
+	case LogicalTypeId::TINYINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int8_t, CastFromBitToNumeric>);
+	case LogicalTypeId::SMALLINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int16_t, CastFromBitToNumeric>);
+	case LogicalTypeId::INTEGER:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int32_t, CastFromBitToNumeric>);
+	case LogicalTypeId::BIGINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int64_t, CastFromBitToNumeric>);
+	case LogicalTypeId::UTINYINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint8_t, CastFromBitToNumeric>);
+	case LogicalTypeId::USMALLINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint16_t, CastFromBitToNumeric>);
+	case LogicalTypeId::UINTEGER:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint32_t, CastFromBitToNumeric>);
+	case LogicalTypeId::UBIGINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint64_t, CastFromBitToNumeric>);
+	case LogicalTypeId::HUGEINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, hugeint_t, CastFromBitToNumeric>);
+	case LogicalTypeId::FLOAT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, float, CastFromBitToNumeric>);
+	case LogicalTypeId::DOUBLE:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, double, CastFromBitToNumeric>);
+
+	case LogicalTypeId::BLOB:
+		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, CastFromBitToBlob>);
+
 	case LogicalTypeId::VARCHAR:
-		// bit to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBit>);
+		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, CastFromBitToString>);
+
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

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

@@ -11,6 +11,9 @@ BoundCastInfo DefaultCasts::BlobCastSwitch(BindCastInput &input, const LogicalTy
 		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBlob>);
 	case LogicalTypeId::AGGREGATE_STATE:
 		return DefaultCasts::ReinterpretCast;
+	case LogicalTypeId::BIT:
+		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBlobToBit>);
+
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

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

@@ -1,3 +1,4 @@
+
 #include "duckdb/function/cast/cast_function_set.hpp"
 
 #include "duckdb/common/pair.hpp"

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

@@ -37,6 +37,8 @@ static BoundCastInfo InternalNumericCastSwitch(const LogicalType &source, const
 		return BoundCastInfo(&VectorCastHelpers::ToDecimalCast<SRC>);
 	case LogicalTypeId::VARCHAR:
 		return BoundCastInfo(&VectorCastHelpers::StringCast<SRC, duckdb::StringCast>);
+	case LogicalTypeId::BIT:
+		return BoundCastInfo(&VectorCastHelpers::StringCast<SRC, duckdb::NumericTryCastToBit>);
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

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

@@ -36,7 +36,6 @@ bool StringEnumCastLoop(const string_t *source_data, ValidityMask &source_mask,
 template <class T>
 bool StringEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	D_ASSERT(source.GetType().id() == LogicalTypeId::VARCHAR);
-	auto enum_name = EnumType::GetTypeName(result.GetType());
 	switch (source.GetVectorType()) {
 	case VectorType::CONSTANT_VECTOR: {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -368,8 +367,9 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 	case LogicalTypeId::DATE:
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, date_t, duckdb::TryCastErrorMessage>);
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, dtime_t, duckdb::TryCastErrorMessage>);
+	case LogicalTypeId::TIME_TZ:
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, dtime_tz_t, duckdb::TryCastErrorMessage>);
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_TZ:
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, timestamp_t, duckdb::TryCastErrorMessage>);

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

@@ -9,10 +9,18 @@ unique_ptr<BoundCastData> StructBoundCastData::BindStructToStructCast(BindCastIn
 	vector<BoundCastInfo> child_cast_info;
 	auto &source_child_types = StructType::GetChildTypes(source);
 	auto &result_child_types = StructType::GetChildTypes(target);
+
+	auto target_is_unnamed = StructType::IsUnnamed(target);
+	auto source_is_unnamed = StructType::IsUnnamed(source);
+
 	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");
+		}
 		auto child_cast = input.GetCastFunction(source_child_types[i].second, result_child_types[i].second);
 		child_cast_info.push_back(std::move(child_cast));
 	}

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

@@ -32,7 +32,7 @@ BoundCastInfo DefaultCasts::TimeCastSwitch(BindCastInput &input, const LogicalTy
 		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_t, duckdb::StringCast>);
 	case LogicalTypeId::TIME_TZ:
 		// time to time with time zone
-		return ReinterpretCast;
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<dtime_t, dtime_tz_t, duckdb::Cast>);
 	default:
 		return TryVectorNullCast;
 	}
@@ -44,10 +44,10 @@ BoundCastInfo DefaultCasts::TimeTzCastSwitch(BindCastInput &input, const Logical
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
 		// time with time zone to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_t, duckdb::StringCastTZ>);
+		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_tz_t, duckdb::StringCastTZ>);
 	case LogicalTypeId::TIME:
 		// time with time zone to time
-		return ReinterpretCast;
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<dtime_tz_t, dtime_t, duckdb::Cast>);
 	default:
 		return TryVectorNullCast;
 	}
@@ -64,9 +64,11 @@ BoundCastInfo DefaultCasts::TimestampCastSwitch(BindCastInput &input, const Logi
 		// timestamp to date
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, date_t, duckdb::Cast>);
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		// timestamp to time
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
+	case LogicalTypeId::TIME_TZ:
+		// timestamp to time_tz
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_tz_t, duckdb::Cast>);
 	case LogicalTypeId::TIMESTAMP_TZ:
 		// timestamp (us) to timestamp with time zone
 		return ReinterpretCast;
@@ -96,8 +98,7 @@ BoundCastInfo DefaultCasts::TimestampTzCastSwitch(BindCastInput &input, const Lo
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::StringCastTZ>);
 	case LogicalTypeId::TIME_TZ:
 		// timestamp with time zone to time with time zone.
-		// TODO: set the offset to +00
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_tz_t, duckdb::Cast>);
 	case LogicalTypeId::TIMESTAMP:
 		// timestamp with time zone to timestamp (us)
 		return ReinterpretCast;
@@ -133,6 +134,10 @@ BoundCastInfo DefaultCasts::TimestampMsCastSwitch(BindCastInput &input, const Lo
 		// timestamp (ms) to timestamp (us)
 		return BoundCastInfo(
 		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampMsToUs>);
+	case LogicalTypeId::TIMESTAMP_NS:
+		// timestamp (ms) to timestamp (ns)
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampMsToNs>);
 	default:
 		return TryVectorNullCast;
 	}
@@ -145,10 +150,18 @@ BoundCastInfo DefaultCasts::TimestampSecCastSwitch(BindCastInput &input, const L
 	case LogicalTypeId::VARCHAR:
 		// timestamp (sec) to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::CastFromTimestampSec>);
+	case LogicalTypeId::TIMESTAMP_MS:
+		// timestamp (s) to timestamp (ms)
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToMs>);
 	case LogicalTypeId::TIMESTAMP:
 		// timestamp (s) to timestamp (us)
 		return BoundCastInfo(
 		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToUs>);
+	case LogicalTypeId::TIMESTAMP_NS:
+		// timestamp (s) to timestamp (ns)
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToNs>);
 	default:
 		return TryVectorNullCast;
 	}

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

@@ -0,0 +1,114 @@
+#include "duckdb/function/cast/bound_cast_data.hpp"
+
+namespace duckdb {
+
+bool StructToUnionCast::AllowImplicitCastFromStruct(const LogicalType &source, const LogicalType &target) {
+	if (source.id() != LogicalTypeId::STRUCT) {
+		return false;
+	}
+	auto target_fields = StructType::GetChildTypes(target);
+	auto fields = StructType::GetChildTypes(source);
+	if (target_fields.size() != fields.size()) {
+		// Struct should have the same amount of fields as the union
+		return false;
+	}
+	for (idx_t i = 0; i < target_fields.size(); i++) {
+		auto &target_field = target_fields[i].second;
+		auto &target_field_name = target_fields[i].first;
+		auto &field = fields[i].second;
+		auto &field_name = fields[i].first;
+		if (i == 0) {
+			// For the tag field we don't accept a type substitute as varchar
+			if (target_field != field) {
+				return false;
+			}
+			continue;
+		}
+		if (!StringUtil::CIEquals(target_field_name, field_name)) {
+			return false;
+		}
+		if (target_field != field && field != LogicalType::VARCHAR) {
+			// We allow the field to be VARCHAR, since unsupported types get cast to VARCHAR by EXPORT DATABASE (format
+			// PARQUET) i.e UNION(a BIT) becomes STRUCT(a VARCHAR)
+			return false;
+		}
+	}
+	return true;
+}
+
+// Physical Cast execution
+
+bool StructToUnionCast::Cast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+	auto &cast_data = parameters.cast_data->Cast<StructBoundCastData>();
+	auto &lstate = parameters.local_state->Cast<StructCastLocalState>();
+
+	D_ASSERT(source.GetType().id() == LogicalTypeId::STRUCT);
+	D_ASSERT(result.GetType().id() == LogicalTypeId::UNION);
+	D_ASSERT(cast_data.target.id() == LogicalTypeId::UNION);
+
+	auto &source_children = StructVector::GetEntries(source);
+	auto &target_children = StructVector::GetEntries(result);
+
+	for (idx_t i = 0; i < source_children.size(); i++) {
+		auto &result_child_vector = *target_children[i];
+		auto &source_child_vector = *source_children[i];
+		CastParameters child_parameters(parameters, cast_data.child_cast_info[i].cast_data, lstate.local_states[i]);
+		auto converted =
+		    cast_data.child_cast_info[i].function(source_child_vector, result_child_vector, count, child_parameters);
+		(void)converted;
+		D_ASSERT(converted);
+	}
+
+	auto check_tags = UnionVector::CheckUnionValidity(result, count);
+	switch (check_tags) {
+	case UnionInvalidReason::TAG_OUT_OF_RANGE:
+		throw ConversionException("One or more of the tags do not point to a valid union member");
+	case UnionInvalidReason::VALIDITY_OVERLAP:
+		throw ConversionException("One or more rows in the produced UNION have validity set for more than 1 member");
+	case UnionInvalidReason::TAG_MISMATCH:
+		throw ConversionException(
+		    "One or more rows in the produced UNION have tags that don't point to the valid member");
+	case UnionInvalidReason::VALID:
+		break;
+	default:
+		throw InternalException("Struct to union cast failed for unknown reason");
+	}
+
+	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		ConstantVector::SetNull(result, ConstantVector::IsNull(source));
+	} else {
+		source.Flatten(count);
+		FlatVector::Validity(result) = FlatVector::Validity(source);
+	}
+	result.Verify(count);
+	return true;
+}
+
+// Bind cast
+
+unique_ptr<BoundCastData> StructToUnionCast::BindData(BindCastInput &input, const LogicalType &source,
+                                                      const LogicalType &target) {
+	vector<BoundCastInfo> child_cast_info;
+	D_ASSERT(source.id() == LogicalTypeId::STRUCT);
+	D_ASSERT(target.id() == LogicalTypeId::UNION);
+
+	auto result_child_count = StructType::GetChildCount(target);
+	D_ASSERT(result_child_count == StructType::GetChildCount(source));
+
+	for (idx_t i = 0; i < result_child_count; i++) {
+		auto &source_child = StructType::GetChildType(source, i);
+		auto &target_child = StructType::GetChildType(target, i);
+
+		auto child_cast = input.GetCastFunction(source_child, target_child);
+		child_cast_info.push_back(std::move(child_cast));
+	}
+	return make_uniq<StructBoundCastData>(std::move(child_cast_info), target);
+}
+
+BoundCastInfo StructToUnionCast::Bind(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
+	auto cast_data = StructToUnionCast::BindData(input, source, target);
+	return BoundCastInfo(&StructToUnionCast::Cast, std::move(cast_data), StructBoundCastData::InitStructCastLocalState);
+}
+
+} // namespace duckdb

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

@@ -11,33 +11,10 @@ namespace duckdb {
 //--------------------------------------------------------------------------------------------------
 // if the source can be implicitly cast to a member of the target union, the cast is valid
 
-struct ToUnionBoundCastData : public BoundCastData {
-	ToUnionBoundCastData(union_tag_t member_idx, string name, LogicalType type, int64_t cost,
-	                     BoundCastInfo member_cast_info)
-	    : tag(member_idx), name(std::move(name)), type(std::move(type)), cost(cost),
-	      member_cast_info(std::move(member_cast_info)) {
-	}
-
-	union_tag_t tag;
-	string name;
-	LogicalType type;
-	int64_t cost;
-	BoundCastInfo member_cast_info;
-
-public:
-	unique_ptr<BoundCastData> Copy() const override {
-		return make_uniq<ToUnionBoundCastData>(tag, name, type, cost, member_cast_info.Copy());
-	}
-
-	static bool SortByCostAscending(const ToUnionBoundCastData &left, const ToUnionBoundCastData &right) {
-		return left.cost < right.cost;
-	}
-};
-
 unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	D_ASSERT(target.id() == LogicalTypeId::UNION);
 
-	vector<ToUnionBoundCastData> candidates;
+	vector<UnionBoundCastData> candidates;
 
 	for (idx_t member_idx = 0; member_idx < UnionType::GetMemberCount(target); member_idx++) {
 		auto member_type = UnionType::GetMemberType(target, member_idx);
@@ -68,7 +45,7 @@ unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalTyp
 	}
 
 	// sort the candidate casts by cost
-	std::sort(candidates.begin(), candidates.end(), ToUnionBoundCastData::SortByCostAscending);
+	std::sort(candidates.begin(), candidates.end(), UnionBoundCastData::SortByCostAscending);
 
 	// select the lowest possible cost cast
 	auto &selected_cast = candidates[0];
@@ -95,11 +72,11 @@ unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalTyp
 	}
 
 	// otherwise, return the selected cast
-	return make_uniq<ToUnionBoundCastData>(std::move(selected_cast));
+	return make_uniq<UnionBoundCastData>(std::move(selected_cast));
 }
 
 unique_ptr<FunctionLocalState> InitToUnionLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<ToUnionBoundCastData>();
+	auto &cast_data = parameters.cast_data->Cast<UnionBoundCastData>();
 	if (!cast_data.member_cast_info.init_local_state) {
 		return nullptr;
 	}
@@ -109,7 +86,7 @@ unique_ptr<FunctionLocalState> InitToUnionLocalState(CastLocalStateParameters &p
 
 static bool ToUnionCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	D_ASSERT(result.GetType().id() == LogicalTypeId::UNION);
-	auto &cast_data = parameters.cast_data->Cast<ToUnionBoundCastData>();
+	auto &cast_data = parameters.cast_data->Cast<UnionBoundCastData>();
 	auto &selected_member_vector = UnionVector::GetMember(result, cast_data.tag);
 
 	CastParameters child_parameters(parameters, cast_data.member_cast_info.cast_data, parameters.local_state);
@@ -127,7 +104,13 @@ 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), InitToUnionLocalState);
+
+	D_ASSERT(target.id() == LogicalTypeId::UNION);
+	if (StructToUnionCast::AllowImplicitCastFromStruct(source, target)) {
+		return StructToUnionCast::Bind(input, source, target);
+	}
+	auto cast_data = BindToUnionCast(input, source, target);
+	return BoundCastInfo(&ToUnionCast, std::move(cast_data), InitToUnionLocalState);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -143,7 +126,7 @@ BoundCastInfo DefaultCasts::ImplicitToUnionCast(BindCastInput &input, const Logi
 // INVALID:	UNION(A, B) 	->	UNION(A, C)		if B can't be implicitly cast to C
 // INVALID:	UNION(A, B, D) 	->	UNION(A, B, C)
 
-struct UnionToUnionBoundCastData : public BoundCastData {
+struct UnionUnionBoundCastData : public BoundCastData {
 
 	// mapping from source member index to target member index
 	// these are always the same size as the source member count
@@ -153,7 +136,7 @@ struct UnionToUnionBoundCastData : public BoundCastData {
 
 	LogicalType target_type;
 
-	UnionToUnionBoundCastData(vector<idx_t> tag_map, vector<BoundCastInfo> member_casts, LogicalType target_type)
+	UnionUnionBoundCastData(vector<idx_t> tag_map, vector<BoundCastInfo> member_casts, LogicalType target_type)
 	    : tag_map(std::move(tag_map)), member_casts(std::move(member_casts)), target_type(std::move(target_type)) {
 	}
 
@@ -163,7 +146,7 @@ public:
 		for (auto &member_cast : member_casts) {
 			member_casts_copy.push_back(member_cast.Copy());
 		}
-		return make_uniq<UnionToUnionBoundCastData>(tag_map, std::move(member_casts_copy), target_type);
+		return make_uniq<UnionUnionBoundCastData>(tag_map, std::move(member_casts_copy), target_type);
 	}
 };
 
@@ -203,11 +186,11 @@ unique_ptr<BoundCastData> BindUnionToUnionCast(BindCastInput &input, const Logic
 		}
 	}
 
-	return make_uniq<UnionToUnionBoundCastData>(tag_map, std::move(member_casts), target);
+	return make_uniq<UnionUnionBoundCastData>(tag_map, std::move(member_casts), target);
 }
 
 unique_ptr<FunctionLocalState> InitUnionToUnionLocalState(CastLocalStateParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<UnionToUnionBoundCastData>();
+	auto &cast_data = parameters.cast_data->Cast<UnionUnionBoundCastData>();
 	auto result = make_uniq<StructCastLocalState>();
 
 	for (auto &entry : cast_data.member_casts) {
@@ -222,7 +205,7 @@ unique_ptr<FunctionLocalState> InitUnionToUnionLocalState(CastLocalStateParamete
 }
 
 static bool UnionToUnionCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	auto &cast_data = parameters.cast_data->Cast<UnionToUnionBoundCastData>();
+	auto &cast_data = parameters.cast_data->Cast<UnionUnionBoundCastData>();
 	auto &lstate = parameters.local_state->Cast<StructCastLocalState>();
 
 	auto source_member_count = UnionType::GetMemberCount(source.GetType());
@@ -313,7 +296,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 = parameters.cast_data->Cast<UnionToUnionBoundCastData>();
+	auto &cast_data = parameters.cast_data->Cast<UnionUnionBoundCastData>();
 	Vector varchar_union(cast_data.target_type, count);
 
 	UnionToUnionCast(source, varchar_union, count, parameters);
@@ -321,6 +304,11 @@ static bool UnionToVarcharCast(Vector &source, Vector &result, idx_t count, Cast
 	// now construct the actual varchar vector
 	varchar_union.Flatten(count);
 	auto &tag_vector = UnionVector::GetTags(source);
+	auto tag_vector_type = tag_vector.GetVectorType();
+	if (tag_vector_type != VectorType::CONSTANT_VECTOR && tag_vector_type != VectorType::FLAT_VECTOR) {
+		tag_vector.Flatten(count);
+	}
+
 	auto tags = FlatVector::GetData<union_tag_t>(tag_vector);
 
 	auto &validity = FlatVector::Validity(varchar_union);
@@ -356,6 +344,7 @@ static bool UnionToVarcharCast(Vector &source, Vector &result, idx_t count, Cast
 
 BoundCastInfo DefaultCasts::UnionCastSwitch(BindCastInput &input, const LogicalType &source,
                                             const LogicalType &target) {
+	D_ASSERT(source.id() == LogicalTypeId::UNION);
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR: {
 		// bind a cast in which we convert all members to VARCHAR first

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

@@ -20,10 +20,16 @@ inline static void SkipWhitespace(const char *buf, idx_t &pos, idx_t len) {
 static bool SkipToCloseQuotes(idx_t &pos, const char *buf, idx_t &len) {
 	char quote = buf[pos];
 	pos++;
+	bool escaped = false;
 
 	while (pos < len) {
-		if (buf[pos] == quote) {
-			return true;
+		if (buf[pos] == '\\') {
+			escaped = !escaped;
+		} else {
+			if (buf[pos] == quote && !escaped) {
+				return true;
+			}
+			escaped = false;
 		}
 		pos++;
 	}
@@ -98,6 +104,9 @@ struct SplitStringListOperation {
 			child_start++;
 			return;
 		}
+		if (start_pos > pos) {
+			pos = start_pos;
+		}
 		child_data[child_start] = StringVector::AddString(child, buf + start_pos, pos - start_pos);
 		child_start++;
 	}
@@ -109,6 +118,7 @@ static bool SplitStringListInternal(const string_t &input, OP &state) {
 	idx_t len = input.GetSize();
 	idx_t lvl = 1;
 	idx_t pos = 0;
+	bool seen_value = false;
 
 	SkipWhitespace(buf, pos, len);
 	if (pos == len || buf[pos] != '[') {
@@ -132,9 +142,10 @@ static bool SplitStringListInternal(const string_t &input, OP &state) {
 			while (StringUtil::CharacterIsSpace(buf[pos - trailing_whitespace - 1])) {
 				trailing_whitespace++;
 			}
-			if (!(buf[pos] == ']' && start_pos == pos)) {
+			if (buf[pos] != ']' || start_pos != pos || seen_value) {
 				state.HandleValue(buf, start_pos, pos - trailing_whitespace);
-			} // else the list is empty
+				seen_value = true;
+			}
 			if (buf[pos] == ']') {
 				lvl--;
 				break;

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

@@ -94,6 +94,8 @@ void BuiltinFunctions::Initialize() {
 
 	RegisterDistributiveAggregates();
 
+	RegisterCompressedMaterializationFunctions();
+
 	RegisterGenericFunctions();
 	RegisterOperators();
 	RegisterSequenceFunctions();
@@ -111,7 +113,7 @@ void BuiltinFunctions::Initialize() {
 hash_t BaseScalarFunction::Hash() const {
 	hash_t hash = return_type.Hash();
 	for (auto &arg : arguments) {
-		duckdb::CombineHash(hash, arg.Hash());
+		hash = duckdb::CombineHash(hash, arg.Hash());
 	}
 	return hash;
 }

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

@@ -1,16 +1,16 @@
 #include "duckdb/function/function_binder.hpp"
-#include "duckdb/common/limits.hpp"
 
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-
-#include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/common/limits.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/aggregate_function.hpp"
 #include "duckdb/function/cast_rules.hpp"
-#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression_binder.hpp"
 
 namespace duckdb {
 
@@ -271,6 +271,16 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogE
 			if (child->return_type == LogicalTypeId::SQLNULL) {
 				return make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL));
 			}
+			if (!child->IsFoldable()) {
+				continue;
+			}
+			Value result;
+			if (!ExpressionExecutor::TryEvaluateScalar(context, *child, result)) {
+				continue;
+			}
+			if (result.IsNull()) {
+				return make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL));
+			}
 		}
 	}
 	return BindScalarFunction(bound_function, std::move(children), is_operator);