duckdb 0.4.1-dev36.0 → 0.4.1-dev42.0

package/package.json

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

package/src/duckdb.cpp

@@ -25536,6 +25536,11 @@ duckdb::string_t StringCast::Operation(hugeint_t input, Vector &vector) {
 
 template <>
 duckdb::string_t StringCast::Operation(date_t input, Vector &vector) {
+	if (input == date_t::infinity()) {
+		return "infinity";
+	} else if (input == date_t::ninfinity()) {
+		return "-infinity";
+	}
 	int32_t date[3];
 	Date::Convert(input, date[0], date[1], date[2]);
 
@@ -25571,6 +25576,11 @@ duckdb::string_t StringCast::Operation(dtime_t input, Vector &vector) {
 
 template <>
 duckdb::string_t StringCast::Operation(timestamp_t input, Vector &vector) {
+	if (input == timestamp_t::infinity()) {
+		return string_t("infinity");
+	} else if (input == timestamp_t::ninfinity()) {
+		return string_t("-infinity");
+	}
 	date_t date_entry;
 	dtime_t time_entry;
 	Timestamp::Convert(input, date_entry, time_entry);
@@ -42133,6 +42143,126 @@ dtime_t AddTimeOperator::Operation(interval_t left, dtime_t right);
 } // namespace duckdb
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/operator/subtract.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct SubtractOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		return left - right;
+	}
+};
+
+template <>
+float SubtractOperator::Operation(float left, float right);
+template <>
+double SubtractOperator::Operation(double left, double right);
+template <>
+interval_t SubtractOperator::Operation(interval_t left, interval_t right);
+template <>
+int64_t SubtractOperator::Operation(date_t left, date_t right);
+template <>
+date_t SubtractOperator::Operation(date_t left, int32_t right);
+template <>
+date_t SubtractOperator::Operation(date_t left, interval_t right);
+template <>
+timestamp_t SubtractOperator::Operation(timestamp_t left, interval_t right);
+template <>
+interval_t SubtractOperator::Operation(timestamp_t left, timestamp_t right);
+
+struct TrySubtractOperator {
+	template <class TA, class TB, class TR>
+	static inline bool Operation(TA left, TB right, TR &result) {
+		throw InternalException("Unimplemented type for TrySubtractOperator");
+	}
+};
+
+template <>
+bool TrySubtractOperator::Operation(uint8_t left, uint8_t right, uint8_t &result);
+template <>
+bool TrySubtractOperator::Operation(uint16_t left, uint16_t right, uint16_t &result);
+template <>
+bool TrySubtractOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
+template <>
+bool TrySubtractOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
+
+template <>
+bool TrySubtractOperator::Operation(int8_t left, int8_t right, int8_t &result);
+template <>
+bool TrySubtractOperator::Operation(int16_t left, int16_t right, int16_t &result);
+template <>
+bool TrySubtractOperator::Operation(int32_t left, int32_t right, int32_t &result);
+template <>
+bool TrySubtractOperator::Operation(int64_t left, int64_t right, int64_t &result);
+template <>
+bool TrySubtractOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
+
+struct SubtractOperatorOverflowCheck {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		TR result;
+		if (!TrySubtractOperator::Operation(left, right, result)) {
+			throw OutOfRangeException("Overflow in subtraction of %s (%d - %d)!", TypeIdToString(GetTypeId<TA>()), left,
+			                          right);
+		}
+		return result;
+	}
+};
+
+struct TryDecimalSubtract {
+	template <class TA, class TB, class TR>
+	static inline bool Operation(TA left, TB right, TR &result) {
+		throw InternalException("Unimplemented type for TryDecimalSubtract");
+	}
+};
+
+template <>
+bool TryDecimalSubtract::Operation(int16_t left, int16_t right, int16_t &result);
+template <>
+bool TryDecimalSubtract::Operation(int32_t left, int32_t right, int32_t &result);
+template <>
+bool TryDecimalSubtract::Operation(int64_t left, int64_t right, int64_t &result);
+template <>
+bool TryDecimalSubtract::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
+
+struct DecimalSubtractOverflowCheck {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		TR result;
+		if (!TryDecimalSubtract::Operation<TA, TB, TR>(left, right, result)) {
+			throw OutOfRangeException("Overflow in subtract of DECIMAL(18) (%d - %d). You might want to add an "
+			                          "explicit cast to a bigger decimal.",
+			                          left, right);
+		}
+		return result;
+	}
+};
+
+template <>
+hugeint_t DecimalSubtractOverflowCheck::Operation(hugeint_t left, hugeint_t right);
+
+struct SubtractTimeOperator {
+	template <class TA, class TB, class TR>
+	static TR Operation(TA left, TB right);
+};
+
+template <>
+dtime_t SubtractTimeOperator::Operation(dtime_t left, interval_t right);
+
+} // namespace duckdb
+
 
 
 namespace duckdb {
@@ -42410,6 +42540,7 @@ int64_t Interval::GetNanoseconds(const interval_t &val) {
 }
 
 interval_t Interval::GetAge(timestamp_t timestamp_1, timestamp_t timestamp_2) {
+	D_ASSERT(Timestamp::IsFinite(timestamp_1) && Timestamp::IsFinite(timestamp_2));
 	date_t date1, date2;
 	dtime_t time1, time2;
 
@@ -42499,9 +42630,15 @@ interval_t Interval::GetAge(timestamp_t timestamp_1, timestamp_t timestamp_2) {
 }
 
 interval_t Interval::GetDifference(timestamp_t timestamp_1, timestamp_t timestamp_2) {
+	if (!Timestamp::IsFinite(timestamp_1) || !Timestamp::IsFinite(timestamp_2)) {
+		throw InvalidInputException("Cannot subtract infinite timestamps");
+	}
 	const auto us_1 = Timestamp::GetEpochMicroSeconds(timestamp_1);
 	const auto us_2 = Timestamp::GetEpochMicroSeconds(timestamp_2);
-	const auto delta_us = us_1 - us_2;
+	int64_t delta_us;
+	if (!TrySubtractOperator::Operation(us_1, us_2, delta_us)) {
+		throw ConversionException("Timestamp difference is out of bounds");
+	}
 	return FromMicro(delta_us);
 }
 
@@ -46769,7 +46906,7 @@ void Vector::Verify(Vector &vector_p, const SelectionVector &sel_p, idx_t count)
 		D_ASSERT(child_types.size() == children.size());
 		for (idx_t child_idx = 0; child_idx < children.size(); child_idx++) {
 			D_ASSERT(children[child_idx]->GetType() == child_types[child_idx].second);
-			children[child_idx]->Verify(count);
+			Vector::Verify(*children[child_idx], sel_p, count);
 			if (vtype == VectorType::CONSTANT_VECTOR) {
 				D_ASSERT(children[child_idx]->GetVectorType() == VectorType::CONSTANT_VECTOR);
 				if (ConstantVector::IsNull(*vector)) {
@@ -74924,125 +75061,6 @@ void PhysicalOperator::Verify() {
 
 } // namespace duckdb
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/subtract.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct SubtractOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left - right;
-	}
-};
-
-template <>
-float SubtractOperator::Operation(float left, float right);
-template <>
-double SubtractOperator::Operation(double left, double right);
-template <>
-interval_t SubtractOperator::Operation(interval_t left, interval_t right);
-template <>
-int64_t SubtractOperator::Operation(date_t left, date_t right);
-template <>
-date_t SubtractOperator::Operation(date_t left, int32_t right);
-template <>
-date_t SubtractOperator::Operation(date_t left, interval_t right);
-template <>
-timestamp_t SubtractOperator::Operation(timestamp_t left, interval_t right);
-template <>
-interval_t SubtractOperator::Operation(timestamp_t left, timestamp_t right);
-
-struct TrySubtractOperator {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TrySubtractOperator");
-	}
-};
-
-template <>
-bool TrySubtractOperator::Operation(uint8_t left, uint8_t right, uint8_t &result);
-template <>
-bool TrySubtractOperator::Operation(uint16_t left, uint16_t right, uint16_t &result);
-template <>
-bool TrySubtractOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
-template <>
-bool TrySubtractOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
-
-template <>
-bool TrySubtractOperator::Operation(int8_t left, int8_t right, int8_t &result);
-template <>
-bool TrySubtractOperator::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TrySubtractOperator::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TrySubtractOperator::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TrySubtractOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-
-struct SubtractOperatorOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TrySubtractOperator::Operation(left, right, result)) {
-			throw OutOfRangeException("Overflow in subtraction of %s (%d - %d)!", TypeIdToString(GetTypeId<TA>()), left,
-			                          right);
-		}
-		return result;
-	}
-};
-
-struct TryDecimalSubtract {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryDecimalSubtract");
-	}
-};
-
-template <>
-bool TryDecimalSubtract::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryDecimalSubtract::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TryDecimalSubtract::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TryDecimalSubtract::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-
-struct DecimalSubtractOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryDecimalSubtract::Operation<TA, TB, TR>(left, right, result)) {
-			throw OutOfRangeException("Overflow in subtract of DECIMAL(18) (%d - %d). You might want to add an "
-			                          "explicit cast to a bigger decimal.",
-			                          left, right);
-		}
-		return result;
-	}
-};
-
-template <>
-hugeint_t DecimalSubtractOverflowCheck::Operation(hugeint_t left, hugeint_t right);
-
-struct SubtractTimeOperator {
-	template <class TA, class TB, class TR>
-	static TR Operation(TA left, TB right);
-};
-
-template <>
-dtime_t SubtractTimeOperator::Operation(dtime_t left, interval_t right);
-
-} // namespace duckdb
 
 
 
@@ -93018,6 +93036,9 @@ string StrfTimeFormat::Format(timestamp_t timestamp, const string &format_str) {
 }
 
 string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeFormat &format) {
+	if (format_string.empty()) {
+		return "Empty format string";
+	}
 	format.specifiers.clear();
 	format.literals.clear();
 	format.numeric_width.clear();
@@ -93396,6 +93417,7 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
 	uint64_t yearday = 0;
 
 	for (idx_t i = 0;; i++) {
+		D_ASSERT(i < literals.size());
 		// first compare the literal
 		const auto &literal = literals[i];
 		for (size_t l = 0; l < literal.size();) {
@@ -93786,7 +93808,10 @@ static unique_ptr<FunctionData> StrpTimeBindFunction(ClientContext &context, Sca
 	Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
 	string format_string = options_str.ToString();
 	StrpTimeFormat format;
-	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
+	if (!options_str.IsNull()) {
+		if (options_str.type().id() != LogicalTypeId::VARCHAR) {
+			throw InvalidInputException("strptime format must be a string");
+		}
 		format.format_specifier = format_string;
 		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
 		if (!error.empty()) {

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "530a5f55c"
-#define DUCKDB_VERSION "v0.4.1-dev36"
+#define DUCKDB_SOURCE_ID "1f06d609f"
+#define DUCKDB_VERSION "v0.4.1-dev42"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -22466,7 +22466,7 @@ protected:
 	//! Format is literals[0], specifiers[0], literals[1], ..., specifiers[n - 1], literals[n]
 	vector<string> literals;
 	//! The constant size that appears in the format string
-	idx_t constant_size;
+	idx_t constant_size = 0;
 	//! The max numeric width of the specifier (if it is parsed as a number), or -1 if it is not a number
 	vector<int> numeric_width;