duckdb 0.10.1-dev9.0 → 0.10.1

package/src/duckdb/src/include/duckdb/common/sort/duckdb_pdqsort.hpp

@@ -401,7 +401,7 @@ inline std::pair<PDQIterator, bool> partition_right_branchless(const PDQIterator
 
 			// Fill the offset blocks.
 			if (left_split >= block_size) {
-				for (size_t i = 0; i < block_size;) {
+				for (unsigned char i = 0; i < block_size;) {
 					offsets_l[num_l] = i++;
 					num_l += !comp(*first, pivot, constants);
 					++first;
@@ -428,7 +428,7 @@ inline std::pair<PDQIterator, bool> partition_right_branchless(const PDQIterator
 					++first;
 				}
 			} else {
-				for (size_t i = 0; i < left_split;) {
+				for (unsigned char i = 0; i < left_split;) {
 					offsets_l[num_l] = i++;
 					num_l += !comp(*first, pivot, constants);
 					++first;
@@ -436,7 +436,7 @@ inline std::pair<PDQIterator, bool> partition_right_branchless(const PDQIterator
 			}
 
 			if (right_split >= block_size) {
-				for (size_t i = 0; i < block_size;) {
+				for (unsigned char i = 0; i < block_size;) {
 					offsets_r[num_r] = ++i;
 					num_r += comp(*--last, pivot, constants);
 					offsets_r[num_r] = ++i;
@@ -455,7 +455,7 @@ inline std::pair<PDQIterator, bool> partition_right_branchless(const PDQIterator
 					num_r += comp(*--last, pivot, constants);
 				}
 			} else {
-				for (size_t i = 0; i < right_split;) {
+				for (unsigned char i = 0; i < right_split;) {
 					offsets_r[num_r] = ++i;
 					num_r += comp(*--last, pivot, constants);
 				}

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

@@ -113,7 +113,7 @@ template <class T>
 string Bit::NumericToBit(T numeric) {
 	auto bit_len = sizeof(T) + 1;
 	auto buffer = make_unsafe_uniq_array<char>(bit_len);
-	string_t output_str(buffer.get(), bit_len);
+	string_t output_str(buffer.get(), UnsafeNumericCast<uint32_t>(bit_len));
 	Bit::NumericToBit(numeric, output_str);
 	return output_str.GetString();
 }

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

@@ -12,6 +12,7 @@
 #include "duckdb/common/types.hpp"
 
 namespace duckdb {
+struct CastParameters;
 
 //! The Blob class is a static class that holds helper functions for the Blob type.
 class Blob {
@@ -35,13 +36,15 @@ public:
 	DUCKDB_API static string ToString(string_t blob);
 
 	//! Returns the blob size of a string -> blob conversion
-	DUCKDB_API static bool TryGetBlobSize(string_t str, idx_t &result_size, string *error_message);
+	DUCKDB_API static bool TryGetBlobSize(string_t str, idx_t &result_size, CastParameters &parameters);
 	DUCKDB_API static idx_t GetBlobSize(string_t str);
+	DUCKDB_API static idx_t GetBlobSize(string_t str, CastParameters &parameters);
 	//! Convert a string to a blob. This function should ONLY be called after calling GetBlobSize, since it does NOT
 	//! perform data validation.
 	DUCKDB_API static void ToBlob(string_t str, data_ptr_t output);
 	//! Convert a string object to a blob
 	DUCKDB_API static string ToBlob(string_t str);
+	DUCKDB_API static string ToBlob(string_t str, CastParameters &parameters);
 
 	// base 64 conversion functions
 	//! Returns the string size of a blob -> base64 conversion

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/types/decimal.hpp"
 #include "duckdb/common/types/interval.hpp"
@@ -32,7 +33,7 @@ public:
 	template <class SIGNED, class UNSIGNED>
 	static int SignedLength(SIGNED value) {
 		int sign = -(value < 0);
-		UNSIGNED unsigned_value = (value ^ sign) - sign;
+		UNSIGNED unsigned_value = UnsafeNumericCast<UNSIGNED>((value ^ sign) - sign);
 		return UnsignedLength(unsigned_value) - sign;
 	}
 
@@ -43,16 +44,16 @@ public:
 			// Integer division is slow so do it for a group of two digits instead
 			// of for every digit. The idea comes from the talk by Alexandrescu
 			// "Three Optimization Tips for C++".
-			auto index = static_cast<unsigned>((value % 100) * 2);
+			auto index = NumericCast<unsigned>((value % 100) * 2);
 			value /= 100;
 			*--ptr = duckdb_fmt::internal::data::digits[index + 1];
 			*--ptr = duckdb_fmt::internal::data::digits[index];
 		}
 		if (value < 10) {
-			*--ptr = static_cast<char>('0' + value);
+			*--ptr = NumericCast<char>('0' + value);
 			return ptr;
 		}
-		auto index = static_cast<unsigned>(value * 2);
+		auto index = NumericCast<unsigned>(value * 2);
 		*--ptr = duckdb_fmt::internal::data::digits[index + 1];
 		*--ptr = duckdb_fmt::internal::data::digits[index];
 		return ptr;
@@ -61,7 +62,7 @@ public:
 	template <class SIGNED, class UNSIGNED>
 	static string_t FormatSigned(SIGNED value, Vector &vector) {
 		int sign = -(value < 0);
-		UNSIGNED unsigned_value = UNSIGNED(value ^ sign) - sign;
+		UNSIGNED unsigned_value = UnsafeNumericCast<UNSIGNED>(UNSIGNED(value ^ sign) - sign);
 		int length = UnsignedLength<UNSIGNED>(unsigned_value) - sign;
 		string_t result = StringVector::EmptyString(vector, length);
 		auto dataptr = result.GetDataWriteable();
@@ -239,7 +240,7 @@ struct HugeintToStringCast {
 			// the remainder is small (i.e. less than 10000000000000000)
 			ptr = NumericHelper::FormatUnsigned<uint64_t>(remainder, ptr);
 
-			int format_length = startptr - ptr;
+			int format_length = UnsafeNumericCast<int>(startptr - ptr);
 			// pad with zero
 			for (int i = format_length; i < 17; i++) {
 				*--ptr = '0';
@@ -399,9 +400,9 @@ struct DateToStringCast {
 			ptr[0] = '-';
 			if (date[i] < 10) {
 				ptr[1] = '0';
-				ptr[2] = '0' + date[i];
+				ptr[2] = '0' + UnsafeNumericCast<char>(date[i]);
 			} else {
-				auto index = static_cast<unsigned>(date[i] * 2);
+				auto index = UnsafeNumericCast<idx_t>(date[i] * 2);
 				ptr[1] = duckdb_fmt::internal::data::digits[index];
 				ptr[2] = duckdb_fmt::internal::data::digits[index + 1];
 			}
@@ -429,7 +430,7 @@ struct TimeToStringCast {
 			}
 			trailing_zeros++;
 		}
-		return trailing_zeros;
+		return UnsafeNumericCast<int32_t>(trailing_zeros);
 	}
 
 	static idx_t Length(int32_t time[], char micro_buffer[]) {
@@ -456,9 +457,9 @@ struct TimeToStringCast {
 		D_ASSERT(value >= 0 && value <= 99);
 		if (value < 10) {
 			ptr[0] = '0';
-			ptr[1] = '0' + value;
+			ptr[1] = '0' + UnsafeNumericCast<char>(value);
 		} else {
-			auto index = static_cast<unsigned>(value * 2);
+			auto index = UnsafeNumericCast<unsigned>(value * 2);
 			ptr[0] = duckdb_fmt::internal::data::digits[index];
 			ptr[1] = duckdb_fmt::internal::data::digits[index + 1];
 		}
@@ -494,7 +495,7 @@ struct IntervalToStringCast {
 	}
 
 	static void FormatTwoDigits(int64_t value, char buffer[], idx_t &length) {
-		TimeToStringCast::FormatTwoDigits(buffer + length, value);
+		TimeToStringCast::FormatTwoDigits(buffer + length, UnsafeNumericCast<int32_t>(value));
 		length += 2;
 	}
 
@@ -566,7 +567,8 @@ struct IntervalToStringCast {
 			FormatTwoDigits(sec, buffer, length);
 			if (micros != 0) {
 				buffer[length++] = '.';
-				auto trailing_zeros = TimeToStringCast::FormatMicros(micros, buffer + length);
+				auto trailing_zeros =
+				    TimeToStringCast::FormatMicros(UnsafeNumericCast<uint32_t>(micros), buffer + length);
 				length += 6 - trailing_zeros;
 			}
 		} else if (length == 0) {

package/src/duckdb/src/include/duckdb/common/types/column/column_data_allocator.hpp

@@ -56,6 +56,9 @@ public:
 		}
 		return total_size;
 	}
+	idx_t AllocationSize() const {
+		return allocated_size;
+	}
 
 public:
 	void AllocateData(idx_t size, uint32_t &block_id, uint32_t &offset, ChunkManagementState *chunk_state);
@@ -99,6 +102,8 @@ private:
 	bool shared = false;
 	//! Lock used in case this ColumnDataAllocator is shared across threads
 	mutex lock;
+	//! Total allocated size
+	idx_t allocated_size = 0;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection.hpp

@@ -63,6 +63,8 @@ public:
 
 	//! The size (in bytes) of this ColumnDataCollection
 	idx_t SizeInBytes() const;
+	//! The allocation size (in bytes) of this ColumnDataCollection - this property is cached
+	idx_t AllocationSize() const;
 
 	//! Get the allocator
 	DUCKDB_API Allocator &GetAllocator() const;

package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection_segment.hpp

@@ -126,7 +126,10 @@ public:
 	}
 
 	idx_t ChunkCount() const;
+	//! Get the total *used* size (not cached)
 	idx_t SizeInBytes() const;
+	//! Get the currently allocated size in bytes (cached)
+	idx_t AllocationSize() const;
 
 	void FetchChunk(idx_t chunk_idx, DataChunk &result);
 	void FetchChunk(idx_t chunk_idx, DataChunk &result, const vector<column_t> &column_ids);

package/src/duckdb/src/include/duckdb/common/types/column/partitioned_column_data.hpp

@@ -112,7 +112,7 @@ protected:
 public:
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>

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

@@ -176,7 +176,7 @@ protected:
 public:
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>

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

@@ -34,9 +34,12 @@ struct TupleDataPinState {
 };
 
 struct CombinedListData {
+	CombinedListData() : combined_validity(STANDARD_VECTOR_SIZE) {
+	}
 	UnifiedVectorFormat combined_data;
-	list_entry_t combined_list_entries[STANDARD_VECTOR_SIZE];
 	buffer_ptr<SelectionData> selection_data;
+	list_entry_t combined_list_entries[STANDARD_VECTOR_SIZE];
+	ValidityMask combined_validity;
 };
 
 struct TupleDataVectorFormat {

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/vector_size.hpp"
 
@@ -83,7 +84,7 @@ public:
 	}
 
 	inline void set_index(idx_t idx, idx_t loc) {
-		sel_vector[idx] = loc;
+		sel_vector[idx] = UnsafeNumericCast<sel_t>(loc);
 	}
 	inline void swap(idx_t i, idx_t j) {
 		sel_t tmp = sel_vector[i];

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

@@ -40,6 +40,8 @@ public:
 
 	//! Size of strings
 	DUCKDB_API idx_t SizeInBytes() const;
+	//! Total allocation size (cached)
+	DUCKDB_API idx_t AllocationSize() const;
 
 private:
 	ArenaAllocator allocator;

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

@@ -11,6 +11,7 @@
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/helper.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 
 #include <cstring>
 
@@ -58,10 +59,14 @@ public:
 			value.pointer.ptr = (char *)data; // NOLINT
 		}
 	}
-	string_t(const char *data) : string_t(data, strlen(data)) { // NOLINT: Allow implicit conversion from `const char*`
+
+	string_t(const char *data)
+	    : string_t(data,
+	               UnsafeNumericCast<uint32_t>(strlen(data))) { // NOLINT: Allow implicit conversion from `const char*`
 	}
 	string_t(const string &value)
-	    : string_t(value.c_str(), value.size()) { // NOLINT: Allow implicit conversion from `const char*`
+	    : string_t(value.c_str(),
+	               UnsafeNumericCast<uint32_t>(value.size())) { // NOLINT: Allow implicit conversion from `const char*`
 	}
 
 	bool IsInlined() const {
@@ -130,6 +135,8 @@ public:
 	}
 
 	void Verify() const;
+	void VerifyUTF8() const;
+	void VerifyCharacters() const;
 	void VerifyNull() const;
 
 	struct StringComparisonOperators {
@@ -165,8 +172,8 @@ public:
 		}
 		// compare up to shared length. if still the same, compare lengths
 		static bool GreaterThan(const string_t &left, const string_t &right) {
-			const uint32_t left_length = left.GetSize();
-			const uint32_t right_length = right.GetSize();
+			const uint32_t left_length = UnsafeNumericCast<uint32_t>(left.GetSize());
+			const uint32_t right_length = UnsafeNumericCast<uint32_t>(right.GetSize());
 			const uint32_t min_length = std::min<uint32_t>(left_length, right_length);
 
 #ifndef DUCKDB_DEBUG_NO_INLINE

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

@@ -26,7 +26,7 @@ public:
 	DUCKDB_API static dtime_t FromCString(const char *buf, idx_t len, bool strict = false);
 	DUCKDB_API static bool TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict = false);
 	DUCKDB_API static bool TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &result,
-	                                        bool strict = false);
+	                                        bool &has_offset, bool strict = false);
 	// No hour limit
 	DUCKDB_API static bool TryConvertInterval(const char *buf, idx_t len, idx_t &pos, dtime_t &result,
 	                                          bool strict = false);

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

@@ -137,14 +137,19 @@ public:
 	DUCKDB_API static timestamp_t GetCurrentTimestamp();
 
 	//! Convert the epoch (in sec) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochSeconds(int64_t ms);
+	DUCKDB_API static timestamp_t FromEpochSecondsPossiblyInfinite(int64_t s);
+	DUCKDB_API static timestamp_t FromEpochSeconds(int64_t s);
 	//! Convert the epoch (in ms) to a timestamp
+	DUCKDB_API static timestamp_t FromEpochMsPossiblyInfinite(int64_t ms);
 	DUCKDB_API static timestamp_t FromEpochMs(int64_t ms);
 	//! Convert the epoch (in microseconds) to a timestamp
 	DUCKDB_API static timestamp_t FromEpochMicroSeconds(int64_t micros);
 	//! Convert the epoch (in nanoseconds) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochNanoSeconds(int64_t micros);
+	DUCKDB_API static timestamp_t FromEpochNanoSecondsPossiblyInfinite(int64_t nanos);
+	DUCKDB_API static timestamp_t FromEpochNanoSeconds(int64_t nanos);
 
+	//! Try convert a timestamp to epoch (in nanoseconds)
+	DUCKDB_API static bool TryGetEpochNanoSeconds(timestamp_t timestamp, int64_t &result);
 	//! Convert the epoch (in seconds) to a timestamp
 	DUCKDB_API static int64_t GetEpochSeconds(timestamp_t timestamp);
 	//! Convert the epoch (in ms) to a timestamp

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

@@ -28,6 +28,9 @@ public:
 	//! Convert a hugeint object to a uuid style string
 	static void ToString(hugeint_t input, char *buf);
 
+	//! Convert a uhugeint_t object to a uuid value
+	static hugeint_t FromUHugeint(uhugeint_t input);
+
 	//! Convert a hugeint object to a uuid style string
 	static hugeint_t GenerateRandomUUID(RandomEngine &engine);
 	static hugeint_t GenerateRandomUUID();

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

@@ -38,6 +38,8 @@ public:
 	DUCKDB_API explicit Value(LogicalType type = LogicalType::SQLNULL);
 	//! Create an INTEGER value
 	DUCKDB_API Value(int32_t val); // NOLINT: Allow implicit conversion from `int32_t`
+	//! Create a BOOLEAN value
+	explicit DUCKDB_API Value(bool val);
 	//! Create a BIGINT value
 	DUCKDB_API Value(int64_t val); // NOLINT: Allow implicit conversion from `int64_t`
 	//! Create a FLOAT value
@@ -188,6 +190,9 @@ public:
 	DUCKDB_API static Value BIT(const_data_ptr_t data, idx_t len);
 	DUCKDB_API static Value BIT(const string &data);
 
+	//! Creates an aggregate state
+	DUCKDB_API static Value AGGREGATE_STATE(const LogicalType &type, const_data_ptr_t data, idx_t len);
+
 	template <class T>
 	T GetValue() const;
 	template <class T>
@@ -555,6 +560,8 @@ DUCKDB_API date_t Value::GetValueUnsafe() const;
 template <>
 DUCKDB_API dtime_t Value::GetValueUnsafe() const;
 template <>
+DUCKDB_API dtime_tz_t Value::GetValueUnsafe() const;
+template <>
 DUCKDB_API timestamp_t Value::GetValueUnsafe() const;
 template <>
 DUCKDB_API interval_t Value::GetValueUnsafe() const;

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

@@ -20,6 +20,14 @@
 namespace duckdb {
 
 struct UnifiedVectorFormat {
+	DUCKDB_API UnifiedVectorFormat();
+	// disable copy constructors
+	UnifiedVectorFormat(const UnifiedVectorFormat &other) = delete;
+	UnifiedVectorFormat &operator=(const UnifiedVectorFormat &) = delete;
+	//! enable move constructors
+	DUCKDB_API UnifiedVectorFormat(UnifiedVectorFormat &&other) noexcept;
+	DUCKDB_API UnifiedVectorFormat &operator=(UnifiedVectorFormat &&) noexcept;
+
 	const SelectionVector *sel;
 	data_ptr_t data;
 	ValidityMask validity;
@@ -205,6 +213,11 @@ public:
 	// Setters
 	DUCKDB_API void SetVectorType(VectorType vector_type);
 
+	// Transform vector to an equivalent dictionary vector
+	static void DebugTransformToDictionary(Vector &vector, idx_t count);
+	// Transform vector to an equivalent nested vector
+	static void DebugShuffleNestedVector(Vector &vector, idx_t count);
+
 private:
 	//! Returns the [index] element of the Vector as a Value.
 	static Value GetValue(const Vector &v, idx_t index);
@@ -295,6 +308,16 @@ struct DictionaryVector {
 };
 
 struct FlatVector {
+	static void VerifyFlatVector(const Vector &vector) {
+#ifdef DUCKDB_DEBUG_NO_SAFETY
+		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
+#else
+		if (vector.GetVectorType() != VectorType::FLAT_VECTOR) {
+			throw InternalException("Operation requires a flat vector but a non-flat vector was encountered");
+		}
+#endif
+	}
+
 	static inline data_ptr_t GetData(Vector &vector) {
 		return ConstantVector::GetData(vector);
 	}
@@ -316,15 +339,15 @@ struct FlatVector {
 		return FlatVector::GetData<T>(vector)[idx];
 	}
 	static inline const ValidityMask &Validity(const Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
+		VerifyFlatVector(vector);
 		return vector.validity;
 	}
 	static inline ValidityMask &Validity(Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
+		VerifyFlatVector(vector);
 		return vector.validity;
 	}
-	static inline void SetValidity(Vector &vector, ValidityMask &new_validity) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
+	static inline void SetValidity(Vector &vector, const ValidityMask &new_validity) {
+		VerifyFlatVector(vector);
 		vector.validity.Initialize(new_validity);
 	}
 	DUCKDB_API static void SetNull(Vector &vector, idx_t idx, bool is_null);
@@ -437,7 +460,15 @@ struct FSSTVector {
 	DUCKDB_API static idx_t GetCount(Vector &vector);
 };
 
-enum class MapInvalidReason : uint8_t { VALID, NULL_KEY_LIST, NULL_KEY, DUPLICATE_KEY };
+enum class MapInvalidReason : uint8_t {
+	VALID,
+	NULL_KEY_LIST,
+	NULL_KEY,
+	DUPLICATE_KEY,
+	NULL_VALUE_LIST,
+	NOT_ALIGNED,
+	INVALID_PARAMS
+};
 
 struct MapVector {
 	DUCKDB_API static const Vector &GetKeys(const Vector &vector);
@@ -446,6 +477,7 @@ struct MapVector {
 	DUCKDB_API static Vector &GetValues(Vector &vector);
 	DUCKDB_API static MapInvalidReason
 	CheckMapValidity(Vector &map, idx_t count, const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
+	DUCKDB_API static void EvalMapInvalidReason(MapInvalidReason reason);
 	DUCKDB_API static void MapConversionVerify(Vector &vector, idx_t count);
 };
 
@@ -494,8 +526,9 @@ struct UnionVector {
 	DUCKDB_API static const Vector &GetTags(const Vector &v);
 	DUCKDB_API static Vector &GetTags(Vector &v);
 
-	//! Get the tag at the specific index of the union vector
-	DUCKDB_API static union_tag_t GetTag(const Vector &vector, idx_t index);
+	//! Try to get the tag at the specific flat index of the union vector. Returns false if the tag is NULL.
+	//! This will handle and map the index properly for constant and dictionary vectors internally.
+	DUCKDB_API static bool TryGetTag(const Vector &vector, idx_t index, union_tag_t &tag);
 
 	//! Get the member vector of a union vector by index
 	DUCKDB_API static const Vector &GetMember(const Vector &vector, idx_t member_index);

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

@@ -126,7 +126,7 @@ protected:
 public:
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>

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

@@ -382,7 +382,7 @@ public:
 	static constexpr const LogicalTypeId ROW_TYPE = LogicalTypeId::BIGINT;
 
 	// explicitly allowing these functions to be capitalized to be in-line with the remaining functions
-	DUCKDB_API static LogicalType DECIMAL(int width, int scale);                 // NOLINT
+	DUCKDB_API static LogicalType DECIMAL(uint8_t width, uint8_t scale);                 // NOLINT
 	DUCKDB_API static LogicalType VARCHAR_COLLATION(string collation);           // NOLINT
 	DUCKDB_API static LogicalType LIST(const LogicalType &child);                // NOLINT
 	DUCKDB_API static LogicalType STRUCT(child_list_t<LogicalType> children);    // NOLINT

package/src/duckdb/src/include/duckdb/common/vector_operations/general_cast.hpp

@@ -13,12 +13,20 @@
 
 namespace duckdb {
 
+struct VectorTryCastData {
+	VectorTryCastData(Vector &result_p, CastParameters &parameters) : result(result_p), parameters(parameters) {
+	}
+
+	Vector &result;
+	CastParameters &parameters;
+	bool all_converted = true;
+};
+
 struct HandleVectorCastError {
 	template <class RESULT_TYPE>
-	static RESULT_TYPE Operation(string error_message, ValidityMask &mask, idx_t idx, string *error_message_ptr,
-	                             bool &all_converted) {
-		HandleCastError::AssignError(error_message, error_message_ptr);
-		all_converted = false;
+	static RESULT_TYPE Operation(string error_message, ValidityMask &mask, idx_t idx, VectorTryCastData &cast_data) {
+		HandleCastError::AssignError(error_message, cast_data.parameters);
+		cast_data.all_converted = false;
 		mask.SetInvalid(idx);
 		return NullValue<RESULT_TYPE>();
 	}

package/src/duckdb/src/include/duckdb/common/vector_operations/generic_executor.hpp

@@ -254,7 +254,7 @@ private:
 
 		for (idx_t i = 0; i < (constant ? 1 : count); i++) {
 			auto a_idx = a_state.main_data.sel->get_index(i);
-			auto b_idx = a_state.main_data.sel->get_index(i);
+			auto b_idx = b_state.main_data.sel->get_index(i);
 			if (!a_state.main_data.validity.RowIsValid(a_idx) || !b_state.main_data.validity.RowIsValid(b_idx)) {
 				FlatVector::SetNull(result, i, true);
 				continue;
@@ -288,8 +288,8 @@ private:
 
 		for (idx_t i = 0; i < (constant ? 1 : count); i++) {
 			auto a_idx = a_state.main_data.sel->get_index(i);
-			auto b_idx = a_state.main_data.sel->get_index(i);
-			auto c_idx = a_state.main_data.sel->get_index(i);
+			auto b_idx = b_state.main_data.sel->get_index(i);
+			auto c_idx = c_state.main_data.sel->get_index(i);
 			if (!a_state.main_data.validity.RowIsValid(a_idx) || !b_state.main_data.validity.RowIsValid(b_idx) ||
 			    !c_state.main_data.validity.RowIsValid(c_idx)) {
 				FlatVector::SetNull(result, i, true);
@@ -329,9 +329,9 @@ private:
 
 		for (idx_t i = 0; i < (constant ? 1 : count); i++) {
 			auto a_idx = a_state.main_data.sel->get_index(i);
-			auto b_idx = a_state.main_data.sel->get_index(i);
-			auto c_idx = a_state.main_data.sel->get_index(i);
-			auto d_idx = a_state.main_data.sel->get_index(i);
+			auto b_idx = b_state.main_data.sel->get_index(i);
+			auto c_idx = c_state.main_data.sel->get_index(i);
+			auto d_idx = d_state.main_data.sel->get_index(i);
 			if (!a_state.main_data.validity.RowIsValid(a_idx) || !b_state.main_data.validity.RowIsValid(b_idx) ||
 			    !c_state.main_data.validity.RowIsValid(c_idx) || !d_state.main_data.validity.RowIsValid(d_idx)) {
 				FlatVector::SetNull(result, i, true);

package/src/duckdb/src/include/duckdb/common/vector_operations/vector_operations.hpp

@@ -158,11 +158,12 @@ struct VectorOperations {
 	//! NULLs. If any elements cannot be converted, returns false and fills in the error_message. If no error message is
 	//! provided, an exception is thrown instead.
 	DUCKDB_API static bool TryCast(CastFunctionSet &set, GetCastFunctionInput &input, Vector &source, Vector &result,
-	                               idx_t count, string *error_message, bool strict = false);
+	                               idx_t count, string *error_message, bool strict = false,
+	                               const bool nullify_parent = false);
 	DUCKDB_API static bool DefaultTryCast(Vector &source, Vector &result, idx_t count, string *error_message,
 	                                      bool strict = false);
 	DUCKDB_API static bool TryCast(ClientContext &context, Vector &source, Vector &result, idx_t count,
-	                               string *error_message, bool strict = false);
+	                               string *error_message, bool strict = false, const bool nullify_parent = false);
 	//! Cast the data from the source type to the target type. Throws an exception if the cast fails.
 	DUCKDB_API static void Cast(ClientContext &context, Vector &source, Vector &result, idx_t count,
 	                            bool strict = false);

package/src/duckdb/src/include/duckdb/common/windows_undefs.hpp

@@ -38,4 +38,8 @@
 #undef RemoveDirectory
 #endif
 
+#ifdef UUID
+#undef UUID
+#endif
+
 #endif

package/src/duckdb/src/include/duckdb/core_functions/aggregate/regression/regr_count.hpp

@@ -28,7 +28,7 @@ struct RegrCountFunction {
 
 	template <class T, class STATE>
 	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
-		target = state;
+		target = static_cast<T>(state);
 	}
 	static bool IgnoreNull() {
 		return true;

package/src/duckdb/src/include/duckdb/core_functions/scalar/list_functions.hpp

@@ -312,4 +312,13 @@ struct ListInnerProductFunAlias {
 	static constexpr const char *Name = "<#>";
 };
 
+struct UnpivotListFun {
+	static constexpr const char *Name = "unpivot_list";
+	static constexpr const char *Parameters = "any,...";
+	static constexpr const char *Description = "Identical to list_value, but generated as part of unpivot for better error messages";
+	static constexpr const char *Example = "unpivot_list(4, 5, 6)";
+
+	static ScalarFunction GetFunction();
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/column_binding_resolver.hpp

@@ -19,13 +19,14 @@ namespace duckdb {
 //! are used within the execution engine
 class ColumnBindingResolver : public LogicalOperatorVisitor {
 public:
-	ColumnBindingResolver();
+	ColumnBindingResolver(bool verify_only = false);
 
 	void VisitOperator(LogicalOperator &op) override;
 	static void Verify(LogicalOperator &op);
 
 protected:
 	vector<ColumnBinding> bindings;
+	bool verify_only;
 
 	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
 	static unordered_set<idx_t> VerifyInternal(LogicalOperator &op);