duckdb 0.4.1-dev29.0 → 0.4.1-dev42.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.4.1-dev29.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);
@@ -39599,7 +39609,7 @@ unique_ptr<VectorData[]> DataChunk::Orrify() {
 }
 
 void DataChunk::Hash(Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::HASH);
+	D_ASSERT(result.GetType().id() == LogicalType::HASH);
 	VectorOperations::Hash(data[0], result, size());
 	for (idx_t i = 1; i < ColumnCount(); i++) {
 		VectorOperations::CombineHash(result, data[i], size());
@@ -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);
 }
 
@@ -44706,8 +44843,6 @@ Value Value::Numeric(const LogicalType &type, int64_t value) {
 		return Value((float)value);
 	case LogicalTypeId::DOUBLE:
 		return Value((double)value);
-	case LogicalTypeId::HASH:
-		return Value::HASH(value);
 	case LogicalTypeId::POINTER:
 		return Value::POINTER(value);
 	case LogicalTypeId::DATE:
@@ -45098,8 +45233,6 @@ string Value::ToString() const {
 		return Blob::ToString(string_t(str_value));
 	case LogicalTypeId::POINTER:
 		return to_string(value_.pointer);
-	case LogicalTypeId::HASH:
-		return to_string(value_.hash);
 	case LogicalTypeId::STRUCT: {
 		string ret = "{";
 		auto &child_types = StructType::GetChildTypes(type_);
@@ -46218,8 +46351,6 @@ Value Vector::GetValue(const Vector &v_p, idx_t index_p) {
 			throw InternalException("ENUM can only have unsigned integers as physical types");
 		}
 	}
-	case LogicalTypeId::HASH:
-		return Value::HASH(((hash_t *)data)[index]);
 	case LogicalTypeId::POINTER:
 		return Value::POINTER(((uintptr_t *)data)[index]);
 	case LogicalTypeId::FLOAT:
@@ -46775,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)) {
@@ -47611,9 +47742,6 @@ PhysicalType LogicalType::GetInternalType() {
 		return PhysicalType::STRUCT;
 	case LogicalTypeId::LIST:
 		return PhysicalType::LIST;
-	case LogicalTypeId::HASH:
-		static_assert(sizeof(hash_t) == sizeof(uint64_t), "Hash must be uint64_t");
-		return PhysicalType::UINT64;
 	case LogicalTypeId::POINTER:
 		// LCOV_EXCL_START
 		if (sizeof(uintptr_t) == sizeof(uint32_t)) {
@@ -47922,8 +48050,6 @@ string LogicalTypeIdToString(LogicalTypeId id) {
 		return "LIST";
 	case LogicalTypeId::MAP:
 		return "MAP";
-	case LogicalTypeId::HASH:
-		return "HASH";
 	case LogicalTypeId::POINTER:
 		return "POINTER";
 	case LogicalTypeId::TABLE:
@@ -52564,7 +52690,7 @@ static inline void ListLoopHash(Vector &input, Vector &hashes, const SelectionVe
 
 template <bool HAS_RSEL>
 static inline void HashTypeSwitch(Vector &input, Vector &result, const SelectionVector *rsel, idx_t count) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::HASH);
+	D_ASSERT(result.GetType().id() == LogicalType::HASH);
 	switch (input.GetType().InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
@@ -52696,7 +52822,7 @@ void TemplatedLoopCombineHash(Vector &input, Vector &hashes, const SelectionVect
 
 template <bool HAS_RSEL>
 static inline void CombineHashTypeSwitch(Vector &hashes, Vector &input, const SelectionVector *rsel, idx_t count) {
-	D_ASSERT(hashes.GetType().id() == LogicalTypeId::HASH);
+	D_ASSERT(hashes.GetType().id() == LogicalType::HASH);
 	switch (input.GetType().InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
@@ -57647,7 +57773,7 @@ void JoinHashTable::Build(DataChunk &keys, DataChunk &payload) {
 }
 
 void JoinHashTable::InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_locations[]) {
-	D_ASSERT(hashes.GetType().id() == LogicalTypeId::HASH);
+	D_ASSERT(hashes.GetType().id() == LogicalType::HASH);
 
 	// use bitmask to get position in array
 	ApplyBitmask(hashes, count);
@@ -60326,7 +60452,7 @@ static void ScanSortedPartition(WindowOperatorState &state, ChunkCollection &inp
 }
 
 static void HashChunk(counts_t &counts, DataChunk &hash_chunk, DataChunk &sort_chunk, const idx_t partition_cols) {
-	const vector<LogicalType> hash_types(1, LogicalTypeId::HASH);
+	const vector<LogicalType> hash_types(1, LogicalType::HASH);
 	hash_chunk.Initialize(hash_types);
 	hash_chunk.SetCardinality(sort_chunk);
 	auto &hash_vector = hash_chunk.data[0];
@@ -74935,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
 
 
 
@@ -93029,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();
@@ -93407,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();) {
@@ -93797,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 "b70bf98b5"
-#define DUCKDB_VERSION "v0.4.1-dev29"
+#define DUCKDB_SOURCE_ID "1f06d609f"
+#define DUCKDB_VERSION "v0.4.1-dev42"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -983,7 +983,7 @@ enum class LogicalTypeId : uint8_t {
 
 	HUGEINT = 50,
 	POINTER = 51,
-	HASH = 52,
+	// HASH = 52, // deprecated, uses UBIGINT instead
 	VALIDITY = 53,
 	UUID = 54,
 
@@ -1095,7 +1095,7 @@ public:
 	static constexpr const LogicalTypeId INTERVAL = LogicalTypeId::INTERVAL;
 	static constexpr const LogicalTypeId HUGEINT = LogicalTypeId::HUGEINT;
 	static constexpr const LogicalTypeId UUID = LogicalTypeId::UUID;
-	static constexpr const LogicalTypeId HASH = LogicalTypeId::HASH;
+	static constexpr const LogicalTypeId HASH = LogicalTypeId::UBIGINT;
 	static constexpr const LogicalTypeId POINTER = LogicalTypeId::POINTER;
 	static constexpr const LogicalTypeId TABLE = LogicalTypeId::TABLE;
 	static constexpr const LogicalTypeId INVALID = LogicalTypeId::INVALID;
@@ -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;