duckdb 0.9.3-dev0.0 → 0.9.3-dev12.0

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

@@ -23,16 +23,24 @@ struct MakeSigned<hugeint_t> {
 	using type = hugeint_t;
 };
 
+template <>
+struct MakeSigned<uhugeint_t> {
+	using type = hugeint_t;
+};
+
 template <class T>
 struct MakeUnsigned {
 	using type = typename std::make_unsigned<T>::type;
 };
 
-// hugeint_t does not actually have an unsigned variant (yet), but this is required to make compression work
-// if an unsigned variant gets implemented this (probably) can be changed without breaking anything
 template <>
 struct MakeUnsigned<hugeint_t> {
-	using type = hugeint_t;
+	using type = uhugeint_t;
+};
+
+template <>
+struct MakeUnsigned<uhugeint_t> {
+	using type = uhugeint_t;
 };
 
 template <class T>
@@ -45,4 +53,9 @@ struct IsIntegral<hugeint_t> {
 	static constexpr bool value = true;
 };
 
+template <>
+struct IsIntegral<uhugeint_t> {
+	static constexpr bool value = true;
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/operator/add.hpp

@@ -35,11 +35,15 @@ timestamp_t AddOperator::Operation(date_t left, dtime_t right);
 template <>
 timestamp_t AddOperator::Operation(dtime_t left, date_t right);
 template <>
+timestamp_t AddOperator::Operation(date_t left, dtime_tz_t right);
+template <>
+timestamp_t AddOperator::Operation(dtime_tz_t left, date_t right);
+template <>
 interval_t AddOperator::Operation(interval_t left, interval_t right);
 template <>
-date_t AddOperator::Operation(date_t left, interval_t right);
+timestamp_t AddOperator::Operation(date_t left, interval_t right);
 template <>
-date_t AddOperator::Operation(interval_t left, date_t right);
+timestamp_t AddOperator::Operation(interval_t left, date_t right);
 template <>
 timestamp_t AddOperator::Operation(timestamp_t left, interval_t right);
 template <>
@@ -70,6 +74,8 @@ bool TryAddOperator::Operation(int32_t left, int32_t right, int32_t &result);
 template <>
 DUCKDB_API bool TryAddOperator::Operation(int64_t left, int64_t right, int64_t &result);
 template <>
+bool TryAddOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_t &result);
+template <>
 bool TryAddOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
 
 struct AddOperatorOverflowCheck {
@@ -126,4 +132,9 @@ dtime_t AddTimeOperator::Operation(dtime_t left, interval_t right);
 template <>
 dtime_t AddTimeOperator::Operation(interval_t left, dtime_t right);
 
+template <>
+dtime_tz_t AddTimeOperator::Operation(dtime_tz_t left, interval_t right);
+template <>
+dtime_tz_t AddTimeOperator::Operation(interval_t left, dtime_tz_t right);
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp

@@ -20,6 +20,7 @@
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/types/vector.hpp"
+#include "duckdb/common/exception/conversion_exception.hpp"
 
 namespace duckdb {
 struct ValidityMask;
@@ -99,6 +100,8 @@ DUCKDB_API bool TryCast::Operation(bool input, int64_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(bool input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(bool input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(bool input, uint8_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(bool input, uint16_t &result, bool strict);
@@ -127,6 +130,8 @@ DUCKDB_API bool TryCast::Operation(int8_t input, int64_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(int8_t input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(int8_t input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(int8_t input, uint8_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(int8_t input, uint16_t &result, bool strict);
@@ -155,6 +160,8 @@ DUCKDB_API bool TryCast::Operation(int16_t input, int64_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(int16_t input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(int16_t input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(int16_t input, uint8_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(int16_t input, uint16_t &result, bool strict);
@@ -183,6 +190,8 @@ DUCKDB_API bool TryCast::Operation(int32_t input, int64_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(int32_t input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(int32_t input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(int32_t input, uint8_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(int32_t input, uint16_t &result, bool strict);
@@ -211,6 +220,8 @@ DUCKDB_API bool TryCast::Operation(int64_t input, int64_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(int64_t input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(int64_t input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(int64_t input, uint8_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(int64_t input, uint16_t &result, bool strict);
@@ -239,6 +250,8 @@ DUCKDB_API bool TryCast::Operation(hugeint_t input, int64_t &result, bool strict
 template <>
 DUCKDB_API bool TryCast::Operation(hugeint_t input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(hugeint_t input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(hugeint_t input, uint8_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(hugeint_t input, uint16_t &result, bool strict);
@@ -251,6 +264,36 @@ DUCKDB_API bool TryCast::Operation(hugeint_t input, float &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(hugeint_t input, double &result, bool strict);
 
+//===--------------------------------------------------------------------===//
+// Cast uhugeint_t -> Numeric
+//===--------------------------------------------------------------------===//
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, bool &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, int8_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, int16_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, int32_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, int64_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, uhugeint_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, hugeint_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, uint8_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, uint16_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, uint32_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, uint64_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, float &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(uhugeint_t input, double &result, bool strict);
+
 //===--------------------------------------------------------------------===//
 // Cast uint8_t -> Numeric
 //===--------------------------------------------------------------------===//
@@ -267,6 +310,8 @@ DUCKDB_API bool TryCast::Operation(uint8_t input, int64_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(uint8_t input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(uint8_t input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(uint8_t input, uint8_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(uint8_t input, uint16_t &result, bool strict);
@@ -295,6 +340,8 @@ DUCKDB_API bool TryCast::Operation(uint16_t input, int64_t &result, bool strict)
 template <>
 DUCKDB_API bool TryCast::Operation(uint16_t input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(uint16_t input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(uint16_t input, uint8_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(uint16_t input, uint16_t &result, bool strict);
@@ -323,6 +370,8 @@ DUCKDB_API bool TryCast::Operation(uint32_t input, int64_t &result, bool strict)
 template <>
 DUCKDB_API bool TryCast::Operation(uint32_t input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(uint32_t input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(uint32_t input, uint8_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(uint32_t input, uint16_t &result, bool strict);
@@ -351,6 +400,8 @@ DUCKDB_API bool TryCast::Operation(uint64_t input, int64_t &result, bool strict)
 template <>
 DUCKDB_API bool TryCast::Operation(uint64_t input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(uint64_t input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(uint64_t input, uint8_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(uint64_t input, uint16_t &result, bool strict);
@@ -379,6 +430,8 @@ DUCKDB_API bool TryCast::Operation(float input, int64_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(float input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(float input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(float input, uint8_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(float input, uint16_t &result, bool strict);
@@ -407,6 +460,8 @@ DUCKDB_API bool TryCast::Operation(double input, int64_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(double input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(double input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(double input, uint8_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(double input, uint16_t &result, bool strict);
@@ -443,6 +498,8 @@ DUCKDB_API bool TryCast::Operation(string_t input, uint64_t &result, bool strict
 template <>
 DUCKDB_API bool TryCast::Operation(string_t input, hugeint_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(string_t input, uhugeint_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(string_t input, float &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(string_t input, double &result, bool strict);
@@ -580,27 +637,27 @@ template <>
 DUCKDB_API bool TryCastToTimestampSec::Operation(date_t input, timestamp_t &result, bool strict);
 
 //===--------------------------------------------------------------------===//
-// Non-Standard Timestamps -> string/standard timestamp
+// Non-Standard Timestamps -> string/timestamp types
 //===--------------------------------------------------------------------===//
 
 struct CastFromTimestampNS {
 	template <class SRC>
 	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
+		throw duckdb::NotImplementedException("Cast to string could not be performed!");
 	}
 };
 
 struct CastFromTimestampMS {
 	template <class SRC>
 	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
+		throw duckdb::NotImplementedException("Cast to string could not be performed!");
 	}
 };
 
 struct CastFromTimestampSec {
 	template <class SRC>
 	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
+		throw duckdb::NotImplementedException("Cast to string could not be performed!");
 	}
 };
 
@@ -625,6 +682,20 @@ struct CastTimestampUsToSec {
 	}
 };
 
+struct CastTimestampMsToDate {
+	template <class SRC, class DST>
+	static inline DST Operation(SRC input) {
+		throw duckdb::NotImplementedException("Cast to DATE could not be performed!");
+	}
+};
+
+struct CastTimestampMsToTime {
+	template <class SRC, class DST>
+	static inline DST Operation(SRC input) {
+		throw duckdb::NotImplementedException("Cast to TIME could not be performed!");
+	}
+};
+
 struct CastTimestampMsToUs {
 	template <class SRC, class DST>
 	static inline DST Operation(SRC input) {
@@ -639,6 +710,18 @@ struct CastTimestampMsToNs {
 	}
 };
 
+struct CastTimestampNsToDate {
+	template <class SRC, class DST>
+	static inline DST Operation(SRC input) {
+		throw duckdb::NotImplementedException("Cast to DATE could not be performed!");
+	}
+};
+struct CastTimestampNsToTime {
+	template <class SRC, class DST>
+	static inline DST Operation(SRC input) {
+		throw duckdb::NotImplementedException("Cast to TIME could not be performed!");
+	}
+};
 struct CastTimestampNsToUs {
 	template <class SRC, class DST>
 	static inline DST Operation(SRC input) {
@@ -646,6 +729,18 @@ struct CastTimestampNsToUs {
 	}
 };
 
+struct CastTimestampSecToDate {
+	template <class SRC, class DST>
+	static inline DST Operation(SRC input) {
+		throw duckdb::NotImplementedException("Cast to DATE could not be performed!");
+	}
+};
+struct CastTimestampSecToTime {
+	template <class SRC, class DST>
+	static inline DST Operation(SRC input) {
+		throw duckdb::NotImplementedException("Cast to TIME could not be performed!");
+	}
+};
 struct CastTimestampSecToMs {
 	template <class SRC, class DST>
 	static inline DST Operation(SRC input) {
@@ -667,19 +762,31 @@ struct CastTimestampSecToNs {
 	}
 };
 
+template <>
+duckdb::timestamp_t CastTimestampUsToSec::Operation(duckdb::timestamp_t input);
 template <>
 duckdb::timestamp_t CastTimestampUsToMs::Operation(duckdb::timestamp_t input);
 template <>
 duckdb::timestamp_t CastTimestampUsToNs::Operation(duckdb::timestamp_t input);
 template <>
-duckdb::timestamp_t CastTimestampUsToSec::Operation(duckdb::timestamp_t input);
+duckdb::date_t CastTimestampMsToDate::Operation(duckdb::timestamp_t input);
+template <>
+duckdb::dtime_t CastTimestampMsToTime::Operation(duckdb::timestamp_t input);
 template <>
 duckdb::timestamp_t CastTimestampMsToUs::Operation(duckdb::timestamp_t input);
 template <>
 duckdb::timestamp_t CastTimestampMsToNs::Operation(duckdb::timestamp_t input);
 template <>
+duckdb::date_t CastTimestampNsToDate::Operation(duckdb::timestamp_t input);
+template <>
+duckdb::dtime_t CastTimestampNsToTime::Operation(duckdb::timestamp_t input);
+template <>
 duckdb::timestamp_t CastTimestampNsToUs::Operation(duckdb::timestamp_t input);
 template <>
+duckdb::date_t CastTimestampSecToDate::Operation(duckdb::timestamp_t input);
+template <>
+duckdb::dtime_t CastTimestampSecToTime::Operation(duckdb::timestamp_t input);
+template <>
 duckdb::timestamp_t CastTimestampSecToMs::Operation(duckdb::timestamp_t input);
 template <>
 duckdb::timestamp_t CastTimestampSecToUs::Operation(duckdb::timestamp_t input);
@@ -755,6 +862,8 @@ template <>
 bool CastFromBitToNumeric::Operation(string_t input, bool &result, bool strict);
 template <>
 bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, bool strict);
+template <>
+bool CastFromBitToNumeric::Operation(string_t input, uhugeint_t &result, bool strict);
 
 struct CastFromBitToBlob {
 	template <class SRC>

package/src/duckdb/src/include/duckdb/common/operator/comparison_operators.hpp

@@ -210,10 +210,6 @@ inline bool GreaterThan::Operation(const interval_t &left, const interval_t &rig
 	return Interval::GreaterThan(left, right);
 }
 
-inline bool operator<(const interval_t &lhs, const interval_t &rhs) {
-	return LessThan::Operation(lhs, rhs);
-}
-
 //===--------------------------------------------------------------------===//
 // Specialized Hugeint Comparison Operators
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/common/operator/convert_to_string.hpp

@@ -43,6 +43,8 @@ DUCKDB_API string ConvertToString::Operation(uint64_t input);
 template <>
 DUCKDB_API string ConvertToString::Operation(hugeint_t input);
 template <>
+DUCKDB_API string ConvertToString::Operation(uhugeint_t input);
+template <>
 DUCKDB_API string ConvertToString::Operation(float input);
 template <>
 DUCKDB_API string ConvertToString::Operation(double input);

package/src/duckdb/src/include/duckdb/common/operator/decimal_cast_operators.hpp

@@ -194,6 +194,35 @@ template <>
 bool TryCastFromDecimal::Operation(hugeint_t input, hugeint_t &result, string *error_message, uint8_t width,
                                    uint8_t scale);
 
+//===--------------------------------------------------------------------===//
+// Cast Decimal <-> uhugeint_t
+//===--------------------------------------------------------------------===//
+template <>
+DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, int16_t &result, string *error_message, uint8_t width,
+                                            uint8_t scale);
+template <>
+DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, int32_t &result, string *error_message, uint8_t width,
+                                            uint8_t scale);
+template <>
+DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, int64_t &result, string *error_message, uint8_t width,
+                                            uint8_t scale);
+template <>
+DUCKDB_API bool TryCastToDecimal::Operation(uhugeint_t input, hugeint_t &result, string *error_message, uint8_t width,
+                                            uint8_t scale);
+
+template <>
+bool TryCastFromDecimal::Operation(int16_t input, uhugeint_t &result, string *error_message, uint8_t width,
+                                   uint8_t scale);
+template <>
+bool TryCastFromDecimal::Operation(int32_t input, uhugeint_t &result, string *error_message, uint8_t width,
+                                   uint8_t scale);
+template <>
+bool TryCastFromDecimal::Operation(int64_t input, uhugeint_t &result, string *error_message, uint8_t width,
+                                   uint8_t scale);
+template <>
+bool TryCastFromDecimal::Operation(hugeint_t input, uhugeint_t &result, string *error_message, uint8_t width,
+                                   uint8_t scale);
+
 //===--------------------------------------------------------------------===//
 // Cast Decimal <-> uint8_t
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/common/operator/double_cast_operator.hpp

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/operator/double_cast_operator.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb.h"
+#include "fast_float/fast_float.h"
+
+namespace duckdb {
+template <class T>
+static bool TryDoubleCast(const char *buf, idx_t len, T &result, bool strict, char decimal_separator = '.') {
+	// skip any spaces at the start
+	while (len > 0 && StringUtil::CharacterIsSpace(*buf)) {
+		buf++;
+		len--;
+	}
+	if (len == 0) {
+		return false;
+	}
+	if (*buf == '+') {
+		if (strict) {
+			// plus is not allowed in strict mode
+			return false;
+		}
+		buf++;
+		len--;
+	}
+	if (strict && len >= 2) {
+		if (buf[0] == '0' && StringUtil::CharacterIsDigit(buf[1])) {
+			// leading zeros are not allowed in strict mode
+			return false;
+		}
+	}
+	auto endptr = buf + len;
+	auto parse_result = duckdb_fast_float::from_chars(buf, buf + len, result, decimal_separator);
+	if (parse_result.ec != std::errc()) {
+		return false;
+	}
+	auto current_end = parse_result.ptr;
+	if (!strict) {
+		while (current_end < endptr && StringUtil::CharacterIsSpace(*current_end)) {
+			current_end++;
+		}
+	}
+	return current_end == endptr;
+}
+} // namespace duckdb