duckdb 0.8.2-dev161.0 → 0.8.2-dev1724.0

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

@@ -16,15 +16,6 @@ PartitionedTupleData::PartitionedTupleData(const PartitionedTupleData &other)
     : type(other.type), buffer_manager(other.buffer_manager), layout(other.layout.Copy()) {
 }
 
-unique_ptr<PartitionedTupleData> PartitionedTupleData::CreateShared() {
-	switch (type) {
-	case PartitionedTupleDataType::RADIX:
-		return make_uniq<RadixPartitionedTupleData>(Cast<RadixPartitionedTupleData>());
-	default:
-		throw NotImplementedException("CreateShared for this type of PartitionedTupleData");
-	}
-}
-
 PartitionedTupleData::~PartitionedTupleData() {
 }
 
@@ -233,6 +224,9 @@ void PartitionedTupleData::Combine(PartitionedTupleData &other) {
 }
 
 void PartitionedTupleData::Partition(TupleDataCollection &source, TupleDataPinProperties properties) {
+	if (source.Count() == 0) {
+		return;
+	}
 #ifdef DEBUG
 	const auto count_before = source.Count();
 #endif

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

@@ -220,6 +220,8 @@ void TupleDataCollection::AppendUnified(TupleDataPinState &pin_state, TupleDataC
 
 static inline void ToUnifiedFormatInternal(TupleDataVectorFormat &format, Vector &vector, const idx_t count) {
 	vector.ToUnifiedFormat(count, format.data);
+	format.original_sel = format.data.sel;
+	format.original_owned_sel.Initialize(format.data.owned_sel);
 	switch (vector.GetType().InternalType()) {
 	case PhysicalType::STRUCT: {
 		auto &entries = StructVector::GetEntries(vector);

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

@@ -296,7 +296,7 @@ static void ApplySliceRecursive(const Vector &source_v, TupleDataVectorFormat &s
 	D_ASSERT(source_format.combined_list_data);
 	auto &combined_list_data = *source_format.combined_list_data;
 
-	combined_list_data.selection_data = source_format.data.sel->Slice(combined_sel, count);
+	combined_list_data.selection_data = source_format.original_sel->Slice(combined_sel, count);
 	source_format.data.owned_sel.Initialize(combined_list_data.selection_data);
 	source_format.data.sel = &source_format.data.owned_sel;
 
@@ -376,8 +376,8 @@ void TupleDataCollection::ListWithinListComputeHeapSizes(Vector &heap_sizes_v, c
 	for (idx_t i = 0; i < child_list_child_count; i++) {
 		combined_sel.set_index(i, 0);
 	}
-	idx_t combined_list_offset = 0;
 
+	idx_t combined_list_offset = 0;
 	for (idx_t i = 0; i < append_count; i++) {
 		const auto list_idx = list_sel.get_index(append_sel.get_index(i));
 		if (!list_validity.RowIsValid(list_idx)) {

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

@@ -49,7 +49,7 @@ bool UUID::FromString(string str, hugeint_t &result) {
 		count++;
 	}
 	// Flip the first bit to make `order by uuid` same as `order by uuid::varchar`
-	result.upper ^= (int64_t(1) << 63);
+	result.upper ^= (uint64_t(1) << 63);
 	return count == 32;
 }
 
@@ -61,7 +61,7 @@ void UUID::ToString(hugeint_t input, char *buf) {
 	};
 
 	// Flip back before convert to string
-	int64_t upper = input.upper ^ (int64_t(1) << 63);
+	int64_t upper = input.upper ^ (uint64_t(1) << 63);
 	idx_t pos = 0;
 	byte_to_hex(upper >> 56 & 0xFF, buf, pos);
 	byte_to_hex(upper >> 48 & 0xFF, buf, pos);

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

@@ -96,6 +96,39 @@ void ValidityMask::SliceInPlace(const ValidityMask &other, idx_t target_offset,
 		memcpy(target_validity + target_offset_entries, source_validity + source_offset_entries,
 		       sizeof(validity_t) * EntryCount(count));
 		return;
+	} else if (IsAligned(target_offset)) {
+		//	Simple common case where we are shifting into an aligned mask (e.g., 0 in Slice above)
+		const idx_t entire_units = count / BITS_PER_VALUE;
+		const idx_t ragged = count % BITS_PER_VALUE;
+		const idx_t tail = source_offset % BITS_PER_VALUE;
+		const idx_t head = BITS_PER_VALUE - tail;
+		auto source_validity = other.GetData() + (source_offset / BITS_PER_VALUE);
+		auto target_validity = this->GetData() + (target_offset / BITS_PER_VALUE);
+		auto src_entry = *source_validity++;
+		for (idx_t i = 0; i < entire_units; ++i) {
+			//	Start with head of previous src
+			validity_t tgt_entry = src_entry >> tail;
+			src_entry = *source_validity++;
+			// 	Add in tail of current src
+			tgt_entry |= (src_entry << head);
+			*target_validity++ = tgt_entry;
+		}
+		//	Finish last ragged entry
+		if (ragged) {
+			//	Start with head of previous src
+			validity_t tgt_entry = (src_entry >> tail);
+			//  Add in the tail of the next src, if head was too small
+			if (head < ragged) {
+				src_entry = *source_validity++;
+				tgt_entry |= (src_entry << head);
+			}
+			//  Mask off the bits that go past the ragged end
+			tgt_entry &= (ValidityBuffer::MAX_ENTRY >> (BITS_PER_VALUE - ragged));
+			//	Restore the ragged end of the target
+			tgt_entry |= *target_validity & (ValidityBuffer::MAX_ENTRY << ragged);
+			*target_validity++ = tgt_entry;
+		}
+		return;
 	}
 
 	// FIXME: use bitwise operations here

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

@@ -678,7 +678,7 @@ Value Value::UNION(child_list_t<LogicalType> members, uint8_t tag, Value value)
 	result.is_null = false;
 	// add the tag to the front of the struct
 	vector<Value> union_values;
-	union_values.emplace_back(Value::TINYINT(tag));
+	union_values.emplace_back(Value::UTINYINT(tag));
 	for (idx_t i = 0; i < members.size(); i++) {
 		if (i != tag) {
 			union_values.emplace_back(members[i].second);
@@ -1465,20 +1465,25 @@ const vector<Value> &ListValue::GetChildren(const Value &value) {
 }
 
 const Value &UnionValue::GetValue(const Value &value) {
-	D_ASSERT(value.type() == LogicalTypeId::UNION);
+	D_ASSERT(value.type().id() == LogicalTypeId::UNION);
 	auto &children = StructValue::GetChildren(value);
-	auto tag = children[0].GetValueUnsafe<uint8_t>();
+	auto tag = children[0].GetValueUnsafe<union_tag_t>();
 	D_ASSERT(tag < children.size() - 1);
 	return children[tag + 1];
 }
 
-uint8_t UnionValue::GetTag(const Value &value) {
-	D_ASSERT(value.type() == LogicalTypeId::UNION);
+union_tag_t UnionValue::GetTag(const Value &value) {
+	D_ASSERT(value.type().id() == LogicalTypeId::UNION);
 	auto children = StructValue::GetChildren(value);
-	auto tag = children[0].GetValueUnsafe<uint8_t>();
+	auto tag = children[0].GetValueUnsafe<union_tag_t>();
+	D_ASSERT(tag < children.size() - 1);
 	return tag;
 }
 
+const LogicalType &UnionValue::GetType(const Value &value) {
+	return UnionType::GetMemberType(value.type(), UnionValue::GetTag(value));
+}
+
 hugeint_t IntegralValue::Get(const Value &value) {
 	switch (value.type().InternalType()) {
 	case PhysicalType::INT8: