duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

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

@@ -103,6 +103,101 @@ int NumericHelper::UnsignedLength(uint64_t value) {
 	}
 }
 
+template <>
+int NumericHelper::UnsignedLength(hugeint_t value) {
+	D_ASSERT(value.upper >= 0);
+	if (value.upper == 0) {
+		return UnsignedLength<uint64_t>(value.lower);
+	}
+	// search the length using the POWERS_OF_TEN array
+	// the length has to be between [17] and [38], because the hugeint is bigger than 2^63
+	// we use the same approach as above, but split a bit more because comparisons for hugeints are more expensive
+	if (value >= Hugeint::POWERS_OF_TEN[27]) {
+		// [27..38]
+		if (value >= Hugeint::POWERS_OF_TEN[32]) {
+			if (value >= Hugeint::POWERS_OF_TEN[36]) {
+				int length = 37;
+				length += value >= Hugeint::POWERS_OF_TEN[37];
+				length += value >= Hugeint::POWERS_OF_TEN[38];
+				return length;
+			} else {
+				int length = 33;
+				length += value >= Hugeint::POWERS_OF_TEN[33];
+				length += value >= Hugeint::POWERS_OF_TEN[34];
+				length += value >= Hugeint::POWERS_OF_TEN[35];
+				return length;
+			}
+		} else {
+			if (value >= Hugeint::POWERS_OF_TEN[30]) {
+				int length = 31;
+				length += value >= Hugeint::POWERS_OF_TEN[31];
+				length += value >= Hugeint::POWERS_OF_TEN[32];
+				return length;
+			} else {
+				int length = 28;
+				length += value >= Hugeint::POWERS_OF_TEN[28];
+				length += value >= Hugeint::POWERS_OF_TEN[29];
+				return length;
+			}
+		}
+	} else {
+		// [17..27]
+		if (value >= Hugeint::POWERS_OF_TEN[22]) {
+			// [22..27]
+			if (value >= Hugeint::POWERS_OF_TEN[25]) {
+				int length = 26;
+				length += value >= Hugeint::POWERS_OF_TEN[26];
+				return length;
+			} else {
+				int length = 23;
+				length += value >= Hugeint::POWERS_OF_TEN[23];
+				length += value >= Hugeint::POWERS_OF_TEN[24];
+				return length;
+			}
+		} else {
+			// [17..22]
+			if (value >= Hugeint::POWERS_OF_TEN[20]) {
+				int length = 21;
+				length += value >= Hugeint::POWERS_OF_TEN[21];
+				return length;
+			} else {
+				int length = 18;
+				length += value >= Hugeint::POWERS_OF_TEN[18];
+				length += value >= Hugeint::POWERS_OF_TEN[19];
+				return length;
+			}
+		}
+	}
+}
+
+template <>
+string_t NumericHelper::FormatSigned(hugeint_t value, Vector &vector) {
+	int negative = value.upper < 0;
+	if (negative) {
+		if (value == NumericLimits<hugeint_t>::Minimum()) {
+			string_t result = StringVector::AddString(vector, Hugeint::HUGEINT_MINIMUM_STRING);
+			return result;
+		}
+		Hugeint::NegateInPlace(value);
+	}
+	int length = UnsignedLength(value) + negative;
+	string_t result = StringVector::EmptyString(vector, NumericCast<size_t>(length));
+	auto dataptr = result.GetDataWriteable();
+	auto endptr = dataptr + length;
+	if (value.upper == 0) {
+		// small value: format as uint64_t
+		endptr = NumericHelper::FormatUnsigned<uint64_t>(value.lower, endptr);
+	} else {
+		endptr = FormatUnsigned(value, endptr);
+	}
+	if (negative) {
+		*--endptr = '-';
+	}
+	D_ASSERT(endptr == dataptr);
+	result.Finalize();
+	return result;
+}
+
 template <>
 std::string NumericHelper::ToString(hugeint_t value) {
 	return Hugeint::ToString(value);
@@ -113,4 +208,106 @@ std::string NumericHelper::ToString(uhugeint_t value) {
 	return Uhugeint::ToString(value);
 }
 
+template <>
+int DecimalToString::DecimalLength(hugeint_t value, uint8_t width, uint8_t scale) {
+	D_ASSERT(value > NumericLimits<hugeint_t>::Minimum());
+	int negative;
+
+	if (value.upper < 0) {
+		Hugeint::NegateInPlace(value);
+		negative = 1;
+	} else {
+		negative = 0;
+	}
+	if (scale == 0) {
+		// scale is 0: regular number
+		return NumericHelper::UnsignedLength(value) + negative;
+	}
+	// length is max of either:
+	// scale + 2 OR
+	// integer length + 1
+	// scale + 2 happens when the number is in the range of (-1, 1)
+	// in that case we print "0.XXX", which is the scale, plus "0." (2 chars)
+	// integer length + 1 happens when the number is outside of that range
+	// in that case we print the integer number, but with one extra character ('.')
+	auto extra_numbers = width > scale ? 2 : 1;
+	return MaxValue(scale + extra_numbers, NumericHelper::UnsignedLength(value) + 1) + negative;
+}
+
+template <>
+string_t DecimalToString::Format(hugeint_t value, uint8_t width, uint8_t scale, Vector &vector) {
+	int length = DecimalLength(value, width, scale);
+	string_t result = StringVector::EmptyString(vector, NumericCast<idx_t>(length));
+
+	auto dst = result.GetDataWriteable();
+
+	FormatDecimal(value, width, scale, dst, NumericCast<idx_t>(length));
+
+	result.Finalize();
+	return result;
+}
+
+template <>
+char *NumericHelper::FormatUnsigned(hugeint_t value, char *ptr) {
+	while (value.upper > 0) {
+		// while integer division is slow, hugeint division is MEGA slow
+		// we want to avoid doing as many divisions as possible
+		// for that reason we start off doing a division by a large power of ten that uint64_t can hold
+		// (100000000000000000) - this is the third largest
+		// the reason we don't use the largest is because that can result in an overflow inside the division
+		// function
+		uint64_t remainder;
+		value = Hugeint::DivModPositive(value, 100000000000000000ULL, remainder);
+
+		auto startptr = ptr;
+		// now we format the remainder: note that we need to pad with zero's in case
+		// the remainder is small (i.e. less than 10000000000000000)
+		ptr = NumericHelper::FormatUnsigned<uint64_t>(remainder, ptr);
+
+		int format_length = UnsafeNumericCast<int>(startptr - ptr);
+		// pad with zero
+		for (int i = format_length; i < 17; i++) {
+			*--ptr = '0';
+		}
+	}
+	// once the value falls in the range of a uint64_t, fallback to formatting as uint64_t to avoid hugeint division
+	return NumericHelper::FormatUnsigned<uint64_t>(value.lower, ptr);
+}
+
+template <>
+void DecimalToString::FormatDecimal(hugeint_t value, uint8_t width, uint8_t scale, char *dst, idx_t len) {
+	auto endptr = dst + len;
+
+	int negative = value.upper < 0;
+	if (negative) {
+		Hugeint::NegateInPlace(value);
+		*dst = '-';
+		dst++;
+	}
+	if (scale == 0) {
+		// with scale=0 we format the number as a regular number
+		NumericHelper::FormatUnsigned(value, endptr);
+		return;
+	}
+
+	// we write two numbers:
+	// the numbers BEFORE the decimal (major)
+	// and the numbers AFTER the decimal (minor)
+	hugeint_t minor;
+	hugeint_t major = Hugeint::DivMod(value, Hugeint::POWERS_OF_TEN[scale], minor);
+
+	// write the number after the decimal
+	dst = NumericHelper::FormatUnsigned(minor, endptr);
+	// (optionally) pad with zeros and add the decimal point
+	while (dst > (endptr - scale)) {
+		*--dst = '0';
+	}
+	*--dst = '.';
+	// now write the part before the decimal
+	D_ASSERT(width > scale || major == 0);
+	if (width > scale) {
+		dst = NumericHelper::FormatUnsigned(major, dst);
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/types/column/column_data_collection.cpp

@@ -51,17 +51,17 @@ ColumnDataCollection::ColumnDataCollection(Allocator &allocator_p) {
 	types.clear();
 	count = 0;
 	this->finished_append = false;
-	allocator = make_shared<ColumnDataAllocator>(allocator_p);
+	allocator = make_shared_ptr<ColumnDataAllocator>(allocator_p);
 }
 
 ColumnDataCollection::ColumnDataCollection(Allocator &allocator_p, vector<LogicalType> types_p) {
 	Initialize(std::move(types_p));
-	allocator = make_shared<ColumnDataAllocator>(allocator_p);
+	allocator = make_shared_ptr<ColumnDataAllocator>(allocator_p);
 }
 
 ColumnDataCollection::ColumnDataCollection(BufferManager &buffer_manager, vector<LogicalType> types_p) {
 	Initialize(std::move(types_p));
-	allocator = make_shared<ColumnDataAllocator>(buffer_manager);
+	allocator = make_shared_ptr<ColumnDataAllocator>(buffer_manager);
 }
 
 ColumnDataCollection::ColumnDataCollection(shared_ptr<ColumnDataAllocator> allocator_p, vector<LogicalType> types_p) {
@@ -71,7 +71,7 @@ ColumnDataCollection::ColumnDataCollection(shared_ptr<ColumnDataAllocator> alloc
 
 ColumnDataCollection::ColumnDataCollection(ClientContext &context, vector<LogicalType> types_p,
                                            ColumnDataAllocatorType type)
-    : ColumnDataCollection(make_shared<ColumnDataAllocator>(context, type), std::move(types_p)) {
+    : ColumnDataCollection(make_shared_ptr<ColumnDataAllocator>(context, type), std::move(types_p)) {
 	D_ASSERT(!types.empty());
 }
 
@@ -199,7 +199,7 @@ ColumnDataChunkIterationHelper::ColumnDataChunkIterationHelper(const ColumnDataC
 
 ColumnDataChunkIterationHelper::ColumnDataChunkIterator::ColumnDataChunkIterator(
     const ColumnDataCollection *collection_p, vector<column_t> column_ids_p)
-    : collection(collection_p), scan_chunk(make_shared<DataChunk>()), row_index(0) {
+    : collection(collection_p), scan_chunk(make_shared_ptr<DataChunk>()), row_index(0) {
 	if (!collection) {
 		return;
 	}
@@ -246,7 +246,7 @@ ColumnDataRowIterationHelper::ColumnDataRowIterationHelper(const ColumnDataColle
 }
 
 ColumnDataRowIterationHelper::ColumnDataRowIterator::ColumnDataRowIterator(const ColumnDataCollection *collection_p)
-    : collection(collection_p), scan_chunk(make_shared<DataChunk>()), current_row(*scan_chunk, 0, 0) {
+    : collection(collection_p), scan_chunk(make_shared_ptr<DataChunk>()), current_row(*scan_chunk, 0, 0) {
 	if (!collection) {
 		return;
 	}
@@ -690,8 +690,16 @@ void ColumnDataCopyArray(ColumnDataMetaData &meta_data, const UnifiedVectorForma
 		}
 	}
 
-	child_function.function(child_meta_data, child_vector_data, child_vector, offset * array_size,
-	                        array_size * copy_count);
+	auto is_constant = source.GetVectorType() == VectorType::CONSTANT_VECTOR;
+	// If the array is constant, we need to copy the child vector n times
+	if (is_constant) {
+		for (idx_t i = 0; i < copy_count; i++) {
+			child_function.function(child_meta_data, child_vector_data, child_vector, 0, array_size);
+		}
+	} else {
+		child_function.function(child_meta_data, child_vector_data, child_vector, offset * array_size,
+		                        copy_count * array_size);
+	}
 }
 
 ColumnDataCopyFunction ColumnDataCollection::GetCopyFunction(const LogicalType &type) {
@@ -1041,7 +1049,7 @@ void ColumnDataCollection::Reset() {
 	segments.clear();
 
 	// Refreshes the ColumnDataAllocator to prevent holding on to allocated data unnecessarily
-	allocator = make_shared<ColumnDataAllocator>(*allocator);
+	allocator = make_shared_ptr<ColumnDataAllocator>(*allocator);
 }
 
 struct ValueResultEquals {

package/src/duckdb/src/common/types/column/column_data_collection_segment.cpp

@@ -7,7 +7,7 @@ namespace duckdb {
 ColumnDataCollectionSegment::ColumnDataCollectionSegment(shared_ptr<ColumnDataAllocator> allocator_p,
                                                          vector<LogicalType> types_p)
     : allocator(std::move(allocator_p)), types(std::move(types_p)), count(0),
-      heap(make_shared<StringHeap>(allocator->GetAllocator())) {
+      heap(make_shared_ptr<StringHeap>(allocator->GetAllocator())) {
 }
 
 idx_t ColumnDataCollectionSegment::GetDataSize(idx_t type_size) {

package/src/duckdb/src/common/types/column/partitioned_column_data.cpp

@@ -9,7 +9,7 @@ namespace duckdb {
 PartitionedColumnData::PartitionedColumnData(PartitionedColumnDataType type_p, ClientContext &context_p,
                                              vector<LogicalType> types_p)
     : type(type_p), context(context_p), types(std::move(types_p)),
-      allocators(make_shared<PartitionColumnDataAllocators>()) {
+      allocators(make_shared_ptr<PartitionColumnDataAllocators>()) {
 }
 
 PartitionedColumnData::PartitionedColumnData(const PartitionedColumnData &other)
@@ -20,8 +20,6 @@ unique_ptr<PartitionedColumnData> PartitionedColumnData::CreateShared() {
 	switch (type) {
 	case PartitionedColumnDataType::RADIX:
 		return make_uniq<RadixPartitionedColumnData>(Cast<RadixPartitionedColumnData>());
-	case PartitionedColumnDataType::HIVE:
-		return make_uniq<HivePartitionedColumnData>(Cast<HivePartitionedColumnData>());
 	default:
 		throw NotImplementedException("CreateShared for this type of PartitionedColumnData");
 	}
@@ -136,6 +134,9 @@ void PartitionedColumnData::Append(PartitionedColumnDataAppendState &state, Data
 
 void PartitionedColumnData::FlushAppendState(PartitionedColumnDataAppendState &state) {
 	for (idx_t i = 0; i < state.partition_buffers.size(); i++) {
+		if (!state.partition_buffers[i]) {
+			continue;
+		}
 		auto &partition_buffer = *state.partition_buffers[i];
 		if (partition_buffer.size() > 0) {
 			partitions[i]->Append(partition_buffer);
@@ -155,7 +156,14 @@ void PartitionedColumnData::Combine(PartitionedColumnData &other) {
 		D_ASSERT(partitions.size() == other.partitions.size());
 		// Combine the append state's partitions into this PartitionedColumnData
 		for (idx_t i = 0; i < other.partitions.size(); i++) {
-			partitions[i]->Combine(*other.partitions[i]);
+			if (!other.partitions[i]) {
+				continue;
+			}
+			if (!partitions[i]) {
+				partitions[i] = std::move(other.partitions[i]);
+			} else {
+				partitions[i]->Combine(*other.partitions[i]);
+			}
 		}
 	}
 }
@@ -165,7 +173,7 @@ vector<unique_ptr<ColumnDataCollection>> &PartitionedColumnData::GetPartitions()
 }
 
 void PartitionedColumnData::CreateAllocator() {
-	allocators->allocators.emplace_back(make_shared<ColumnDataAllocator>(BufferManager::GetBufferManager(context)));
+	allocators->allocators.emplace_back(make_shared_ptr<ColumnDataAllocator>(BufferManager::GetBufferManager(context)));
 	allocators->allocators.back()->MakeShared();
 }
 

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

@@ -12,7 +12,7 @@ bool ConflictInfo::ConflictTargetMatches(Index &index) const {
 		return true;
 	}
 	// Check whether the column ids match
-	return column_ids == index.column_id_set;
+	return column_ids == index.GetColumnIdSet();
 }
 
 } // namespace duckdb

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

@@ -159,7 +159,7 @@ bool ConflictManager::AddNull(idx_t chunk_index) {
 	if (!IsConflict(LookupResultType::LOOKUP_NULL)) {
 		return false;
 	}
-	return AddHit(chunk_index, DConstants::INVALID_INDEX);
+	return AddHit(chunk_index, static_cast<row_t>(DConstants::INVALID_INDEX));
 }
 
 bool ConflictManager::SingleIndexTarget() const {

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

@@ -273,7 +273,7 @@ void DataChunk::Deserialize(Deserializer &deserializer) {
 
 	// initialize the data chunk
 	D_ASSERT(!types.empty());
-	Initialize(Allocator::DefaultAllocator(), types);
+	Initialize(Allocator::DefaultAllocator(), types, MaxValue<idx_t>(row_count, STANDARD_VECTOR_SIZE));
 	SetCardinality(row_count);
 
 	// read the data

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

@@ -307,7 +307,7 @@ bool Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result
 	// in strict mode, check remaining string for non-space characters
 	if (strict) {
 		// skip trailing spaces
-		while (pos < len && StringUtil::CharacterIsSpace((unsigned char)buf[pos])) {
+		while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
 			pos++;
 		}
 		// check position. if end was not reached, non-space chars remaining
@@ -316,7 +316,7 @@ bool Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result
 		}
 	} else {
 		// in non-strict mode, check for any direct trailing digits
-		if (pos < len && StringUtil::CharacterIsDigit((unsigned char)buf[pos])) {
+		if (pos < len && StringUtil::CharacterIsDigit(buf[pos])) {
 			return false;
 		}
 	}

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

@@ -3,31 +3,31 @@
 
 namespace duckdb {
 
-template <class SIGNED, class UNSIGNED>
+template <class SIGNED>
 string TemplatedDecimalToString(SIGNED value, uint8_t width, uint8_t scale) {
-	auto len = DecimalToString::DecimalLength<SIGNED, UNSIGNED>(value, width, scale);
-	auto data = make_unsafe_uniq_array<char>(len + 1);
-	DecimalToString::FormatDecimal<SIGNED, UNSIGNED>(value, width, scale, data.get(), len);
-	return string(data.get(), len);
+	auto len = DecimalToString::DecimalLength<SIGNED>(value, width, scale);
+	auto data = make_unsafe_uniq_array<char>(UnsafeNumericCast<size_t>(len + 1));
+	DecimalToString::FormatDecimal<SIGNED>(value, width, scale, data.get(), UnsafeNumericCast<idx_t>(len));
+	return string(data.get(), UnsafeNumericCast<uint32_t>(len));
 }
 
 string Decimal::ToString(int16_t value, uint8_t width, uint8_t scale) {
-	return TemplatedDecimalToString<int16_t, uint16_t>(value, width, scale);
+	return TemplatedDecimalToString<int16_t>(value, width, scale);
 }
 
 string Decimal::ToString(int32_t value, uint8_t width, uint8_t scale) {
-	return TemplatedDecimalToString<int32_t, uint32_t>(value, width, scale);
+	return TemplatedDecimalToString<int32_t>(value, width, scale);
 }
 
 string Decimal::ToString(int64_t value, uint8_t width, uint8_t scale) {
-	return TemplatedDecimalToString<int64_t, uint64_t>(value, width, scale);
+	return TemplatedDecimalToString<int64_t>(value, width, scale);
 }
 
 string Decimal::ToString(hugeint_t value, uint8_t width, uint8_t scale) {
-	auto len = HugeintToStringCast::DecimalLength(value, width, scale);
-	auto data = make_unsafe_uniq_array<char>(len + 1);
-	HugeintToStringCast::FormatDecimal(value, width, scale, data.get(), len);
-	return string(data.get(), len);
+	auto len = DecimalToString::DecimalLength(value, width, scale);
+	auto data = make_unsafe_uniq_array<char>(UnsafeNumericCast<size_t>(len + 1));
+	DecimalToString::FormatDecimal(value, width, scale, data.get(), UnsafeNumericCast<idx_t>(len));
+	return string(data.get(), UnsafeNumericCast<uint32_t>(len));
 }
 
 } // namespace duckdb

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

@@ -22,7 +22,7 @@ hash_t Hash(int64_t val) {
 
 template <>
 hash_t Hash(hugeint_t val) {
-	return MurmurHash64(val.lower) ^ MurmurHash64(val.upper);
+	return MurmurHash64(val.lower) ^ MurmurHash64(static_cast<uint64_t>(val.upper));
 }
 
 template <>

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

@@ -85,7 +85,7 @@ static uint8_t PositiveHugeintHighestBit(hugeint_t bits) {
 	uint8_t out = 0;
 	if (bits.upper) {
 		out = 64;
-		uint64_t up = bits.upper;
+		uint64_t up = static_cast<uint64_t>(bits.upper);
 		while (up) {
 			up >>= 1;
 			out++;
@@ -104,7 +104,7 @@ static bool PositiveHugeintIsBitSet(hugeint_t lhs, uint8_t bit_position) {
 	if (bit_position < 64) {
 		return lhs.lower & (uint64_t(1) << uint64_t(bit_position));
 	} else {
-		return lhs.upper & (uint64_t(1) << uint64_t(bit_position - 64));
+		return static_cast<uint64_t>(lhs.upper) & (uint64_t(1) << uint64_t(bit_position - 64));
 	}
 }
 
@@ -112,7 +112,8 @@ static hugeint_t PositiveHugeintLeftShift(hugeint_t lhs, uint32_t amount) {
 	D_ASSERT(amount > 0 && amount < 64);
 	hugeint_t result;
 	result.lower = lhs.lower << amount;
-	result.upper = (lhs.upper << amount) + (lhs.lower >> (64 - amount));
+	result.upper =
+	    UnsafeNumericCast<int64_t>((UnsafeNumericCast<uint64_t>(lhs.upper) << amount) + (lhs.lower >> (64 - amount)));
 	return result;
 }
 
@@ -625,7 +626,7 @@ bool Hugeint::TryCast(hugeint_t input, uhugeint_t &result) {
 	}
 
 	result.lower = input.lower;
-	result.upper = input.upper;
+	result.upper = UnsafeNumericCast<uint64_t>(input.upper);
 	return true;
 }
 
@@ -744,7 +745,7 @@ bool ConvertFloatingToBigint(REAL_T value, hugeint_t &result) {
 		value = -value;
 	}
 	result.lower = (uint64_t)fmod(value, REAL_T(NumericLimits<uint64_t>::Maximum()));
-	result.upper = (uint64_t)(value / REAL_T(NumericLimits<uint64_t>::Maximum()));
+	result.upper = (int64_t)(value / REAL_T(NumericLimits<uint64_t>::Maximum()));
 	if (negative) {
 		Hugeint::NegateInPlace(result);
 	}
@@ -829,14 +830,14 @@ hugeint_t hugeint_t::operator>>(const hugeint_t &rhs) const {
 		return *this;
 	} else if (shift == 64) {
 		result.upper = (upper < 0) ? -1 : 0;
-		result.lower = upper;
+		result.lower = uint64_t(upper);
 	} else if (shift < 64) {
 		// perform lower shift in unsigned integer, and mask away the most significant bit
 		result.lower = (uint64_t(upper) << (64 - shift)) | (lower >> shift);
 		result.upper = upper >> shift;
 	} else {
 		D_ASSERT(shift < 128);
-		result.lower = upper >> (shift - 64);
+		result.lower = uint64_t(upper >> (shift - 64));
 		result.upper = (upper < 0) ? -1 : 0;
 	}
 	return result;
@@ -851,7 +852,7 @@ hugeint_t hugeint_t::operator<<(const hugeint_t &rhs) const {
 	if (rhs.upper != 0 || shift >= 128) {
 		return hugeint_t(0);
 	} else if (shift == 64) {
-		result.upper = lower;
+		result.upper = int64_t(lower);
 		result.lower = 0;
 	} else if (shift == 0) {
 		return *this;
@@ -859,7 +860,7 @@ hugeint_t hugeint_t::operator<<(const hugeint_t &rhs) const {
 		// perform upper shift in unsigned integer, and mask away the most significant bit
 		uint64_t upper_shift = ((uint64_t(upper) << shift) + (lower >> (64 - shift))) & 0x7FFFFFFFFFFFFFFF;
 		result.lower = lower << shift;
-		result.upper = upper_shift;
+		result.upper = int64_t(upper_shift);
 	} else {
 		D_ASSERT(shift < 128);
 		result.lower = 0;

package/src/duckdb/src/common/types/row/partitioned_tuple_data.cpp

@@ -9,7 +9,7 @@ namespace duckdb {
 PartitionedTupleData::PartitionedTupleData(PartitionedTupleDataType type_p, BufferManager &buffer_manager_p,
                                            const TupleDataLayout &layout_p)
     : type(type_p), buffer_manager(buffer_manager_p), layout(layout_p.Copy()), count(0), data_size(0),
-      allocators(make_shared<PartitionTupleDataAllocators>()) {
+      allocators(make_shared_ptr<PartitionTupleDataAllocators>()) {
 }
 
 PartitionedTupleData::PartitionedTupleData(const PartitionedTupleData &other)
@@ -329,8 +329,8 @@ void PartitionedTupleData::Repartition(PartitionedTupleData &new_partitioned_dat
 	const int64_t update = reverse ? -1 : 1;
 	const int64_t adjustment = reverse ? -1 : 0;
 
-	for (idx_t partition_idx = start_idx; partition_idx != end_idx; partition_idx += update) {
-		auto actual_partition_idx = partition_idx + adjustment;
+	for (idx_t partition_idx = start_idx; partition_idx != end_idx; partition_idx += idx_t(update)) {
+		auto actual_partition_idx = partition_idx + idx_t(adjustment);
 		auto &partition = *partitions[actual_partition_idx];
 
 		if (partition.Count() > 0) {
@@ -434,7 +434,7 @@ void PartitionedTupleData::Print() {
 // LCOV_EXCL_STOP
 
 void PartitionedTupleData::CreateAllocator() {
-	allocators->allocators.emplace_back(make_shared<TupleDataAllocator>(buffer_manager, layout));
+	allocators->allocators.emplace_back(make_shared_ptr<TupleDataAllocator>(buffer_manager, layout));
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/types/row/row_data_collection_scanner.cpp

@@ -56,7 +56,8 @@ void RowDataCollectionScanner::AlignHeapBlocks(RowDataCollection &swizzled_block
 			if (!swizzled_string_heap.keep_pinned) {
 				auto heap_ptr = Load<data_ptr_t>(data_ptr + layout.GetHeapOffset());
 				auto heap_offset = heap_ptr - heap_handle.Ptr();
-				RowOperations::SwizzleHeapPointer(layout, data_ptr, heap_ptr, data_block->count, heap_offset);
+				RowOperations::SwizzleHeapPointer(layout, data_ptr, heap_ptr, data_block->count,
+				                                  NumericCast<idx_t>(heap_offset));
 			} else {
 				swizzled_string_heap.pinned_blocks.emplace_back(std::move(heap_handle));
 			}
@@ -84,7 +85,7 @@ void RowDataCollectionScanner::AlignHeapBlocks(RowDataCollection &swizzled_block
 				auto heap_start_ptr = Load<data_ptr_t>(data_ptr + layout.GetHeapOffset());
 				auto heap_end_ptr =
 				    Load<data_ptr_t>(data_ptr + layout.GetHeapOffset() + (next - 1) * layout.GetRowWidth());
-				idx_t size = heap_end_ptr - heap_start_ptr + Load<uint32_t>(heap_end_ptr);
+				auto size = NumericCast<idx_t>(heap_end_ptr - heap_start_ptr + Load<uint32_t>(heap_end_ptr));
 				ptrs_and_sizes.emplace_back(heap_start_ptr, size);
 				D_ASSERT(size <= heap_blocks[heap_block_idx]->byte_offset);
 
@@ -100,7 +101,7 @@ void RowDataCollectionScanner::AlignHeapBlocks(RowDataCollection &swizzled_block
 
 			// Finally, we allocate a new heap block and copy data to it
 			swizzled_string_heap.blocks.emplace_back(make_uniq<RowDataBlock>(
-			    MemoryTag::ORDER_BY, buffer_manager, MaxValue<idx_t>(total_size, (idx_t)Storage::BLOCK_SIZE), 1));
+			    MemoryTag::ORDER_BY, buffer_manager, MaxValue<idx_t>(total_size, (idx_t)Storage::BLOCK_SIZE), 1U));
 			auto new_heap_handle = buffer_manager.Pin(swizzled_string_heap.blocks.back()->block);
 			auto new_heap_ptr = new_heap_handle.Ptr();
 			for (auto &ptr_and_size : ptrs_and_sizes) {
@@ -174,7 +175,7 @@ RowDataCollectionScanner::RowDataCollectionScanner(RowDataCollection &rows_p, Ro
 	//	Pretend that we have scanned up to the start block
 	//	and will stop at the end
 	auto begin = rows.blocks.begin();
-	auto end = begin + block_idx;
+	auto end = begin + NumericCast<int64_t>(block_idx);
 	total_scanned =
 	    std::accumulate(begin, end, idx_t(0), [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
 	total_count = total_scanned + (*end)->count;
@@ -194,7 +195,7 @@ void RowDataCollectionScanner::SwizzleBlock(RowDataBlock &data_block, RowDataBlo
 	auto heap_handle = heap.buffer_manager.Pin(heap_block.block);
 	auto heap_ptr = Load<data_ptr_t>(data_ptr + layout.GetHeapOffset());
 	auto heap_offset = heap_ptr - heap_handle.Ptr();
-	RowOperations::SwizzleHeapPointer(layout, data_ptr, heap_ptr, data_block.count, heap_offset);
+	RowOperations::SwizzleHeapPointer(layout, data_ptr, heap_ptr, data_block.count, NumericCast<idx_t>(heap_offset));
 }
 
 void RowDataCollectionScanner::ReSwizzle() {

package/src/duckdb/src/common/types/row/tuple_data_allocator.cpp

@@ -1,9 +1,9 @@
 #include "duckdb/common/types/row/tuple_data_allocator.hpp"
 
+#include "duckdb/common/fast_mem.hpp"
 #include "duckdb/common/types/row/tuple_data_segment.hpp"
 #include "duckdb/common/types/row/tuple_data_states.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/common/fast_mem.hpp"
 
 namespace duckdb {
 
@@ -140,22 +140,12 @@ TupleDataChunkPart TupleDataAllocator::BuildChunkPart(TupleDataPinState &pin_sta
 		}
 
 		if (total_heap_size == 0) {
-			// We don't need a heap at all
-			result.heap_block_index = TupleDataChunkPart::INVALID_INDEX;
-			result.heap_block_offset = TupleDataChunkPart::INVALID_INDEX;
-			result.total_heap_size = 0;
-			result.base_heap_ptr = nullptr;
+			result.SetHeapEmpty();
 		} else {
-			// Allocate heap block (if needed)
-			if (heap_blocks.empty() || heap_blocks.back().RemainingCapacity() < heap_sizes[append_offset]) {
-				const auto size = MaxValue<idx_t>((idx_t)Storage::BLOCK_SIZE, heap_sizes[append_offset]);
-				heap_blocks.emplace_back(buffer_manager, size);
-			}
-			result.heap_block_index = NumericCast<uint32_t>(heap_blocks.size() - 1);
-			auto &heap_block = heap_blocks[result.heap_block_index];
-			result.heap_block_offset = NumericCast<uint32_t>(heap_block.size);
+			const auto heap_remaining = MaxValue<idx_t>(heap_blocks.empty() ? (idx_t)Storage::BLOCK_SIZE
+			                                                                : heap_blocks.back().RemainingCapacity(),
+			                                            heap_sizes[append_offset]);
 
-			const auto heap_remaining = heap_block.RemainingCapacity();
 			if (total_heap_size <= heap_remaining) {
 				// Everything fits
 				result.total_heap_size = NumericCast<uint32_t>(total_heap_size);
@@ -172,9 +162,22 @@ TupleDataChunkPart TupleDataAllocator::BuildChunkPart(TupleDataPinState &pin_sta
 				}
 			}
 
-			// Mark this portion of the heap block as filled and set the pointer
-			heap_block.size += result.total_heap_size;
-			result.base_heap_ptr = GetBaseHeapPointer(pin_state, result);
+			if (result.total_heap_size == 0) {
+				result.SetHeapEmpty();
+			} else {
+				// Allocate heap block (if needed)
+				if (heap_blocks.empty() || heap_blocks.back().RemainingCapacity() < heap_sizes[append_offset]) {
+					const auto size = MaxValue<idx_t>((idx_t)Storage::BLOCK_SIZE, heap_sizes[append_offset]);
+					heap_blocks.emplace_back(buffer_manager, size);
+				}
+				result.heap_block_index = NumericCast<uint32_t>(heap_blocks.size() - 1);
+				auto &heap_block = heap_blocks[result.heap_block_index];
+				result.heap_block_offset = NumericCast<uint32_t>(heap_block.size);
+
+				// Mark this portion of the heap block as filled and set the pointer
+				heap_block.size += result.total_heap_size;
+				result.base_heap_ptr = GetBaseHeapPointer(pin_state, result);
+			}
 		}
 	}
 	D_ASSERT(result.count != 0 && result.count <= STANDARD_VECTOR_SIZE);