duckdb 0.5.2-dev2196.0 → 0.5.2-dev2214.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.5.2-dev2196.0",
+  "version": "0.5.2-dev2214.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -39768,6 +39768,7 @@ void GlobalSortState::Print() {
 
 
 
+
 #include <numeric>
 
 namespace duckdb {
@@ -40047,85 +40048,65 @@ void SBScanState::SetIndices(idx_t block_idx_to, idx_t entry_idx_to) {
 	entry_idx = entry_idx_to;
 }
 
-PayloadScanner::PayloadScanner(SortedData &sorted_data, GlobalSortState &global_sort_state, bool flush_p)
-    : sorted_data(sorted_data), read_state(global_sort_state.buffer_manager, global_sort_state),
-      total_count(sorted_data.Count()), total_scanned(0), flush(flush_p),
-      unswizzling(!sorted_data.layout.AllConstant() && global_sort_state.external) {
-	ValidateUnscannedBlock();
+PayloadScanner::PayloadScanner(SortedData &sorted_data, GlobalSortState &global_sort_state, bool flush_p) {
+	auto count = sorted_data.Count();
+	auto &layout = sorted_data.layout;
+
+	// Create collections to put the data into so we can use RowDataCollectionScanner
+	rows = make_unique<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1);
+	rows->count = count;
+
+	heap = make_unique<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1);
+	if (!sorted_data.layout.AllConstant()) {
+		heap->count = count;
+	}
+
+	if (flush_p) {
+		// If we are flushing, we can just move the data
+		rows->blocks = move(sorted_data.data_blocks);
+		if (!layout.AllConstant()) {
+			heap->blocks = move(sorted_data.heap_blocks);
+		}
+	} else {
+		// Not flushing, create references to the blocks
+		for (auto &block : sorted_data.data_blocks) {
+			rows->blocks.emplace_back(block->Copy());
+		}
+		if (!layout.AllConstant()) {
+			for (auto &block : sorted_data.heap_blocks) {
+				heap->blocks.emplace_back(block->Copy());
+			}
+		}
+	}
+
+	scanner = make_unique<RowDataCollectionScanner>(*rows, *heap, layout, global_sort_state.external, flush_p);
 }
 
 PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, bool flush_p)
     : PayloadScanner(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state, flush_p) {
 }
 
-PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, idx_t block_idx)
-    : sorted_data(*global_sort_state.sorted_blocks[0]->payload_data),
-      read_state(global_sort_state.buffer_manager, global_sort_state),
-      total_count(sorted_data.data_blocks[block_idx]->count), total_scanned(0), flush(false),
-      unswizzling(!sorted_data.layout.AllConstant() && global_sort_state.external) {
-	read_state.SetIndices(block_idx, 0);
-	ValidateUnscannedBlock();
-}
+PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, idx_t block_idx) {
+	auto &sorted_data = *global_sort_state.sorted_blocks[0]->payload_data;
+	auto count = sorted_data.data_blocks[block_idx]->count;
+	auto &layout = sorted_data.layout;
 
-void PayloadScanner::ValidateUnscannedBlock() const {
-	if (unswizzling && read_state.block_idx < sorted_data.data_blocks.size()) {
-		D_ASSERT(sorted_data.data_blocks[read_state.block_idx]->block->IsSwizzled());
+	// Create collections to put the data into so we can use RowDataCollectionScanner
+	rows = make_unique<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1);
+	rows->blocks.emplace_back(sorted_data.data_blocks[block_idx]->Copy());
+	rows->count = count;
+
+	heap = make_unique<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1);
+	if (!sorted_data.layout.AllConstant() && sorted_data.swizzled) {
+		heap->blocks.emplace_back(sorted_data.heap_blocks[block_idx]->Copy());
+		heap->count = count;
 	}
+
+	scanner = make_unique<RowDataCollectionScanner>(*rows, *heap, layout, global_sort_state.external, false);
 }
 
 void PayloadScanner::Scan(DataChunk &chunk) {
-	auto count = MinValue((idx_t)STANDARD_VECTOR_SIZE, total_count - total_scanned);
-	if (count == 0) {
-		chunk.SetCardinality(count);
-		return;
-	}
-	// Eagerly delete references to blocks that we've passed
-	if (flush) {
-		for (idx_t i = 0; i < read_state.block_idx; i++) {
-			sorted_data.data_blocks[i]->block = nullptr;
-			if (unswizzling) {
-				sorted_data.heap_blocks[i]->block = nullptr;
-			}
-		}
-	}
-	const idx_t &row_width = sorted_data.layout.GetRowWidth();
-	// Set up a batch of pointers to scan data from
-	idx_t scanned = 0;
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-	while (scanned < count) {
-		read_state.PinData(sorted_data);
-		auto &data_block = *sorted_data.data_blocks[read_state.block_idx];
-		idx_t next = MinValue(data_block.count - read_state.entry_idx, count - scanned);
-		const data_ptr_t data_ptr = read_state.payload_data_handle.Ptr() + read_state.entry_idx * row_width;
-		// Set up the next pointers
-		data_ptr_t row_ptr = data_ptr;
-		for (idx_t i = 0; i < next; i++) {
-			data_pointers[scanned + i] = row_ptr;
-			row_ptr += row_width;
-		}
-		// Unswizzle the offsets back to pointers (if needed)
-		if (unswizzling) {
-			RowOperations::UnswizzlePointers(sorted_data.layout, data_ptr, read_state.payload_heap_handle.Ptr(), next);
-			sorted_data.data_blocks[read_state.block_idx]->block->SetSwizzling("PayloadScanner::Scan");
-		}
-		// Update state indices
-		read_state.entry_idx += next;
-		if (read_state.entry_idx == data_block.count) {
-			read_state.block_idx++;
-			read_state.entry_idx = 0;
-			ValidateUnscannedBlock();
-		}
-		scanned += next;
-	}
-	D_ASSERT(scanned == count);
-	// Deserialize the payload data
-	for (idx_t col_no = 0; col_no < sorted_data.layout.ColumnCount(); col_no++) {
-		RowOperations::Gather(addresses, *FlatVector::IncrementalSelectionVector(), chunk.data[col_no],
-		                      *FlatVector::IncrementalSelectionVector(), count, sorted_data.layout, col_no);
-	}
-	chunk.SetCardinality(count);
-	chunk.Verify();
-	total_scanned += scanned;
+	scanner->Scan(chunk);
 }
 
 int SBIterator::ComparisonValue(ExpressionType comparison) {
@@ -43412,14 +43393,21 @@ ColumnDataRowCollection::ColumnDataRowCollection(const ColumnDataCollection &col
 		return;
 	}
 	// read all the chunks
-	ColumnDataScanState scan_state;
-	collection.InitializeScan(scan_state);
+	ColumnDataScanState temp_scan_state;
+	collection.InitializeScan(temp_scan_state);
 	while (true) {
 		auto chunk = make_unique<DataChunk>();
 		collection.InitializeScanChunk(*chunk);
-		if (!collection.Scan(scan_state, *chunk)) {
+		if (!collection.Scan(temp_scan_state, *chunk)) {
 			break;
 		}
+		// we keep the BufferHandles that are needed for the materialized collection pinned in the supplied scan_state
+		auto &temp_handles = temp_scan_state.current_chunk_state.handles;
+		auto &scan_handles = scan_state.current_chunk_state.handles;
+		for (auto &temp_handle_pair : temp_handles) {
+			auto handle_copy = make_pair<uint32_t, BufferHandle>(scan_handles.size(), move(temp_handle_pair.second));
+			scan_state.current_chunk_state.handles.insert(move(handle_copy));
+		}
 		chunks.push_back(move(chunk));
 	}
 	// now create all of the column data rows
@@ -47745,6 +47733,7 @@ void RowDataCollection::Merge(RowDataCollection &other) {
 		temp.block_capacity = other.block_capacity;
 		temp.entry_size = other.entry_size;
 		temp.blocks = move(other.blocks);
+		temp.pinned_blocks = move(other.pinned_blocks);
 	}
 	other.Clear();
 
@@ -47761,115 +47750,6 @@ void RowDataCollection::Merge(RowDataCollection &other) {
 }
 
 } // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row_data_collection_scanner.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class BufferHandle;
-class RowDataCollection;
-struct RowDataBlock;
-class DataChunk;
-
-//! Used to scan the data into DataChunks after sorting
-struct RowDataCollectionScanner {
-public:
-	using Types = vector<LogicalType>;
-
-	struct ScanState {
-		explicit ScanState(const RowDataCollectionScanner &scanner_p) : scanner(scanner_p), block_idx(0), entry_idx(0) {
-		}
-
-		void PinData();
-
-		//! The data layout
-		const RowDataCollectionScanner &scanner;
-
-		idx_t block_idx;
-		idx_t entry_idx;
-
-		BufferHandle data_handle;
-		BufferHandle heap_handle;
-
-		// We must pin ALL blocks we are going to gather from
-		vector<BufferHandle> pinned_blocks;
-	};
-
-	//! Ensure that heap blocks correspond to row blocks
-	static void AlignHeapBlocks(RowDataCollection &dst_block_collection, RowDataCollection &dst_string_heap,
-	                            RowDataCollection &src_block_collection, RowDataCollection &src_string_heap,
-	                            const RowLayout &layout);
-
-	RowDataCollectionScanner(RowDataCollection &rows, RowDataCollection &heap, const RowLayout &layout, bool external,
-	                         bool flush = true);
-
-	//! The type layout of the payload
-	inline const vector<LogicalType> &GetTypes() const {
-		return layout.GetTypes();
-	}
-
-	//! The number of rows in the collection
-	inline idx_t Count() const {
-		return total_count;
-	}
-
-	//! The number of rows scanned so far
-	inline idx_t Scanned() const {
-		return total_scanned;
-	}
-
-	//! The number of remaining rows
-	inline idx_t Remaining() const {
-		return total_count - total_scanned;
-	}
-
-	//! Swizzle the blocks for external scanning
-	//! Swizzling is all or nothing, so if we have scanned previously,
-	//! we need to re-swizzle.
-	void ReSwizzle();
-
-	void SwizzleBlock(RowDataBlock &data_block, RowDataBlock &heap_block);
-
-	//! Scans the next data chunk from the sorted data
-	void Scan(DataChunk &chunk);
-
-private:
-	//! The row data being scanned
-	RowDataCollection &rows;
-	//! The row heap being scanned
-	RowDataCollection &heap;
-	//! The data layout
-	const RowLayout layout;
-	//! Read state
-	ScanState read_state;
-	//! The total count of sorted_data
-	const idx_t total_count;
-	//! The number of rows scanned so far
-	idx_t total_scanned;
-	//! Addresses used to gather from the sorted data
-	Vector addresses = Vector(LogicalType::POINTER);
-	//! Whether the blocks can be flushed to disk
-	const bool external;
-	//! Whether to flush the blocks after scanning
-	const bool flush;
-	//! Whether we are unswizzling the blocks
-	const bool unswizzling;
-
-	//! Checks that the newest block is valid
-	void ValidateUnscannedBlock() const;
-};
-
-} // namespace duckdb
 
 
 
@@ -63506,6 +63386,8 @@ public:
 
 	//! Fill the pointer with all the addresses from the hashtable for full scan
 	idx_t FillWithHTOffsets(data_ptr_t *key_locations, JoinHTScanState &state);
+	//! Pins all fixed-size blocks
+	void PinAllBlocks();
 
 	idx_t Count() const {
 		return block_collection->count;
@@ -64602,6 +64484,12 @@ idx_t JoinHashTable::FillWithHTOffsets(data_ptr_t *key_locations, JoinHTScanStat
 	return key_count;
 }
 
+void JoinHashTable::PinAllBlocks() {
+	for (auto &block : block_collection->blocks) {
+		pinned_handles.push_back(buffer_manager.Pin(block->block));
+	}
+}
+
 void JoinHashTable::SwizzleBlocks() {
 	if (block_collection->count == 0) {
 		return;
@@ -73113,6 +73001,9 @@ bool PerfectHashJoinExecutor::BuildPerfectHashTable(LogicalType &key_type) {
 	bitmap_build_idx = unique_ptr<bool[]>(new bool[build_size]);
 	memset(bitmap_build_idx.get(), 0, sizeof(bool) * build_size); // set false
 
+	// pin all fixed-size blocks (variable-sized should still be pinned)
+	ht.PinAllBlocks();
+
 	// Now fill columns with build data
 	JoinHTScanState join_ht_state;
 	return FullScanHashTable(join_ht_state, key_type);
@@ -76735,6 +76626,7 @@ public:
 
 	ArenaAllocator arena_allocator;
 	vector<Key> keys;
+	unique_ptr<ColumnFetchState> fetch_state;
 
 public:
 	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
@@ -76814,9 +76706,9 @@ void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, Data
 			return;
 		}
 		state.rhs_chunk.Reset();
-		ColumnFetchState fetch_state;
+		state.fetch_state = make_unique<ColumnFetchState>();
 		Vector row_ids(LogicalType::ROW_TYPE, (data_ptr_t)&fetch_rows[0]);
-		tbl->Fetch(transaction, state.rhs_chunk, fetch_ids, row_ids, output_sel_idx, fetch_state);
+		tbl->Fetch(transaction, state.rhs_chunk, fetch_ids, row_ids, output_sel_idx, *state.fetch_state);
 	}
 
 	//! Now we actually produce our result chunk
@@ -77824,6 +77716,7 @@ public:
 	RowLayout lhs_layout;
 	unique_ptr<LocalSortedTable> lhs_local_table;
 	unique_ptr<GlobalSortState> lhs_global_state;
+	unique_ptr<PayloadScanner> scanner;
 
 	// Simple scans
 	idx_t left_position;
@@ -77840,7 +77733,7 @@ public:
 	DataChunk rhs_keys;
 	DataChunk rhs_input;
 	ExpressionExecutor rhs_executor;
-	BufferHandle payload_heap_handle;
+	vector<BufferHandle> payload_heap_handles;
 
 public:
 	void ResolveJoinKeys(DataChunk &input) {
@@ -77862,9 +77755,9 @@ public:
 		// Scan the sorted payload
 		D_ASSERT(lhs_global_state->sorted_blocks.size() == 1);
 
-		PayloadScanner scanner(*lhs_global_state->sorted_blocks[0]->payload_data, *lhs_global_state);
+		scanner = make_unique<PayloadScanner>(*lhs_global_state->sorted_blocks[0]->payload_data, *lhs_global_state);
 		lhs_payload.Reset();
-		scanner.Scan(lhs_payload);
+		scanner->Scan(lhs_payload);
 
 		// Recompute the sorted keys from the sorted input
 		lhs_local_table->keys.Reset();
@@ -78138,6 +78031,8 @@ OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionConte
 	auto &rsorted = *gstate.table->global_sort_state.sorted_blocks[0];
 	const auto left_cols = input.ColumnCount();
 	const auto tail_cols = conditions.size() - 1;
+
+	state.payload_heap_handles.clear();
 	do {
 		if (state.first_fetch) {
 			state.ResolveJoinKeys(input);
@@ -78188,8 +78083,8 @@ OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionConte
 			for (idx_t c = 0; c < state.lhs_payload.ColumnCount(); ++c) {
 				chunk.data[c].Slice(state.lhs_payload.data[c], left_info.result, result_count);
 			}
-			state.payload_heap_handle = SliceSortedPayload(chunk, right_info.state, right_info.block_idx,
-			                                               right_info.result, result_count, left_cols);
+			state.payload_heap_handles.push_back(SliceSortedPayload(chunk, right_info.state, right_info.block_idx,
+			                                                        right_info.result, result_count, left_cols));
 			chunk.SetCardinality(result_count);
 
 			auto sel = FlatVector::IncrementalSelectionVector();
@@ -202218,6 +202113,16 @@ void BufferManager::AddToEvictionQueue(shared_ptr<BlockHandle> &handle) {
 	queue->q.enqueue(BufferEvictionNode(weak_ptr<BlockHandle>(handle), handle->eviction_timestamp));
 }
 
+void BufferManager::VerifyZeroReaders(shared_ptr<BlockHandle> &handle) {
+#ifdef DUCKDB_DEBUG_DESTROY_BLOCKS
+	auto replacement_buffer = make_unique<FileBuffer>(Allocator::Get(db), handle->buffer->type,
+	                                                  handle->memory_usage - Storage::BLOCK_HEADER_SIZE);
+	memcpy(replacement_buffer->buffer, handle->buffer->buffer, handle->buffer->size);
+	memset(handle->buffer->buffer, 190, handle->buffer->size);
+	handle->buffer = move(replacement_buffer);
+#endif
+}
+
 void BufferManager::Unpin(shared_ptr<BlockHandle> &handle) {
 	lock_guard<mutex> lock(handle->lock);
 	if (!handle->buffer || handle->buffer->type == FileBufferType::TINY_BUFFER) {
@@ -202226,6 +202131,7 @@ void BufferManager::Unpin(shared_ptr<BlockHandle> &handle) {
 	D_ASSERT(handle->readers > 0);
 	handle->readers--;
 	if (handle->readers == 0) {
+		VerifyZeroReaders(handle);
 		AddToEvictionQueue(handle);
 	}
 }
@@ -217286,6 +217192,7 @@ void ColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx)
 }
 
 idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remaining) {
+	state.previous_states.clear();
 	if (state.version != version) {
 		InitializeScanWithOffset(state, state.row_index);
 		state.current->InitializeScan(state);
@@ -217320,6 +217227,7 @@ idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remai
 			if (!state.current->next) {
 				break;
 			}
+			state.previous_states.emplace_back(move(state.scan_state));
 			state.current = (ColumnSegment *)state.current->Next();
 			state.current->InitializeScan(state);
 			state.segment_checked = false;