duckdb 0.10.1-dev6.0 → 0.10.1

package/src/duckdb/src/common/types/string_heap.cpp

@@ -52,11 +52,15 @@ string_t StringHeap::AddBlob(const string_t &data) {
 string_t StringHeap::EmptyString(idx_t len) {
 	D_ASSERT(len > string_t::INLINE_LENGTH);
 	auto insert_pos = const_char_ptr_cast(allocator.Allocate(len));
-	return string_t(insert_pos, len);
+	return string_t(insert_pos, UnsafeNumericCast<uint32_t>(len));
 }
 
 idx_t StringHeap::SizeInBytes() const {
 	return allocator.SizeInBytes();
 }
 
+idx_t StringHeap::AllocationSize() const {
+	return allocator.AllocationSize();
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/types/string_type.cpp

@@ -1,23 +1,37 @@
 #include "duckdb/common/types/string_type.hpp"
+
+#include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/types/value.hpp"
-#include "duckdb/common/algorithm.hpp"
 #include "utf8proc_wrapper.hpp"
 
 namespace duckdb {
 
 void string_t::Verify() const {
+#ifdef DEBUG
+	VerifyUTF8();
+#endif
+
+	VerifyCharacters();
+}
+
+void string_t::VerifyUTF8() const {
 	auto dataptr = GetData();
 	(void)dataptr;
 	D_ASSERT(dataptr);
 
-#ifdef DEBUG
 	auto utf_type = Utf8Proc::Analyze(dataptr, GetSize());
+	(void)utf_type;
 	D_ASSERT(utf_type != UnicodeType::INVALID);
-#endif
+}
+
+void string_t::VerifyCharacters() const {
+	auto dataptr = GetData();
+	(void)dataptr;
+	D_ASSERT(dataptr);
 
 	// verify that the prefix contains the first four characters of the string
-	for (idx_t i = 0; i < MinValue<uint32_t>(PREFIX_LENGTH, GetSize()); i++) {
+	for (idx_t i = 0; i < MinValue<idx_t>(PREFIX_LENGTH, GetSize()); i++) {
 		D_ASSERT(GetPrefix()[i] == dataptr[i]);
 	}
 	// verify that for strings with length <= INLINE_LENGTH, the rest of the string is zero

package/src/duckdb/src/common/types/time.cpp

@@ -137,8 +137,9 @@ bool Time::TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &resul
 	return result.micros <= Interval::MICROS_PER_DAY;
 }
 
-bool Time::TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &result, bool strict) {
+bool Time::TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &result, bool &has_offset, bool strict) {
 	dtime_t time_part;
+	has_offset = false;
 	if (!Time::TryConvertInternal(buf, len, pos, time_part, false)) {
 		if (!strict) {
 			// last chance, check if we can parse as timestamp
@@ -162,7 +163,8 @@ bool Time::TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &
 	//	Get the ±HH[:MM] part
 	int hh = 0;
 	int mm = 0;
-	if (pos < len && !Timestamp::TryParseUTCOffset(buf, pos, len, hh, mm)) {
+	has_offset = (pos < len);
+	if (has_offset && !Timestamp::TryParseUTCOffset(buf, pos, len, hh, mm)) {
 		return false;
 	}
 

package/src/duckdb/src/common/types/timestamp.cpp

@@ -109,7 +109,7 @@ bool Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &r
 			}
 			auto tz_len = str + pos - tz_name;
 			if (tz_len) {
-				tz = string_t(tz_name, tz_len);
+				tz = string_t(tz_name, UnsafeNumericCast<uint32_t>(tz_len));
 			}
 			// Note that the caller must reinterpret the instant we return to the given time zone
 		}
@@ -309,7 +309,7 @@ timestamp_t Timestamp::GetCurrentTimestamp() {
 	return Timestamp::FromEpochMs(epoch_ms);
 }
 
-timestamp_t Timestamp::FromEpochSeconds(int64_t sec) {
+timestamp_t Timestamp::FromEpochSecondsPossiblyInfinite(int64_t sec) {
 	int64_t result;
 	if (!TryMultiplyOperator::Operation(sec, Interval::MICROS_PER_SEC, result)) {
 		throw ConversionException("Could not convert Timestamp(S) to Timestamp(US)");
@@ -317,7 +317,12 @@ timestamp_t Timestamp::FromEpochSeconds(int64_t sec) {
 	return timestamp_t(result);
 }
 
-timestamp_t Timestamp::FromEpochMs(int64_t ms) {
+timestamp_t Timestamp::FromEpochSeconds(int64_t sec) {
+	D_ASSERT(Timestamp::IsFinite(timestamp_t(sec)));
+	return FromEpochSecondsPossiblyInfinite(sec);
+}
+
+timestamp_t Timestamp::FromEpochMsPossiblyInfinite(int64_t ms) {
 	int64_t result;
 	if (!TryMultiplyOperator::Operation(ms, Interval::MICROS_PER_MSEC, result)) {
 		throw ConversionException("Could not convert Timestamp(MS) to Timestamp(US)");
@@ -325,19 +330,31 @@ timestamp_t Timestamp::FromEpochMs(int64_t ms) {
 	return timestamp_t(result);
 }
 
+timestamp_t Timestamp::FromEpochMs(int64_t ms) {
+	D_ASSERT(Timestamp::IsFinite(timestamp_t(ms)));
+	return FromEpochMsPossiblyInfinite(ms);
+}
+
 timestamp_t Timestamp::FromEpochMicroSeconds(int64_t micros) {
 	return timestamp_t(micros);
 }
 
-timestamp_t Timestamp::FromEpochNanoSeconds(int64_t ns) {
+timestamp_t Timestamp::FromEpochNanoSecondsPossiblyInfinite(int64_t ns) {
 	return timestamp_t(ns / 1000);
 }
 
+timestamp_t Timestamp::FromEpochNanoSeconds(int64_t ns) {
+	D_ASSERT(Timestamp::IsFinite(timestamp_t(ns)));
+	return FromEpochNanoSecondsPossiblyInfinite(ns);
+}
+
 int64_t Timestamp::GetEpochSeconds(timestamp_t timestamp) {
+	D_ASSERT(Timestamp::IsFinite(timestamp));
 	return timestamp.value / Interval::MICROS_PER_SEC;
 }
 
 int64_t Timestamp::GetEpochMs(timestamp_t timestamp) {
+	D_ASSERT(Timestamp::IsFinite(timestamp));
 	return timestamp.value / Interval::MICROS_PER_MSEC;
 }
 
@@ -345,10 +362,19 @@ int64_t Timestamp::GetEpochMicroSeconds(timestamp_t timestamp) {
 	return timestamp.value;
 }
 
+bool Timestamp::TryGetEpochNanoSeconds(timestamp_t timestamp, int64_t &result) {
+	constexpr static const int64_t NANOSECONDS_IN_MICROSECOND = 1000;
+	D_ASSERT(Timestamp::IsFinite(timestamp));
+	if (!TryMultiplyOperator::Operation(timestamp.value, NANOSECONDS_IN_MICROSECOND, result)) {
+		return false;
+	}
+	return true;
+}
+
 int64_t Timestamp::GetEpochNanoSeconds(timestamp_t timestamp) {
 	int64_t result;
-	int64_t ns_in_us = 1000;
-	if (!TryMultiplyOperator::Operation(timestamp.value, ns_in_us, result)) {
+	D_ASSERT(Timestamp::IsFinite(timestamp));
+	if (!TryGetEpochNanoSeconds(timestamp, result)) {
 		throw ConversionException("Could not convert Timestamp(US) to Timestamp(NS)");
 	}
 	return result;

package/src/duckdb/src/common/types/ub_duckdb_common_types.cpp

@@ -0,0 +1,28 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/common/types/batched_data_collection.cpp>
+#include </Users/carlo/duckdb/src/common/types/bit.cpp>
+#include </Users/carlo/duckdb/src/common/types/blob.cpp>
+#include </Users/carlo/duckdb/src/common/types/cast_helpers.cpp>
+#include </Users/carlo/duckdb/src/common/types/chunk_collection.cpp>
+#include </Users/carlo/duckdb/src/common/types/conflict_manager.cpp>
+#include </Users/carlo/duckdb/src/common/types/conflict_info.cpp>
+#include </Users/carlo/duckdb/src/common/types/data_chunk.cpp>
+#include </Users/carlo/duckdb/src/common/types/date.cpp>
+#include </Users/carlo/duckdb/src/common/types/decimal.cpp>
+#include </Users/carlo/duckdb/src/common/types/hash.cpp>
+#include </Users/carlo/duckdb/src/common/types/hugeint.cpp>
+#include </Users/carlo/duckdb/src/common/types/uuid.cpp>
+#include </Users/carlo/duckdb/src/common/types/hyperloglog.cpp>
+#include </Users/carlo/duckdb/src/common/types/interval.cpp>
+#include </Users/carlo/duckdb/src/common/types/list_segment.cpp>
+#include </Users/carlo/duckdb/src/common/types/selection_vector.cpp>
+#include </Users/carlo/duckdb/src/common/types/string_heap.cpp>
+#include </Users/carlo/duckdb/src/common/types/string_type.cpp>
+#include </Users/carlo/duckdb/src/common/types/timestamp.cpp>
+#include </Users/carlo/duckdb/src/common/types/time.cpp>
+#include </Users/carlo/duckdb/src/common/types/validity_mask.cpp>
+#include </Users/carlo/duckdb/src/common/types/value.cpp>
+#include </Users/carlo/duckdb/src/common/types/vector_buffer.cpp>
+#include </Users/carlo/duckdb/src/common/types/vector.cpp>
+#include </Users/carlo/duckdb/src/common/types/vector_cache.cpp>
+#include </Users/carlo/duckdb/src/common/types/vector_constants.cpp>

package/src/duckdb/src/common/types/uhugeint.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/limits.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/windows_undefs.hpp"
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
@@ -64,7 +65,7 @@ string Uhugeint::ToString(uhugeint_t input) {
 			break;
 		}
 		input = Uhugeint::DivMod(input, 10, remainder);
-		result = string(1, '0' + remainder.lower) + result; // NOLINT
+		result = string(1, UnsafeNumericCast<char>('0' + remainder.lower)) + result; // NOLINT
 	}
 	if (result.empty()) {
 		// value is zero
@@ -432,7 +433,7 @@ uhugeint_t UhugeintConvertInteger(DST input) {
 template <>
 bool Uhugeint::TryConvert(const char *value, uhugeint_t &result) {
 	auto len = strlen(value);
-	string_t string_val(value, len);
+	string_t string_val(value, UnsafeNumericCast<uint32_t>(len));
 	return TryCast::Operation<string_t, uhugeint_t>(string_val, result, true);
 }
 

package/src/duckdb/src/common/types/uuid.cpp

@@ -85,6 +85,17 @@ void UUID::ToString(hugeint_t input, char *buf) {
 	byte_to_hex(input.lower & 0xFF, buf, pos);
 }
 
+hugeint_t UUID::FromUHugeint(uhugeint_t input) {
+	hugeint_t result;
+	result.lower = input.lower;
+	if (input.upper > uint64_t(NumericLimits<int64_t>::Maximum())) {
+		result.upper = int64_t(input.upper - uint64_t(NumericLimits<int64_t>::Maximum()) - 1);
+	} else {
+		result.upper = int64_t(input.upper) - NumericLimits<int64_t>::Maximum() - 1;
+	}
+	return result;
+}
+
 hugeint_t UUID::GenerateRandomUUID(RandomEngine &engine) {
 	uint8_t bytes[16];
 	for (int i = 0; i < 16; i += 4) {

package/src/duckdb/src/common/types/validity_mask.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/common/types/validity_mask.hpp"
 #include "duckdb/common/limits.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/serializer/write_stream.hpp"
 #include "duckdb/common/serializer/read_stream.hpp"
 
@@ -195,13 +196,13 @@ void ValidityMask::Write(WriteStream &writer, idx_t count) {
 		// serialize (in)valid value indexes as [COUNT][V0][V1][...][VN]
 		auto flag = serialize_valid ? ValiditySerialization::VALID_VALUES : ValiditySerialization::INVALID_VALUES;
 		writer.Write(flag);
-		writer.Write<uint32_t>(MinValue<uint32_t>(valid_values, invalid_values));
+		writer.Write<uint32_t>(NumericCast<uint32_t>(MinValue(valid_values, invalid_values)));
 		for (idx_t i = 0; i < count; i++) {
 			if (RowIsValid(i) == serialize_valid) {
 				if (need_u32) {
-					writer.Write<uint32_t>(i);
+					writer.Write<uint32_t>(UnsafeNumericCast<uint32_t>(i));
 				} else {
-					writer.Write<uint16_t>(i);
+					writer.Write<uint16_t>(UnsafeNumericCast<uint16_t>(i));
 				}
 			}
 		}

package/src/duckdb/src/common/types/value.cpp

@@ -133,6 +133,10 @@ Value::Value(int32_t val) : type_(LogicalType::INTEGER), is_null(false) {
 	value_.integer = val;
 }
 
+Value::Value(bool val) : type_(LogicalType::BOOLEAN), is_null(false) {
+	value_.boolean = val;
+}
+
 Value::Value(int64_t val) : type_(LogicalType::BIGINT), is_null(false) {
 	value_.bigint = val;
 }
@@ -530,10 +534,10 @@ Value Value::DECIMAL(int64_t value, uint8_t width, uint8_t scale) {
 	Value result(decimal_type);
 	switch (decimal_type.InternalType()) {
 	case PhysicalType::INT16:
-		result.value_.smallint = value;
+		result.value_.smallint = NumericCast<int16_t>(value);
 		break;
 	case PhysicalType::INT32:
-		result.value_.integer = value;
+		result.value_.integer = NumericCast<int32_t>(value);
 		break;
 	case PhysicalType::INT64:
 		result.value_.bigint = value;
@@ -820,6 +824,13 @@ Value Value::BLOB(const string &data) {
 	return result;
 }
 
+Value Value::AGGREGATE_STATE(const LogicalType &type, const_data_ptr_t data, idx_t len) { // NOLINT
+	Value result(type);
+	result.is_null = false;
+	result.value_info_ = make_shared<StringValueInfo>(string(const_char_ptr_cast(data), len));
+	return result;
+}
+
 Value Value::BIT(const_data_ptr_t data, idx_t len) {
 	Value result(LogicalType::BIT);
 	result.is_null = false;
@@ -839,13 +850,13 @@ Value Value::ENUM(uint64_t value, const LogicalType &original_type) {
 	Value result(original_type);
 	switch (original_type.InternalType()) {
 	case PhysicalType::UINT8:
-		result.value_.utinyint = value;
+		result.value_.utinyint = NumericCast<uint8_t>(value);
 		break;
 	case PhysicalType::UINT16:
-		result.value_.usmallint = value;
+		result.value_.usmallint = NumericCast<uint16_t>(value);
 		break;
 	case PhysicalType::UINT32:
-		result.value_.uinteger = value;
+		result.value_.uinteger = NumericCast<uint32_t>(value);
 		break;
 	default:
 		throw InternalException("Incorrect Physical Type for ENUM");
@@ -1213,7 +1224,7 @@ Value Value::Numeric(const LogicalType &type, int64_t value) {
 		return Value::POINTER(value);
 	case LogicalTypeId::DATE:
 		D_ASSERT(value >= NumericLimits<int32_t>::Minimum() && value <= NumericLimits<int32_t>::Maximum());
-		return Value::DATE(date_t(value));
+		return Value::DATE(date_t(NumericCast<int32_t>(value)));
 	case LogicalTypeId::TIME:
 		return Value::TIME(dtime_t(value));
 	case LogicalTypeId::TIMESTAMP: