duckdb 0.3.2-dev362.0 → 0.3.2-dev479.0

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "eacccc7a8"
-#define DUCKDB_VERSION "0.3.2-dev362"
+#define DUCKDB_SOURCE_ID "8a0e93080"
+#define DUCKDB_VERSION "0.3.2-dev479"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -916,6 +916,9 @@ enum class LogicalTypeId : uint8_t {
 	USMALLINT = 29,
 	UINTEGER = 30,
 	UBIGINT = 31,
+	TIMESTAMP_TZ = 32,
+	DATE_TZ = 33,
+	TIME_TZ = 34,
 
 
 	HUGEINT = 50,
@@ -1016,6 +1019,9 @@ 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 TIMESTAMP_TZ = LogicalTypeId::TIMESTAMP_TZ;
+	static constexpr const LogicalTypeId DATE_TZ = LogicalTypeId::DATE_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;
@@ -2231,14 +2237,14 @@ struct TemplatedValidityData {
 	static constexpr const V MAX_ENTRY = ~V(0);
 
 public:
-	DUCKDB_API explicit TemplatedValidityData(idx_t count) {
+	inline explicit TemplatedValidityData(idx_t count) {
 		auto entry_count = EntryCount(count);
 		owned_data = unique_ptr<V[]>(new V[entry_count]);
 		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
 			owned_data[entry_idx] = MAX_ENTRY;
 		}
 	}
-	DUCKDB_API TemplatedValidityData(const V *validity_mask, idx_t count) {
+	inline TemplatedValidityData(const V *validity_mask, idx_t count) {
 		D_ASSERT(validity_mask);
 		auto entry_count = EntryCount(count);
 		owned_data = unique_ptr<V[]>(new V[entry_count]);
@@ -2250,7 +2256,7 @@ public:
 	unique_ptr<V[]> owned_data;
 
 public:
-	DUCKDB_API static inline idx_t EntryCount(idx_t count) {
+	static inline idx_t EntryCount(idx_t count) {
 		return (count + (BITS_PER_VALUE - 1)) / BITS_PER_VALUE;
 	}
 };
@@ -2274,24 +2280,24 @@ public:
 	static constexpr const int STANDARD_MASK_SIZE = STANDARD_ENTRY_COUNT * sizeof(validity_t);
 
 public:
-	DUCKDB_API TemplatedValidityMask() : validity_mask(nullptr) {
+	inline TemplatedValidityMask() : validity_mask(nullptr) {
 	}
-	DUCKDB_API explicit TemplatedValidityMask(idx_t max_count) {
+	inline explicit TemplatedValidityMask(idx_t max_count) {
 		Initialize(max_count);
 	}
-	DUCKDB_API explicit TemplatedValidityMask(V *ptr) : validity_mask(ptr) {
+	inline explicit TemplatedValidityMask(V *ptr) : validity_mask(ptr) {
 	}
-	DUCKDB_API TemplatedValidityMask(const TemplatedValidityMask &original, idx_t count) {
+	inline TemplatedValidityMask(const TemplatedValidityMask &original, idx_t count) {
 		Copy(original, count);
 	}
 
-	DUCKDB_API static inline idx_t ValidityMaskSize(idx_t count = STANDARD_VECTOR_SIZE) {
+	static inline idx_t ValidityMaskSize(idx_t count = STANDARD_VECTOR_SIZE) {
 		return ValidityBuffer::EntryCount(count) * sizeof(V);
 	}
-	DUCKDB_API inline bool AllValid() const {
+	inline bool AllValid() const {
 		return !validity_mask;
 	}
-	DUCKDB_API bool CheckAllValid(idx_t count) const {
+	inline bool CheckAllValid(idx_t count) const {
 		if (AllValid()) {
 			return true;
 		}
@@ -2303,7 +2309,7 @@ public:
 		return valid_count == entry_count;
 	}
 
-	DUCKDB_API bool CheckAllValid(idx_t to, idx_t from) const {
+	inline bool CheckAllValid(idx_t to, idx_t from) const {
 		if (AllValid()) {
 			return true;
 		}
@@ -2315,40 +2321,40 @@ public:
 		return true;
 	}
 
-	DUCKDB_API inline V *GetData() const {
+	inline V *GetData() const {
 		return validity_mask;
 	}
-	DUCKDB_API void Reset() {
+	inline void Reset() {
 		validity_mask = nullptr;
 		validity_data.reset();
 	}
 
-	DUCKDB_API static inline idx_t EntryCount(idx_t count) {
+	static inline idx_t EntryCount(idx_t count) {
 		return ValidityBuffer::EntryCount(count);
 	}
-	DUCKDB_API inline V GetValidityEntry(idx_t entry_idx) const {
+	inline V GetValidityEntry(idx_t entry_idx) const {
 		if (!validity_mask) {
 			return ValidityBuffer::MAX_ENTRY;
 		}
 		return validity_mask[entry_idx];
 	}
-	DUCKDB_API static inline bool AllValid(V entry) {
+	static inline bool AllValid(V entry) {
 		return entry == ValidityBuffer::MAX_ENTRY;
 	}
-	DUCKDB_API static inline bool NoneValid(V entry) {
+	static inline bool NoneValid(V entry) {
 		return entry == 0;
 	}
-	DUCKDB_API static inline bool RowIsValid(V entry, idx_t idx_in_entry) {
+	static inline bool RowIsValid(V entry, idx_t idx_in_entry) {
 		return entry & (V(1) << V(idx_in_entry));
 	}
-	DUCKDB_API static inline void GetEntryIndex(idx_t row_idx, idx_t &entry_idx, idx_t &idx_in_entry) {
+	static inline void GetEntryIndex(idx_t row_idx, idx_t &entry_idx, idx_t &idx_in_entry) {
 		entry_idx = row_idx / BITS_PER_VALUE;
 		idx_in_entry = row_idx % BITS_PER_VALUE;
 	}
 
 	//! RowIsValidUnsafe should only be used if AllValid() is false: it achieves the same as RowIsValid but skips a
 	//! not-null check
-	DUCKDB_API inline bool RowIsValidUnsafe(idx_t row_idx) const {
+	inline bool RowIsValidUnsafe(idx_t row_idx) const {
 		D_ASSERT(validity_mask);
 		idx_t entry_idx, idx_in_entry;
 		GetEntryIndex(row_idx, entry_idx, idx_in_entry);
@@ -2357,7 +2363,7 @@ public:
 	}
 
 	//! Returns true if a row is valid (i.e. not null), false otherwise
-	DUCKDB_API inline bool RowIsValid(idx_t row_idx) const {
+	inline bool RowIsValid(idx_t row_idx) const {
 		if (!validity_mask) {
 			return true;
 		}
@@ -2365,7 +2371,7 @@ public:
 	}
 
 	//! Same as SetValid, but skips a null check on validity_mask
-	DUCKDB_API inline void SetValidUnsafe(idx_t row_idx) {
+	inline void SetValidUnsafe(idx_t row_idx) {
 		D_ASSERT(validity_mask);
 		idx_t entry_idx, idx_in_entry;
 		GetEntryIndex(row_idx, entry_idx, idx_in_entry);
@@ -2373,7 +2379,7 @@ public:
 	}
 
 	//! Marks the entry at the specified row index as valid (i.e. not-null)
-	DUCKDB_API inline void SetValid(idx_t row_idx) {
+	inline void SetValid(idx_t row_idx) {
 		if (!validity_mask) {
 			// if AllValid() we don't need to do anything
 			// the row is already valid
@@ -2383,20 +2389,20 @@ public:
 	}
 
 	//! Marks the bit at the specified entry as invalid (i.e. null)
-	DUCKDB_API inline void SetInvalidUnsafe(idx_t entry_idx, idx_t idx_in_entry) {
+	inline void SetInvalidUnsafe(idx_t entry_idx, idx_t idx_in_entry) {
 		D_ASSERT(validity_mask);
 		validity_mask[entry_idx] &= ~(V(1) << V(idx_in_entry));
 	}
 
 	//! Marks the bit at the specified row index as invalid (i.e. null)
-	DUCKDB_API inline void SetInvalidUnsafe(idx_t row_idx) {
+	inline void SetInvalidUnsafe(idx_t row_idx) {
 		idx_t entry_idx, idx_in_entry;
 		GetEntryIndex(row_idx, entry_idx, idx_in_entry);
 		SetInvalidUnsafe(entry_idx, idx_in_entry);
 	}
 
 	//! Marks the entry at the specified row index as invalid (i.e. null)
-	DUCKDB_API inline void SetInvalid(idx_t row_idx) {
+	inline void SetInvalid(idx_t row_idx) {
 		if (!validity_mask) {
 			D_ASSERT(row_idx <= STANDARD_VECTOR_SIZE);
 			Initialize(STANDARD_VECTOR_SIZE);
@@ -2405,7 +2411,7 @@ public:
 	}
 
 	//! Mark the entry at the specified index as either valid or invalid (non-null or null)
-	DUCKDB_API inline void Set(idx_t row_idx, bool valid) {
+	inline void Set(idx_t row_idx, bool valid) {
 		if (valid) {
 			SetValid(row_idx);
 		} else {
@@ -2414,14 +2420,14 @@ public:
 	}
 
 	//! Ensure the validity mask is writable, allocating space if it is not initialized
-	DUCKDB_API inline void EnsureWritable() {
+	inline void EnsureWritable() {
 		if (!validity_mask) {
 			Initialize();
 		}
 	}
 
 	//! Marks "count" entries in the validity mask as invalid (null)
-	DUCKDB_API inline void SetAllInvalid(idx_t count) {
+	inline void SetAllInvalid(idx_t count) {
 		EnsureWritable();
 		for (idx_t i = 0; i < ValidityBuffer::EntryCount(count); i++) {
 			validity_mask[i] = 0;
@@ -2429,14 +2435,14 @@ public:
 	}
 
 	//! Marks "count" entries in the validity mask as valid (not null)
-	DUCKDB_API inline void SetAllValid(idx_t count) {
+	inline void SetAllValid(idx_t count) {
 		EnsureWritable();
 		for (idx_t i = 0; i < ValidityBuffer::EntryCount(count); i++) {
 			validity_mask[i] = ValidityBuffer::MAX_ENTRY;
 		}
 	}
 
-	DUCKDB_API inline bool IsMaskSet() const {
+	inline bool IsMaskSet() const {
 		if (validity_mask) {
 			return true;
 		}
@@ -2444,19 +2450,19 @@ public:
 	}
 
 public:
-	DUCKDB_API void Initialize(validity_t *validity) {
+	inline void Initialize(validity_t *validity) {
 		validity_data.reset();
 		validity_mask = validity;
 	}
-	DUCKDB_API void Initialize(const TemplatedValidityMask &other) {
+	inline void Initialize(const TemplatedValidityMask &other) {
 		validity_mask = other.validity_mask;
 		validity_data = other.validity_data;
 	}
-	DUCKDB_API void Initialize(idx_t count = STANDARD_VECTOR_SIZE) {
+	inline void Initialize(idx_t count = STANDARD_VECTOR_SIZE) {
 		validity_data = make_buffer<ValidityBuffer>(count);
 		validity_mask = validity_data->owned_data.get();
 	}
-	DUCKDB_API void Copy(const TemplatedValidityMask &other, idx_t count) {
+	inline void Copy(const TemplatedValidityMask &other, idx_t count) {
 		if (other.AllValid()) {
 			validity_data = nullptr;
 			validity_mask = nullptr;
@@ -2473,13 +2479,13 @@ protected:
 
 struct ValidityMask : public TemplatedValidityMask<validity_t> {
 public:
-	DUCKDB_API ValidityMask() : TemplatedValidityMask(nullptr) {
+	inline ValidityMask() : TemplatedValidityMask(nullptr) {
 	}
-	DUCKDB_API explicit ValidityMask(idx_t max_count) : TemplatedValidityMask(max_count) {
+	inline explicit ValidityMask(idx_t max_count) : TemplatedValidityMask(max_count) {
 	}
-	DUCKDB_API explicit ValidityMask(validity_t *ptr) : TemplatedValidityMask(ptr) {
+	inline explicit ValidityMask(validity_t *ptr) : TemplatedValidityMask(ptr) {
 	}
-	DUCKDB_API ValidityMask(const ValidityMask &original, idx_t count) : TemplatedValidityMask(original, count) {
+	inline ValidityMask(const ValidityMask &original, idx_t count) : TemplatedValidityMask(original, count) {
 	}
 
 public:
@@ -2579,10 +2585,12 @@ public:
 	DUCKDB_API static Value POINTER(uintptr_t value);
 	//! Create a date Value from a specified date
 	DUCKDB_API static Value DATE(date_t date);
+	DUCKDB_API static Value DATETZ(date_t date);
 	//! Create a date Value from a specified date
 	DUCKDB_API static Value DATE(int32_t year, int32_t month, int32_t day);
 	//! Create a time Value from a specified time
 	DUCKDB_API static Value TIME(dtime_t time);
+	DUCKDB_API static Value TIMETZ(dtime_t time);
 	//! Create a time Value from a specified time
 	DUCKDB_API static Value TIME(int32_t hour, int32_t min, int32_t sec, int32_t micros);
 	//! Create a timestamp Value from a specified date/time combination
@@ -2592,6 +2600,7 @@ public:
 	DUCKDB_API static Value TimestampNs(timestamp_t timestamp);
 	DUCKDB_API static Value TimestampMs(timestamp_t timestamp);
 	DUCKDB_API static Value TimestampSec(timestamp_t timestamp);
+	DUCKDB_API static Value TIMESTAMPTZ(timestamp_t timestamp);
 	//! Create a timestamp Value from a specified timestamp in separate values
 	DUCKDB_API static Value TIMESTAMP(int32_t year, int32_t month, int32_t day, int32_t hour, int32_t min, int32_t sec,
 	                                  int32_t micros);
@@ -3660,10 +3669,10 @@ public:
 	vector<Vector> data;
 
 public:
-	DUCKDB_API idx_t size() const {
+	inline idx_t size() const { // NOLINT
 		return count;
 	}
-	DUCKDB_API idx_t ColumnCount() const {
+	inline idx_t ColumnCount() const {
 		return data.size();
 	}
 	inline void SetCardinality(idx_t count_p) {
@@ -6019,7 +6028,7 @@ public:
 	static string ToString(const interval_t &val);
 
 	//! Convert milliseconds to a normalised interval
-	static interval_t FromMicro(int64_t micros);
+	DUCKDB_API static interval_t FromMicro(int64_t micros);
 
 	//! Get Interval in milliseconds
 	static int64_t GetMilli(const interval_t &val);
@@ -7471,6 +7480,11 @@ public:
 	T *GetEntry(ClientContext &context, const string &schema_name, const string &name, bool if_exists = false,
 	            QueryErrorContext error_context = QueryErrorContext());
 
+	//! Append a scalar or aggregate function to the catalog
+	DUCKDB_API CatalogEntry *AddFunction(ClientContext &context, CreateFunctionInfo *info);
+	//! Append a scalar or aggregate function to the catalog
+	DUCKDB_API CatalogEntry *AddFunction(ClientContext &context, SchemaCatalogEntry *schema, CreateFunctionInfo *info);
+
 	//! Alter an existing entry in the catalog.
 	DUCKDB_API void Alter(ClientContext &context, AlterInfo *info);
 
@@ -8566,7 +8580,7 @@ private:
 	}
 
 	template <typename T>
-	static bool TypesMatch(LogicalType sql_type) {
+	static bool TypesMatch(const LogicalType &sql_type) {
 		switch (sql_type.id()) {
 		case LogicalTypeId::BOOLEAN:
 			return std::is_same<T, bool>();
@@ -8579,13 +8593,16 @@ private:
 		case LogicalTypeId::BIGINT:
 			return std::is_same<T, int64_t>();
 		case LogicalTypeId::DATE:
+		case LogicalTypeId::DATE_TZ:
 			return std::is_same<T, date_t>();
 		case LogicalTypeId::TIME:
+		case LogicalTypeId::TIME_TZ:
 			return std::is_same<T, dtime_t>();
 		case LogicalTypeId::TIMESTAMP:
 		case LogicalTypeId::TIMESTAMP_MS:
 		case LogicalTypeId::TIMESTAMP_NS:
 		case LogicalTypeId::TIMESTAMP_SEC:
+		case LogicalTypeId::TIMESTAMP_TZ:
 			return std::is_same<T, timestamp_t>();
 		case LogicalTypeId::FLOAT:
 			return std::is_same<T, float>();
@@ -11869,6 +11886,8 @@ public:
 
 	//! Convert a time object to a string in the format "hh:mm:ss"
 	DUCKDB_API static string ToString(dtime_t time);
+	//! Convert a UTC offset to ±HH[:MM]
+	DUCKDB_API static string ToUTCOffset(int hour_offset, int minute_offset);
 
 	DUCKDB_API static dtime_t FromTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds = 0);
 
@@ -12579,6 +12598,9 @@ private:
 	//! Drops an entry from the schema
 	void DropEntry(ClientContext &context, DropInfo *info);
 
+	//! Append a scalar or aggregate function within the given schema
+	CatalogEntry *AddFunction(ClientContext &context, CreateFunctionInfo *info);
+
 	//! Alters a catalog entry
 	void Alter(ClientContext &context, AlterInfo *info);