duckdb 1.3.3-dev0.0 → 1.3.3-dev4.0

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

@@ -0,0 +1,202 @@
+#pragma once
+
+#include "duckdb/common/typedefs.hpp"
+#include "duckdb/function/cast/default_casts.hpp"
+#include "duckdb/common/types/vector.hpp"
+
+namespace duckdb_yyjson {
+struct yyjson_mut_doc;
+struct yyjson_mut_val;
+} // namespace duckdb_yyjson
+
+namespace duckdb {
+
+enum class VariantChildLookupMode : uint8_t { BY_KEY, BY_INDEX };
+
+struct VariantPathComponent {
+	VariantChildLookupMode lookup_mode;
+	string key;
+	uint32_t index;
+};
+
+struct VariantNestedData {
+	//! The amount of children in the nested structure
+	uint32_t child_count;
+	//! Index of the first child
+	uint32_t children_idx;
+	//! Whether the row is null
+	bool is_null;
+};
+
+struct VariantDecimalData {
+	uint32_t width;
+	uint32_t scale;
+};
+
+struct VariantVectorData {
+public:
+	explicit VariantVectorData(Vector &variant)
+	    : variant(variant), keys_index_validity(FlatVector::Validity(VariantVector::GetChildrenKeysIndex(variant))),
+	      keys(VariantVector::GetKeys(variant)) {
+		blob_data = FlatVector::GetData<string_t>(VariantVector::GetData(variant));
+		type_ids_data = FlatVector::GetData<uint8_t>(VariantVector::GetValuesTypeId(variant));
+		byte_offset_data = FlatVector::GetData<uint32_t>(VariantVector::GetValuesByteOffset(variant));
+		keys_index_data = FlatVector::GetData<uint32_t>(VariantVector::GetChildrenKeysIndex(variant));
+		values_index_data = FlatVector::GetData<uint32_t>(VariantVector::GetChildrenValuesIndex(variant));
+		values_data = FlatVector::GetData<list_entry_t>(VariantVector::GetValues(variant));
+		children_data = FlatVector::GetData<list_entry_t>(VariantVector::GetChildren(variant));
+		keys_data = FlatVector::GetData<list_entry_t>(keys);
+	}
+
+public:
+	Vector &variant;
+
+	//! value
+	string_t *blob_data;
+
+	//! values
+	uint8_t *type_ids_data;
+	uint32_t *byte_offset_data;
+
+	//! children
+	uint32_t *keys_index_data;
+	uint32_t *values_index_data;
+	ValidityMask &keys_index_validity;
+
+	//! values | children | keys
+	list_entry_t *values_data;
+	list_entry_t *children_data;
+	list_entry_t *keys_data;
+
+	Vector &keys;
+};
+
+enum class VariantLogicalType : uint8_t {
+	VARIANT_NULL = 0,
+	BOOL_TRUE = 1,
+	BOOL_FALSE = 2,
+	INT8 = 3,
+	INT16 = 4,
+	INT32 = 5,
+	INT64 = 6,
+	INT128 = 7,
+	UINT8 = 8,
+	UINT16 = 9,
+	UINT32 = 10,
+	UINT64 = 11,
+	UINT128 = 12,
+	FLOAT = 13,
+	DOUBLE = 14,
+	DECIMAL = 15,
+	VARCHAR = 16,
+	BLOB = 17,
+	UUID = 18,
+	DATE = 19,
+	TIME_MICROS = 20,
+	TIME_NANOS = 21,
+	TIMESTAMP_SEC = 22,
+	TIMESTAMP_MILIS = 23,
+	TIMESTAMP_MICROS = 24,
+	TIMESTAMP_NANOS = 25,
+	TIME_MICROS_TZ = 26,
+	TIMESTAMP_MICROS_TZ = 27,
+	INTERVAL = 28,
+	OBJECT = 29,
+	ARRAY = 30,
+	BIGNUM = 31,
+	BITSTRING = 32,
+	ENUM_SIZE /* always kept as last item of the enum */
+};
+
+struct UnifiedVariantVectorData {
+public:
+	explicit UnifiedVariantVectorData(const RecursiveUnifiedVectorFormat &variant)
+	    : variant(variant), keys(UnifiedVariantVector::GetKeys(variant)),
+	      keys_entry(UnifiedVariantVector::GetKeysEntry(variant)), children(UnifiedVariantVector::GetChildren(variant)),
+	      keys_index(UnifiedVariantVector::GetChildrenKeysIndex(variant)),
+	      values_index(UnifiedVariantVector::GetChildrenValuesIndex(variant)),
+	      values(UnifiedVariantVector::GetValues(variant)), type_id(UnifiedVariantVector::GetValuesTypeId(variant)),
+	      byte_offset(UnifiedVariantVector::GetValuesByteOffset(variant)), data(UnifiedVariantVector::GetData(variant)),
+	      keys_index_validity(keys_index.validity) {
+		blob_data = data.GetData<string_t>();
+		type_id_data = type_id.GetData<uint8_t>();
+		byte_offset_data = byte_offset.GetData<uint32_t>();
+		keys_index_data = keys_index.GetData<uint32_t>();
+		values_index_data = values_index.GetData<uint32_t>();
+		values_data = values.GetData<list_entry_t>();
+		children_data = children.GetData<list_entry_t>();
+		keys_data = keys.GetData<list_entry_t>();
+		keys_entry_data = keys_entry.GetData<string_t>();
+	}
+
+public:
+	bool RowIsValid(idx_t row) const {
+		return variant.unified.validity.RowIsValid(variant.unified.sel->get_index(row));
+	}
+	bool KeysIndexIsValid(idx_t row, idx_t index) const {
+		auto list_entry = GetChildrenListEntry(row);
+		return keys_index_validity.RowIsValid(keys_index.sel->get_index(list_entry.offset + index));
+	}
+
+	list_entry_t GetChildrenListEntry(idx_t row) const {
+		return children_data[children.sel->get_index(row)];
+	}
+	list_entry_t GetValuesListEntry(idx_t row) const {
+		return values_data[values.sel->get_index(row)];
+	}
+	const string_t &GetKey(idx_t row, idx_t index) const {
+		auto list_entry = keys_data[keys.sel->get_index(row)];
+		return keys_entry_data[keys_entry.sel->get_index(list_entry.offset + index)];
+	}
+	uint32_t GetKeysIndex(idx_t row, idx_t child_index) const {
+		auto list_entry = GetChildrenListEntry(row);
+		return keys_index_data[keys_index.sel->get_index(list_entry.offset + child_index)];
+	}
+	uint32_t GetValuesIndex(idx_t row, idx_t child_index) const {
+		auto list_entry = GetChildrenListEntry(row);
+		return values_index_data[values_index.sel->get_index(list_entry.offset + child_index)];
+	}
+	VariantLogicalType GetTypeId(idx_t row, idx_t value_index) const {
+		auto list_entry = values_data[values.sel->get_index(row)];
+		return static_cast<VariantLogicalType>(type_id_data[type_id.sel->get_index(list_entry.offset + value_index)]);
+	}
+	uint32_t GetByteOffset(idx_t row, idx_t value_index) const {
+		auto list_entry = values_data[values.sel->get_index(row)];
+		return byte_offset_data[byte_offset.sel->get_index(list_entry.offset + value_index)];
+	}
+	const string_t &GetData(idx_t row) const {
+		return blob_data[data.sel->get_index(row)];
+	}
+
+public:
+	const RecursiveUnifiedVectorFormat &variant;
+	const UnifiedVectorFormat &keys;
+	const UnifiedVectorFormat &keys_entry;
+	const UnifiedVectorFormat &children;
+	const UnifiedVectorFormat &keys_index;
+	const UnifiedVectorFormat &values_index;
+	const UnifiedVectorFormat &values;
+	const UnifiedVectorFormat &type_id;
+	const UnifiedVectorFormat &byte_offset;
+	const UnifiedVectorFormat &data;
+
+	const list_entry_t *keys_data = nullptr;
+	const string_t *keys_entry_data = nullptr;
+	const list_entry_t *children_data = nullptr;
+	const uint32_t *keys_index_data = nullptr;
+	const uint32_t *values_index_data = nullptr;
+	const list_entry_t *values_data = nullptr;
+	const uint8_t *type_id_data = nullptr;
+	const uint32_t *byte_offset_data = nullptr;
+	const string_t *blob_data = nullptr;
+
+	const ValidityMask &keys_index_validity;
+};
+
+struct VariantCasts {
+	static duckdb_yyjson::yyjson_mut_val *ConvertVariantToJSON(duckdb_yyjson::yyjson_mut_doc *doc,
+	                                                           const RecursiveUnifiedVectorFormat &source, idx_t row,
+	                                                           uint32_t values_idx);
+};
+
+} // namespace duckdb

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

@@ -16,6 +16,7 @@
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/common/types/vector_buffer.hpp"
 #include "duckdb/common/vector_size.hpp"
+#include "duckdb/common/type_util.hpp"
 
 namespace duckdb {
 
@@ -38,13 +39,36 @@ struct UnifiedVectorFormat {
 	data_ptr_t data;
 	ValidityMask validity;
 	SelectionVector owned_sel;
+	PhysicalType physical_type;
 
 	template <class T>
-	static inline const T *GetData(const UnifiedVectorFormat &format) {
+	void VerifyVectorType() const {
+#ifdef DUCKDB_DEBUG_NO_SAFETY
+		D_ASSERT(StorageTypeCompatible<T>(physical_type));
+#else
+		if (!StorageTypeCompatible<T>(physical_type)) {
+			throw InternalException("Expected unified vector format of type %s, but found type %s", GetTypeId<T>(),
+			                        physical_type);
+		}
+#endif
+	}
+
+	template <class T>
+	static inline const T *GetDataUnsafe(const UnifiedVectorFormat &format) {
 		return reinterpret_cast<const T *>(format.data);
 	}
 	template <class T>
+	static inline const T *GetData(const UnifiedVectorFormat &format) {
+		return format.GetData<T>();
+	}
+	template <class T>
+	inline const T *GetData() const {
+		VerifyVectorType<T>();
+		return GetDataUnsafe<T>(*this);
+	}
+	template <class T>
 	static inline T *GetDataNoConst(UnifiedVectorFormat &format) {
+		format.VerifyVectorType<T>();
 		return reinterpret_cast<T *>(format.data);
 	}
 };
@@ -55,6 +79,27 @@ struct RecursiveUnifiedVectorFormat {
 	LogicalType logical_type;
 };
 
+struct UnifiedVariantVector {
+	//! The 'keys' list (dictionary)
+	DUCKDB_API static const UnifiedVectorFormat &GetKeys(const RecursiveUnifiedVectorFormat &vec);
+	//! The 'keys' list entry
+	DUCKDB_API static const UnifiedVectorFormat &GetKeysEntry(const RecursiveUnifiedVectorFormat &vec);
+	//! The 'children' list
+	DUCKDB_API static const UnifiedVectorFormat &GetChildren(const RecursiveUnifiedVectorFormat &vec);
+	//! The 'keys_index' inside the 'children' list
+	DUCKDB_API static const UnifiedVectorFormat &GetChildrenKeysIndex(const RecursiveUnifiedVectorFormat &vec);
+	//! The 'values_index' inside the 'children' list
+	DUCKDB_API static const UnifiedVectorFormat &GetChildrenValuesIndex(const RecursiveUnifiedVectorFormat &vec);
+	//! The 'values' list
+	DUCKDB_API static const UnifiedVectorFormat &GetValues(const RecursiveUnifiedVectorFormat &vec);
+	//! The 'type_id' inside the 'values' list
+	DUCKDB_API static const UnifiedVectorFormat &GetValuesTypeId(const RecursiveUnifiedVectorFormat &vec);
+	//! The 'byte_offset' inside the 'values' list
+	DUCKDB_API static const UnifiedVectorFormat &GetValuesByteOffset(const RecursiveUnifiedVectorFormat &vec);
+	//! The binary blob 'data' encoding the Variant for the row
+	DUCKDB_API static const UnifiedVectorFormat &GetData(const RecursiveUnifiedVectorFormat &vec);
+};
+
 //! 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)
@@ -149,7 +194,7 @@ public:
 	//! Turn this vector into a dictionary vector
 	DUCKDB_API void Dictionary(idx_t dictionary_size, const SelectionVector &sel, idx_t count);
 	//! Creates a reference to a dictionary of the other vector
-	DUCKDB_API void Dictionary(const Vector &dict, idx_t dictionary_size, const SelectionVector &sel, idx_t count);
+	DUCKDB_API void Dictionary(Vector &dict, idx_t dictionary_size, const SelectionVector &sel, idx_t count);
 
 	//! Creates the data of this vector with the specified type. Any data that
 	//! is currently in the vector is destroyed.
@@ -184,6 +229,7 @@ public:
 	//! Asserts that the CheckMapValidity returns MapInvalidReason::VALID
 	DUCKDB_API static void VerifyMap(Vector &map, const SelectionVector &sel, idx_t count);
 	DUCKDB_API static void VerifyUnion(Vector &map, const SelectionVector &sel, idx_t count);
+	DUCKDB_API static void VerifyVariant(Vector &map, const SelectionVector &sel, idx_t count);
 	DUCKDB_API static void Verify(Vector &vector, const SelectionVector &sel, idx_t count);
 	DUCKDB_API void UTFVerify(idx_t count);
 	DUCKDB_API void UTFVerify(const SelectionVector &sel, idx_t count);
@@ -219,7 +265,7 @@ public:
 	inline const LogicalType &GetType() const {
 		return type;
 	}
-	inline data_ptr_t GetData() {
+	inline data_ptr_t GetData() const {
 		return data;
 	}
 
@@ -260,6 +306,9 @@ protected:
 	//! The buffer holding auxiliary data of the vector
 	//! e.g. a string vector uses this to store strings
 	buffer_ptr<VectorBuffer> auxiliary;
+	//! The buffer holding precomputed hashes of the data in the vector
+	//! used for caching hashes of string dictionaries
+	buffer_ptr<VectorBuffer> cached_hashes;
 };
 
 //! The DictionaryBuffer holds a selection vector
@@ -274,6 +323,18 @@ public:
 };
 
 struct ConstantVector {
+	template <class T>
+	static void VerifyVectorType(const Vector &vector) {
+#ifdef DUCKDB_DEBUG_NO_SAFETY
+		D_ASSERT(StorageTypeCompatible<T>(vector.GetType().InternalType()));
+#else
+		if (!StorageTypeCompatible<T>(vector.GetType().InternalType())) {
+			throw InternalException("Expected vector of type %s, but found vector of type %s", GetTypeId<T>(),
+			                        vector.GetType().InternalType());
+		}
+#endif
+	}
+
 	static inline const_data_ptr_t GetData(const Vector &vector) {
 		D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR ||
 		         vector.GetVectorType() == VectorType::FLAT_VECTOR);
@@ -285,12 +346,22 @@ struct ConstantVector {
 		return vector.data;
 	}
 	template <class T>
+	static inline const T *GetDataUnsafe(const Vector &vector) {
+		return reinterpret_cast<const T *>(GetData(vector));
+	}
+	template <class T>
+	static inline T *GetDataUnsafe(Vector &vector) {
+		return reinterpret_cast<T *>(GetData(vector));
+	}
+	template <class T>
 	static inline const T *GetData(const Vector &vector) {
-		return (const T *)ConstantVector::GetData(vector);
+		VerifyVectorType<T>(vector);
+		return GetDataUnsafe<T>(vector);
 	}
 	template <class T>
 	static inline T *GetData(Vector &vector) {
-		return (T *)ConstantVector::GetData(vector);
+		VerifyVectorType<T>(vector);
+		return GetDataUnsafe<T>(vector);
 	}
 	static inline bool IsNull(const Vector &vector) {
 		D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
@@ -348,6 +419,13 @@ struct DictionaryVector {
 		VerifyDictionary(vector);
 		vector.buffer->Cast<DictionaryBuffer>().SetDictionaryId(std::move(new_id));
 	}
+	static inline bool CanCacheHashes(const LogicalType &type) {
+		return type.InternalType() == PhysicalType::VARCHAR;
+	}
+	static inline bool CanCacheHashes(const Vector &vector) {
+		return DictionarySize(vector).IsValid() && CanCacheHashes(vector.GetType());
+	}
+	static const Vector &GetCachedHashes(Vector &input);
 };
 
 struct FlatVector {
@@ -372,6 +450,14 @@ struct FlatVector {
 	static inline T *GetData(Vector &vector) {
 		return ConstantVector::GetData<T>(vector);
 	}
+	template <class T>
+	static inline const T *GetDataUnsafe(const Vector &vector) {
+		return ConstantVector::GetDataUnsafe<T>(vector);
+	}
+	template <class T>
+	static inline T *GetDataUnsafe(Vector &vector) {
+		return ConstantVector::GetDataUnsafe<T>(vector);
+	}
 	static inline void SetData(Vector &vector, data_ptr_t data) {
 		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
 		vector.data = data;
@@ -542,6 +628,33 @@ private:
 	static T &GetEntryInternal(T &vector);
 };
 
+struct VariantVector {
+	//! Gets a reference to the 'keys' list (dictionary) of a Variant
+	DUCKDB_API static Vector &GetKeys(Vector &vec);
+	DUCKDB_API static Vector &GetKeys(const Vector &vec);
+	//! Gets a reference to the 'children' list of a Variant
+	DUCKDB_API static Vector &GetChildren(Vector &vec);
+	DUCKDB_API static Vector &GetChildren(const Vector &vec);
+	//! Gets a reference to the 'keys_index' inside the 'children' list of a Variant
+	DUCKDB_API static Vector &GetChildrenKeysIndex(Vector &vec);
+	DUCKDB_API static Vector &GetChildrenKeysIndex(const Vector &vec);
+	//! Gets a reference to the 'values_index' inside the 'children' list of a Variant
+	DUCKDB_API static Vector &GetChildrenValuesIndex(Vector &vec);
+	DUCKDB_API static Vector &GetChildrenValuesIndex(const Vector &vec);
+	//! Gets a reference to the 'values' list of a Variant
+	DUCKDB_API static Vector &GetValues(Vector &vec);
+	DUCKDB_API static Vector &GetValues(const Vector &vec);
+	//! Gets a reference to the 'type_id' inside the 'values' list of a Variant
+	DUCKDB_API static Vector &GetValuesTypeId(Vector &vec);
+	DUCKDB_API static Vector &GetValuesTypeId(const Vector &vec);
+	//! Gets a reference to the 'byte_offset' inside the 'values' list of a Variant
+	DUCKDB_API static Vector &GetValuesByteOffset(Vector &vec);
+	DUCKDB_API static Vector &GetValuesByteOffset(const Vector &vec);
+	//! Gets a reference to the binary blob 'value', which encodes the data of the row
+	DUCKDB_API static Vector &GetData(Vector &vec);
+	DUCKDB_API static Vector &GetData(const Vector &vec);
+};
+
 enum class UnionInvalidReason : uint8_t {
 	VALID,
 	TAG_OUT_OF_RANGE,

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

@@ -104,6 +104,10 @@ public:
 		SetAuxiliaryData(std::move(source_buffer.aux_data));
 	}
 
+	virtual optional_ptr<Allocator> GetAllocator() const {
+		return data.GetAllocator();
+	}
+
 	static buffer_ptr<VectorBuffer> CreateStandardVector(PhysicalType type, idx_t capacity = STANDARD_VECTOR_SIZE);
 	static buffer_ptr<VectorBuffer> CreateConstantVector(PhysicalType type);
 	static buffer_ptr<VectorBuffer> CreateConstantVector(const LogicalType &logical_type);
@@ -182,6 +186,7 @@ private:
 class VectorStringBuffer : public VectorBuffer {
 public:
 	VectorStringBuffer();
+	explicit VectorStringBuffer(Allocator &allocator);
 	explicit VectorStringBuffer(VectorBufferType type);
 
 public:
@@ -198,6 +203,9 @@ public:
 		return heap.EmptyString(len);
 	}
 
+	ArenaAllocator &GetStringAllocator() {
+		return heap.GetAllocator();
+	}
 	//! Allocate a buffer to store up to "len" bytes for a string
 	//! This can be turned into a proper string by using FinalizeBuffer afterwards
 	//! Note that alloc_len only has to be an upper bound, the final string may be smaller

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

@@ -8,13 +8,11 @@
 
 #pragma once
 
-#include "duckdb/common/assert.hpp"
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/helper.hpp"
 
-#include <limits>
 
 namespace duckdb {
 
@@ -188,6 +186,15 @@ enum class LogicalTypeId : uint8_t {
 	UNKNOWN = 2, /* unknown type, used for parameter expressions */
 	ANY = 3,     /* ANY type, used for functions that accept any type as parameter */
 	USER = 4,    /* A User Defined Type (e.g., ENUMs before the binder) */
+
+
+	// A "template" type functions as a "placeholder" type for function arguments and return types.
+	// Templates only exist during the binding phase, in the scope of a function, and are replaced with concrete types
+	// before execution. When defining a template, you provide a name to distinguish between different template types,
+	// specifying to the binder that they dont need to resolve to the same concrete type. Two templates with the same
+	// name are always resolved to the same concrete type.
+	TEMPLATE = 5,
+
 	BOOLEAN = 10,
 	TINYINT = 11,
 	SMALLINT = 12,
@@ -212,10 +219,11 @@ enum class LogicalTypeId : uint8_t {
 	UBIGINT = 31,
 	TIMESTAMP_TZ = 32,
 	TIME_TZ = 34,
+	TIME_NS = 35,
 	BIT = 36,
 	STRING_LITERAL = 37, /* string literals, used for constant strings - only exists while binding */
 	INTEGER_LITERAL = 38,/* integer literals, used for constant integers - only exists while binding */
-	VARINT = 39,
+	BIGNUM = 39,
 	UHUGEINT = 49,
 	HUGEINT = 50,
 	POINTER = 51,
@@ -230,7 +238,8 @@ enum class LogicalTypeId : uint8_t {
 	AGGREGATE_STATE = 105,
 	LAMBDA = 106,
 	UNION = 107,
-	ARRAY = 108
+	ARRAY = 108,
+	VARIANT = 109
 };
 
 struct ExtraTypeInfo;
@@ -277,7 +286,9 @@ struct LogicalType {
 		return type_info_;
 	}
 
-	//! DeepCopy() will make a unique copy of any ExtraTypeInfo as well
+	//! Copies the logical type, making a new ExtraTypeInfo
+	LogicalType Copy() const;
+	//! DeepCopy() will make a unique copy of any nested ExtraTypeInfo as well
 	LogicalType DeepCopy() const;
 
 	inline void CopyAuxInfo(const LogicalType &other) {
@@ -354,6 +365,7 @@ struct LogicalType {
 
 	DUCKDB_API bool IsValid() const;
 	DUCKDB_API bool IsComplete() const;
+	DUCKDB_API bool IsTemplated() const;
 
 	//! True, if this type supports in-place updates.
 	bool SupportsRegularUpdate() const;
@@ -387,13 +399,14 @@ public:
 	static constexpr const LogicalTypeId TIMESTAMP_MS = LogicalTypeId::TIMESTAMP_MS;
 	static constexpr const LogicalTypeId TIMESTAMP_NS = LogicalTypeId::TIMESTAMP_NS;
 	static constexpr const LogicalTypeId TIME = LogicalTypeId::TIME;
+	static constexpr const LogicalTypeId TIME_NS = LogicalTypeId::TIME_NS;
 	static constexpr const LogicalTypeId TIMESTAMP_TZ = LogicalTypeId::TIMESTAMP_TZ;
 	static constexpr const LogicalTypeId TIME_TZ = LogicalTypeId::TIME_TZ;
 	static constexpr const LogicalTypeId VARCHAR = LogicalTypeId::VARCHAR;
 	static constexpr const LogicalTypeId ANY = LogicalTypeId::ANY;
 	static constexpr const LogicalTypeId BLOB = LogicalTypeId::BLOB;
 	static constexpr const LogicalTypeId BIT = LogicalTypeId::BIT;
-	static constexpr const LogicalTypeId VARINT = LogicalTypeId::VARINT;
+	static constexpr const LogicalTypeId BIGNUM = LogicalTypeId::BIGNUM;
 
 	static constexpr const LogicalTypeId INTERVAL = LogicalTypeId::INTERVAL;
 	static constexpr const LogicalTypeId HUGEINT = LogicalTypeId::HUGEINT;
@@ -419,6 +432,8 @@ public:
 	DUCKDB_API static LogicalType ENUM(Vector &ordered_data, idx_t size); // NOLINT
 	// ANY but with special rules (default is LogicalType::ANY, 5)
 	DUCKDB_API static LogicalType ANY_PARAMS(LogicalType target, idx_t cast_score = 5); // NOLINT
+	DUCKDB_API static LogicalType TEMPLATE(const string &name);							// NOLINT
+	DUCKDB_API static LogicalType VARIANT(); // NOLINT
 	//! Integer literal of the specified value
 	DUCKDB_API static LogicalType INTEGER_LITERAL(const Value &constant);               // NOLINT
 	// DEPRECATED - provided for backwards compatibility
@@ -521,6 +536,11 @@ struct IntegerLiteral {
 	DUCKDB_API static bool FitsInType(const LogicalType &type, const LogicalType &target);
 };
 
+struct TemplateType {
+	// Get the name of the template type
+	DUCKDB_API static const string &GetName(const LogicalType &type);
+};
+
 // **DEPRECATED**: Use EnumUtil directly instead.
 DUCKDB_API string LogicalTypeIdToString(LogicalTypeId type);
 

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

@@ -42,12 +42,18 @@ private:
 #endif
 
 	template <class STATE_TYPE, class OP>
-	static inline void NullaryScatterLoop(STATE_TYPE **__restrict states, AggregateInputData &aggr_input_data,
-	                                      const SelectionVector &ssel, idx_t count) {
-
-		for (idx_t i = 0; i < count; i++) {
-			auto sidx = ssel.get_index(i);
-			OP::template Operation<STATE_TYPE, OP>(*states[sidx], aggr_input_data, sidx);
+	static inline void NullaryScatterLoop(STATE_TYPE *__restrict const *__restrict const states,
+	                                      AggregateInputData &aggr_input_data, const SelectionVector &ssel,
+	                                      const idx_t count) {
+		if (ssel.IsSet()) {
+			for (idx_t i = 0; i < count; i++) {
+				auto sidx = ssel.get_index_unsafe(i);
+				OP::template Operation<STATE_TYPE, OP>(*states[sidx], aggr_input_data, sidx);
+			}
+		} else {
+			for (idx_t i = 0; i < count; i++) {
+				OP::template Operation<STATE_TYPE, OP>(*states[i], aggr_input_data, i);
+			}
 		}
 	}
 
@@ -93,17 +99,25 @@ private:
 	}
 #endif
 
+#ifndef DUCKDB_SMALLER_BINARY
+	template <class STATE_TYPE, class INPUT_TYPE, class OP, bool HAS_ISEL, bool HAS_SSEL>
+#else
 	template <class STATE_TYPE, class INPUT_TYPE, class OP>
+#endif
 	static inline void UnaryScatterLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
 	                                    STATE_TYPE **__restrict states, const SelectionVector &isel,
 	                                    const SelectionVector &ssel, ValidityMask &mask, idx_t count) {
+#ifdef DUCKDB_SMALLER_BINARY
+		const auto HAS_ISEL = isel.IsSet();
+		const auto HAS_SSEL = ssel.IsSet();
+#endif
 		if (OP::IgnoreNull() && !mask.AllValid()) {
 			// potential NULL values and NULL values are ignored
 			AggregateUnaryInput input(aggr_input_data, mask);
 			for (idx_t i = 0; i < count; i++) {
-				input.input_idx = isel.get_index(i);
-				auto sidx = ssel.get_index(i);
-				if (mask.RowIsValid(input.input_idx)) {
+				input.input_idx = HAS_ISEL ? isel.get_index_unsafe(i) : i;
+				auto sidx = HAS_SSEL ? ssel.get_index_unsafe(i) : i;
+				if (mask.RowIsValidUnsafe(input.input_idx)) {
 					OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*states[sidx], idata[input.input_idx], input);
 				}
 			}
@@ -111,8 +125,8 @@ private:
 			// quick path: no NULL values or NULL values are not ignored
 			AggregateUnaryInput input(aggr_input_data, mask);
 			for (idx_t i = 0; i < count; i++) {
-				input.input_idx = isel.get_index(i);
-				auto sidx = ssel.get_index(i);
+				input.input_idx = HAS_ISEL ? isel.get_index_unsafe(i) : i;
+				auto sidx = HAS_SSEL ? ssel.get_index_unsafe(i) : i;
 				OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*states[sidx], idata[input.input_idx], input);
 			}
 		}
@@ -278,9 +292,34 @@ public:
 			UnifiedVectorFormat idata, sdata;
 			input.ToUnifiedFormat(count, idata);
 			states.ToUnifiedFormat(count, sdata);
+#ifdef DUCKDB_SMALLER_BINARY
 			UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP>(UnifiedVectorFormat::GetData<INPUT_TYPE>(idata),
 			                                             aggr_input_data, (STATE_TYPE **)sdata.data, *idata.sel,
 			                                             *sdata.sel, idata.validity, count);
+#else
+			if (idata.sel->IsSet()) {
+				if (sdata.sel->IsSet()) {
+					UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP, true, true>(
+					    UnifiedVectorFormat::GetData<INPUT_TYPE>(idata), aggr_input_data, (STATE_TYPE **)sdata.data,
+					    *idata.sel, *sdata.sel, idata.validity, count);
+				} else {
+					UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP, true, false>(
+					    UnifiedVectorFormat::GetData<INPUT_TYPE>(idata), aggr_input_data, (STATE_TYPE **)sdata.data,
+					    *idata.sel, *sdata.sel, idata.validity, count);
+				}
+			} else {
+				if (sdata.sel->IsSet()) {
+					UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP, false, true>(
+					    UnifiedVectorFormat::GetData<INPUT_TYPE>(idata), aggr_input_data, (STATE_TYPE **)sdata.data,
+					    *idata.sel, *sdata.sel, idata.validity, count);
+				} else {
+					UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP, false, false>(
+					    UnifiedVectorFormat::GetData<INPUT_TYPE>(idata), aggr_input_data, (STATE_TYPE **)sdata.data,
+					    *idata.sel, *sdata.sel, idata.validity, count);
+				}
+			}
+
+#endif
 		}
 	}
 

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

@@ -22,13 +22,11 @@ public:
 
 	void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override;
 	void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override;
-
 	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-
 	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
 
 	int64_t GetFileSize(FileHandle &handle) override;
-	time_t GetLastModifiedTime(FileHandle &handle) override;
+	timestamp_t GetLastModifiedTime(FileHandle &handle) override;
 	string GetVersionTag(FileHandle &handle) override;
 	FileType GetFileType(FileHandle &handle) override;
 
@@ -65,6 +63,7 @@ public:
 	std::string GetName() const override;
 
 	void SetDisabledFileSystems(const vector<string> &names) override;
+	bool SubSystemIsDisabled(const string &name) override;
 
 	string PathSeparator(const string &path) override;
 

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

@@ -29,11 +29,7 @@
 #ifdef DUCKDB_STATIC_BUILD
 #define DUCKDB_EXTENSION_API
 #else
-#ifdef DUCKDB_BUILD_LOADABLE_EXTENSION
 #define DUCKDB_EXTENSION_API __declspec(dllexport)
-#else
-#define DUCKDB_EXTENSION_API
-#endif
 #endif
 #else
 #define DUCKDB_EXTENSION_API __attribute__((visibility("default")))