duckdb 0.4.1-dev787.0 → 0.4.1-dev790.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.4.1-dev787.0",
+  "version": "0.4.1-dev790.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -33160,6 +33160,8 @@ static inline int FastMemcmp(const void *str1, const void *str2, const size_t si
 
 
 
+
+
 namespace duckdb {
 
 class BufferManager;
@@ -33318,6 +33320,84 @@ private:
 	const bool flush;
 };
 
+struct SBIterator {
+	static int ComparisonValue(ExpressionType comparison);
+
+	SBIterator(GlobalSortState &gss, ExpressionType comparison, idx_t entry_idx_p = 0);
+
+	inline idx_t GetIndex() const {
+		return entry_idx;
+	}
+
+	inline void SetIndex(idx_t entry_idx_p) {
+		const auto new_block_idx = entry_idx_p / block_capacity;
+		if (new_block_idx != scan.block_idx) {
+			scan.SetIndices(new_block_idx, 0);
+			if (new_block_idx < block_count) {
+				scan.PinRadix(scan.block_idx);
+				block_ptr = scan.RadixPtr();
+				if (!all_constant) {
+					scan.PinData(*scan.sb->blob_sorting_data);
+				}
+			}
+		}
+
+		scan.entry_idx = entry_idx_p % block_capacity;
+		entry_ptr = block_ptr + scan.entry_idx * entry_size;
+		entry_idx = entry_idx_p;
+	}
+
+	inline SBIterator &operator++() {
+		if (++scan.entry_idx < block_capacity) {
+			entry_ptr += entry_size;
+			++entry_idx;
+		} else {
+			SetIndex(entry_idx + 1);
+		}
+
+		return *this;
+	}
+
+	inline SBIterator &operator--() {
+		if (scan.entry_idx) {
+			--scan.entry_idx;
+			--entry_idx;
+			entry_ptr -= entry_size;
+		} else {
+			SetIndex(entry_idx - 1);
+		}
+
+		return *this;
+	}
+
+	inline bool Compare(const SBIterator &other) const {
+		int comp_res;
+		if (all_constant) {
+			comp_res = FastMemcmp(entry_ptr, other.entry_ptr, cmp_size);
+		} else {
+			comp_res = Comparators::CompareTuple(scan, other.scan, entry_ptr, other.entry_ptr, sort_layout, external);
+		}
+
+		return comp_res <= cmp;
+	}
+
+	// Fixed comparison parameters
+	const SortLayout &sort_layout;
+	const idx_t block_count;
+	const idx_t block_capacity;
+	const size_t cmp_size;
+	const size_t entry_size;
+	const bool all_constant;
+	const bool external;
+	const int cmp;
+
+	// Iteration state
+	SBScanState scan;
+	idx_t entry_idx;
+	data_ptr_t block_ptr;
+	data_ptr_t entry_ptr;
+};
+
 } // namespace duckdb
 
 
@@ -35661,6 +35741,30 @@ void PayloadScanner::Scan(DataChunk &chunk) {
 	total_scanned += scanned;
 }
 
+int SBIterator::ComparisonValue(ExpressionType comparison) {
+	switch (comparison) {
+	case ExpressionType::COMPARE_LESSTHAN:
+	case ExpressionType::COMPARE_GREATERTHAN:
+		return -1;
+	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+		return 0;
+	default:
+		throw InternalException("Unimplemented comparison type for IEJoin!");
+	}
+}
+
+SBIterator::SBIterator(GlobalSortState &gss, ExpressionType comparison, idx_t entry_idx_p)
+    : sort_layout(gss.sort_layout), block_count(gss.sorted_blocks[0]->radix_sorting_data.size()),
+      block_capacity(gss.block_capacity), cmp_size(sort_layout.comparison_size), entry_size(sort_layout.entry_size),
+      all_constant(sort_layout.all_constant), external(gss.external), cmp(ComparisonValue(comparison)),
+      scan(gss.buffer_manager, gss), block_ptr(nullptr), entry_ptr(nullptr) {
+
+	scan.sb = gss.sorted_blocks[0].get();
+	scan.block_idx = block_count;
+	SetIndex(entry_idx_p);
+}
+
 } // namespace duckdb
 
 
@@ -60152,9 +60256,9 @@ public:
 	using Orders = vector<BoundOrderByNode>;
 	using Types = vector<LogicalType>;
 
-	WindowGlobalHashGroup(BufferManager &buffer_manager, const Orders &orders, const Types &payload_types,
-	                      idx_t max_mem, bool external)
-	    : memory_per_thread(max_mem), count(0) {
+	WindowGlobalHashGroup(BufferManager &buffer_manager, const Orders &partitions, const Orders &orders,
+	                      const Types &payload_types, idx_t max_mem, bool external)
+	    : memory_per_thread(max_mem), count(0), partition_layout(partitions) {
 
 		RowLayout payload_layout;
 		payload_layout.Initialize(payload_types);
@@ -60170,11 +60274,47 @@ public:
 		global_sort->PrepareMergePhase();
 	}
 
+	void ComputeMasks(ValidityMask &partition_mask, ValidityMask &order_mask);
+
 	const idx_t memory_per_thread;
 	GlobalSortStatePtr global_sort;
 	atomic<idx_t> count;
+
+	// Mask computation
+	SortLayout partition_layout;
 };
 
+void WindowGlobalHashGroup::ComputeMasks(ValidityMask &partition_mask, ValidityMask &order_mask) {
+	D_ASSERT(count > 0);
+
+	//	Set up a comparator for the partition subset
+	const auto partition_size = partition_layout.comparison_size;
+
+	SBIterator prev(*global_sort, ExpressionType::COMPARE_LESSTHAN);
+	SBIterator curr(*global_sort, ExpressionType::COMPARE_LESSTHAN);
+
+	partition_mask.SetValidUnsafe(0);
+	order_mask.SetValidUnsafe(0);
+	for (++curr; curr.GetIndex() < count; ++curr) {
+		//	Compare the partition subset first because if that differs, then so does the full ordering
+		int part_cmp = 0;
+		if (partition_layout.all_constant) {
+			part_cmp = FastMemcmp(prev.entry_ptr, curr.entry_ptr, partition_size);
+		} else {
+			part_cmp = Comparators::CompareTuple(prev.scan, curr.scan, prev.entry_ptr, curr.entry_ptr, partition_layout,
+			                                     prev.external);
+		}
+
+		if (part_cmp) {
+			partition_mask.SetValidUnsafe(curr.GetIndex());
+			order_mask.SetValidUnsafe(curr.GetIndex());
+		} else if (prev.Compare(curr)) {
+			order_mask.SetValidUnsafe(curr.GetIndex());
+		}
+		++prev;
+	}
+}
+
 //	Global sink state
 class WindowGlobalSinkState : public GlobalSinkState {
 public:
@@ -60204,6 +60344,7 @@ public:
 				orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, pexpr->Copy(),
 				                    wexpr->partitions_stats[prt_idx]->Copy());
 			}
+			partitions.emplace_back(orders.back().Copy());
 		}
 
 		for (const auto &order : wexpr->orders) {
@@ -60220,8 +60361,8 @@ public:
 		lock_guard<mutex> guard(lock);
 
 		if (!ungrouped) {
-			ungrouped =
-			    make_unique<WindowGlobalHashGroup>(buffer_manager, orders, payload_types, memory_per_thread, external);
+			ungrouped = make_unique<WindowGlobalHashGroup>(buffer_manager, partitions, orders, payload_types,
+			                                               memory_per_thread, external);
 		}
 
 		return ungrouped.get();
@@ -60249,7 +60390,8 @@ public:
 		auto &hash_group = hash_groups[group];
 		if (!hash_group) {
 			const auto maxmem = memory_per_thread / partition_info.n_partitions;
-			hash_group = make_unique<WindowGlobalHashGroup>(buffer_manager, orders, payload_types, maxmem, external);
+			hash_group =
+			    make_unique<WindowGlobalHashGroup>(buffer_manager, partitions, orders, payload_types, maxmem, external);
 		}
 
 		return hash_group.get();
@@ -60276,6 +60418,7 @@ public:
 	mutex lock;
 
 	// Sorting
+	Orders partitions;
 	Orders orders;
 	Types payload_types;
 	HashGroupPtr ungrouped;
@@ -60676,7 +60819,7 @@ void WindowGlobalSinkState::Finalize() {
 		global_sort.InitializeMergeRound();
 		MergeSorter merge_sorter(global_sort, global_sort.buffer_manager);
 		merge_sorter.PerformInMergeRound();
-		global_sort.CompleteMergeRound();
+		global_sort.CompleteMergeRound(true);
 	}
 
 	// 	Sink it into a temporary local sink state
@@ -60719,120 +60862,6 @@ PhysicalWindow::PhysicalWindow(vector<LogicalType> types, vector<unique_ptr<Expr
     : PhysicalOperator(type, move(types), estimated_cardinality), select_list(move(select_list)) {
 }
 
-struct MaskColumnOperator {
-	template <class INPUT_TYPE>
-	static INPUT_TYPE GetData(Vector &v, idx_t row_idx) {
-		auto data = FlatVector::GetData<INPUT_TYPE>(v);
-		return data[row_idx];
-	}
-};
-
-struct MaskColumnOperatorValue {
-	template <class INPUT_TYPE>
-	static INPUT_TYPE GetData(Vector &v, idx_t row_idx) {
-		return v.GetValue(row_idx);
-	}
-};
-
-template <typename INPUT_TYPE, class OP = MaskColumnOperator>
-static void MaskTypedColumn(ValidityMask &mask, ChunkCollection &over_collection, const idx_t c) {
-	idx_t r = 0;
-	bool prev_valid;
-	INPUT_TYPE prev;
-	bool first_chunk = true;
-
-	for (auto &chunk : over_collection.Chunks()) {
-		auto &v = chunk->data[c];
-		auto validity = FlatVector::Validity(v);
-		if (mask.CheckAllValid(r + chunk->size(), r)) {
-#ifdef DEBUG
-			for (idx_t i = 0; i < chunk->size(); i++) {
-				D_ASSERT(mask.RowIsValid(r + i));
-			}
-#endif
-			// all valid for this chunk: we can skip this
-			// we should update the "prev" values though
-			auto last_idx = chunk->size() - 1;
-			prev_valid = validity.RowIsValid(last_idx);
-			prev = OP::template GetData<INPUT_TYPE>(v, last_idx);
-			first_chunk = false;
-			r += chunk->size();
-			continue;
-		}
-		idx_t start_index = 0;
-		if (first_chunk) {
-			// record the first value (if this is the first chunk)
-			prev_valid = validity.RowIsValid(0);
-			prev = OP::template GetData<INPUT_TYPE>(v, 0);
-			first_chunk = false;
-			start_index++;
-			r++;
-		}
-		for (idx_t i = start_index; i < chunk->size(); i++) {
-			auto curr_valid = validity.RowIsValid(i);
-			auto curr = OP::template GetData<INPUT_TYPE>(v, i);
-
-			if (!mask.RowIsValid(r)) {
-				if (curr_valid != prev_valid || (curr_valid && !Equals::Operation(curr, prev))) {
-					mask.SetValidUnsafe(r);
-				}
-			}
-			prev_valid = curr_valid;
-			prev = curr;
-			r++;
-		}
-	}
-}
-
-static void MaskColumn(ValidityMask &mask, ChunkCollection &over_collection, const idx_t c) {
-	auto &vector = over_collection.GetChunk(0).data[c];
-	switch (vector.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		MaskTypedColumn<int8_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INT16:
-		MaskTypedColumn<int16_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INT32:
-		MaskTypedColumn<int32_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INT64:
-		MaskTypedColumn<int64_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::UINT8:
-		MaskTypedColumn<uint8_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::UINT16:
-		MaskTypedColumn<uint16_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::UINT32:
-		MaskTypedColumn<uint32_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::UINT64:
-		MaskTypedColumn<uint64_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INT128:
-		MaskTypedColumn<hugeint_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::FLOAT:
-		MaskTypedColumn<float>(mask, over_collection, c);
-		break;
-	case PhysicalType::DOUBLE:
-		MaskTypedColumn<double>(mask, over_collection, c);
-		break;
-	case PhysicalType::VARCHAR:
-		MaskTypedColumn<string_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INTERVAL:
-		MaskTypedColumn<interval_t>(mask, over_collection, c);
-		break;
-	default:
-		MaskTypedColumn<Value, MaskColumnOperatorValue>(mask, over_collection, c);
-		break;
-	}
-}
-
 static idx_t FindNextStart(const ValidityMask &mask, idx_t l, const idx_t r, idx_t &n) {
 	if (mask.AllValid()) {
 		auto start = MinValue(l + n - 1, r);
@@ -61661,31 +61690,12 @@ using WindowExpressions = vector<BoundWindowExpression *>;
 
 static void ComputeWindowExpressions(WindowExpressions &window_exprs, ChunkCollection &input,
                                      ChunkCollection &window_results, ChunkCollection &over,
+                                     const ValidityMask &partition_mask, const ValidityMask &order_mask,
                                      WindowAggregationMode mode) {
 	//	Idempotency
 	if (input.Count() == 0) {
 		return;
 	}
-	//	Pick out a function for the OVER clause
-	auto over_expr = window_exprs[0];
-
-	//	Set bits for the start of each partition
-	vector<validity_t> partition_bits(ValidityMask::EntryCount(input.Count()), 0);
-	ValidityMask partition_mask(partition_bits.data());
-	partition_mask.SetValid(0);
-
-	for (idx_t c = 0; c < over_expr->partitions.size(); ++c) {
-		MaskColumn(partition_mask, over, c);
-	}
-
-	//	Set bits for the start of each peer group.
-	//	Partitions also break peer groups, so start with the partition bits.
-	const auto sort_col_count = over_expr->partitions.size() + over_expr->orders.size();
-	ValidityMask order_mask(partition_mask, input.Count());
-	for (idx_t c = over_expr->partitions.size(); c < sort_col_count; ++c) {
-		MaskColumn(order_mask, over, c);
-	}
-
 	//	Compute the functions columnwise
 	for (idx_t expr_idx = 0; expr_idx < window_exprs.size(); ++expr_idx) {
 		ChunkCollection output(input.GetAllocator());
@@ -61719,6 +61729,24 @@ static void GeneratePartition(WindowLocalSourceState &state, WindowGlobalSinkSta
 	// 3. Multiple partitions (sorting and hashing)
 	const auto &input_types = op.children[0]->types;
 
+	//	How big is the partition?
+	idx_t count = 0;
+	if (hash_bin < gstate.hash_groups.size() && gstate.hash_groups[hash_bin]) {
+		count = gstate.hash_groups[hash_bin]->count;
+	} else if (gstate.rows && !hash_bin) {
+		count = gstate.count;
+	} else {
+		return;
+	}
+
+	//	Initialise masks to false
+	const auto bit_count = ValidityMask::ValidityMaskSize(count);
+	vector<validity_t> partition_bits(bit_count, 0);
+	ValidityMask partition_mask(partition_bits.data());
+
+	vector<validity_t> order_bits(bit_count, 0);
+	ValidityMask order_mask(order_bits.data());
+
 	// Scan the sorted data into new Collections
 	auto &allocator = gstate.allocator;
 	ChunkCollection input(allocator);
@@ -61726,9 +61754,12 @@ static void GeneratePartition(WindowLocalSourceState &state, WindowGlobalSinkSta
 	if (gstate.rows && !hash_bin) {
 		//	No partition - convert row collection to chunk collection
 		ScanRowCollection(*gstate.rows, *gstate.strings, input, input_types);
+		partition_mask.SetValidUnsafe(0);
+		order_mask.SetValidUnsafe(0);
 	} else if (hash_bin < gstate.hash_groups.size() && gstate.hash_groups[hash_bin]) {
 		// Overwrite the collections with the sorted data
 		state.hash_group = move(gstate.hash_groups[hash_bin]);
+		state.hash_group->ComputeMasks(partition_mask, order_mask);
 		const auto over_types = state.hash_group->global_sort->sort_layout.logical_types;
 		ScanSortedPartition(state, input, input_types, over, over_types);
 	} else {
@@ -61736,7 +61767,7 @@ static void GeneratePartition(WindowLocalSourceState &state, WindowGlobalSinkSta
 	}
 
 	ChunkCollection output(allocator);
-	ComputeWindowExpressions(window_exprs, input, output, over, gstate.mode);
+	ComputeWindowExpressions(window_exprs, input, output, over, partition_mask, order_mask, gstate.mode);
 	state.chunks.Merge(input);
 	state.window_results.Merge(output);
 }
@@ -61837,7 +61868,7 @@ public:
 	}
 
 	void FinishEvent() override {
-		hash_group.global_sort->CompleteMergeRound();
+		hash_group.global_sort->CompleteMergeRound(true);
 		CreateMergeTasks(pipeline, *this, gstate, hash_group);
 	}
 
@@ -66078,7 +66109,6 @@ private:
 
 
 
-
 #include <thread>
 
 namespace duckdb {
@@ -66259,104 +66289,6 @@ OperatorResultType PhysicalIEJoin::Execute(ExecutionContext &context, DataChunk
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
-struct SBIterator {
-	static int ComparisonValue(ExpressionType comparison) {
-		switch (comparison) {
-		case ExpressionType::COMPARE_LESSTHAN:
-		case ExpressionType::COMPARE_GREATERTHAN:
-			return -1;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			return 0;
-		default:
-			throw InternalException("Unimplemented comparison type for IEJoin!");
-		}
-	}
-
-	explicit SBIterator(GlobalSortState &gss, ExpressionType comparison, idx_t entry_idx_p = 0)
-	    : sort_layout(gss.sort_layout), block_count(gss.sorted_blocks[0]->radix_sorting_data.size()),
-	      block_capacity(gss.block_capacity), cmp_size(sort_layout.comparison_size), entry_size(sort_layout.entry_size),
-	      all_constant(sort_layout.all_constant), external(gss.external), cmp(ComparisonValue(comparison)),
-	      scan(gss.buffer_manager, gss), block_ptr(nullptr), entry_ptr(nullptr) {
-
-		scan.sb = gss.sorted_blocks[0].get();
-		scan.block_idx = block_count;
-		SetIndex(entry_idx_p);
-	}
-
-	inline idx_t GetIndex() const {
-		return entry_idx;
-	}
-
-	inline void SetIndex(idx_t entry_idx_p) {
-		const auto new_block_idx = entry_idx_p / block_capacity;
-		if (new_block_idx != scan.block_idx) {
-			scan.SetIndices(new_block_idx, 0);
-			if (new_block_idx < block_count) {
-				scan.PinRadix(scan.block_idx);
-				block_ptr = scan.RadixPtr();
-				if (!all_constant) {
-					scan.PinData(*scan.sb->blob_sorting_data);
-				}
-			}
-		}
-
-		scan.entry_idx = entry_idx_p % block_capacity;
-		entry_ptr = block_ptr + scan.entry_idx * entry_size;
-		entry_idx = entry_idx_p;
-	}
-
-	inline SBIterator &operator++() {
-		if (++scan.entry_idx < block_capacity) {
-			entry_ptr += entry_size;
-			++entry_idx;
-		} else {
-			SetIndex(entry_idx + 1);
-		}
-
-		return *this;
-	}
-
-	inline SBIterator &operator--() {
-		if (scan.entry_idx) {
-			--scan.entry_idx;
-			--entry_idx;
-			entry_ptr -= entry_size;
-		} else {
-			SetIndex(entry_idx - 1);
-		}
-
-		return *this;
-	}
-
-	inline bool Compare(const SBIterator &other) const {
-		int comp_res;
-		if (all_constant) {
-			comp_res = FastMemcmp(entry_ptr, other.entry_ptr, cmp_size);
-		} else {
-			comp_res = Comparators::CompareTuple(scan, other.scan, entry_ptr, other.entry_ptr, sort_layout, external);
-		}
-
-		return comp_res <= cmp;
-	}
-
-	// Fixed comparison parameters
-	const SortLayout &sort_layout;
-	const idx_t block_count;
-	const idx_t block_capacity;
-	const size_t cmp_size;
-	const size_t entry_size;
-	const bool all_constant;
-	const bool external;
-	const int cmp;
-
-	// Iteration state
-	SBScanState scan;
-	idx_t entry_idx;
-	data_ptr_t block_ptr;
-	data_ptr_t entry_ptr;
-};
-
 struct IEJoinUnion {
 	using SortedTable = PhysicalRangeJoin::GlobalSortedTable;
 

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "cafd60e6b"
-#define DUCKDB_VERSION "v0.4.1-dev787"
+#define DUCKDB_SOURCE_ID "d163f7ee3"
+#define DUCKDB_VERSION "v0.4.1-dev790"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //