duckdb 0.9.3-dev0.0 → 0.9.3-dev14.0

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

@@ -27,8 +27,9 @@ public:
 	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);
-	//!	Format is ±[HH]HH[:MM[:SS]]
-	DUCKDB_API static bool TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int32_t &offset);
+	// No hour limit
+	DUCKDB_API static bool TryConvertInterval(const char *buf, idx_t len, idx_t &pos, dtime_t &result,
+	                                          bool strict = false);
 
 	//! Convert a time object to a string in the format "hh:mm:ss"
 	DUCKDB_API static string ToString(dtime_t time);
@@ -37,6 +38,9 @@ public:
 
 	DUCKDB_API static dtime_t FromTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds = 0);
 
+	//! Normalize a TIME_TZ by adding the offset to the time part and returning the TIME
+	DUCKDB_API static dtime_t NormalizeTimeTZ(dtime_tz_t timetz);
+
 	//! Extract the time from a given timestamp object
 	DUCKDB_API static void Convert(dtime_t time, int32_t &out_hour, int32_t &out_min, int32_t &out_sec,
 	                               int32_t &out_micros);

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

@@ -20,6 +20,7 @@ namespace duckdb {
 
 struct date_t;
 struct dtime_t;
+struct dtime_tz_t;
 
 //! Type used to represent timestamps (seconds,microseconds,milliseconds or nanoseconds since 1970-01-01)
 struct timestamp_t { // NOLINT
@@ -117,6 +118,7 @@ public:
 	//! Create a Timestamp object from a specified (date, time) combination
 	DUCKDB_API static timestamp_t FromDatetime(date_t date, dtime_t time);
 	DUCKDB_API static bool TryFromDatetime(date_t date, dtime_t time, timestamp_t &result);
+	DUCKDB_API static bool TryFromDatetime(date_t date, dtime_tz_t timetz, timestamp_t &result);
 
 	//! Is the character a valid part of a time zone name?
 	static inline bool CharacterIsTimeZone(char c) {

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

@@ -0,0 +1,216 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/uhugeint.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/types.hpp"
+#include "duckdb/common/type_util.hpp"
+#include "duckdb/common/limits.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/uhugeint.hpp"
+
+namespace duckdb {
+
+//! The uhugeint class contains static operations for the UINT128 type
+class Uhugeint {
+public:
+	//! Convert a uhugeint object to a string
+	static string ToString(uhugeint_t input);
+
+	template <class T>
+	DUCKDB_API static bool TryCast(uhugeint_t input, T &result);
+
+	template <class T>
+	static T Cast(uhugeint_t input) {
+		T result = 0;
+		TryCast(input, result);
+		return result;
+	}
+
+	template <class T>
+	static bool TryConvert(T value, uhugeint_t &result);
+
+	template <class T>
+	static uhugeint_t Convert(T value) {
+		uhugeint_t result;
+		if (!TryConvert(value, result)) { // LCOV_EXCL_START
+			throw OutOfRangeException(double(value), GetTypeId<T>(), GetTypeId<uhugeint_t>());
+		} // LCOV_EXCL_STOP
+		return result;
+	}
+
+	static bool TryNegate(uhugeint_t input, uhugeint_t &result);
+
+	// "The negative of an unsigned quantity is computed by subtracting its value from 2^n, where n is the number of
+	// bits in the promoted operand."
+	template <bool CHECK_OVERFLOW = true>
+	inline static void NegateInPlace(uhugeint_t &input) {
+		if (!TryNegate(input, input)) {
+			throw OutOfRangeException("UHUGEINT is out of range");
+		}
+	}
+
+	template <bool CHECK_OVERFLOW = true>
+	inline static uhugeint_t Negate(uhugeint_t input) {
+		NegateInPlace<CHECK_OVERFLOW>(input);
+		return input;
+	}
+
+	static bool TryMultiply(uhugeint_t lhs, uhugeint_t rhs, uhugeint_t &result);
+
+	template <bool CHECK_OVERFLOW = true>
+	inline static uhugeint_t Multiply(uhugeint_t lhs, uhugeint_t rhs) {
+		uhugeint_t result;
+		if (!TryMultiply(lhs, rhs, result)) {
+			throw OutOfRangeException("Overflow in UHUGEINT multiplication!: %s + %s", lhs.ToString(), rhs.ToString());
+		}
+		return result;
+	}
+
+	static bool TryDivMod(uhugeint_t lhs, uhugeint_t rhs, uhugeint_t &result, uhugeint_t &remainder);
+
+	template <bool CHECK_OVERFLOW = true>
+	inline static uhugeint_t Divide(uhugeint_t lhs, uhugeint_t rhs) {
+		// division between two same-size unsigned intergers can only go wrong with division by zero
+		if (rhs == 0) {
+			throw OutOfRangeException("Division of UHUGEINT by zero!");
+		}
+		return Divide<false>(lhs, rhs);
+	}
+
+	template <bool CHECK_OVERFLOW = true>
+	inline static uhugeint_t Modulo(uhugeint_t lhs, uhugeint_t rhs) {
+		if (rhs == 0) {
+			throw OutOfRangeException("Modulo of UHUGEINT by zero!");
+		}
+		return Modulo<false>(lhs, rhs);
+	}
+
+	static bool TryAddInPlace(uhugeint_t &lhs, uhugeint_t rhs);
+
+	template <bool CHECK_OVERFLOW = true>
+	inline static uhugeint_t Add(uhugeint_t lhs, uhugeint_t rhs) {
+		if (!TryAddInPlace(lhs, rhs)) {
+			throw OutOfRangeException("Overflow in UHUGEINT addition: %s + %s", lhs.ToString(), rhs.ToString());
+		}
+		return lhs;
+	}
+
+	static bool TrySubtractInPlace(uhugeint_t &lhs, uhugeint_t rhs);
+
+	template <bool CHECK_OVERFLOW = true>
+	inline static uhugeint_t Subtract(uhugeint_t lhs, uhugeint_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 uhugeint_t DivMod(uhugeint_t lhs, uhugeint_t rhs, uhugeint_t &remainder);
+
+	static int Sign(hugeint_t n);
+	static hugeint_t Abs(hugeint_t n);
+
+	// comparison operators
+	// note that everywhere here we intentionally use bitwise ops
+	// this is because they seem to be consistently much faster (benchmarked on a Macbook Pro)
+	static bool Equals(uhugeint_t lhs, uhugeint_t rhs) {
+		int lower_equals = lhs.lower == rhs.lower;
+		int upper_equals = lhs.upper == rhs.upper;
+		return lower_equals & upper_equals;
+	}
+
+	static bool NotEquals(uhugeint_t lhs, uhugeint_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(uhugeint_t lhs, uhugeint_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(uhugeint_t lhs, uhugeint_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(uhugeint_t lhs, uhugeint_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(uhugeint_t lhs, uhugeint_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 uhugeint_t POWERS_OF_TEN[40];
+};
+
+template <>
+DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, int8_t &result);
+template <>
+DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, int16_t &result);
+template <>
+DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, int32_t &result);
+template <>
+DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, int64_t &result);
+template <>
+DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, uint8_t &result);
+template <>
+DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, uint16_t &result);
+template <>
+DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, uint32_t &result);
+template <>
+DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, uint64_t &result);
+template <>
+DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, hugeint_t &result);
+template <>
+DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, uhugeint_t &result);
+template <>
+DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, float &result);
+template <>
+DUCKDB_API bool Uhugeint::TryCast(uhugeint_t input, double &result);
+
+template <>
+bool Uhugeint::TryConvert(int8_t value, uhugeint_t &result);
+template <>
+bool Uhugeint::TryConvert(int16_t value, uhugeint_t &result);
+template <>
+bool Uhugeint::TryConvert(int32_t value, uhugeint_t &result);
+template <>
+bool Uhugeint::TryConvert(int64_t value, uhugeint_t &result);
+template <>
+bool Uhugeint::TryConvert(uint8_t value, uhugeint_t &result);
+template <>
+bool Uhugeint::TryConvert(uint16_t value, uhugeint_t &result);
+template <>
+bool Uhugeint::TryConvert(uint32_t value, uhugeint_t &result);
+template <>
+bool Uhugeint::TryConvert(uint64_t value, uhugeint_t &result);
+template <>
+bool Uhugeint::TryConvert(float value, uhugeint_t &result);
+template <>
+bool Uhugeint::TryConvert(double value, uhugeint_t &result);
+template <>
+bool Uhugeint::TryConvert(long double value, uhugeint_t &result);
+template <>
+bool Uhugeint::TryConvert(const char *value, uhugeint_t &result);
+
+} // namespace duckdb

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

@@ -65,12 +65,11 @@ public:
 	static constexpr const int STANDARD_MASK_SIZE = STANDARD_ENTRY_COUNT * sizeof(validity_t);
 
 public:
-	inline TemplatedValidityMask() : validity_mask(nullptr) {
+	inline TemplatedValidityMask() : validity_mask(nullptr), target_count(STANDARD_VECTOR_SIZE) {
 	}
-	inline explicit TemplatedValidityMask(idx_t max_count) {
-		Initialize(max_count);
+	inline explicit TemplatedValidityMask(idx_t target_count) : validity_mask(nullptr), target_count(target_count) {
 	}
-	inline explicit TemplatedValidityMask(V *ptr) : validity_mask(ptr) {
+	inline explicit TemplatedValidityMask(V *ptr) : validity_mask(ptr), target_count(STANDARD_VECTOR_SIZE) {
 	}
 	inline TemplatedValidityMask(const TemplatedValidityMask &original, idx_t count) {
 		Copy(original, count);
@@ -136,9 +135,10 @@ public:
 	inline V *GetData() const {
 		return validity_mask;
 	}
-	inline void Reset() {
+	inline void Reset(idx_t target_count_p = STANDARD_VECTOR_SIZE) {
 		validity_mask = nullptr;
 		validity_data.reset();
+		target_count = target_count_p;
 	}
 
 	static inline idx_t EntryCount(idx_t count) {
@@ -229,8 +229,8 @@ public:
 	//! Marks the entry at the specified row index as invalid (i.e. null)
 	inline void SetInvalid(idx_t row_idx) {
 		if (!validity_mask) {
-			D_ASSERT(row_idx <= STANDARD_VECTOR_SIZE);
-			Initialize(STANDARD_VECTOR_SIZE);
+			D_ASSERT(row_idx <= target_count);
+			Initialize(target_count);
 		}
 		SetInvalidUnsafe(row_idx);
 	}
@@ -295,12 +295,18 @@ public:
 	inline void Initialize(const TemplatedValidityMask &other) {
 		validity_mask = other.validity_mask;
 		validity_data = other.validity_data;
+		target_count = other.target_count;
 	}
-	inline void Initialize(idx_t count = STANDARD_VECTOR_SIZE) {
+	inline void Initialize(idx_t count) {
+		target_count = count;
 		validity_data = make_buffer<ValidityBuffer>(count);
 		validity_mask = validity_data->owned_data.get();
 	}
+	inline void Initialize() {
+		Initialize(target_count);
+	}
 	inline void Copy(const TemplatedValidityMask &other, idx_t count) {
+		target_count = count;
 		if (other.AllValid()) {
 			validity_data = nullptr;
 			validity_mask = nullptr;
@@ -313,13 +319,15 @@ public:
 protected:
 	V *validity_mask;
 	buffer_ptr<ValidityBuffer> validity_data;
+	// The size to initialize the validity mask to when/if the mask is lazily initialized
+	idx_t target_count;
 };
 
 struct ValidityMask : public TemplatedValidityMask<validity_t> {
 public:
 	inline ValidityMask() : TemplatedValidityMask(nullptr) {
 	}
-	inline explicit ValidityMask(idx_t max_count) : TemplatedValidityMask(max_count) {
+	inline explicit ValidityMask(idx_t target_count) : TemplatedValidityMask(target_count) {
 	}
 	inline explicit ValidityMask(validity_t *ptr) : TemplatedValidityMask(ptr) {
 	}
@@ -328,7 +336,7 @@ public:
 
 public:
 	DUCKDB_API void Resize(idx_t old_size, idx_t new_size);
-
+	DUCKDB_API idx_t TargetCount();
 	DUCKDB_API void SliceInPlace(const ValidityMask &other, idx_t target_offset, idx_t source_offset, idx_t count);
 	DUCKDB_API void Slice(const ValidityMask &other, idx_t source_offset, idx_t count);
 	DUCKDB_API void Combine(const ValidityMask &other, idx_t count);

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

@@ -11,6 +11,7 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types.hpp"
+#include "duckdb/common/uhugeint.hpp"
 #include "duckdb/common/winapi.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/types/date.hpp"
@@ -30,6 +31,7 @@ class Value {
 	friend struct StructValue;
 	friend struct ListValue;
 	friend struct UnionValue;
+	friend struct ArrayValue;
 
 public:
 	//! Create an empty NULL value of the specified type
@@ -83,6 +85,7 @@ public:
 	//! Create a Numeric value of the specified type with the specified value
 	DUCKDB_API static Value Numeric(const LogicalType &type, int64_t value);
 	DUCKDB_API static Value Numeric(const LogicalType &type, hugeint_t value);
+	DUCKDB_API static Value Numeric(const LogicalType &type, uhugeint_t value);
 
 	//! Create a tinyint Value from a specified value
 	DUCKDB_API static Value BOOLEAN(int8_t value);
@@ -104,6 +107,8 @@ public:
 	DUCKDB_API static Value UBIGINT(uint64_t value);
 	//! Create a hugeint Value from a specified value
 	DUCKDB_API static Value HUGEINT(hugeint_t value);
+	//! Create a uhugeint Value from a specified value
+	DUCKDB_API static Value UHUGEINT(uhugeint_t value);
 	//! Create a uuid Value from a specified value
 	DUCKDB_API static Value UUID(const string &value);
 	//! Create a uuid Value from a specified value
@@ -149,6 +154,7 @@ public:
 	DUCKDB_API static Value DOUBLE(double value);
 	//! Create a struct value with given list of entries
 	DUCKDB_API static Value STRUCT(child_list_t<Value> values);
+	DUCKDB_API static Value STRUCT(const LogicalType &type, vector<Value> struct_values);
 	//! Create a list value with the given entries, list type is inferred from children
 	//! Cannot be called with an empty list, use either EMPTYLIST or LIST with a type instead
 	DUCKDB_API static Value LIST(vector<Value> values);
@@ -156,8 +162,18 @@ public:
 	DUCKDB_API static Value LIST(const LogicalType &child_type, vector<Value> values);
 	//! Create an empty list with the specified child-type
 	DUCKDB_API static Value EMPTYLIST(const LogicalType &child_type);
+	//! Create an array value with the given entries. Array type is inferred from children
+	//! Cannot be called with an empty list, use either EMPTYARRAY or ARRAY with a type instead
+	DUCKDB_API static Value ARRAY(vector<Value> values);
+	// Create an array value with the given entries
+	DUCKDB_API static Value ARRAY(const LogicalType &type, vector<Value> values);
+	//! Create an empty array of the given type and size
+	DUCKDB_API static Value EMPTYARRAY(const LogicalType &type, uint32_t size);
 	//! Create a map value with the given entries
 	DUCKDB_API static Value MAP(const LogicalType &child_type, vector<Value> values);
+	//! 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 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);
 
@@ -292,6 +308,7 @@ private:
 		uint32_t uinteger;
 		uint64_t ubigint;
 		hugeint_t hugeint;
+		uhugeint_t uhugeint;
 		float float_;   // NOLINT
 		double double_; // NOLINT
 		uintptr_t pointer;
@@ -355,6 +372,10 @@ struct UBigIntValue {
 	DUCKDB_API static uint64_t Get(const Value &value);
 };
 
+struct UhugeIntValue {
+	DUCKDB_API static uhugeint_t Get(const Value &value);
+};
+
 struct FloatValue {
 	DUCKDB_API static float Get(const Value &value);
 };
@@ -391,6 +412,10 @@ struct ListValue {
 	DUCKDB_API static const vector<Value> &GetChildren(const Value &value);
 };
 
+struct ArrayValue {
+	DUCKDB_API static const vector<Value> &GetChildren(const Value &value);
+};
+
 struct UnionValue {
 	DUCKDB_API static const Value &GetValue(const Value &value);
 	DUCKDB_API static uint8_t GetTag(const Value &value);
@@ -424,6 +449,8 @@ Value DUCKDB_API Value::CreateValue(int64_t value);
 template <>
 Value DUCKDB_API Value::CreateValue(hugeint_t value);
 template <>
+Value DUCKDB_API Value::CreateValue(uhugeint_t value);
+template <>
 Value DUCKDB_API Value::CreateValue(date_t value);
 template <>
 Value DUCKDB_API Value::CreateValue(dtime_t value);
@@ -475,6 +502,8 @@ DUCKDB_API uint64_t Value::GetValue() const;
 template <>
 DUCKDB_API hugeint_t Value::GetValue() const;
 template <>
+DUCKDB_API uhugeint_t Value::GetValue() const;
+template <>
 DUCKDB_API string Value::GetValue() const;
 template <>
 DUCKDB_API float Value::GetValue() const;
@@ -504,6 +533,8 @@ DUCKDB_API int64_t Value::GetValueUnsafe() const;
 template <>
 DUCKDB_API hugeint_t Value::GetValueUnsafe() const;
 template <>
+DUCKDB_API uhugeint_t Value::GetValueUnsafe() const;
+template <>
 DUCKDB_API uint8_t Value::GetValueUnsafe() const;
 template <>
 DUCKDB_API uint16_t Value::GetValueUnsafe() const;

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

@@ -38,6 +38,7 @@ struct UnifiedVectorFormat {
 struct RecursiveUnifiedVectorFormat {
 	UnifiedVectorFormat unified;
 	vector<RecursiveUnifiedVectorFormat> children;
+	LogicalType logical_type;
 };
 
 class VectorCache;
@@ -65,6 +66,7 @@ class Vector {
 	friend struct StructVector;
 	friend struct UnionVector;
 	friend struct SequenceVector;
+	friend struct ArrayVector;
 
 	friend class DataChunk;
 	friend class VectorCacheBuffer;
@@ -116,9 +118,9 @@ public:
 	DUCKDB_API void ResetFromCache(const VectorCache &cache);
 
 	//! Creates a reference to a slice of the other vector
-	DUCKDB_API void Slice(Vector &other, idx_t offset, idx_t end);
+	DUCKDB_API void Slice(const Vector &other, idx_t offset, idx_t end);
 	//! Creates a reference to a slice of the other vector
-	DUCKDB_API void Slice(Vector &other, const SelectionVector &sel, idx_t count);
+	DUCKDB_API void Slice(const Vector &other, const SelectionVector &sel, idx_t count);
 	//! Turns the vector into a dictionary vector with the specified dictionary
 	DUCKDB_API void Slice(const SelectionVector &sel, idx_t count);
 	//! Slice the vector, keeping the result around in a cache or potentially using the cache instead of slicing
@@ -170,6 +172,11 @@ public:
 		auxiliary = std::move(new_buffer);
 	};
 
+	inline void CopyBuffer(Vector &other) {
+		buffer = other.buffer;
+		data = other.data;
+	}
+
 	//! This functions resizes the vector
 	DUCKDB_API void Resize(idx_t cur_size, idx_t new_size);
 
@@ -447,6 +454,15 @@ struct StructVector {
 	DUCKDB_API static vector<unique_ptr<Vector>> &GetEntries(Vector &vector);
 };
 
+struct ArrayVector {
+	//! Gets a reference to the underlying child-vector of an array
+	DUCKDB_API static const Vector &GetEntry(const Vector &vector);
+	//! Gets a reference to the underlying child-vector of an array
+	DUCKDB_API static Vector &GetEntry(Vector &vector);
+	//! Gets the total size of the underlying child-vector of an array
+	DUCKDB_API static idx_t GetTotalSize(const Vector &vector);
+};
+
 enum class UnionInvalidReason : uint8_t {
 	VALID,
 	TAG_OUT_OF_RANGE,

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

@@ -29,7 +29,8 @@ enum class VectorBufferType : uint8_t {
 	STRUCT_BUFFER,       // struct buffer, holds a ordered mapping from name to child vector
 	LIST_BUFFER,         // list buffer, holds a single flatvector child
 	MANAGED_BUFFER,      // managed buffer, holds a buffer managed by the buffermanager
-	OPAQUE_BUFFER        // opaque buffer, can be created for example by the parquet reader
+	OPAQUE_BUFFER,       // opaque buffer, can be created for example by the parquet reader
+	ARRAY_BUFFER         // array buffer, holds a single flatvector child
 };
 
 enum class VectorAuxiliaryDataType : uint8_t {
@@ -271,6 +272,26 @@ private:
 	idx_t size = 0;
 };
 
+class VectorArrayBuffer : public VectorBuffer {
+public:
+	explicit VectorArrayBuffer(unique_ptr<Vector> child_vector, idx_t array_size, idx_t initial_capacity);
+	explicit VectorArrayBuffer(const LogicalType &array, idx_t initial = STANDARD_VECTOR_SIZE);
+	~VectorArrayBuffer() override;
+
+public:
+	Vector &GetChild();
+	idx_t GetArraySize();
+	idx_t GetChildSize();
+
+private:
+	unique_ptr<Vector> child;
+	// The size of each array in this buffer
+	idx_t array_size = 0;
+	// How many arrays are currently stored in this buffer
+	// The child vector has size (array_size * size)
+	idx_t size = 0;
+};
+
 //! The ManagedVectorBuffer holds a buffer handle
 class ManagedVectorBuffer : public VectorBuffer {
 public: