duckdb 0.9.3-dev0.0 → 0.9.3-dev3.0

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

@@ -41,10 +41,10 @@ struct list_entry_t {
 	list_entry_t() = default;
 	list_entry_t(uint64_t offset, uint64_t length) : offset(offset), length(length) {
 	}
-	inline constexpr bool operator != (const list_entry_t &other) const {
+	inline constexpr bool operator!=(const list_entry_t &other) const {
 		return !(*this == other);
 	}
-	inline constexpr bool operator == (const list_entry_t &other) const {
+	inline constexpr bool operator==(const list_entry_t &other) const {
 		return offset == other.offset && length == other.length;
 	}
 
@@ -52,7 +52,7 @@ struct list_entry_t {
 	uint64_t length;
 };
 
-using union_tag_t = uint8_t; 
+using union_tag_t = uint8_t;
 
 //===--------------------------------------------------------------------===//
 // Internal Types
@@ -61,7 +61,7 @@ using union_tag_t = uint8_t;
 // taken from arrow's type.h
 enum class PhysicalType : uint8_t {
 	///// A NULL type having no physical storage
-	//NA = 0,
+	// NA = 0,
 
 	/// Boolean as 8 bit "bool" value
 	BOOL = 1,
@@ -91,7 +91,7 @@ enum class PhysicalType : uint8_t {
 	INT64 = 9,
 
 	///// 2-byte floating point value
-	//HALF_FLOAT = 10,
+	// HALF_FLOAT = 10,
 
 	/// 4-byte floating point value
 	FLOAT = 11,
@@ -100,31 +100,31 @@ enum class PhysicalType : uint8_t {
 	DOUBLE = 12,
 
 	///// UTF8 variable-length string as List<Char>
-	//STRING = 13,
+	// STRING = 13,
 
 	///// Variable-length bytes (no guarantee of UTF8-ness)
-	//BINARY = 14,
+	// BINARY = 14,
 
 	///// Fixed-size binary. Each value occupies the same number of bytes
-	//FIXED_SIZE_BINARY = 15,
+	// FIXED_SIZE_BINARY = 15,
 
 	///// int32_t days since the UNIX epoch
-	//DATE32 = 16,
+	// DATE32 = 16,
 
 	///// int64_t milliseconds since the UNIX epoch
-	//DATE64 = 17,
+	// DATE64 = 17,
 
 	///// Exact timestamp encoded with int64 since UNIX epoch
 	///// Default unit millisecond
-	//TIMESTAMP = 18,
+	// TIMESTAMP = 18,
 
 	///// Time as signed 32-bit integer, representing either seconds or
 	///// milliseconds since midnight
-	//TIME32 = 19,
+	// TIME32 = 19,
 
 	///// Time as signed 64-bit integer, representing either microseconds or
 	///// nanoseconds since midnight
-	//TIME64 = 20,
+	// TIME64 = 20,
 
 	/// YEAR_MONTH or DAY_TIME interval in SQL style
 	INTERVAL = 21,
@@ -140,35 +140,36 @@ enum class PhysicalType : uint8_t {
 	STRUCT = 24,
 
 	///// Unions of logical types
-	//UNION = 25,
+	// UNION = 25,
 
 	///// Dictionary-encoded type, also called "categorical" or "factor"
 	///// in other programming languages. Holds the dictionary value
 	///// type but not the dictionary itself, which is part of the
 	///// ArrayData struct
-	//DICTIONARY = 26,
+	// DICTIONARY = 26,
 
 	///// Custom data type, implemented by user
-	//EXTENSION = 28,
+	// EXTENSION = 28,
 
-	///// Fixed size list of some logical type
-	//FIXED_SIZE_LIST = 29,
+	///// Array with fixed length of some logical type (a fixed-size list)
+	ARRAY = 29,
 
 	///// Measure of elapsed time in either seconds, milliseconds, microseconds
 	///// or nanoseconds.
-	//DURATION = 30,
+	// DURATION = 30,
 
 	///// Like STRING, but with 64-bit offsets
-	//LARGE_STRING = 31,
+	// LARGE_STRING = 31,
 
 	///// Like BINARY, but with 64-bit offsets
-	//LARGE_BINARY = 32,
+	// LARGE_BINARY = 32,
 
 	///// Like LIST, but with 64-bit offsets
-	//LARGE_LIST = 33,
+	// LARGE_LIST = 33,
 
 	/// DuckDB Extensions
 	VARCHAR = 200, // our own string representation, different from STRING and LARGE_STRING above
+	UINT128 = 203, // 128-bit unsigned integers
 	INT128 = 204, // 128-bit integers
 	UNKNOWN = 205, // Unknown physical type of user defined types
 	/// Boolean as 1 bit, LSB bit-packed ordering
@@ -185,7 +186,7 @@ enum class LogicalTypeId : uint8_t {
 	SQLNULL = 1, /* NULL type, used for constant NULL */
 	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) */
+	USER = 4,    /* A User Defined Type (e.g., ENUMs before the binder) */
 	BOOLEAN = 10,
 	TINYINT = 11,
 	SMALLINT = 12,
@@ -211,7 +212,10 @@ enum class LogicalTypeId : uint8_t {
 	TIMESTAMP_TZ = 32,
 	TIME_TZ = 34,
 	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 */
 
+	UHUGEINT = 49,
 	HUGEINT = 50,
 	POINTER = 51,
 	VALIDITY = 53,
@@ -224,10 +228,10 @@ enum class LogicalTypeId : uint8_t {
 	ENUM = 104,
 	AGGREGATE_STATE = 105,
 	LAMBDA = 106,
-	UNION = 107
+	UNION = 107,
+	ARRAY = 108
 };
 
-
 struct ExtraTypeInfo;
 
 struct aggregate_state_t;
@@ -250,25 +254,38 @@ struct LogicalType {
 	inline const ExtraTypeInfo *AuxInfo() const {
 		return type_info_.get();
 	}
+	inline bool IsNested() const {
+		auto internal = InternalType();
+		if (internal == PhysicalType::STRUCT) {
+			return true;
+		}
+		if (internal == PhysicalType::LIST) {
+			return true;
+		}
+		if (internal == PhysicalType::ARRAY) {
+			return true;
+		}
+		return false;
+	}
 
 	inline shared_ptr<ExtraTypeInfo> GetAuxInfoShrPtr() const {
 		return type_info_;
 	}
 
-	inline void CopyAuxInfo(const LogicalType& other) {
+	inline void CopyAuxInfo(const LogicalType &other) {
 		type_info_ = other.type_info_;
 	}
-	bool EqualTypeInfo(const LogicalType& rhs) const;
+	bool EqualTypeInfo(const LogicalType &rhs) const;
 
 	// copy assignment
-	inline LogicalType& operator=(const LogicalType &other) {
+	inline LogicalType &operator=(const LogicalType &other) {
 		id_ = other.id_;
 		physical_type_ = other.physical_type_;
 		type_info_ = other.type_info_;
 		return *this;
 	}
 	// move assignment
-	inline LogicalType& operator=(LogicalType&& other) noexcept {
+	inline LogicalType &operator=(LogicalType &&other) noexcept {
 		id_ = other.id_;
 		physical_type_ = other.physical_type_;
 		std::swap(type_info_, other.type_info_);
@@ -283,15 +300,12 @@ struct LogicalType {
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API static LogicalType Deserialize(Deserializer &deserializer);
 
-
 	static bool TypeIsTimestamp(LogicalTypeId id) {
-		return (id == LogicalTypeId::TIMESTAMP ||
-				id == LogicalTypeId::TIMESTAMP_MS ||
-				id == LogicalTypeId::TIMESTAMP_NS ||
-				id == LogicalTypeId::TIMESTAMP_SEC ||
-				id == LogicalTypeId::TIMESTAMP_TZ);
+		return (id == LogicalTypeId::TIMESTAMP || id == LogicalTypeId::TIMESTAMP_MS ||
+		        id == LogicalTypeId::TIMESTAMP_NS || id == LogicalTypeId::TIMESTAMP_SEC ||
+		        id == LogicalTypeId::TIMESTAMP_TZ);
 	}
-	static bool TypeIsTimestamp(const LogicalType& type) {
+	static bool TypeIsTimestamp(const LogicalType &type) {
 		return TypeIsTimestamp(type.id());
 	}
 	DUCKDB_API string ToString() const;
@@ -302,15 +316,26 @@ struct LogicalType {
 	DUCKDB_API bool HasAlias() const;
 	DUCKDB_API string GetAlias() const;
 
-	DUCKDB_API static LogicalType MaxLogicalType(const LogicalType &left, const LogicalType &right);
+	//! 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);
+	DUCKDB_API static bool TryGetMaxLogicalType(ClientContext &context, const LogicalType &left, const LogicalType &right, LogicalType &result);
+	//! Forcibly returns a maximum logical type - similar to MaxLogicalType but never throws. As a fallback either left or right are returned.
+	DUCKDB_API static LogicalType ForceMaxLogicalType(const LogicalType &left, const LogicalType &right);
+	//! Normalize a type - removing literals
+	DUCKDB_API static LogicalType NormalizeType(const LogicalType &type);
 
-	//! Gets the decimal properties of a numeric type. Fails if the type is not numeric.
+
+		//! Gets the decimal properties of a numeric type. Fails if the type is not numeric.
 	DUCKDB_API bool GetDecimalProperties(uint8_t &width, uint8_t &scale) const;
 
 	DUCKDB_API void Verify() const;
 
 	DUCKDB_API bool IsValid() const;
 
+	template<class F>
+	bool Contains(F &&predicate) const;
+	bool Contains(LogicalTypeId type_id) const;
+
 private:
 	LogicalTypeId id_;
 	PhysicalType physical_type_;
@@ -344,9 +369,10 @@ public:
 	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 INTERVAL = LogicalTypeId::INTERVAL;
+	static constexpr const LogicalTypeId BIT = LogicalTypeId::BIT;
+	static constexpr const LogicalTypeId INTERVAL = LogicalTypeId::INTERVAL;
 	static constexpr const LogicalTypeId HUGEINT = LogicalTypeId::HUGEINT;
+	static constexpr const LogicalTypeId UHUGEINT = LogicalTypeId::UHUGEINT;
 	static constexpr const LogicalTypeId UUID = LogicalTypeId::UUID;
 	static constexpr const LogicalTypeId HASH = LogicalTypeId::UBIGINT;
 	static constexpr const LogicalTypeId POINTER = LogicalTypeId::POINTER;
@@ -358,22 +384,38 @@ public:
 	// 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 VARCHAR_COLLATION(string collation);           // NOLINT
-	DUCKDB_API static LogicalType LIST(const LogicalType &child);                       // NOLINT
+	DUCKDB_API static LogicalType LIST(const LogicalType &child);                // NOLINT
 	DUCKDB_API static LogicalType STRUCT(child_list_t<LogicalType> children);    // NOLINT
-	DUCKDB_API static LogicalType AGGREGATE_STATE(aggregate_state_t state_type);    // NOLINT
-	DUCKDB_API static LogicalType MAP(const LogicalType &child);				// NOLINT
-	DUCKDB_API static LogicalType MAP(LogicalType key, LogicalType value); // NOLINT
-	DUCKDB_API static LogicalType UNION( child_list_t<LogicalType> members);     // NOLINT
+	DUCKDB_API static LogicalType AGGREGATE_STATE(aggregate_state_t state_type); // NOLINT
+	DUCKDB_API static LogicalType MAP(const LogicalType &child);                 // NOLINT
+	DUCKDB_API static LogicalType MAP(LogicalType key, LogicalType value);       // NOLINT
+	DUCKDB_API static LogicalType UNION(child_list_t<LogicalType> members);      // NOLINT
+	DUCKDB_API static LogicalType ARRAY(const LogicalType &child, idx_t size);   // NOLINT
+	// an array of unknown size (only used for binding)
+	DUCKDB_API static LogicalType ARRAY(const LogicalType &child);        // NOLINT
 	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
+	//! Integer literal of the specified value
+	DUCKDB_API static LogicalType INTEGER_LITERAL(const Value &constant);               // NOLINT
 	// 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(const string &user_type_name);                              // NOLINT
+	DUCKDB_API static LogicalType USER(string catalog, string schema, string name);                // 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
 	DUCKDB_API static const vector<LogicalType> Integral();
+	//! A list of all REAL types
+	DUCKDB_API static const vector<LogicalType> Real();
 	//! A list of ALL SQL types
 	DUCKDB_API static const vector<LogicalType> AllTypes();
+
+public:
+	//! The JSON type lives in the JSON extension, but we need to define this here for special handling
+	static constexpr auto JSON_TYPE_NAME = "JSON";
+	DUCKDB_API static LogicalType JSON(); // NOLINT
+	DUCKDB_API bool IsJSONType() const;
 };
 
 struct DecimalType {
@@ -391,11 +433,13 @@ struct ListType {
 };
 
 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);
 };
 
 struct EnumType {
-	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string_t& key);
+	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string_t &key);
 	DUCKDB_API static const Vector &GetValuesInsertOrder(const LogicalType &type);
 	DUCKDB_API static idx_t GetSize(const LogicalType &type);
 	DUCKDB_API static const string GetValue(const Value &val);
@@ -407,6 +451,7 @@ struct StructType {
 	DUCKDB_API static const child_list_t<LogicalType> &GetChildTypes(const LogicalType &type);
 	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type, idx_t index);
 	DUCKDB_API static const string &GetChildName(const LogicalType &type, idx_t index);
+	DUCKDB_API static idx_t GetChildIndexUnsafe(const LogicalType &type, const string &name);
 	DUCKDB_API static idx_t GetChildCount(const LogicalType &type);
 	DUCKDB_API static bool IsUnnamed(const LogicalType &type);
 };
@@ -424,11 +469,32 @@ struct UnionType {
 	DUCKDB_API static const child_list_t<LogicalType> CopyMemberTypes(const LogicalType &type);
 };
 
+struct ArrayType {
+	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type);
+	DUCKDB_API static idx_t GetSize(const LogicalType &type);
+	DUCKDB_API static bool IsAnySize(const LogicalType &type);
+	DUCKDB_API static constexpr idx_t MAX_ARRAY_SIZE = 100000; // 100k for now
+	//! Recursively replace all ARRAY types to LIST types within the given type
+	DUCKDB_API static LogicalType ConvertToList(const LogicalType &type);
+};
+
 struct AggregateStateType {
 	DUCKDB_API static const string GetTypeName(const LogicalType &type);
 	DUCKDB_API static const aggregate_state_t &GetStateType(const LogicalType &type);
 };
 
+struct AnyType {
+	DUCKDB_API static LogicalType GetTargetType(const LogicalType &type);
+	DUCKDB_API static idx_t GetCastScore(const LogicalType &type);
+};
+
+struct IntegerLiteral {
+	//! Returns the type that this integer literal "prefers"
+	DUCKDB_API static LogicalType GetType(const LogicalType &type);
+	//! Whether or not the integer literal fits into the target numeric type
+	DUCKDB_API static bool FitsInType(const LogicalType &type, const LogicalType &target);
+};
+
 // **DEPRECATED**: Use EnumUtil directly instead.
 DUCKDB_API string LogicalTypeIdToString(LogicalTypeId type);
 
@@ -452,8 +518,11 @@ bool ApproxEqual(float l, float r);
 bool ApproxEqual(double l, double r);
 
 struct aggregate_state_t {
-	aggregate_state_t() {}
-	aggregate_state_t(string function_name_p, LogicalType return_type_p, vector<LogicalType> bound_argument_types_p) : function_name(std::move(function_name_p)), return_type(std::move(return_type_p)), bound_argument_types(std::move(bound_argument_types_p)) {
+	aggregate_state_t() {
+	}
+	aggregate_state_t(string function_name_p, LogicalType return_type_p, vector<LogicalType> bound_argument_types_p)
+	    : function_name(std::move(function_name_p)), return_type(std::move(return_type_p)),
+	      bound_argument_types(std::move(bound_argument_types_p)) {
 	}
 
 	string function_name;
@@ -461,4 +530,37 @@ struct aggregate_state_t {
 	vector<LogicalType> bound_argument_types;
 };
 
+template<class F>
+bool LogicalType::Contains(F &&predicate) const {
+	if(predicate(*this)) {
+		return true;
+	}
+	switch(id()) {
+	case LogicalTypeId::STRUCT: {
+		for(const auto &child : StructType::GetChildTypes(*this)) {
+			if(child.second.Contains(predicate)) {
+				return true;
+			}
+		}
+		}
+		break;
+	case LogicalTypeId::LIST:
+		return ListType::GetChildType(*this).Contains(predicate);
+	case LogicalTypeId::MAP:
+		return MapType::KeyType(*this).Contains(predicate) || MapType::ValueType(*this).Contains(predicate);
+	case LogicalTypeId::UNION:
+		for(const auto &child : UnionType::CopyMemberTypes(*this)) {
+			if(child.second.Contains(predicate)) {
+				return true;
+			}
+		}
+		break;
+	case LogicalTypeId::ARRAY:
+		return ArrayType::GetChildType(*this).Contains(predicate);
+	default:
+		return false;
+	}
+	return false;
+}
+
 } // namespace duckdb

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

@@ -0,0 +1,81 @@
+#pragma once
+
+#include "duckdb/common/winapi.hpp"
+#include "duckdb/common/string.hpp"
+#include <stdint.h>
+
+namespace duckdb {
+
+// Forward declaration to allow conversion between hugeint and uhugeint
+struct hugeint_t;
+
+struct uhugeint_t {
+public:
+	uint64_t lower;
+	uint64_t upper;
+
+public:
+	uhugeint_t() = default;
+	DUCKDB_API uhugeint_t(uint64_t value); // NOLINT: Allow implicit conversion from `uint64_t`
+	constexpr uhugeint_t(uint64_t upper, uint64_t lower) : lower(lower), upper(upper) {
+	}
+	constexpr uhugeint_t(const uhugeint_t &rhs) = default;
+	constexpr uhugeint_t(uhugeint_t &&rhs) = default;
+	uhugeint_t &operator=(const uhugeint_t &rhs) = default;
+	uhugeint_t &operator=(uhugeint_t &&rhs) = default;
+
+	DUCKDB_API string ToString() const;
+
+	// comparison operators
+	DUCKDB_API bool operator==(const uhugeint_t &rhs) const;
+	DUCKDB_API bool operator!=(const uhugeint_t &rhs) const;
+	DUCKDB_API bool operator<=(const uhugeint_t &rhs) const;
+	DUCKDB_API bool operator<(const uhugeint_t &rhs) const;
+	DUCKDB_API bool operator>(const uhugeint_t &rhs) const;
+	DUCKDB_API bool operator>=(const uhugeint_t &rhs) const;
+
+	// arithmetic operators
+	DUCKDB_API uhugeint_t operator+(const uhugeint_t &rhs) const;
+	DUCKDB_API uhugeint_t operator-(const uhugeint_t &rhs) const;
+	DUCKDB_API uhugeint_t operator*(const uhugeint_t &rhs) const;
+	DUCKDB_API uhugeint_t operator/(const uhugeint_t &rhs) const;
+	DUCKDB_API uhugeint_t operator%(const uhugeint_t &rhs) const;
+	DUCKDB_API uhugeint_t operator-() const;
+
+	// bitwise operators
+	DUCKDB_API uhugeint_t operator>>(const uhugeint_t &rhs) const;
+	DUCKDB_API uhugeint_t operator<<(const uhugeint_t &rhs) const;
+	DUCKDB_API uhugeint_t operator&(const uhugeint_t &rhs) const;
+	DUCKDB_API uhugeint_t operator|(const uhugeint_t &rhs) const;
+	DUCKDB_API uhugeint_t operator^(const uhugeint_t &rhs) const;
+	DUCKDB_API uhugeint_t operator~() const;
+
+	// in-place operators
+	DUCKDB_API uhugeint_t &operator+=(const uhugeint_t &rhs);
+	DUCKDB_API uhugeint_t &operator-=(const uhugeint_t &rhs);
+	DUCKDB_API uhugeint_t &operator*=(const uhugeint_t &rhs);
+	DUCKDB_API uhugeint_t &operator/=(const uhugeint_t &rhs);
+	DUCKDB_API uhugeint_t &operator%=(const uhugeint_t &rhs);
+	DUCKDB_API uhugeint_t &operator>>=(const uhugeint_t &rhs);
+	DUCKDB_API uhugeint_t &operator<<=(const uhugeint_t &rhs);
+	DUCKDB_API uhugeint_t &operator&=(const uhugeint_t &rhs);
+	DUCKDB_API uhugeint_t &operator|=(const uhugeint_t &rhs);
+	DUCKDB_API uhugeint_t &operator^=(const uhugeint_t &rhs);
+
+	// boolean operators
+	DUCKDB_API explicit operator bool() const;
+	DUCKDB_API bool operator!() const;
+
+	// cast operators -- doesn't check bounds/overflow/underflow
+	DUCKDB_API explicit operator uint8_t() const;
+	DUCKDB_API explicit operator uint16_t() const;
+	DUCKDB_API explicit operator uint32_t() const;
+	DUCKDB_API explicit operator uint64_t() const;
+	DUCKDB_API explicit operator int8_t() const;
+	DUCKDB_API explicit operator int16_t() const;
+	DUCKDB_API explicit operator int32_t() const;
+	DUCKDB_API explicit operator int64_t() const;
+	DUCKDB_API operator hugeint_t() const; // NOLINT: Allow implicit conversion from `uhugeint_t`
+};
+
+} // namespace duckdb

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

@@ -17,6 +17,8 @@ namespace duckdb {
 
 // structs
 struct AggregateInputData;
+
+// The bounds of a window frame
 struct FrameBounds {
 	FrameBounds() : start(0), end(0) {};
 	FrameBounds(idx_t start, idx_t end) : start(start), end(end) {};
@@ -24,6 +26,9 @@ struct FrameBounds {
 	idx_t end = 0;
 };
 
+// A set of window subframes for windowed EXCLUDE
+using SubFrames = vector<FrameBounds>;
+
 class AggregateExecutor {
 private:
 	template <class STATE_TYPE, class OP>
@@ -383,14 +388,73 @@ public:
 	}
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void UnaryWindow(Vector &input, const ValidityMask &ifilter, AggregateInputData &aggr_input_data,
-	                        data_ptr_t state, const FrameBounds &frame, const FrameBounds &prev, Vector &result,
-	                        idx_t rid, idx_t bias) {
+	static void UnaryWindow(const Vector &input, const ValidityMask &ifilter, AggregateInputData &aggr_input_data,
+	                        data_ptr_t state_p, const SubFrames &frames, Vector &result, idx_t ridx,
+	                        const_data_ptr_t gstate_p) {
 
-		auto idata = FlatVector::GetData<const INPUT_TYPE>(input) - bias;
+		auto idata = FlatVector::GetData<const INPUT_TYPE>(input);
 		const auto &ivalid = FlatVector::Validity(input);
-		OP::template Window<STATE, INPUT_TYPE, RESULT_TYPE>(
-		    idata, ifilter, ivalid, aggr_input_data, *reinterpret_cast<STATE *>(state), frame, prev, result, rid, bias);
+		auto &state = *reinterpret_cast<STATE *>(state_p);
+		auto gstate = reinterpret_cast<const STATE *>(gstate_p);
+		OP::template Window<STATE, INPUT_TYPE, RESULT_TYPE>(idata, ifilter, ivalid, aggr_input_data, state, frames,
+		                                                    result, ridx, gstate);
+	}
+
+	template <typename OP>
+	static void IntersectFrames(const SubFrames &lefts, const SubFrames &rights, OP &op) {
+		const auto cover_start = MinValue(rights[0].start, lefts[0].start);
+		const auto cover_end = MaxValue(rights.back().end, lefts.back().end);
+		const FrameBounds last(cover_end, cover_end);
+
+		//	Subframe indices
+		idx_t l = 0;
+		idx_t r = 0;
+		for (auto i = cover_start; i < cover_end;) {
+			uint8_t overlap = 0;
+
+			// Are we in the previous frame?
+			auto left = &last;
+			if (l < lefts.size()) {
+				left = &lefts[l];
+				overlap |= uint8_t(left->start <= i && i < left->end) << 0;
+			}
+
+			// Are we in the current frame?
+			auto right = &last;
+			if (r < rights.size()) {
+				right = &rights[r];
+				overlap |= uint8_t(right->start <= i && i < right->end) << 1;
+			}
+
+			auto limit = i;
+			switch (overlap) {
+			case 0x00:
+				// i ∉ F U P
+				limit = MinValue(right->start, left->start);
+				op.Neither(i, limit);
+				break;
+			case 0x01:
+				// i ∈ P \ F
+				limit = MinValue(left->end, right->start);
+				op.Left(i, limit);
+				break;
+			case 0x02:
+				// i ∈ F \ P
+				limit = MinValue(right->end, left->start);
+				op.Right(i, limit);
+				break;
+			case 0x03:
+				// i ∈ F ∩ P
+				limit = MinValue(right->end, left->end);
+				op.Both(i, limit);
+				break;
+			}
+
+			// Advance  the subframe indices
+			i = limit;
+			l += (i == left->end);
+			r += (i == right->end);
+		}
 	}
 
 	template <class STATE_TYPE, class OP>

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

@@ -12,16 +12,16 @@
 
 namespace duckdb {
 
+//! The default standard vector size
+#define DEFAULT_STANDARD_VECTOR_SIZE 2048
+
 //! The vector size used in the execution engine
 #ifndef STANDARD_VECTOR_SIZE
-#define STANDARD_VECTOR_SIZE 2048
+#define STANDARD_VECTOR_SIZE DEFAULT_STANDARD_VECTOR_SIZE
 #endif
 
-#if ((STANDARD_VECTOR_SIZE & (STANDARD_VECTOR_SIZE - 1)) != 0)
-#error Vector size should be a power of two
+#if (STANDARD_VECTOR_SIZE & (STANDARD_VECTOR_SIZE - 1) != 0)
+#error The vector size must be a power of two
 #endif
 
-//! Zero selection vector: completely filled with the value 0 [READ ONLY]
-extern const sel_t ZERO_VECTOR[STANDARD_VECTOR_SIZE];
-
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/aggregate/distributive_functions.hpp

@@ -27,7 +27,7 @@ struct ApproxCountDistinctFun {
 struct ArgMinFun {
 	static constexpr const char *Name = "arg_min";
 	static constexpr const char *Parameters = "arg,val";
-	static constexpr const char *Description = "Finds the row with the minimum val. Calculates the arg expression at that row.";
+	static constexpr const char *Description = "Finds the row with the minimum val. Calculates the non-NULL arg expression at that row.";
 	static constexpr const char *Example = "arg_min(A,B)";
 
 	static AggregateFunctionSet GetFunctions();
@@ -45,10 +45,19 @@ struct MinByFun {
 	static constexpr const char *Name = "min_by";
 };
 
+struct ArgMinNullFun {
+	static constexpr const char *Name = "arg_min_null";
+	static constexpr const char *Parameters = "arg,val";
+	static constexpr const char *Description = "Finds the row with the minimum val. Calculates the arg expression at that row.";
+	static constexpr const char *Example = "arg_min_null(A,B)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
 struct ArgMaxFun {
 	static constexpr const char *Name = "arg_max";
 	static constexpr const char *Parameters = "arg,val";
-	static constexpr const char *Description = "Finds the row with the maximum val. Calculates the arg expression at that row.";
+	static constexpr const char *Description = "Finds the row with the maximum val. Calculates the non-NULL arg expression at that row.";
 	static constexpr const char *Example = "arg_max(A,B)";
 
 	static AggregateFunctionSet GetFunctions();
@@ -66,6 +75,15 @@ struct MaxByFun {
 	static constexpr const char *Name = "max_by";
 };
 
+struct ArgMaxNullFun {
+	static constexpr const char *Name = "arg_max_null";
+	static constexpr const char *Parameters = "arg,val";
+	static constexpr const char *Description = "Finds the row with the maximum val. Calculates the arg expression at that row.";
+	static constexpr const char *Example = "arg_max_null(A,B)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
 struct BitAndFun {
 	static constexpr const char *Name = "bit_and";
 	static constexpr const char *Parameters = "arg";
@@ -159,6 +177,15 @@ struct KurtosisFun {
 	static AggregateFunction GetFunction();
 };
 
+struct KurtosisPopFun {
+	static constexpr const char *Name = "kurtosis_pop";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the excess kurtosis (Fisher’s definition) of all input values, without bias correction";
+	static constexpr const char *Example = "";
+
+	static AggregateFunction GetFunction();
+};
+
 struct MinFun {
 	static constexpr const char *Name = "min";
 	static constexpr const char *Parameters = "arg";