duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/include/duckdb/common/types/cast_helpers.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/common/types/decimal.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/types/uhugeint.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "fmt/format.h"
 
@@ -91,6 +92,9 @@ int NumericHelper::UnsignedLength(uint64_t value);
 template <>
 std::string NumericHelper::ToString(hugeint_t value);
 
+template <>
+std::string NumericHelper::ToString(uhugeint_t value);
+
 struct DecimalToString {
 	template <class SIGNED, class UNSIGNED>
 	static int DecimalLength(SIGNED value, uint8_t width, uint8_t scale) {
@@ -248,6 +252,10 @@ struct HugeintToStringCast {
 	static string_t FormatSigned(hugeint_t value, Vector &vector) {
 		int negative = value.upper < 0;
 		if (negative) {
+			if (value == NumericLimits<hugeint_t>::Minimum()) {
+				string_t result = StringVector::AddString(vector, Hugeint::HUGEINT_MINIMUM_STRING);
+				return result;
+			}
 			Hugeint::NegateInPlace(value);
 		}
 		int length = UnsignedLength(value) + negative;
@@ -269,7 +277,9 @@ struct HugeintToStringCast {
 	}
 
 	static int DecimalLength(hugeint_t value, uint8_t width, uint8_t scale) {
+		D_ASSERT(value > NumericLimits<hugeint_t>::Minimum());
 		int negative;
+
 		if (value.upper < 0) {
 			Hugeint::NegateInPlace(value);
 			negative = 1;
@@ -339,6 +349,19 @@ struct HugeintToStringCast {
 	}
 };
 
+struct UhugeintToStringCast {
+	static string_t Format(uhugeint_t value, Vector &vector) {
+		std::string str = value.ToString();
+		string_t result = StringVector::EmptyString(vector, str.length());
+		auto data = result.GetDataWriteable();
+
+		// null-termination not required
+		memcpy(data, str.data(), str.length());
+		result.Finalize();
+		return result;
+	}
+};
+
 struct DateToStringCast {
 	static idx_t Length(int32_t date[], idx_t &year_length, bool &add_bc) {
 		// format is YYYY-MM-DD with optional (BC) at the end
@@ -386,7 +409,7 @@ struct DateToStringCast {
 		}
 		// optionally add BC to the end of the date
 		if (add_bc) {
-			memcpy(ptr, " (BC)", 5);
+			memcpy(ptr, " (BC)", 5); // NOLINT
 		}
 	}
 };
@@ -487,7 +510,7 @@ struct IntervalToStringCast {
 		// append the name together with a potential "s" (for plurals)
 		memcpy(buffer + length, name, name_len);
 		length += name_len;
-		if (value != 1) {
+		if (value != 1 && value != -1) {
 			buffer[length++] = 's';
 		}
 	}
@@ -548,7 +571,7 @@ struct IntervalToStringCast {
 			}
 		} else if (length == 0) {
 			// empty interval: default to 00:00:00
-			memcpy(buffer, "00:00:00", 8);
+			memcpy(buffer, "00:00:00", 8); // NOLINT
 			return 8;
 		}
 		return length;

package/src/duckdb/src/include/duckdb/common/types/conflict_manager.hpp

@@ -1,3 +1,11 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/conflict_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
 #pragma once
 
 #include "duckdb/common/common.hpp"

package/src/duckdb/src/include/duckdb/common/types/data_chunk.hpp

@@ -133,6 +133,9 @@ public:
 	//! Turning all Vectors into Dictionary Vectors, using 'sel'
 	DUCKDB_API void Slice(DataChunk &other, const SelectionVector &sel, idx_t count, idx_t col_offset = 0);
 
+	//! Slice a DataChunk from "offset" to "offset + count"
+	DUCKDB_API void Slice(idx_t offset, idx_t count);
+
 	//! Resets the DataChunk to its state right after the DataChunk::Initialize
 	//! function was called. This sets the count to 0, and resets each member
 	//! Vector to point back to the data owned by this DataChunk.

package/src/duckdb/src/include/duckdb/common/types/date.hpp

@@ -122,6 +122,9 @@ public:
 	DUCKDB_API static date_t FromCString(const char *str, idx_t len, bool strict = false);
 	//! Convert a date object to a string in the format "YYYY-MM-DD"
 	DUCKDB_API static string ToString(date_t date);
+	//! Try to convert the string as a give "special" date (e.g, PINF, ...)
+	//! Returns true if it was successful and updates the scan pos.
+	DUCKDB_API static bool TryConvertDateSpecial(const char *buf, idx_t len, idx_t &pos, const char *special);
 	//! Try to convert text in a buffer to a date; returns true if parsing was successful
 	//! If the date was a "special" value, the special flag will be set.
 	DUCKDB_API static bool TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result, bool &special,

package/src/duckdb/src/include/duckdb/common/types/datetime.hpp

@@ -90,7 +90,7 @@ struct dtime_tz_t { // NOLINT
 	static constexpr const int TIME_BITS = 40;
 	static constexpr const int OFFSET_BITS = 24;
 	static constexpr const uint64_t OFFSET_MASK = ~uint64_t(0) >> TIME_BITS;
-	static constexpr const int32_t MAX_OFFSET = 1559 * 60 * 60;
+	static constexpr const int32_t MAX_OFFSET = 16 * 60 * 60 - 1; // ±15:59:59
 	static constexpr const int32_t MIN_OFFSET = -MAX_OFFSET;
 
 	uint64_t bits;
@@ -98,7 +98,9 @@ struct dtime_tz_t { // NOLINT
 	dtime_tz_t() = default;
 
 	inline dtime_tz_t(dtime_t t, int32_t offset)
-	    : bits((uint64_t(t.micros) << OFFSET_BITS) | uint64_t(offset + MAX_OFFSET)) {
+	    : bits((uint64_t(t.micros) << OFFSET_BITS) | uint64_t(MAX_OFFSET - offset)) {
+	}
+	explicit inline dtime_tz_t(uint64_t bits_p) : bits(bits_p) {
 	}
 
 	inline dtime_t time() const { // NOLINT
@@ -106,7 +108,7 @@ struct dtime_tz_t { // NOLINT
 	}
 
 	inline int32_t offset() const { // NOLINT
-		return int32_t(bits & OFFSET_MASK) - MAX_OFFSET;
+		return MAX_OFFSET - int32_t(bits & OFFSET_MASK);
 	}
 
 	// comparison operators

package/src/duckdb/src/include/duckdb/common/types/hash.hpp

@@ -50,6 +50,8 @@ DUCKDB_API hash_t Hash(int64_t val);
 template <>
 DUCKDB_API hash_t Hash(hugeint_t val);
 template <>
+DUCKDB_API hash_t Hash(uhugeint_t val);
+template <>
 DUCKDB_API hash_t Hash(float val);
 template <>
 DUCKDB_API hash_t Hash(double val);

package/src/duckdb/src/include/duckdb/common/types/hugeint.hpp

@@ -18,6 +18,8 @@ namespace duckdb {
 //! The Hugeint class contains static operations for the INT128 type
 class Hugeint {
 public:
+	constexpr static const char *HUGEINT_MINIMUM_STRING = "-170141183460469231731687303715884105728";
+
 	//! Convert a hugeint object to a string
 	static string ToString(hugeint_t input);
 
@@ -38,38 +40,94 @@ public:
 	static hugeint_t Convert(T value) {
 		hugeint_t result;
 		if (!TryConvert(value, result)) { // LCOV_EXCL_START
-			throw ValueOutOfRangeException(double(value), GetTypeId<T>(), GetTypeId<hugeint_t>());
+			throw OutOfRangeException(double(value), GetTypeId<T>(), GetTypeId<hugeint_t>());
 		} // LCOV_EXCL_STOP
 		return result;
 	}
 
-	static void NegateInPlace(hugeint_t &input) {
-		if (input.upper == NumericLimits<int64_t>::Minimum() && input.lower == 0) {
-			throw OutOfRangeException("HUGEINT is out of range");
+	static bool TryNegate(hugeint_t input, hugeint_t &result);
+
+	template <bool CHECK_OVERFLOW = true>
+	inline static void NegateInPlace(hugeint_t &input) {
+		if (!TryNegate(input, input)) {
+			throw OutOfRangeException("Negation of HUGEINT is out of range!");
 		}
-		input.lower = NumericLimits<uint64_t>::Maximum() - input.lower + 1;
-		input.upper = -1 - input.upper + (input.lower == 0);
 	}
-	static hugeint_t Negate(hugeint_t input) {
-		NegateInPlace(input);
+
+	template <bool CHECK_OVERFLOW = true>
+	inline static hugeint_t Negate(hugeint_t input) {
+		NegateInPlace<CHECK_OVERFLOW>(input);
 		return input;
 	}
 
 	static bool TryMultiply(hugeint_t lhs, hugeint_t rhs, hugeint_t &result);
 
-	static hugeint_t Add(hugeint_t lhs, hugeint_t rhs);
-	static hugeint_t Subtract(hugeint_t lhs, hugeint_t rhs);
-	static hugeint_t Multiply(hugeint_t lhs, hugeint_t rhs);
-	static hugeint_t Divide(hugeint_t lhs, hugeint_t rhs);
-	static hugeint_t Modulo(hugeint_t lhs, hugeint_t rhs);
+	template <bool CHECK_OVERFLOW = true>
+	inline static hugeint_t Multiply(hugeint_t lhs, hugeint_t rhs) {
+		hugeint_t result;
+		if (!TryMultiply(lhs, rhs, result)) {
+			throw OutOfRangeException("Overflow in HUGEINT multiplication: %s + %s", lhs.ToString(), rhs.ToString());
+		}
+		return result;
+	}
+
+	static bool TryDivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &result, hugeint_t &remainder);
+
+	template <bool CHECK_OVERFLOW = true>
+	inline static hugeint_t Divide(hugeint_t lhs, hugeint_t rhs) {
+		// No division by zero
+		if (rhs == 0) {
+			throw OutOfRangeException("Division of HUGEINT by zero!");
+		}
+
+		// division only has one reason to overflow: MINIMUM / -1
+		if (lhs == NumericLimits<hugeint_t>::Minimum() && rhs == -1) {
+			throw OutOfRangeException("Overflow in HUGEINT division: %s + %s", lhs.ToString(), rhs.ToString());
+		}
+		return Divide<false>(lhs, rhs);
+	}
+
+	template <bool CHECK_OVERFLOW = true>
+	inline static hugeint_t Modulo(hugeint_t lhs, hugeint_t rhs) {
+		// No division by zero
+		if (rhs == 0) {
+			throw OutOfRangeException("Modulo of HUGEINT by zero: %s + %s", lhs.ToString(), rhs.ToString());
+		}
+
+		// division only has one reason to overflow: MINIMUM / -1
+		if (lhs == NumericLimits<hugeint_t>::Minimum() && rhs == -1) {
+			throw OutOfRangeException("Overflow in HUGEINT modulo: %s + %s", lhs.ToString(), rhs.ToString());
+		}
+		return Modulo<false>(lhs, rhs);
+	}
+
+	static bool TryAddInPlace(hugeint_t &lhs, hugeint_t rhs);
+
+	template <bool CHECK_OVERFLOW = true>
+	inline static hugeint_t Add(hugeint_t lhs, hugeint_t rhs) {
+		if (!TryAddInPlace(lhs, rhs)) {
+			throw OutOfRangeException("Overflow in HUGEINT addition: %s + %s", lhs.ToString(), rhs.ToString());
+		}
+		return lhs;
+	}
+
+	static bool TrySubtractInPlace(hugeint_t &lhs, hugeint_t rhs);
+
+	template <bool CHECK_OVERFLOW = true>
+	inline static hugeint_t Subtract(hugeint_t lhs, hugeint_t rhs) {
+		if (!TrySubtractInPlace(lhs, rhs)) {
+			throw OutOfRangeException("Underflow in HUGEINT addition: %s - %s", lhs.ToString(), rhs.ToString());
+		}
+		return lhs;
+	}
 
 	// DivMod -> returns the result of the division (lhs / rhs), and fills up the remainder
 	static hugeint_t DivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &remainder);
 	// DivMod but lhs MUST be positive, and rhs is a uint64_t
 	static hugeint_t DivModPositive(hugeint_t lhs, uint64_t rhs, uint64_t &remainder);
 
-	static bool AddInPlace(hugeint_t &lhs, hugeint_t rhs);
-	static bool SubtractInPlace(hugeint_t &lhs, hugeint_t rhs);
+	static int Sign(hugeint_t n);
+	static hugeint_t Abs(hugeint_t n);
 
 	// comparison operators
 	// note that everywhere here we intentionally use bitwise ops
@@ -79,35 +137,41 @@ public:
 		int upper_equals = lhs.upper == rhs.upper;
 		return lower_equals & upper_equals;
 	}
+
 	static bool NotEquals(hugeint_t lhs, hugeint_t rhs) {
 		int lower_not_equals = lhs.lower != rhs.lower;
 		int upper_not_equals = lhs.upper != rhs.upper;
 		return lower_not_equals | upper_not_equals;
 	}
+
 	static bool GreaterThan(hugeint_t lhs, hugeint_t rhs) {
 		int upper_bigger = lhs.upper > rhs.upper;
 		int upper_equal = lhs.upper == rhs.upper;
 		int lower_bigger = lhs.lower > rhs.lower;
 		return upper_bigger | (upper_equal & lower_bigger);
 	}
+
 	static bool GreaterThanEquals(hugeint_t lhs, hugeint_t rhs) {
 		int upper_bigger = lhs.upper > rhs.upper;
 		int upper_equal = lhs.upper == rhs.upper;
 		int lower_bigger_equals = lhs.lower >= rhs.lower;
 		return upper_bigger | (upper_equal & lower_bigger_equals);
 	}
+
 	static bool LessThan(hugeint_t lhs, hugeint_t rhs) {
 		int upper_smaller = lhs.upper < rhs.upper;
 		int upper_equal = lhs.upper == rhs.upper;
 		int lower_smaller = lhs.lower < rhs.lower;
 		return upper_smaller | (upper_equal & lower_smaller);
 	}
+
 	static bool LessThanEquals(hugeint_t lhs, hugeint_t rhs) {
 		int upper_smaller = lhs.upper < rhs.upper;
 		int upper_equal = lhs.upper == rhs.upper;
 		int lower_smaller_equals = lhs.lower <= rhs.lower;
 		return upper_smaller | (upper_equal & lower_smaller_equals);
 	}
+
 	static const hugeint_t POWERS_OF_TEN[40];
 };
 
@@ -130,6 +194,8 @@ DUCKDB_API bool Hugeint::TryCast(hugeint_t input, uint64_t &result);
 template <>
 DUCKDB_API bool Hugeint::TryCast(hugeint_t input, hugeint_t &result);
 template <>
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, uhugeint_t &result);
+template <>
 DUCKDB_API bool Hugeint::TryCast(hugeint_t input, float &result);
 template <>
 DUCKDB_API bool Hugeint::TryCast(hugeint_t input, double &result);

package/src/duckdb/src/include/duckdb/common/types/interval.hpp

@@ -14,18 +14,63 @@ namespace duckdb {
 
 struct dtime_t;
 struct date_t;
+struct dtime_tz_t;
 struct timestamp_t;
 
 class Serializer;
 class Deserializer;
 
-struct interval_t {
+struct interval_t { // NOLINT
 	int32_t months;
 	int32_t days;
 	int64_t micros;
 
-	inline bool operator==(const interval_t &rhs) const {
-		return this->days == rhs.days && this->months == rhs.months && this->micros == rhs.micros;
+	inline void Normalize(int64_t &months, int64_t &days, int64_t &micros) const;
+	inline bool operator==(const interval_t &right) const {
+		//	Quick equality check
+		const auto &left = *this;
+		if (left.months == right.months && left.days == right.days && left.micros == right.micros) {
+			return true;
+		}
+
+		int64_t lmonths, ldays, lmicros;
+		int64_t rmonths, rdays, rmicros;
+		left.Normalize(lmonths, ldays, lmicros);
+		right.Normalize(rmonths, rdays, rmicros);
+
+		return lmonths == rmonths && ldays == rdays && lmicros == rmicros;
+	}
+
+	inline bool operator>(const interval_t &right) const {
+		const auto &left = *this;
+		int64_t lmonths, ldays, lmicros;
+		int64_t rmonths, rdays, rmicros;
+		left.Normalize(lmonths, ldays, lmicros);
+		right.Normalize(rmonths, rdays, rmicros);
+
+		if (lmonths > rmonths) {
+			return true;
+		} else if (lmonths < rmonths) {
+			return false;
+		}
+		if (ldays > rdays) {
+			return true;
+		} else if (ldays < rdays) {
+			return false;
+		}
+		return lmicros > rmicros;
+	}
+
+	inline bool operator<(const interval_t &right) const {
+		return right > *this;
+	}
+
+	inline bool operator<=(const interval_t &right) const {
+		return !(*this > right);
+	}
+
+	inline bool operator>=(const interval_t &right) const {
+		return !(*this < right);
 	}
 
 	// Serialization
@@ -106,12 +151,18 @@ public:
 	//! Add an interval to a time. In case the time overflows or underflows, modify the date by the overflow.
 	//! For example if we go from 23:00 to 02:00, we add a day to the date
 	static dtime_t Add(dtime_t left, interval_t right, date_t &date);
+	static dtime_tz_t Add(dtime_tz_t left, interval_t right, date_t &date);
 
 	//! Comparison operators
-	inline static bool Equals(const interval_t &left, const interval_t &right);
-	inline static bool GreaterThan(const interval_t &left, const interval_t &right);
+	inline static bool Equals(const interval_t &left, const interval_t &right) {
+		return left == right;
+	}
+	inline static bool GreaterThan(const interval_t &left, const interval_t &right) {
+		return left > right;
+	}
 };
-static void NormalizeIntervalEntries(interval_t input, int64_t &months, int64_t &days, int64_t &micros) {
+void interval_t::Normalize(int64_t &months, int64_t &days, int64_t &micros) const {
+	auto input = *this;
 	int64_t extra_months_d = input.days / Interval::DAYS_PER_MONTH;
 	int64_t extra_months_micros = input.micros / Interval::MICROS_PER_MONTH;
 	input.days -= extra_months_d * Interval::DAYS_PER_MONTH;
@@ -125,27 +176,4 @@ static void NormalizeIntervalEntries(interval_t input, int64_t &months, int64_t
 	micros = input.micros;
 }
 
-bool Interval::Equals(const interval_t &left, const interval_t &right) {
-	return left.months == right.months && left.days == right.days && left.micros == right.micros;
-}
-
-bool Interval::GreaterThan(const interval_t &left, const interval_t &right) {
-	int64_t lmonths, ldays, lmicros;
-	int64_t rmonths, rdays, rmicros;
-	NormalizeIntervalEntries(left, lmonths, ldays, lmicros);
-	NormalizeIntervalEntries(right, rmonths, rdays, rmicros);
-
-	if (lmonths > rmonths) {
-		return true;
-	} else if (lmonths < rmonths) {
-		return false;
-	}
-	if (ldays > rdays) {
-		return true;
-	} else if (ldays < rdays) {
-		return false;
-	}
-	return lmicros > rmicros;
-}
-
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/list_segment.hpp

@@ -51,7 +51,7 @@ struct ListSegmentFunctions {
 
 	void AppendRow(ArenaAllocator &allocator, LinkedList &linked_list, RecursiveUnifiedVectorFormat &input_data,
 	               idx_t &entry_idx) const;
-	void BuildListVector(const LinkedList &linked_list, Vector &result, idx_t &initial_total_count) const;
+	void BuildListVector(const LinkedList &linked_list, Vector &result, idx_t total_count) const;
 };
 
 void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType &type);

package/src/duckdb/src/include/duckdb/common/types/row/partitioned_tuple_data.hpp

@@ -82,7 +82,7 @@ public:
 	//! Unpins the data
 	void Unpin();
 	//! Get the partitions in this PartitionedTupleData
-	vector<unique_ptr<TupleDataCollection>> &GetPartitions();
+	unsafe_vector<unique_ptr<TupleDataCollection>> &GetPartitions();
 	//! Get the data of this PartitionedTupleData as a single unpartitioned TupleDataCollection
 	unique_ptr<TupleDataCollection> GetUnpartitioned();
 	//! Get the count of this PartitionedTupleData
@@ -91,6 +91,8 @@ public:
 	idx_t SizeInBytes() const;
 	//! Get the number of partitions of this PartitionedTupleData
 	idx_t PartitionCount() const;
+	//! Get the count and size of the largest partition
+	void GetSizesAndCounts(vector<idx_t> &partition_sizes, vector<idx_t> &partition_counts) const;
 	//! Converts this PartitionedTupleData to a string representation
 	string ToString();
 	//! Prints the string representation of this PartitionedTupleData
@@ -169,7 +171,7 @@ protected:
 
 	mutex lock;
 	shared_ptr<PartitionTupleDataAllocators> allocators;
-	vector<unique_ptr<TupleDataCollection>> partitions;
+	unsafe_vector<unique_ptr<TupleDataCollection>> partitions;
 
 public:
 	template <class TARGET>

package/src/duckdb/src/include/duckdb/common/types/row/row_data_collection.hpp

@@ -17,10 +17,10 @@ namespace duckdb {
 
 struct RowDataBlock {
 public:
-	RowDataBlock(BufferManager &buffer_manager, idx_t capacity, idx_t entry_size)
+	RowDataBlock(MemoryTag tag, BufferManager &buffer_manager, idx_t capacity, idx_t entry_size)
 	    : capacity(capacity), entry_size(entry_size), count(0), byte_offset(0) {
 		idx_t size = MaxValue<idx_t>(Storage::BLOCK_SIZE, capacity * entry_size);
-		buffer_manager.Allocate(size, false, &block);
+		buffer_manager.Allocate(tag, size, false, &block);
 		D_ASSERT(BufferManager::GetAllocSize(size) == block->GetMemoryUsage());
 	}
 	explicit RowDataBlock(idx_t entry_size) : entry_size(entry_size) {

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_collection.hpp

@@ -33,7 +33,7 @@ struct TupleDataScatterFunction {
 
 typedef void (*tuple_data_gather_function_t)(const TupleDataLayout &layout, Vector &row_locations, const idx_t col_idx,
                                              const SelectionVector &scan_sel, const idx_t scan_count, Vector &target,
-                                             const SelectionVector &target_sel, Vector &list_vector,
+                                             const SelectionVector &target_sel, optional_ptr<Vector> list_vector,
                                              const vector<TupleDataGatherFunction> &child_functions);
 
 struct TupleDataGatherFunction {
@@ -68,9 +68,9 @@ public:
 	void Unpin();
 
 	//! Gets the scatter function for the given type
-	static TupleDataScatterFunction GetScatterFunction(const LogicalType &type, bool within_list = false);
+	static TupleDataScatterFunction GetScatterFunction(const LogicalType &type, bool within_collection = false);
 	//! Gets the gather function for the given type
-	static TupleDataGatherFunction GetGatherFunction(const LogicalType &type, bool within_list = false);
+	static TupleDataGatherFunction GetGatherFunction(const LogicalType &type);
 
 	//! Initializes an Append state - useful for optimizing many appends made to the same tuple data collection
 	void InitializeAppend(TupleDataAppendState &append_state,
@@ -168,15 +168,16 @@ public:
 
 	//! Gathers a DataChunk from the TupleDataCollection, given the specific row locations (requires full pin)
 	void Gather(Vector &row_locations, const SelectionVector &scan_sel, const idx_t scan_count, DataChunk &result,
-	            const SelectionVector &target_sel) const;
+	            const SelectionVector &target_sel, vector<unique_ptr<Vector>> &cached_cast_vectors) const;
 	//! Gathers a DataChunk (only the columns given by column_ids) from the TupleDataCollection,
 	//! given the specific row locations (requires full pin)
 	void Gather(Vector &row_locations, const SelectionVector &scan_sel, const idx_t scan_count,
-	            const vector<column_t> &column_ids, DataChunk &result, const SelectionVector &target_sel) const;
+	            const vector<column_t> &column_ids, DataChunk &result, const SelectionVector &target_sel,
+	            vector<unique_ptr<Vector>> &cached_cast_vectors) const;
 	//! Gathers a Vector (from the given column id) from the TupleDataCollection
 	//! given the specific row locations (requires full pin)
 	void Gather(Vector &row_locations, const SelectionVector &sel, const idx_t scan_count, const column_t column_id,
-	            Vector &result, const SelectionVector &target_sel) const;
+	            Vector &result, const SelectionVector &target_sel, optional_ptr<Vector> cached_cast_vector) const;
 
 	//! Converts this TupleDataCollection to a string representation
 	string ToString();
@@ -198,27 +199,30 @@ private:
 	static void ComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v, TupleDataVectorFormat &source,
 	                             const SelectionVector &append_sel, const idx_t append_count);
 	//! Computes the heap sizes for the specific Vector that will be appended (within a list)
-	static void WithinListHeapComputeSizes(Vector &heap_sizes_v, const Vector &source_v,
-	                                       TupleDataVectorFormat &source_format, const SelectionVector &append_sel,
-	                                       const idx_t append_count, const UnifiedVectorFormat &list_data);
-	//! Computes the heap sizes for the fixed-size type Vector that will be appended (within a list)
-	static void ComputeFixedWithinListHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-	                                            TupleDataVectorFormat &source_format, const SelectionVector &append_sel,
-	                                            const idx_t append_count, const UnifiedVectorFormat &list_data);
-	//! Computes the heap sizes for the string Vector that will be appended (within a list)
-	static void StringWithinListComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
+	static void WithinCollectionComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
 	                                             TupleDataVectorFormat &source_format,
 	                                             const SelectionVector &append_sel, const idx_t append_count,
 	                                             const UnifiedVectorFormat &list_data);
+	//! Computes the heap sizes for the fixed-size type Vector that will be appended (within a list)
+	static void ComputeFixedWithinCollectionHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
+	                                                  TupleDataVectorFormat &source_format,
+	                                                  const SelectionVector &append_sel, const idx_t append_count,
+	                                                  const UnifiedVectorFormat &list_data);
+	//! Computes the heap sizes for the string Vector that will be appended (within a list)
+	static void StringWithinCollectionComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
+	                                                   TupleDataVectorFormat &source_format,
+	                                                   const SelectionVector &append_sel, const idx_t append_count,
+	                                                   const UnifiedVectorFormat &list_data);
 	//! Computes the heap sizes for the struct Vector that will be appended (within a list)
-	static void StructWithinListComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-	                                             TupleDataVectorFormat &source_format,
-	                                             const SelectionVector &append_sel, const idx_t append_count,
-	                                             const UnifiedVectorFormat &list_data);
+	static void StructWithinCollectionComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
+	                                                   TupleDataVectorFormat &source_format,
+	                                                   const SelectionVector &append_sel, const idx_t append_count,
+	                                                   const UnifiedVectorFormat &list_data);
 	//! Computes the heap sizes for the list Vector that will be appended (within a list)
-	static void ListWithinListComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
-	                                           TupleDataVectorFormat &source_format, const SelectionVector &append_sel,
-	                                           const idx_t append_count, const UnifiedVectorFormat &list_data);
+	static void CollectionWithinCollectionComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
+	                                                       TupleDataVectorFormat &source_format,
+	                                                       const SelectionVector &append_sel, const idx_t append_count,
+	                                                       const UnifiedVectorFormat &list_data);
 
 	//! Get the next segment/chunk index for the scan
 	bool NextScanIndex(TupleDataScanState &scan_state, idx_t &segment_index, idx_t &chunk_index);

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_states.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/perfect_map_set.hpp"
 #include "duckdb/common/types.hpp"
+#include "duckdb/common/types/vector_cache.hpp"
 
 namespace duckdb {
 
@@ -45,6 +46,9 @@ struct TupleDataVectorFormat {
 	UnifiedVectorFormat unified;
 	vector<TupleDataVectorFormat> children;
 	unique_ptr<CombinedListData> combined_list_data;
+
+	// Optional: only used for ArrayVector to fake being a list vector
+	unique_array<list_entry_t> array_list_entries;
 };
 
 struct TupleDataChunkState {
@@ -54,6 +58,9 @@ struct TupleDataChunkState {
 	Vector row_locations = Vector(LogicalType::POINTER);
 	Vector heap_locations = Vector(LogicalType::POINTER);
 	Vector heap_sizes = Vector(LogicalType::UBIGINT);
+
+	vector<unique_ptr<Vector>> cached_cast_vectors;
+	vector<unique_ptr<VectorCache>> cached_cast_vector_cache;
 };
 
 struct TupleDataAppendState {

package/src/duckdb/src/include/duckdb/common/types/string_type.hpp

@@ -80,17 +80,21 @@ public:
 	}
 
 	const char *GetPrefix() const {
-		return value.pointer.prefix;
+		return value.inlined.inlined;
 	}
 
 	char *GetPrefixWriteable() const {
-		return (char *)value.pointer.prefix;
+		return (char *)value.inlined.inlined;
 	}
 
 	idx_t GetSize() const {
 		return value.inlined.length;
 	}
 
+	bool Empty() const {
+		return value.inlined.length == 0;
+	}
+
 	string GetString() const {
 		return string(GetData(), GetSize());
 	}
@@ -113,9 +117,7 @@ public:
 		// set trailing NULL byte
 		if (GetSize() <= INLINE_LENGTH) {
 			// fill prefix with zeros if the length is smaller than the prefix length
-			for (idx_t i = GetSize(); i < INLINE_BYTES; i++) {
-				value.inlined.inlined[i] = '\0';
-			}
+			memset(value.inlined.inlined + GetSize(), 0, INLINE_BYTES - GetSize());
 		} else {
 			// copy the data into the prefix
 #ifndef DUCKDB_DEBUG_NO_INLINE