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

package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/serializer.hpp"
-#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/serializer/serialization_traits.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/string_type.hpp"
@@ -20,47 +20,79 @@
 namespace duckdb {
 
 class FormatSerializer {
-	friend Vector;
-
 protected:
 	bool serialize_enum_as_string = false;
+	bool serialize_default_values = false;
+
+public:
+	class List {
+		friend FormatSerializer;
+
+	private:
+		FormatSerializer &serializer;
+		explicit List(FormatSerializer &serializer) : serializer(serializer) {
+		}
+
+	public:
+		// Serialize an element
+		template <class T>
+		void WriteElement(const T &value);
+
+		// Serialize an object
+		template <class FUNC>
+		void WriteObject(FUNC f);
+	};
 
 public:
 	// Serialize a value
 	template <class T>
 	void WriteProperty(const field_id_t field_id, const char *tag, const T &value) {
-		SetTag(field_id, tag);
+		OnPropertyBegin(field_id, tag);
 		WriteValue(value);
+		OnPropertyEnd();
 	}
 
-	// Optional pointer
-	template <class POINTER>
-	void WriteOptionalProperty(const field_id_t field_id, const char *tag, POINTER &&ptr) {
-		SetTag(field_id, tag);
-		if (ptr == nullptr) {
-			OnOptionalBegin(false);
-			OnOptionalEnd(false);
-		} else {
-			OnOptionalBegin(true);
-			WriteValue(*ptr);
-			OnOptionalEnd(true);
+	// Default value
+	template <class T>
+	void WritePropertyWithDefault(const field_id_t field_id, const char *tag, const T &value, const T &&default_value) {
+		// If current value is default, don't write it
+		if (!serialize_default_values && (value == default_value)) {
+			OnOptionalPropertyBegin(field_id, tag, false);
+			OnOptionalPropertyEnd(false);
+			return;
 		}
+		OnOptionalPropertyBegin(field_id, tag, true);
+		WriteValue(value);
+		OnOptionalPropertyEnd(true);
 	}
 
 	// Special case: data_ptr_T
 	void WriteProperty(const field_id_t field_id, const char *tag, const_data_ptr_t ptr, idx_t count) {
-		SetTag(field_id, tag);
+		OnPropertyBegin(field_id, tag);
 		WriteDataPtr(ptr, count);
+		OnPropertyEnd();
 	}
 
-	// Manually begin an object - should be followed by EndObject
-	void BeginObject(const field_id_t field_id, const char *tag) {
-		SetTag(field_id, tag);
+	// Manually begin an object
+	template <class FUNC>
+	void WriteObject(const field_id_t field_id, const char *tag, FUNC f) {
+		OnPropertyBegin(field_id, tag);
 		OnObjectBegin();
+		f(*this);
+		OnObjectEnd();
+		OnPropertyEnd();
 	}
 
-	void EndObject() {
-		OnObjectEnd();
+	template <class FUNC>
+	void WriteList(const field_id_t field_id, const char *tag, idx_t count, FUNC func) {
+		OnPropertyBegin(field_id, tag);
+		OnListBegin(count);
+		List list {*this};
+		for (idx_t i = 0; i < count; i++) {
+			func(list, i);
+		}
+		OnListEnd();
+		OnPropertyEnd();
 	}
 
 protected:
@@ -82,27 +114,38 @@ protected:
 		WriteValue(ptr.get());
 	}
 
+	// Shared Pointer Ref
+	template <typename T>
+	void WriteValue(const shared_ptr<T> &ptr) {
+		WriteValue(ptr.get());
+	}
+
 	// Pointer
 	template <typename T>
-	typename std::enable_if<std::is_pointer<T>::value, void>::type WriteValue(const T ptr) {
+	void WriteValue(const T *ptr) {
 		if (ptr == nullptr) {
-			WriteNull();
+			OnNullableBegin(false);
+			OnNullableEnd();
 		} else {
+			OnNullableBegin(true);
 			WriteValue(*ptr);
+			OnNullableEnd();
 		}
 	}
 
 	// Pair
 	template <class K, class V>
 	void WriteValue(const std::pair<K, V> &pair) {
-		OnPairBegin();
-		OnPairKeyBegin();
-		WriteValue(pair.first);
-		OnPairKeyEnd();
-		OnPairValueBegin();
-		WriteValue(pair.second);
-		OnPairValueEnd();
-		OnPairEnd();
+		OnObjectBegin();
+		WriteProperty(0, "first", pair.first);
+		WriteProperty(1, "second", pair.second);
+		OnObjectEnd();
+	}
+
+	// Reference Wrapper
+	template <class T>
+	void WriteValue(const reference<T> ref) {
+		WriteValue(ref.get());
 	}
 
 	// Vector
@@ -113,7 +156,7 @@ protected:
 		for (auto &item : vec) {
 			WriteValue(item);
 		}
-		OnListEnd(count);
+		OnListEnd();
 	}
 
 	template <class T>
@@ -123,7 +166,7 @@ protected:
 		for (auto &item : vec) {
 			WriteValue(item);
 		}
-		OnListEnd(count);
+		OnListEnd();
 	}
 
 	// UnorderedSet
@@ -135,7 +178,7 @@ protected:
 		for (auto &item : set) {
 			WriteValue(item);
 		}
-		OnListEnd(count);
+		OnListEnd();
 	}
 
 	// Set
@@ -147,108 +190,65 @@ protected:
 		for (auto &item : set) {
 			WriteValue(item);
 		}
-		OnListEnd(count);
+		OnListEnd();
 	}
 
 	// Map
+	// serialized as a list of pairs
 	template <class K, class V, class HASH, class CMP>
 	void WriteValue(const duckdb::unordered_map<K, V, HASH, CMP> &map) {
 		auto count = map.size();
-		OnMapBegin(count);
+		OnListBegin(count);
 		for (auto &item : map) {
-			OnMapEntryBegin();
-			OnMapKeyBegin();
-			WriteValue(item.first);
-			OnMapKeyEnd();
-			OnMapValueBegin();
-			WriteValue(item.second);
-			OnMapValueEnd();
-			OnMapEntryEnd();
+			OnObjectBegin();
+			WriteProperty(0, "key", item.first);
+			WriteProperty(1, "value", item.second);
+			OnObjectEnd();
 		}
-		OnMapEnd(count);
+		OnListEnd();
 	}
 
 	// Map
+	// serialized as a list of pairs
 	template <class K, class V, class HASH, class CMP>
 	void WriteValue(const duckdb::map<K, V, HASH, CMP> &map) {
 		auto count = map.size();
-		OnMapBegin(count);
+		OnListBegin(count);
 		for (auto &item : map) {
-			OnMapEntryBegin();
-			OnMapKeyBegin();
-			WriteValue(item.first);
-			OnMapKeyEnd();
-			OnMapValueBegin();
-			WriteValue(item.second);
-			OnMapValueEnd();
-			OnMapEntryEnd();
+			OnObjectBegin();
+			WriteProperty(0, "key", item.first);
+			WriteProperty(1, "value", item.second);
+			OnObjectEnd();
 		}
-		OnMapEnd(count);
+		OnListEnd();
 	}
 
 	// class or struct implementing `FormatSerialize(FormatSerializer& FormatSerializer)`;
 	template <typename T>
 	typename std::enable_if<has_serialize<T>::value>::type WriteValue(const T &value) {
-		// Else, we defer to the .FormatSerialize method
 		OnObjectBegin();
 		value.FormatSerialize(*this);
 		OnObjectEnd();
 	}
 
-	// Handle setting a "tag" (optional)
-	virtual void SetTag(const field_id_t field_id, const char *tag) {
-		(void)field_id;
-		(void)tag;
-	}
-
+protected:
 	// Hooks for subclasses to override to implement custom behavior
-	virtual void OnListBegin(idx_t count) {
-		(void)count;
-	}
-	virtual void OnListEnd(idx_t count) {
-		(void)count;
-	}
-	virtual void OnMapBegin(idx_t count) {
-		(void)count;
-	}
-	virtual void OnMapEnd(idx_t count) {
-		(void)count;
-	}
-	virtual void OnMapEntryBegin() {
-	}
-	virtual void OnMapEntryEnd() {
-	}
-	virtual void OnMapKeyBegin() {
-	}
-	virtual void OnMapKeyEnd() {
-	}
-	virtual void OnMapValueBegin() {
-	}
-	virtual void OnMapValueEnd() {
-	}
-	virtual void OnOptionalBegin(bool present) {
-	}
-	virtual void OnOptionalEnd(bool present) {
-	}
-	virtual void OnObjectBegin() {
-	}
-	virtual void OnObjectEnd() {
-	}
-	virtual void OnPairBegin() {
-	}
-	virtual void OnPairKeyBegin() {
-	}
-	virtual void OnPairKeyEnd() {
-	}
-	virtual void OnPairValueBegin() {
-	}
-	virtual void OnPairValueEnd() {
-	}
-	virtual void OnPairEnd() {
-	}
+	virtual void OnPropertyBegin(const field_id_t field_id, const char *tag) = 0;
+	virtual void OnPropertyEnd() = 0;
+	virtual void OnOptionalPropertyBegin(const field_id_t field_id, const char *tag, bool present) = 0;
+	virtual void OnOptionalPropertyEnd(bool present) = 0;
+	virtual void OnObjectBegin() = 0;
+	virtual void OnObjectEnd() = 0;
+	virtual void OnListBegin(idx_t count) = 0;
+	virtual void OnListEnd() = 0;
+	virtual void OnNullableBegin(bool present) = 0;
+	virtual void OnNullableEnd() = 0;
 
 	// Handle primitive types, a serializer needs to implement these.
 	virtual void WriteNull() = 0;
+	virtual void WriteValue(char value) {
+		throw NotImplementedException("Write char value not implemented");
+	}
 	virtual void WriteValue(bool value) = 0;
 	virtual void WriteValue(uint8_t value) = 0;
 	virtual void WriteValue(int8_t value) = 0;
@@ -264,7 +264,6 @@ protected:
 	virtual void WriteValue(const string_t value) = 0;
 	virtual void WriteValue(const string &value) = 0;
 	virtual void WriteValue(const char *str) = 0;
-	virtual void WriteValue(interval_t value) = 0;
 	virtual void WriteDataPtr(const_data_ptr_t ptr, idx_t count) = 0;
 	void WriteValue(LogicalIndex value) {
 		WriteValue(value.index);
@@ -278,4 +277,17 @@ protected:
 template <>
 void FormatSerializer::WriteValue(const vector<bool> &vec);
 
+// List Impl
+template <class FUNC>
+void FormatSerializer::List::WriteObject(FUNC f) {
+	serializer.OnObjectBegin();
+	f(serializer);
+	serializer.OnObjectEnd();
+}
+
+template <class T>
+void FormatSerializer::List::WriteElement(const T &value) {
+	serializer.WriteValue(value);
+}
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp

@@ -12,7 +12,8 @@ namespace duckdb {
 class FormatSerializer;   // Forward declare
 class FormatDeserializer; // Forward declare
 
-typedef uint32_t field_id_t;
+typedef uint16_t field_id_t;
+const field_id_t MESSAGE_TERMINATOR_FIELD_ID = 0xFFFF;
 
 // Backport to c++11
 template <class...>

package/src/duckdb/src/include/duckdb/common/shared_ptr.hpp

@@ -1,3 +1,11 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/shared_ptr.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
 #pragma once
 
 #include <memory>

package/src/duckdb/src/include/duckdb/common/sort/partition_state.hpp

@@ -31,6 +31,7 @@ public:
 
 	GlobalSortStatePtr global_sort;
 	atomic<idx_t> count;
+	idx_t batch_base;
 
 	// Mask computation
 	SortLayout partition_layout;
@@ -59,9 +60,6 @@ public:
 	void UpdateLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append);
 	void CombineLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append);
 
-	void BuildSortState(TupleDataCollection &group_data, GlobalSortState &global_sort) const;
-	void BuildSortState(TupleDataCollection &group_data, PartitionGlobalHashGroup &global_sort);
-
 	ClientContext &context;
 	BufferManager &buffer_manager;
 	Allocator &allocator;
@@ -128,7 +126,7 @@ public:
 	void Combine();
 };
 
-enum class PartitionSortStage : uint8_t { INIT, PREPARE, MERGE, SORTED };
+enum class PartitionSortStage : uint8_t { INIT, SCAN, PREPARE, MERGE, SORTED };
 
 class PartitionLocalMergeState;
 
@@ -150,7 +148,11 @@ public:
 	PartitionGlobalSinkState &sink;
 	GroupDataPtr group_data;
 	PartitionGlobalHashGroup *hash_group;
+	vector<column_t> column_ids;
+	TupleDataParallelScanState chunk_state;
 	GlobalSortState *global_sort;
+	const idx_t memory_per_thread;
+	const idx_t num_threads;
 
 private:
 	mutable mutex lock;
@@ -162,15 +164,14 @@ private:
 
 class PartitionLocalMergeState {
 public:
-	PartitionLocalMergeState() : merge_state(nullptr), stage(PartitionSortStage::INIT) {
-		finished = true;
-	}
+	explicit PartitionLocalMergeState(PartitionGlobalSinkState &gstate);
 
 	bool TaskFinished() {
 		return finished;
 	}
 
 	void Prepare();
+	void Scan();
 	void Merge();
 
 	void ExecuteTask();
@@ -178,6 +179,11 @@ public:
 	PartitionGlobalMergeState *merge_state;
 	PartitionSortStage stage;
 	atomic<bool> finished;
+
+	//	Sorting buffers
+	ExpressionExecutor executor;
+	DataChunk sort_chunk;
+	DataChunk payload_chunk;
 };
 
 class PartitionGlobalMergeStates {

package/src/duckdb/src/include/duckdb/common/types/data_chunk.hpp

@@ -19,6 +19,8 @@ class Allocator;
 class ClientContext;
 class ExecutionContext;
 class VectorCache;
+class FormatSerializer;
+class FormatDeserializer;
 
 //!  A Data Chunk represents a set of vectors.
 /*!
@@ -141,6 +143,9 @@ public:
 	//! Deserializes a blob back into a DataChunk
 	DUCKDB_API void Deserialize(Deserializer &source);
 
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
+	DUCKDB_API void FormatDeserialize(FormatDeserializer &source);
+
 	//! Hashes the DataChunk to the target vector
 	DUCKDB_API void Hash(Vector &result);
 	//! Hashes specific vectors of the DataChunk to the target vector

package/src/duckdb/src/include/duckdb/common/types/hyperloglog.hpp

@@ -18,11 +18,14 @@ struct robj;
 
 namespace duckdb {
 
-enum class HLLStorageType { UNCOMPRESSED = 1 };
+enum class HLLStorageType : uint8_t { UNCOMPRESSED = 1 };
 
 class FieldWriter;
 class FieldReader;
 
+class FormatSerializer;
+class FormatDeserializer;
+
 //! The HyperLogLog class holds a HyperLogLog counter for approximate cardinality counting
 class HyperLogLog {
 public:
@@ -50,6 +53,9 @@ public:
 	void Serialize(FieldWriter &writer) const;
 	static unique_ptr<HyperLogLog> Deserialize(FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<HyperLogLog> FormatDeserialize(FormatDeserializer &deserializer);
+
 public:
 	//! Compute HLL hashes over vdata, and store them in 'hashes'
 	//! Then, compute register indices and prefix lengths, and also store them in 'hashes' as a pair of uint32_t

package/src/duckdb/src/include/duckdb/common/types/interval.hpp

@@ -16,6 +16,9 @@ struct dtime_t;
 struct date_t;
 struct timestamp_t;
 
+class FormatSerializer;
+class FormatDeserializer;
+
 struct interval_t {
 	int32_t months;
 	int32_t days;
@@ -24,6 +27,10 @@ struct interval_t {
 	inline bool operator==(const interval_t &rhs) const {
 		return this->days == rhs.days && this->months == rhs.months && this->micros == rhs.micros;
 	}
+
+	// Serialization
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static interval_t FormatDeserialize(FormatDeserializer &source);
 };
 
 //! The Interval class is a static class that holds helper functions for the Interval

package/src/duckdb/src/include/duckdb/common/types/row/partitioned_tuple_data.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/common/fixed_size_map.hpp"
 #include "duckdb/common/perfect_map_set.hpp"
 #include "duckdb/common/types/row/tuple_data_allocator.hpp"
 #include "duckdb/common/types/row/tuple_data_collection.hpp"
@@ -23,10 +24,11 @@ public:
 public:
 	Vector partition_indices;
 	SelectionVector partition_sel;
+	SelectionVector reverse_partition_sel;
 
-	static constexpr idx_t MAP_THRESHOLD = 32;
+	static constexpr idx_t MAP_THRESHOLD = 256;
 	perfect_map_t<list_entry_t> partition_entries;
-	list_entry_t partition_entries_arr[MAP_THRESHOLD];
+	fixed_size_map_t<list_entry_t> fixed_partition_entries;
 
 	vector<unique_ptr<TupleDataPinState>> partition_pin_states;
 	TupleDataChunkState chunk_state;
@@ -51,30 +53,48 @@ public:
 	virtual ~PartitionedTupleData();
 
 public:
+	//! Get the layout of this PartitionedTupleData
+	const TupleDataLayout &GetLayout() const;
 	//! Get the partitioning type of this PartitionedTupleData
 	PartitionedTupleDataType GetType() const;
 	//! Initializes a local state for parallel partitioning that can be merged into this PartitionedTupleData
 	void InitializeAppendState(PartitionedTupleDataAppendState &state,
 	                           TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE) const;
 	//! Appends a DataChunk to this PartitionedTupleData
-	void Append(PartitionedTupleDataAppendState &state, DataChunk &input);
+	void Append(PartitionedTupleDataAppendState &state, DataChunk &input,
+	            const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
+	            const idx_t append_count = DConstants::INVALID_INDEX);
+	//! Appends a DataChunk to this PartitionedTupleData
+	//! - ToUnifiedFormat has already been called
+	void AppendUnified(PartitionedTupleDataAppendState &state, DataChunk &input,
+	                   const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
+	                   const idx_t append_count = DConstants::INVALID_INDEX);
 	//! Appends rows to this PartitionedTupleData
-	void Append(PartitionedTupleDataAppendState &state, TupleDataChunkState &input, idx_t count);
+	void Append(PartitionedTupleDataAppendState &state, TupleDataChunkState &input, const idx_t count);
 	//! Flushes any remaining data in the append state into this PartitionedTupleData
 	void FlushAppendState(PartitionedTupleDataAppendState &state);
 	//! Combine another PartitionedTupleData into this PartitionedTupleData
 	void Combine(PartitionedTupleData &other);
-	//! Partition a TupleDataCollection
-	void Partition(TupleDataCollection &source,
-	               TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE);
+	//! Resets this PartitionedTupleData
+	void Reset();
 	//! Repartition this PartitionedTupleData into the new PartitionedTupleData
 	void Repartition(PartitionedTupleData &new_partitioned_data);
+	//! Unpins the data
+	void Unpin();
 	//! Get the partitions in this PartitionedTupleData
 	vector<unique_ptr<TupleDataCollection>> &GetPartitions();
+	//! Get the data of this PartitionedTupleData as a single unpartitioned TupleDataCollection
+	unique_ptr<TupleDataCollection> GetUnpartitioned();
 	//! Get the count of this PartitionedTupleData
 	idx_t Count() const;
 	//! Get the size (in bytes) of this PartitionedTupleData
 	idx_t SizeInBytes() const;
+	//! Get the number of partitions of this PartitionedTupleData
+	idx_t PartitionCount() const;
+	//! Converts this PartitionedTupleData to a string representation
+	string ToString();
+	//! Prints the string representation of this PartitionedTupleData
+	void Print();
 
 protected:
 	//===--------------------------------------------------------------------===//
@@ -91,7 +111,7 @@ protected:
 		throw NotImplementedException("ComputePartitionIndices for this type of PartitionedTupleData");
 	}
 	//! Compute partition indices from rows (similar to function above)
-	virtual void ComputePartitionIndices(Vector &row_locations, idx_t count, Vector &partition_indices) const {
+	virtual void ComputePartitionIndices(Vector &row_locations, idx_t append_count, Vector &partition_indices) const {
 		throw NotImplementedException("ComputePartitionIndices for this type of PartitionedTupleData");
 	}
 	//! Maximum partition index (optional)
@@ -116,11 +136,19 @@ protected:
 
 	//! Create a new shared allocator
 	void CreateAllocator();
+	//! Whether to use fixed size map or regular marp
+	bool UseFixedSizeMap() const;
 	//! Builds a selection vector in the Append state for the partitions
 	//! - returns true if everything belongs to the same partition - stores partition index in single_partition_idx
-	void BuildPartitionSel(PartitionedTupleDataAppendState &state, idx_t count);
+	void BuildPartitionSel(PartitionedTupleDataAppendState &state, const SelectionVector &append_sel,
+	                       const idx_t append_count);
+	template <class MAP_TYPE, class GETTER>
+	void BuildPartitionSel(PartitionedTupleDataAppendState &state, MAP_TYPE &partition_entries,
+	                       const SelectionVector &append_sel, const idx_t append_count);
 	//! Builds out the buffer space in the partitions
 	void BuildBufferSpace(PartitionedTupleDataAppendState &state);
+	template <class MAP_TYPE, class GETTER>
+	void BuildBufferSpace(PartitionedTupleDataAppendState &state, const MAP_TYPE &partition_entries);
 	//! Create a collection for a specific a partition
 	unique_ptr<TupleDataCollection> CreatePartitionCollection(idx_t partition_index) const {
 		if (allocators) {
@@ -129,11 +157,15 @@ protected:
 			return make_uniq<TupleDataCollection>(buffer_manager, layout);
 		}
 	}
+	//! Verify count/data size of this PartitionedTupleData
+	void Verify() const;
 
 protected:
 	PartitionedTupleDataType type;
 	BufferManager &buffer_manager;
 	const TupleDataLayout layout;
+	idx_t count;
+	idx_t data_size;
 
 	mutex lock;
 	shared_ptr<PartitionTupleDataAllocators> allocators;

package/src/duckdb/src/include/duckdb/common/types/row/row_data_collection_scanner.hpp

@@ -74,6 +74,11 @@ public:
 		return total_count - total_scanned;
 	}
 
+	//! The number of remaining rows
+	inline idx_t BlockIndex() const {
+		return read_state.block_idx;
+	}
+
 	//! Swizzle the blocks for external scanning
 	//! Swizzling is all or nothing, so if we have scanned previously,
 	//! we need to re-swizzle.