duckdb 0.10.2 → 0.10.3-dev10.0

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

@@ -30,6 +30,7 @@ public:
 public:
 	template <class T>
 	static int UnsignedLength(T value);
+
 	template <class SIGNED, class UNSIGNED>
 	static int SignedLength(SIGNED value) {
 		int sign = -(value < 0);
@@ -59,11 +60,12 @@ public:
 		return ptr;
 	}
 
-	template <class SIGNED, class UNSIGNED>
-	static string_t FormatSigned(SIGNED value, Vector &vector) {
-		int sign = -(value < 0);
-		UNSIGNED unsigned_value = UnsafeNumericCast<UNSIGNED>(UNSIGNED(value ^ sign) - sign);
-		int length = UnsignedLength<UNSIGNED>(unsigned_value) - sign;
+	template <class T>
+	static string_t FormatSigned(T value, Vector &vector) {
+		typedef typename MakeUnsigned<T>::type unsigned_t;
+		int8_t sign = -(value < 0);
+		unsigned_t unsigned_value = unsigned_t(value ^ T(sign)) + unsigned_t(AbsValue(sign));
+		auto length = UnsafeNumericCast<idx_t>(UnsignedLength<unsigned_t>(unsigned_value) + AbsValue(sign));
 		string_t result = StringVector::EmptyString(vector, length);
 		auto dataptr = result.GetDataWriteable();
 		auto endptr = dataptr + length;
@@ -89,6 +91,11 @@ template <>
 int NumericHelper::UnsignedLength(uint32_t value);
 template <>
 int NumericHelper::UnsignedLength(uint64_t value);
+template <>
+int NumericHelper::UnsignedLength(hugeint_t value);
+
+template <>
+char *NumericHelper::FormatUnsigned(hugeint_t value, char *ptr);
 
 template <>
 std::string NumericHelper::ToString(hugeint_t value);
@@ -96,9 +103,13 @@ std::string NumericHelper::ToString(hugeint_t value);
 template <>
 std::string NumericHelper::ToString(uhugeint_t value);
 
+template <>
+string_t NumericHelper::FormatSigned(hugeint_t value, Vector &vector);
+
 struct DecimalToString {
-	template <class SIGNED, class UNSIGNED>
+	template <class SIGNED>
 	static int DecimalLength(SIGNED value, uint8_t width, uint8_t scale) {
+		using UNSIGNED = typename MakeUnsigned<SIGNED>::type;
 		if (scale == 0) {
 			// scale is 0: regular number
 			return NumericHelper::SignedLength<SIGNED, UNSIGNED>(value);
@@ -115,24 +126,27 @@ struct DecimalToString {
 		                NumericHelper::SignedLength<SIGNED, UNSIGNED>(value) + 1);
 	}
 
-	template <class SIGNED, class UNSIGNED>
+	template <class SIGNED>
 	static void FormatDecimal(SIGNED value, uint8_t width, uint8_t scale, char *dst, idx_t len) {
+		using UNSIGNED = typename MakeUnsigned<SIGNED>::type;
 		char *end = dst + len;
 		if (value < 0) {
 			value = -value;
 			*dst = '-';
 		}
 		if (scale == 0) {
-			NumericHelper::FormatUnsigned<UNSIGNED>(value, end);
+			NumericHelper::FormatUnsigned<UNSIGNED>(UnsafeNumericCast<UNSIGNED>(value), end);
 			return;
 		}
 		// we write two numbers:
 		// the numbers BEFORE the decimal (major)
 		// and the numbers AFTER the decimal (minor)
-		UNSIGNED minor = value % (UNSIGNED)NumericHelper::POWERS_OF_TEN[scale];
-		UNSIGNED major = value / (UNSIGNED)NumericHelper::POWERS_OF_TEN[scale];
+		auto minor =
+		    UnsafeNumericCast<UNSIGNED>(value) % UnsafeNumericCast<UNSIGNED>(NumericHelper::POWERS_OF_TEN[scale]);
+		auto major =
+		    UnsafeNumericCast<UNSIGNED>(value) / UnsafeNumericCast<UNSIGNED>(NumericHelper::POWERS_OF_TEN[scale]);
 		// write the number after the decimal
-		dst = NumericHelper::FormatUnsigned<UNSIGNED>(minor, end);
+		dst = NumericHelper::FormatUnsigned<UNSIGNED>(UnsafeNumericCast<UNSIGNED>(minor), end);
 		// (optionally) pad with zeros and add the decimal point
 		while (dst > (end - scale)) {
 			*--dst = '0';
@@ -142,213 +156,28 @@ struct DecimalToString {
 		D_ASSERT(width > scale || major == 0);
 		if (width > scale) {
 			// there are numbers after the comma
-			dst = NumericHelper::FormatUnsigned<UNSIGNED>(major, dst);
+			dst = NumericHelper::FormatUnsigned<UNSIGNED>(UnsafeNumericCast<UNSIGNED>(major), dst);
 		}
 	}
 
-	template <class SIGNED, class UNSIGNED>
+	template <class SIGNED>
 	static string_t Format(SIGNED value, uint8_t width, uint8_t scale, Vector &vector) {
-		int len = DecimalLength<SIGNED, UNSIGNED>(value, width, scale);
-		string_t result = StringVector::EmptyString(vector, len);
-		FormatDecimal<SIGNED, UNSIGNED>(value, width, scale, result.GetDataWriteable(), len);
+		int len = DecimalLength<SIGNED>(value, width, scale);
+		string_t result = StringVector::EmptyString(vector, NumericCast<size_t>(len));
+		FormatDecimal<SIGNED>(value, width, scale, result.GetDataWriteable(), UnsafeNumericCast<idx_t>(len));
 		result.Finalize();
 		return result;
 	}
 };
 
-struct HugeintToStringCast {
-	static int UnsignedLength(hugeint_t value) {
-		D_ASSERT(value.upper >= 0);
-		if (value.upper == 0) {
-			return NumericHelper::UnsignedLength<uint64_t>(value.lower);
-		}
-		// search the length using the POWERS_OF_TEN array
-		// the length has to be between [17] and [38], because the hugeint is bigger than 2^63
-		// we use the same approach as above, but split a bit more because comparisons for hugeints are more expensive
-		if (value >= Hugeint::POWERS_OF_TEN[27]) {
-			// [27..38]
-			if (value >= Hugeint::POWERS_OF_TEN[32]) {
-				if (value >= Hugeint::POWERS_OF_TEN[36]) {
-					int length = 37;
-					length += value >= Hugeint::POWERS_OF_TEN[37];
-					length += value >= Hugeint::POWERS_OF_TEN[38];
-					return length;
-				} else {
-					int length = 33;
-					length += value >= Hugeint::POWERS_OF_TEN[33];
-					length += value >= Hugeint::POWERS_OF_TEN[34];
-					length += value >= Hugeint::POWERS_OF_TEN[35];
-					return length;
-				}
-			} else {
-				if (value >= Hugeint::POWERS_OF_TEN[30]) {
-					int length = 31;
-					length += value >= Hugeint::POWERS_OF_TEN[31];
-					length += value >= Hugeint::POWERS_OF_TEN[32];
-					return length;
-				} else {
-					int length = 28;
-					length += value >= Hugeint::POWERS_OF_TEN[28];
-					length += value >= Hugeint::POWERS_OF_TEN[29];
-					return length;
-				}
-			}
-		} else {
-			// [17..27]
-			if (value >= Hugeint::POWERS_OF_TEN[22]) {
-				// [22..27]
-				if (value >= Hugeint::POWERS_OF_TEN[25]) {
-					int length = 26;
-					length += value >= Hugeint::POWERS_OF_TEN[26];
-					return length;
-				} else {
-					int length = 23;
-					length += value >= Hugeint::POWERS_OF_TEN[23];
-					length += value >= Hugeint::POWERS_OF_TEN[24];
-					return length;
-				}
-			} else {
-				// [17..22]
-				if (value >= Hugeint::POWERS_OF_TEN[20]) {
-					int length = 21;
-					length += value >= Hugeint::POWERS_OF_TEN[21];
-					return length;
-				} else {
-					int length = 18;
-					length += value >= Hugeint::POWERS_OF_TEN[18];
-					length += value >= Hugeint::POWERS_OF_TEN[19];
-					return length;
-				}
-			}
-		}
-	}
-
-	// Formats value in reverse and returns a pointer to the beginning.
-	static char *FormatUnsigned(hugeint_t value, char *ptr) {
-		while (value.upper > 0) {
-			// while integer division is slow, hugeint division is MEGA slow
-			// we want to avoid doing as many divisions as possible
-			// for that reason we start off doing a division by a large power of ten that uint64_t can hold
-			// (100000000000000000) - this is the third largest
-			// the reason we don't use the largest is because that can result in an overflow inside the division
-			// function
-			uint64_t remainder;
-			value = Hugeint::DivModPositive(value, 100000000000000000ULL, remainder);
-
-			auto startptr = ptr;
-			// now we format the remainder: note that we need to pad with zero's in case
-			// the remainder is small (i.e. less than 10000000000000000)
-			ptr = NumericHelper::FormatUnsigned<uint64_t>(remainder, ptr);
-
-			int format_length = UnsafeNumericCast<int>(startptr - ptr);
-			// pad with zero
-			for (int i = format_length; i < 17; i++) {
-				*--ptr = '0';
-			}
-		}
-		// once the value falls in the range of a uint64_t, fallback to formatting as uint64_t to avoid hugeint division
-		return NumericHelper::FormatUnsigned<uint64_t>(value.lower, ptr);
-	}
-
-	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;
-		string_t result = StringVector::EmptyString(vector, length);
-		auto dataptr = result.GetDataWriteable();
-		auto endptr = dataptr + length;
-		if (value.upper == 0) {
-			// small value: format as uint64_t
-			endptr = NumericHelper::FormatUnsigned<uint64_t>(value.lower, endptr);
-		} else {
-			endptr = FormatUnsigned(value, endptr);
-		}
-		if (negative) {
-			*--endptr = '-';
-		}
-		D_ASSERT(endptr == dataptr);
-		result.Finalize();
-		return result;
-	}
-
-	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;
-		} else {
-			negative = 0;
-		}
-		if (scale == 0) {
-			// scale is 0: regular number
-			return UnsignedLength(value) + negative;
-		}
-		// length is max of either:
-		// scale + 2 OR
-		// integer length + 1
-		// scale + 2 happens when the number is in the range of (-1, 1)
-		// in that case we print "0.XXX", which is the scale, plus "0." (2 chars)
-		// integer length + 1 happens when the number is outside of that range
-		// in that case we print the integer number, but with one extra character ('.')
-		auto extra_numbers = width > scale ? 2 : 1;
-		return MaxValue(scale + extra_numbers, UnsignedLength(value) + 1) + negative;
-	}
-
-	static void FormatDecimal(hugeint_t value, uint8_t width, uint8_t scale, char *dst, int len) {
-		auto endptr = dst + len;
-
-		int negative = value.upper < 0;
-		if (negative) {
-			Hugeint::NegateInPlace(value);
-			*dst = '-';
-			dst++;
-		}
-		if (scale == 0) {
-			// with scale=0 we format the number as a regular number
-			FormatUnsigned(value, endptr);
-			return;
-		}
-
-		// we write two numbers:
-		// the numbers BEFORE the decimal (major)
-		// and the numbers AFTER the decimal (minor)
-		hugeint_t minor;
-		hugeint_t major = Hugeint::DivMod(value, Hugeint::POWERS_OF_TEN[scale], minor);
-
-		// write the number after the decimal
-		dst = FormatUnsigned(minor, endptr);
-		// (optionally) pad with zeros and add the decimal point
-		while (dst > (endptr - scale)) {
-			*--dst = '0';
-		}
-		*--dst = '.';
-		// now write the part before the decimal
-		D_ASSERT(width > scale || major == 0);
-		if (width > scale) {
-			dst = FormatUnsigned(major, dst);
-		}
-	}
-
-	static string_t FormatDecimal(hugeint_t value, uint8_t width, uint8_t scale, Vector &vector) {
-		int length = DecimalLength(value, width, scale);
-		string_t result = StringVector::EmptyString(vector, length);
-
-		auto dst = result.GetDataWriteable();
+template <>
+int DecimalToString::DecimalLength(hugeint_t value, uint8_t width, uint8_t scale);
 
-		FormatDecimal(value, width, scale, dst, length);
+template <>
+string_t DecimalToString::Format(hugeint_t value, uint8_t width, uint8_t scale, Vector &vector);
 
-		result.Finalize();
-		return result;
-	}
-};
+template <>
+void DecimalToString::FormatDecimal(hugeint_t value, uint8_t width, uint8_t scale, char *dst, idx_t len);
 
 struct UhugeintToStringCast {
 	static string_t Format(uhugeint_t value, Vector &vector) {
@@ -416,9 +245,9 @@ struct DateToStringCast {
 
 struct TimeToStringCast {
 	//! Format microseconds to a buffer of length 6. Returns the number of trailing zeros
-	static int32_t FormatMicros(uint32_t microseconds, char micro_buffer[]) {
+	static int32_t FormatMicros(int32_t microseconds, char micro_buffer[]) {
 		char *endptr = micro_buffer + 6;
-		endptr = NumericHelper::FormatUnsigned<uint32_t>(microseconds, endptr);
+		endptr = NumericHelper::FormatUnsigned<int32_t>(microseconds, endptr);
 		while (endptr > micro_buffer) {
 			*--endptr = '0';
 		}
@@ -447,7 +276,7 @@ struct TimeToStringCast {
 			// we write backwards and pad with zeros to the left
 			// now we figure out how many digits we need to include by looking backwards
 			// and checking how many zeros we encounter
-			length -= FormatMicros(time[3], micro_buffer);
+			length -= NumericCast<idx_t>(FormatMicros(time[3], micro_buffer));
 		}
 		return length;
 	}
@@ -484,8 +313,8 @@ struct TimeToStringCast {
 struct IntervalToStringCast {
 	static void FormatSignedNumber(int64_t value, char buffer[], idx_t &length) {
 		int sign = -(value < 0);
-		uint64_t unsigned_value = (value ^ sign) - sign;
-		length += NumericHelper::UnsignedLength<uint64_t>(unsigned_value) - sign;
+		auto unsigned_value = NumericCast<uint64_t>((value ^ sign) - sign);
+		length += NumericCast<idx_t>(NumericHelper::UnsignedLength<uint64_t>(unsigned_value) - sign);
 		auto endptr = buffer + length;
 		endptr = NumericHelper::FormatUnsigned<uint64_t>(unsigned_value, endptr);
 		if (sign) {
@@ -566,9 +395,8 @@ struct IntervalToStringCast {
 			FormatTwoDigits(sec, buffer, length);
 			if (micros != 0) {
 				buffer[length++] = '.';
-				auto trailing_zeros =
-				    TimeToStringCast::FormatMicros(UnsafeNumericCast<uint32_t>(micros), buffer + length);
-				length += 6 - trailing_zeros;
+				auto trailing_zeros = TimeToStringCast::FormatMicros(NumericCast<int32_t>(micros), buffer + length);
+				length += NumericCast<idx_t>(6 - trailing_zeros);
 			}
 		} else if (length == 0) {
 			// empty interval: default to 00:00:00

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 
 #include <functional>
 
@@ -57,10 +58,10 @@ struct dtime_t { // NOLINT
 		return dtime_t(this->micros - micros);
 	};
 	inline dtime_t operator*(const idx_t &copies) const {
-		return dtime_t(this->micros * copies);
+		return dtime_t(this->micros * UnsafeNumericCast<int64_t>(copies));
 	};
 	inline dtime_t operator/(const idx_t &copies) const {
-		return dtime_t(this->micros / copies);
+		return dtime_t(this->micros / UnsafeNumericCast<int64_t>(copies));
 	};
 	inline int64_t operator-(const dtime_t &other) const {
 		return this->micros - other.micros;
@@ -92,23 +93,47 @@ struct dtime_tz_t { // NOLINT
 	static constexpr const uint64_t OFFSET_MASK = ~uint64_t(0) >> TIME_BITS;
 	static constexpr const int32_t MAX_OFFSET = 16 * 60 * 60 - 1; // ±15:59:59
 	static constexpr const int32_t MIN_OFFSET = -MAX_OFFSET;
+	static constexpr const uint64_t OFFSET_MICROS = 1000000;
 
 	uint64_t bits;
 
+	//	Offsets are reverse ordered e.g., 13:00:00+01 < 12:00:00+00 < 11:00:00-01
+	//	Because we encode them as the low order bits,
+	//	they are also biased into an unsigned integer: (-16, 16) => (32, 0)
+	static inline uint64_t encode_offset(int32_t offset) { // NOLINT
+		return uint64_t(MAX_OFFSET - offset);
+	}
+	static inline int32_t decode_offset(uint64_t bits) { // NOLINT
+		return MAX_OFFSET - int32_t(bits & OFFSET_MASK);
+	}
+
+	static inline uint64_t encode_micros(int64_t micros) { // NOLINT
+		return uint64_t(micros) << OFFSET_BITS;
+	}
+	static inline int64_t decode_micros(uint64_t bits) { // NOLINT
+		return int64_t(bits >> OFFSET_BITS);
+	}
+
 	dtime_tz_t() = default;
 
-	inline dtime_tz_t(dtime_t t, int32_t offset)
-	    : bits((uint64_t(t.micros) << OFFSET_BITS) | uint64_t(MAX_OFFSET - offset)) {
+	inline dtime_tz_t(dtime_t t, int32_t offset) : bits(encode_micros(t.micros) | encode_offset(offset)) {
 	}
 	explicit inline dtime_tz_t(uint64_t bits_p) : bits(bits_p) {
 	}
 
 	inline dtime_t time() const { // NOLINT
-		return dtime_t(bits >> OFFSET_BITS);
+		return dtime_t(decode_micros(bits));
 	}
 
 	inline int32_t offset() const { // NOLINT
-		return MAX_OFFSET - int32_t(bits & OFFSET_MASK);
+		return decode_offset(bits);
+	}
+
+	//	Times are compared after adjusting to offset +00:00:00, e.g., 13:01:00+01 > 12:00:00+00
+	//	Because we encode them as the high order bits,
+	//	they are biased by the maximum offset: (0, 24) => (0, 56)
+	inline uint64_t sort_key() const { // NOLINT
+		return bits + encode_micros((bits & OFFSET_MASK) * OFFSET_MICROS);
 	}
 
 	// comparison operators
@@ -119,16 +144,16 @@ struct dtime_tz_t { // NOLINT
 		return bits != rhs.bits;
 	};
 	inline bool operator<=(const dtime_tz_t &rhs) const {
-		return bits <= rhs.bits;
+		return sort_key() <= rhs.sort_key();
 	};
 	inline bool operator<(const dtime_tz_t &rhs) const {
-		return bits < rhs.bits;
+		return sort_key() < rhs.sort_key();
 	};
 	inline bool operator>(const dtime_tz_t &rhs) const {
-		return bits > rhs.bits;
+		return sort_key() > rhs.sort_key();
 	};
 	inline bool operator>=(const dtime_tz_t &rhs) const {
-		return bits >= rhs.bits;
+		return sort_key() >= rhs.sort_key();
 	};
 };
 
@@ -149,7 +174,7 @@ template <>
 struct hash<duckdb::dtime_tz_t> {
 	std::size_t operator()(const duckdb::dtime_tz_t &k) const {
 		using std::hash;
-		return hash<int64_t>()(k.bits);
+		return hash<uint64_t>()(k.bits);
 	}
 };
 } // namespace std

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

@@ -35,7 +35,7 @@ inline hash_t MurmurHash32(uint32_t x) {
 
 template <class T>
 hash_t Hash(T value) {
-	return MurmurHash32(value);
+	return MurmurHash32(static_cast<uint32_t>(value));
 }
 
 //! Combine two hashes by XORing them

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

@@ -32,7 +32,9 @@ public:
 	TupleDataChunkPart(TupleDataChunkPart &&other) noexcept;
 	TupleDataChunkPart &operator=(TupleDataChunkPart &&) noexcept;
 
-	static constexpr const uint32_t INVALID_INDEX = (uint32_t)-1;
+public:
+	//! Mark heap as empty
+	void SetHeapEmpty();
 
 public:
 	//! Index/offset of the row block
@@ -48,6 +50,10 @@ public:
 	uint32_t count;
 	//! Lock for recomputing heap pointers (owned by TupleDataChunk)
 	reference<mutex> lock;
+
+private:
+	//! Marker for empty heaps
+	static constexpr const uint32_t INVALID_INDEX = (uint32_t)-1;
 };
 
 struct TupleDataChunk {

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

@@ -71,7 +71,7 @@ public:
 		sel_vector = sel;
 	}
 	void Initialize(idx_t count = STANDARD_VECTOR_SIZE) {
-		selection_data = make_shared<SelectionData>(count);
+		selection_data = make_shared_ptr<SelectionData>(count);
 		sel_vector = selection_data->owned_data.get();
 	}
 	void Initialize(buffer_ptr<SelectionData> data) {

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

@@ -12,6 +12,7 @@
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/helper.hpp"
 #include "duckdb/common/numeric_utils.hpp"
+#include "duckdb/common/limits.hpp"
 
 #include <cstring>
 #include <algorithm>
@@ -26,6 +27,7 @@ public:
 	static constexpr idx_t PREFIX_BYTES = 4 * sizeof(char);
 	static constexpr idx_t INLINE_BYTES = 12 * sizeof(char);
 	static constexpr idx_t HEADER_SIZE = sizeof(uint32_t) + PREFIX_BYTES;
+	static constexpr idx_t MAX_STRING_SIZE = NumericLimits<uint32_t>::Maximum();
 #ifndef DUCKDB_DEBUG_NO_INLINE
 	static constexpr idx_t PREFIX_LENGTH = PREFIX_BYTES;
 	static constexpr idx_t INLINE_LENGTH = INLINE_BYTES;

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

@@ -158,6 +158,8 @@ public:
 	DUCKDB_API static int64_t GetEpochMicroSeconds(timestamp_t timestamp);
 	//! Convert a timestamp to epoch (in nanoseconds)
 	DUCKDB_API static int64_t GetEpochNanoSeconds(timestamp_t timestamp);
+	//! Convert a timestamp to a rounded epoch at a given resolution.
+	DUCKDB_API static int64_t GetEpochRounded(timestamp_t timestamp, const int64_t power_of_ten);
 	//! Convert a timestamp to a Julian Day
 	DUCKDB_API static double GetJulianDay(timestamp_t timestamp);
 

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

@@ -19,7 +19,7 @@ struct ValidityMask;
 template <typename V>
 struct TemplatedValidityData {
 	static constexpr const int BITS_PER_VALUE = sizeof(V) * 8;
-	static constexpr const V MAX_ENTRY = ~V(0);
+	static constexpr const V MAX_ENTRY = V(~V(0));
 
 public:
 	inline explicit TemplatedValidityData(idx_t count) {

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

@@ -17,6 +17,7 @@
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/datetime.hpp"
 #include "duckdb/common/types/interval.hpp"
+#include "duckdb/common/shared_ptr.hpp"
 
 namespace duckdb {
 
@@ -176,6 +177,9 @@ public:
 	//! Create a map value with the given entries
 	DUCKDB_API static Value MAP(const LogicalType &key_type, const LogicalType &value_type, vector<Value> keys,
 	                            vector<Value> values);
+	//! Create a map value from a set of key-value pairs
+	DUCKDB_API static Value MAP(const unordered_map<string, string> &kv_pairs);
+
 	//! Create a union value from a selected value and a tag from a set of alternatives.
 	DUCKDB_API static Value UNION(child_list_t<LogicalType> members, uint8_t tag, Value value);
 

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

@@ -19,6 +19,11 @@
 
 namespace duckdb {
 
+class VectorCache;
+class VectorStructBuffer;
+class VectorListBuffer;
+struct SelCache;
+
 struct UnifiedVectorFormat {
 	DUCKDB_API UnifiedVectorFormat();
 	// disable copy constructors
@@ -49,11 +54,17 @@ struct RecursiveUnifiedVectorFormat {
 	LogicalType logical_type;
 };
 
-class VectorCache;
-class VectorStructBuffer;
-class VectorListBuffer;
+//! This is a helper data structure. It contains all fields necessary to resize a vector.
+struct ResizeInfo {
+	ResizeInfo(Vector &vec, data_ptr_t data, optional_ptr<VectorBuffer> buffer, const idx_t multiplier)
+	    : vec(vec), data(data), buffer(buffer), multiplier(multiplier) {
+	}
 
-struct SelCache;
+	Vector &vec;
+	data_ptr_t data;
+	optional_ptr<VectorBuffer> buffer;
+	idx_t multiplier;
+};
 
 struct ConsecutiveChildListInfo {
 	ConsecutiveChildListInfo() : is_constant(true), needs_slicing(false), child_list_info(list_entry_t(0, 0)) {
@@ -63,7 +74,7 @@ struct ConsecutiveChildListInfo {
 	list_entry_t child_list_info;
 };
 
-//!  Vector of values of a specified PhysicalType.
+//! Vector of values of a specified PhysicalType.
 class Vector {
 	friend struct ConstantVector;
 	friend struct DictionaryVector;
@@ -185,8 +196,10 @@ public:
 		data = other.data;
 	}
 
-	//! This functions resizes the vector
+	//! Resizes the vector.
 	DUCKDB_API void Resize(idx_t cur_size, idx_t new_size);
+	//! Returns a vector of ResizeInfo containing each (nested) vector to resize.
+	DUCKDB_API void FindResizeInfos(vector<ResizeInfo> &resize_infos, const idx_t multiplier);
 
 	DUCKDB_API void Serialize(Serializer &serializer, idx_t count);
 	DUCKDB_API void Deserialize(Deserializer &deserializer, idx_t count);
@@ -464,15 +477,7 @@ struct FSSTVector {
 	DUCKDB_API static idx_t GetCount(Vector &vector);
 };
 
-enum class MapInvalidReason : uint8_t {
-	VALID,
-	NULL_KEY_LIST,
-	NULL_KEY,
-	DUPLICATE_KEY,
-	NULL_VALUE_LIST,
-	NOT_ALIGNED,
-	INVALID_PARAMS
-};
+enum class MapInvalidReason : uint8_t { VALID, NULL_KEY, DUPLICATE_KEY, NOT_ALIGNED, INVALID_PARAMS };
 
 struct MapVector {
 	DUCKDB_API static const Vector &GetKeys(const Vector &vector);

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

@@ -12,6 +12,7 @@
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/vector.hpp"
+#include "duckdb/common/helper.hpp"
 
 #include <limits>
 
@@ -34,7 +35,7 @@ using buffer_ptr = shared_ptr<T>;
 
 template <class T, typename... ARGS>
 buffer_ptr<T> make_buffer(ARGS &&...args) { // NOLINT: mimic std casing
-	return make_shared<T>(std::forward<ARGS>(args)...);
+	return make_shared_ptr<T>(std::forward<ARGS>(args)...);
 }
 
 struct list_entry_t { // NOLINT: mimic std casing
@@ -272,6 +273,9 @@ struct LogicalType {
 		return type_info_;
 	}
 
+	//! DeepCopy() will make a unique copy of any ExtraTypeInfo as well
+	LogicalType DeepCopy() const;
+
 	inline void CopyAuxInfo(const LogicalType &other) {
 		type_info_ = other.type_info_;
 	}
@@ -318,6 +322,11 @@ struct LogicalType {
 	DUCKDB_API void SetAlias(string alias);
 	DUCKDB_API bool HasAlias() const;
 	DUCKDB_API string GetAlias() const;
+	DUCKDB_API void SetModifiers(vector<Value> modifiers);
+	DUCKDB_API bool HasModifiers() const;
+	DUCKDB_API vector<Value> GetModifiersCopy() const;
+	DUCKDB_API optional_ptr<vector<Value>> GetModifiers();
+	DUCKDB_API optional_ptr<const vector<Value>> GetModifiers() const;
 
 	//! Returns the maximum logical type when combining the two types - or throws an exception if combining is not possible
 	DUCKDB_API static LogicalType MaxLogicalType(ClientContext &context, const LogicalType &left, const LogicalType &right);
@@ -404,7 +413,8 @@ public:
 	// DEPRECATED - provided for backwards compatibility
 	DUCKDB_API static LogicalType ENUM(const string &enum_name, Vector &ordered_data, idx_t size); // NOLINT
 	DUCKDB_API static LogicalType USER(const string &user_type_name);                              // NOLINT
-	DUCKDB_API static LogicalType USER(string catalog, string schema, string name);                // NOLINT
+	DUCKDB_API static LogicalType USER(const string &user_type_name, const vector<Value> &user_type_mods); // NOLINT
+	DUCKDB_API static LogicalType USER(string catalog, string schema, string name, vector<Value> user_type_mods); // NOLINT
 	//! A list of all NUMERIC types (integral and floating point types)
 	DUCKDB_API static const vector<LogicalType> Numeric();
 	//! A list of all INTEGRAL types
@@ -439,6 +449,8 @@ struct UserType {
 	DUCKDB_API static const string &GetCatalog(const LogicalType &type);
 	DUCKDB_API static const string &GetSchema(const LogicalType &type);
 	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
+	DUCKDB_API static const vector<Value> &GetTypeModifiers(const LogicalType &type);
+	DUCKDB_API static vector<Value> &GetTypeModifiers(LogicalType &type);
 };
 
 struct EnumType {