duckdb 0.3.3-dev1422.0 → 0.3.3-dev1432.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.3-dev1422.0",
+  "version": "0.3.3-dev1432.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -12780,6 +12780,7 @@ FMT_END_NAMESPACE
 // LICENSE_CHANGE_END
 
 
+
 namespace duckdb {
 
 ExceptionFormatValue::ExceptionFormatValue(double dbl_val)
@@ -12788,6 +12789,9 @@ ExceptionFormatValue::ExceptionFormatValue(double dbl_val)
 ExceptionFormatValue::ExceptionFormatValue(int64_t int_val)
     : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER), int_val(int_val) {
 }
+ExceptionFormatValue::ExceptionFormatValue(hugeint_t huge_val)
+    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(Hugeint::ToString(huge_val)) {
+}
 ExceptionFormatValue::ExceptionFormatValue(string str_val)
     : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(move(str_val)) {
 }
@@ -12821,6 +12825,10 @@ template <>
 ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(char *value) {
 	return ExceptionFormatValue(string(value));
 }
+template <>
+ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(hugeint_t value) {
+	return ExceptionFormatValue(value);
+}
 
 string ExceptionFormatValue::Format(const string &msg, vector<ExceptionFormatValue> &values) {
 	std::vector<duckdb_fmt::basic_format_arg<duckdb_fmt::printf_context>> format_args;
@@ -19136,6 +19144,11 @@ public:
 		result.Finalize();
 		return result;
 	}
+
+	template <class T>
+	static std::string ToString(T value) {
+		return std::to_string(value);
+	}
 };
 
 template <>
@@ -19147,6 +19160,9 @@ int NumericHelper::UnsignedLength(uint32_t value);
 template <>
 int NumericHelper::UnsignedLength(uint64_t value);
 
+template <>
+std::string NumericHelper::ToString(hugeint_t value);
+
 struct DecimalToString {
 	template <class SIGNED, class UNSIGNED>
 	static int DecimalLength(SIGNED value, uint8_t scale) {
@@ -32653,6 +32669,7 @@ void Blob::FromBase64(string_t str, data_ptr_t output, idx_t output_size) {
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 const int64_t NumericHelper::POWERS_OF_TEN[] {1,
@@ -32754,6 +32771,11 @@ int NumericHelper::UnsignedLength(uint64_t value) {
 	}
 }
 
+template <>
+std::string NumericHelper::ToString(hugeint_t value) {
+	return Hugeint::ToString(value);
+}
+
 } // namespace duckdb
 
 
@@ -90501,6 +90523,7 @@ void ModFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
 namespace duckdb {
 
 template <class OP>
@@ -90637,15 +90660,32 @@ void BitwiseXorFun::RegisterFunction(BuiltinFunctions &set) {
 //===--------------------------------------------------------------------===//
 // << [bitwise_left_shift]
 //===--------------------------------------------------------------------===//
-template <class T>
-bool ShiftInRange(T shift) {
-	return shift >= 0 && shift < T(sizeof(T) * 8);
-}
 
 struct BitwiseShiftLeftOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA input, TB shift) {
-		return ShiftInRange(shift) ? input << shift : 0;
+		TA max_shift = TA(sizeof(TA) * 8);
+		if (input < 0) {
+			throw OutOfRangeException("Cannot left-shift negative number %s", NumericHelper::ToString(input));
+		}
+		if (shift < 0) {
+			throw OutOfRangeException("Cannot left-shift by negative number %s", NumericHelper::ToString(shift));
+		}
+		if (shift >= max_shift) {
+			if (input == 0) {
+				return 0;
+			}
+			throw OutOfRangeException("Left-shift value %s is out of range", NumericHelper::ToString(shift));
+		}
+		if (shift == 0) {
+			return input;
+		}
+		TA max_value = (TA(1) << (max_shift - shift - 1));
+		if (input >= max_value) {
+			throw OutOfRangeException("Overflow in left shift (%s << %s)", NumericHelper::ToString(input),
+			                          NumericHelper::ToString(shift));
+		}
+		return input << shift;
 	}
 };
 
@@ -90661,10 +90701,15 @@ void LeftShiftFun::RegisterFunction(BuiltinFunctions &set) {
 //===--------------------------------------------------------------------===//
 // >> [bitwise_right_shift]
 //===--------------------------------------------------------------------===//
+template <class T>
+bool RightShiftInRange(T shift) {
+	return shift >= 0 && shift < T(sizeof(T) * 8);
+}
+
 struct BitwiseShiftRightOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA input, TB shift) {
-		return ShiftInRange(shift) ? input >> shift : 0;
+		return RightShiftInRange(shift) ? input >> shift : 0;
 	}
 };
 
@@ -129455,6 +129500,7 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundAggreg
 
 
 
+
 namespace duckdb {
 
 unique_ptr<Expression> CastHugeintToSmallestType(unique_ptr<Expression> expr, NumericStatistics &num_stats) {
@@ -129517,23 +129563,21 @@ unique_ptr<Expression> TemplatedCastToSmallestType(unique_ptr<Expression> expr,
 		return expr;
 	}
 
-	// Prevent signed integer overflow - we can't range map these
-	if (std::is_signed<T>() && signed_min_val < -((T)1 << (sizeof(T) * 8 - 2)) &&
-	    signed_max_val > ((T)1 << (sizeof(T) * 8 - 2))) {
+	// Compute range, cast to unsigned to prevent comparing signed with unsigned
+	T signed_range;
+	if (!TrySubtractOperator::Operation(signed_min_val, signed_max_val, signed_range)) {
+		// overflow in subtraction: cannot do any simplification
 		return expr;
 	}
-
-	// Compute range, cast to unsigned to prevent comparing signed with unsigned
-	auto signed_range = signed_max_val - signed_min_val;
 	auto range = static_cast<typename std::make_unsigned<decltype(signed_range)>::type>(signed_range);
 
 	// Check if this range fits in a smaller type
 	LogicalType cast_type;
-	if (range < NumericLimits<uint8_t>().Maximum()) {
+	if (range < NumericLimits<uint8_t>::Maximum()) {
 		cast_type = LogicalType::UTINYINT;
-	} else if (sizeof(T) > sizeof(uint16_t) && range < NumericLimits<uint16_t>().Maximum()) {
+	} else if (sizeof(T) > sizeof(uint16_t) && range < NumericLimits<uint16_t>::Maximum()) {
 		cast_type = LogicalType::USMALLINT;
-	} else if (sizeof(T) > sizeof(uint32_t) && range < NumericLimits<uint32_t>().Maximum()) {
+	} else if (sizeof(T) > sizeof(uint32_t) && range < NumericLimits<uint32_t>::Maximum()) {
 		cast_type = LogicalType::UINTEGER;
 	} else {
 		return expr;