duckdb 0.8.2-dev3458.0 → 0.8.2-dev3949.0

package/src/duckdb/src/common/radix_partitioning.cpp

@@ -26,9 +26,11 @@ public:
 };
 
 template <class OP, class RETURN_TYPE, typename... ARGS>
-RETURN_TYPE RadixBitsSwitch(idx_t radix_bits, ARGS &&... args) {
+RETURN_TYPE RadixBitsSwitch(idx_t radix_bits, ARGS &&...args) {
 	D_ASSERT(radix_bits <= RadixPartitioning::MAX_RADIX_BITS);
 	switch (radix_bits) {
+	case 0:
+		return OP::template Operation<0>(std::forward<ARGS>(args)...);
 	case 1:
 		return OP::template Operation<1>(std::forward<ARGS>(args)...);
 	case 2:
@@ -82,36 +84,6 @@ idx_t RadixPartitioning::Select(Vector &hashes, const SelectionVector *sel, idx_
 	return RadixBitsSwitch<SelectFunctor, idx_t>(radix_bits, hashes, sel, count, cutoff, true_sel, false_sel);
 }
 
-struct HashsToBinsFunctor {
-	template <idx_t radix_bits>
-	static void Operation(Vector &hashes, Vector &bins, idx_t count) {
-		using CONSTANTS = RadixPartitioningConstants<radix_bits>;
-		UnaryExecutor::Execute<hash_t, hash_t>(hashes, bins, count,
-		                                       [&](hash_t hash) { return CONSTANTS::ApplyMask(hash); });
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Row Data Partitioning
-//===--------------------------------------------------------------------===//
-template <idx_t radix_bits>
-static void InitPartitions(BufferManager &buffer_manager, vector<unique_ptr<RowDataCollection>> &partition_collections,
-                           RowDataBlock *partition_blocks[], vector<BufferHandle> &partition_handles,
-                           data_ptr_t partition_ptrs[], idx_t block_capacity, idx_t row_width) {
-	using CONSTANTS = RadixPartitioningConstants<radix_bits>;
-
-	partition_collections.reserve(CONSTANTS::NUM_PARTITIONS);
-	partition_handles.reserve(CONSTANTS::NUM_PARTITIONS);
-	for (idx_t i = 0; i < CONSTANTS::NUM_PARTITIONS; i++) {
-		partition_collections.push_back(make_uniq<RowDataCollection>(buffer_manager, block_capacity, row_width));
-		partition_blocks[i] = &partition_collections[i]->CreateBlock();
-		partition_handles.push_back(buffer_manager.Pin(partition_blocks[i]->block));
-		if (partition_ptrs) {
-			partition_ptrs[i] = partition_handles[i].Ptr();
-		}
-	}
-}
-
 struct ComputePartitionIndicesFunctor {
 	template <idx_t radix_bits>
 	static void Operation(Vector &hashes, Vector &partition_indices, idx_t count) {
@@ -129,6 +101,7 @@ RadixPartitionedColumnData::RadixPartitionedColumnData(ClientContext &context_p,
                                                        idx_t radix_bits_p, idx_t hash_col_idx_p)
     : PartitionedColumnData(PartitionedColumnDataType::RADIX, context_p, std::move(types_p)), radix_bits(radix_bits_p),
       hash_col_idx(hash_col_idx_p) {
+	D_ASSERT(radix_bits <= RadixPartitioning::MAX_RADIX_BITS);
 	D_ASSERT(hash_col_idx < types.size());
 	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
 	allocators->allocators.reserve(num_partitions);
@@ -173,6 +146,7 @@ RadixPartitionedTupleData::RadixPartitionedTupleData(BufferManager &buffer_manag
                                                      idx_t radix_bits_p, idx_t hash_col_idx_p)
     : PartitionedTupleData(PartitionedTupleDataType::RADIX, buffer_manager, layout_p.Copy()), radix_bits(radix_bits_p),
       hash_col_idx(hash_col_idx_p) {
+	D_ASSERT(radix_bits <= RadixPartitioning::MAX_RADIX_BITS);
 	D_ASSERT(hash_col_idx < layout.GetTypes().size());
 	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
 	allocators->allocators.reserve(num_partitions);
@@ -215,6 +189,9 @@ void RadixPartitionedTupleData::InitializeAppendStateInternal(PartitionedTupleDa
 		column_ids.emplace_back(col_idx);
 	}
 	partitions[0]->InitializeAppend(state.chunk_state, std::move(column_ids));
+
+	// Initialize fixed-size map
+	state.fixed_partition_entries.resize(RadixPartitioning::NumberOfPartitions(radix_bits));
 }
 
 void RadixPartitionedTupleData::ComputePartitionIndices(PartitionedTupleDataAppendState &state, DataChunk &input) {

package/src/duckdb/src/common/row_operations/row_aggregate.cpp

@@ -76,6 +76,10 @@ void RowOperations::CombineStates(RowOperationsState &state, TupleDataLayout &la
 	//	Move to the first aggregate states
 	VectorOperations::AddInPlace(sources, layout.GetAggrOffset(), count);
 	VectorOperations::AddInPlace(targets, layout.GetAggrOffset(), count);
+
+	// Keep track of the offset
+	idx_t offset = layout.GetAggrOffset();
+
 	for (auto &aggr : layout.GetAggregates()) {
 		D_ASSERT(aggr.function.combine);
 		AggregateInputData aggr_input_data(aggr.GetFunctionData(), state.allocator);
@@ -84,23 +88,34 @@ void RowOperations::CombineStates(RowOperationsState &state, TupleDataLayout &la
 		// Move to the next aggregate states
 		VectorOperations::AddInPlace(sources, aggr.payload_size, count);
 		VectorOperations::AddInPlace(targets, aggr.payload_size, count);
+
+		// Increment the offset
+		offset += aggr.payload_size;
 	}
+
+	// Now subtract the offset to get back to the original position
+	VectorOperations::AddInPlace(sources, -offset, count);
+	VectorOperations::AddInPlace(targets, -offset, count);
 }
 
 void RowOperations::FinalizeStates(RowOperationsState &state, TupleDataLayout &layout, Vector &addresses,
                                    DataChunk &result, idx_t aggr_idx) {
+	// Copy the addresses
+	Vector addresses_copy(LogicalType::POINTER);
+	VectorOperations::Copy(addresses, addresses_copy, result.size(), 0, 0);
+
 	//	Move to the first aggregate state
-	VectorOperations::AddInPlace(addresses, layout.GetAggrOffset(), result.size());
+	VectorOperations::AddInPlace(addresses_copy, layout.GetAggrOffset(), result.size());
 
 	auto &aggregates = layout.GetAggregates();
 	for (idx_t i = 0; i < aggregates.size(); i++) {
 		auto &target = result.data[aggr_idx + i];
 		auto &aggr = aggregates[i];
 		AggregateInputData aggr_input_data(aggr.GetFunctionData(), state.allocator);
-		aggr.function.finalize(addresses, aggr_input_data, target, result.size(), 0);
+		aggr.function.finalize(addresses_copy, aggr_input_data, target, result.size(), 0);
 
 		// Move to the next aggregate state
-		VectorOperations::AddInPlace(addresses, aggr.payload_size, result.size());
+		VectorOperations::AddInPlace(addresses_copy, aggr.payload_size, result.size());
 	}
 }
 

package/src/duckdb/src/common/serializer/binary_deserializer.cpp

@@ -2,147 +2,132 @@
 
 namespace duckdb {
 
-void BinaryDeserializer::SetTag(const field_id_t field_id, const char *tag) {
-	current_field_id = field_id;
-	current_tag = tag;
-	stack.back().read_field_count++;
-	if (stack.back().read_field_count > stack.back().expected_field_count) {
-		throw SerializationException("Attempting to read a required field, but field is missing");
+//-------------------------------------------------------------------------
+// Nested Type Hooks
+//-------------------------------------------------------------------------
+void BinaryDeserializer::OnPropertyBegin(const field_id_t field_id, const char *) {
+	auto field = NextField();
+	if (field != field_id) {
+		throw InternalException("Failed to deserialize: field id mismatch, expected: %d, got: %d", field_id, field);
 	}
 }
 
-//===--------------------------------------------------------------------===//
-// Nested Types Hooks
-//===--------------------------------------------------------------------===//
-void BinaryDeserializer::OnObjectBegin() {
-	auto expected_field_id = ReadPrimitive<field_id_t>();
-	auto expected_field_count = ReadPrimitive<uint32_t>();
-	auto expected_size = ReadPrimitive<uint64_t>();
-	D_ASSERT(expected_field_count > 0);
-	D_ASSERT(expected_size > 0);
-	D_ASSERT(expected_field_id == current_field_id);
-	stack.emplace_back(expected_field_count, expected_size, expected_field_id);
+void BinaryDeserializer::OnPropertyEnd() {
 }
 
-void BinaryDeserializer::OnObjectEnd() {
-	auto &frame = stack.back();
-	if (frame.read_field_count < frame.expected_field_count) {
-		throw SerializationException("Not all fields were read. This file might have been written with a newer version "
-		                             "of DuckDB and is incompatible with this version of DuckDB.");
+bool BinaryDeserializer::OnOptionalPropertyBegin(const field_id_t field_id, const char *s) {
+	auto next_field = PeekField();
+	auto present = next_field == field_id;
+	if (present) {
+		ConsumeField();
 	}
-	stack.pop_back();
-}
-
-idx_t BinaryDeserializer::OnListBegin() {
-	return ReadPrimitive<idx_t>();
-}
-
-void BinaryDeserializer::OnListEnd() {
-}
-
-// Deserialize maps as [ { key: ..., value: ... } ]
-idx_t BinaryDeserializer::OnMapBegin() {
-	return ReadPrimitive<idx_t>();
-}
-
-void BinaryDeserializer::OnMapEntryBegin() {
-}
-
-void BinaryDeserializer::OnMapKeyBegin() {
-}
-
-void BinaryDeserializer::OnMapValueBegin() {
+	return present;
 }
 
-void BinaryDeserializer::OnMapEntryEnd() {
+void BinaryDeserializer::OnOptionalPropertyEnd(bool present) {
 }
 
-void BinaryDeserializer::OnMapEnd() {
+void BinaryDeserializer::OnObjectBegin() {
+	nesting_level++;
 }
 
-void BinaryDeserializer::OnPairBegin() {
+void BinaryDeserializer::OnObjectEnd() {
+	auto next_field = NextField();
+	if (next_field != MESSAGE_TERMINATOR_FIELD_ID) {
+		throw InternalException("Failed to deserialize: expected end of object, but found field id: %d", next_field);
+	}
+	nesting_level--;
 }
 
-void BinaryDeserializer::OnPairKeyBegin() {
+idx_t BinaryDeserializer::OnListBegin() {
+	return VarIntDecode<idx_t>();
 }
 
-void BinaryDeserializer::OnPairValueBegin() {
+void BinaryDeserializer::OnListEnd() {
 }
 
-void BinaryDeserializer::OnPairEnd() {
+bool BinaryDeserializer::OnNullableBegin() {
+	return ReadBool();
 }
 
-bool BinaryDeserializer::OnOptionalBegin() {
-	return ReadPrimitive<bool>();
+void BinaryDeserializer::OnNullableEnd() {
 }
 
-//===--------------------------------------------------------------------===//
+//-------------------------------------------------------------------------
 // Primitive Types
-//===--------------------------------------------------------------------===//
+//-------------------------------------------------------------------------
 bool BinaryDeserializer::ReadBool() {
-	return ReadPrimitive<bool>();
+	return static_cast<bool>(ReadPrimitive<uint8_t>());
+}
+
+char BinaryDeserializer::ReadChar() {
+	return ReadPrimitive<char>();
 }
 
 int8_t BinaryDeserializer::ReadSignedInt8() {
-	return ReadPrimitive<int8_t>();
+	return VarIntDecode<int8_t>();
 }
 
 uint8_t BinaryDeserializer::ReadUnsignedInt8() {
-	return ReadPrimitive<uint8_t>();
+	return VarIntDecode<uint8_t>();
 }
 
 int16_t BinaryDeserializer::ReadSignedInt16() {
-	return ReadPrimitive<int16_t>();
+	return VarIntDecode<int16_t>();
 }
 
 uint16_t BinaryDeserializer::ReadUnsignedInt16() {
-	return ReadPrimitive<uint16_t>();
+	return VarIntDecode<uint16_t>();
 }
 
 int32_t BinaryDeserializer::ReadSignedInt32() {
-	return ReadPrimitive<int32_t>();
+	return VarIntDecode<int32_t>();
 }
 
 uint32_t BinaryDeserializer::ReadUnsignedInt32() {
-	return ReadPrimitive<uint32_t>();
+	return VarIntDecode<uint32_t>();
 }
 
 int64_t BinaryDeserializer::ReadSignedInt64() {
-	return ReadPrimitive<int64_t>();
+	return VarIntDecode<int64_t>();
 }
 
 uint64_t BinaryDeserializer::ReadUnsignedInt64() {
-	return ReadPrimitive<uint64_t>();
+	return VarIntDecode<uint64_t>();
 }
 
 float BinaryDeserializer::ReadFloat() {
-	return ReadPrimitive<float>();
+	auto value = ReadPrimitive<float>();
+	return value;
 }
 
 double BinaryDeserializer::ReadDouble() {
-	return ReadPrimitive<double>();
+	auto value = ReadPrimitive<double>();
+	return value;
 }
 
 string BinaryDeserializer::ReadString() {
-	uint32_t size = ReadPrimitive<uint32_t>();
-	if (size == 0) {
+	auto len = VarIntDecode<uint32_t>();
+	if (len == 0) {
 		return string();
 	}
-	auto buffer = make_unsafe_uniq_array<data_t>(size);
-	ReadData(buffer.get(), size);
-	return string(const_char_ptr_cast(buffer.get()), size);
-}
-
-interval_t BinaryDeserializer::ReadInterval() {
-	return ReadPrimitive<interval_t>();
+	auto buffer = make_unsafe_uniq_array<data_t>(len);
+	ReadData(buffer.get(), len);
+	return string(const_char_ptr_cast(buffer.get()), len);
 }
 
 hugeint_t BinaryDeserializer::ReadHugeInt() {
-	return ReadPrimitive<hugeint_t>();
+	auto upper = VarIntDecode<int64_t>();
+	auto lower = VarIntDecode<uint64_t>();
+	return hugeint_t(upper, lower);
 }
 
-void BinaryDeserializer::ReadDataPtr(data_ptr_t &ptr, idx_t count) {
-	ReadData(ptr, count);
+void BinaryDeserializer::ReadDataPtr(data_ptr_t &ptr_p, idx_t count) {
+	auto len = VarIntDecode<uint64_t>();
+	if (len != count) {
+		throw SerializationException("Tried to read blob of %d size, but only %d elements are available", count, len);
+	}
+	ReadData(ptr_p, count);
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/serializer/binary_serializer.cpp

@@ -1,121 +1,134 @@
 #include "duckdb/common/serializer/binary_serializer.hpp"
 
-namespace duckdb {
-
-void BinarySerializer::SetTag(const field_id_t field_id, const char *tag) {
-	current_field_id = field_id;
-	current_tag = tag;
-	// Increment the number of fields
-	stack.back().field_count++;
-}
-
-//===--------------------------------------------------------------------===//
-// Nested types
-//===--------------------------------------------------------------------===//
-void BinarySerializer::OnOptionalBegin(bool present) {
-	Write(present);
-}
-
-void BinarySerializer::OnListBegin(idx_t count) {
-	Write(count);
-}
-
-void BinarySerializer::OnListEnd(idx_t count) {
-}
+#ifdef DEBUG
+#include "duckdb/common/string_util.hpp"
+#endif
 
-// Serialize maps as arrays of objects with "key" and "value" properties.
-void BinarySerializer::OnMapBegin(idx_t count) {
-	Write(count);
-}
+namespace duckdb {
 
-void BinarySerializer::OnMapEntryBegin() {
-}
+void BinarySerializer::OnPropertyBegin(const field_id_t field_id, const char *tag) {
+	// Just write the field id straight up
+	Write<field_id_t>(field_id);
+#ifdef DEBUG
+	// Check that the tag is unique
+	auto &state = debug_stack.back();
+	auto &seen_field_ids = state.seen_field_ids;
+	auto &seen_field_tags = state.seen_field_tags;
+	auto &seen_fields = state.seen_fields;
+
+	if (seen_field_ids.find(field_id) != seen_field_ids.end() || seen_field_tags.find(tag) != seen_field_tags.end()) {
+		string all_fields;
+		for (auto &field : seen_fields) {
+			all_fields += StringUtil::Format("\"%s\":%d ", field.first, field.second);
+		}
+		throw InternalException("Duplicate field id/tag in field: \"%s\":%d, other fields: %s", tag, field_id,
+		                        all_fields);
+	}
 
-void BinarySerializer::OnMapKeyBegin() {
+	seen_field_ids.insert(field_id);
+	seen_field_tags.insert(tag);
+	seen_fields.emplace_back(tag, field_id);
+#else
+	(void)tag;
+#endif
 }
 
-void BinarySerializer::OnMapValueBegin() {
+void BinarySerializer::OnPropertyEnd() {
+	// Nothing to do here
 }
 
-void BinarySerializer::OnMapEntryEnd() {
+void BinarySerializer::OnOptionalPropertyBegin(const field_id_t field_id, const char *tag, bool present) {
+	// Dont write anything at all if the property is not present
+	if (present) {
+		OnPropertyBegin(field_id, tag);
+	}
 }
 
-void BinarySerializer::OnMapEnd(idx_t count) {
+void BinarySerializer::OnOptionalPropertyEnd(bool present) {
+	// Nothing to do here
 }
 
+//-------------------------------------------------------------------------
+// Nested Type Hooks
+//-------------------------------------------------------------------------
 void BinarySerializer::OnObjectBegin() {
-	stack.push_back(State({0, 0, data.size()}));
-	// Store the field id
-	Write<field_id_t>(current_field_id);
-	// Store the offset so we can patch the field count and size later
-	Write<uint32_t>(0); // Placeholder for the field count
-	Write<uint64_t>(0); // Placeholder for the size
+#ifdef DEBUG
+	debug_stack.emplace_back();
+#endif
 }
 
 void BinarySerializer::OnObjectEnd() {
-	auto &frame = stack.back();
-	// Patch the field count and size
-	auto ptr = &data[frame.offset];
-	ptr += sizeof(field_id_t); // Skip the field id
-	Store<uint32_t>(frame.field_count, ptr);
-	ptr += sizeof(uint32_t); // Skip the field count
-	Store<uint64_t>(frame.size, ptr);
-	stack.pop_back();
+#ifdef DEBUG
+	debug_stack.pop_back();
+#endif
+	// Write object terminator
+	Write<field_id_t>(MESSAGE_TERMINATOR_FIELD_ID);
 }
 
-void BinarySerializer::OnPairBegin() {
+void BinarySerializer::OnListBegin(idx_t count) {
+	VarIntEncode(count);
 }
 
-void BinarySerializer::OnPairKeyBegin() {
+void BinarySerializer::OnListEnd() {
 }
 
-void BinarySerializer::OnPairValueBegin() {
+void BinarySerializer::OnNullableBegin(bool present) {
+	WriteValue(present);
 }
 
-void BinarySerializer::OnPairEnd() {
+void BinarySerializer::OnNullableEnd() {
 }
 
-//===--------------------------------------------------------------------===//
-// Primitive types
-//===--------------------------------------------------------------------===//
+//-------------------------------------------------------------------------
+// Primitive Types
+//-------------------------------------------------------------------------
 void BinarySerializer::WriteNull() {
 	// This should never be called, optional writes should be handled by OnOptionalBegin
 }
 
+void BinarySerializer::WriteValue(bool value) {
+	Write<uint8_t>(value);
+}
+
 void BinarySerializer::WriteValue(uint8_t value) {
+	VarIntEncode(value);
+}
+
+void BinarySerializer::WriteValue(char value) {
 	Write(value);
 }
 
 void BinarySerializer::WriteValue(int8_t value) {
-	Write(value);
+	VarIntEncode(value);
 }
 
 void BinarySerializer::WriteValue(uint16_t value) {
-	Write(value);
+	VarIntEncode(value);
 }
 
 void BinarySerializer::WriteValue(int16_t value) {
-	Write(value);
+	VarIntEncode(value);
 }
 
 void BinarySerializer::WriteValue(uint32_t value) {
-	Write(value);
+	VarIntEncode(value);
 }
 
 void BinarySerializer::WriteValue(int32_t value) {
-	Write(value);
+	VarIntEncode(value);
 }
 
 void BinarySerializer::WriteValue(uint64_t value) {
-	Write(value);
+	VarIntEncode(value);
 }
 
 void BinarySerializer::WriteValue(int64_t value) {
-	Write(value);
+	VarIntEncode(value);
 }
 
 void BinarySerializer::WriteValue(hugeint_t value) {
-	Write(value);
+	VarIntEncode(value.upper);
+	VarIntEncode(value.lower);
 }
 
 void BinarySerializer::WriteValue(float value) {
@@ -126,39 +139,26 @@ void BinarySerializer::WriteValue(double value) {
 	Write(value);
 }
 
-void BinarySerializer::WriteValue(interval_t value) {
-	Write(value);
-}
-
 void BinarySerializer::WriteValue(const string &value) {
-	auto len = value.length();
-	Write<uint32_t>((uint32_t)len);
-	if (len > 0) {
-		WriteDataInternal(value.c_str(), len);
-	}
+	uint32_t len = value.length();
+	VarIntEncode(len);
+	WriteDataInternal(value.c_str(), len);
 }
 
 void BinarySerializer::WriteValue(const string_t value) {
-	auto len = value.GetSize();
-	Write<uint32_t>((uint32_t)len);
-	if (len > 0) {
-		WriteDataInternal(value.GetDataUnsafe(), len);
-	}
+	uint32_t len = value.GetSize();
+	VarIntEncode(len);
+	WriteDataInternal(value.GetDataUnsafe(), len);
 }
 
 void BinarySerializer::WriteValue(const char *value) {
-	auto len = strlen(value);
-	Write<uint32_t>((uint32_t)len);
-	if (len > 0) {
-		WriteDataInternal(value, len);
-	}
-}
-
-void BinarySerializer::WriteValue(bool value) {
-	Write(value);
+	uint32_t len = strlen(value);
+	VarIntEncode(len);
+	WriteDataInternal(value, len);
 }
 
 void BinarySerializer::WriteDataPtr(const_data_ptr_t ptr, idx_t count) {
+	VarIntEncode(static_cast<uint64_t>(count));
 	WriteDataInternal(ptr, count);
 }
 

package/src/duckdb/src/common/serializer/format_serializer.cpp

@@ -9,7 +9,7 @@ void FormatSerializer::WriteValue(const vector<bool> &vec) {
 	for (auto item : vec) {
 		WriteValue(item);
 	}
-	OnListEnd(count);
+	OnListEnd();
 }
 
 } // namespace duckdb