duckdb 0.4.1-dev1777.0 → 0.4.1-dev1784.0

package/package.json

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

package/src/duckdb.cpp

@@ -31367,6 +31367,9 @@ struct RowOperations {
 	//! Swizzles the base pointer of each row to offset within heap block
 	static void SwizzleHeapPointer(const RowLayout &layout, data_ptr_t row_ptr, const data_ptr_t heap_base_ptr,
 	                               const idx_t count, const idx_t base_offset = 0);
+	//! Unswizzles the base offset within heap block the rows to pointers
+	static void UnswizzleHeapPointer(const RowLayout &layout, const data_ptr_t base_row_ptr,
+	                                 const data_ptr_t base_heap_ptr, const idx_t count);
 	//! Unswizzles all offsets back to pointers
 	static void UnswizzlePointers(const RowLayout &layout, const data_ptr_t base_row_ptr,
 	                              const data_ptr_t base_heap_ptr, const idx_t count);
@@ -31693,6 +31696,16 @@ void RowOperations::SwizzleHeapPointer(const RowLayout &layout, data_ptr_t row_p
 	}
 }
 
+void RowOperations::UnswizzleHeapPointer(const RowLayout &layout, const data_ptr_t base_row_ptr,
+                                         const data_ptr_t base_heap_ptr, const idx_t count) {
+	const auto row_width = layout.GetRowWidth();
+	data_ptr_t heap_ptr_ptr = base_row_ptr + layout.GetHeapPointerOffset();
+	for (idx_t i = 0; i < count; i++) {
+		Store<data_ptr_t>(base_heap_ptr + Load<idx_t>(heap_ptr_ptr), heap_ptr_ptr);
+		heap_ptr_ptr += row_width;
+	}
+}
+
 void RowOperations::UnswizzlePointers(const RowLayout &layout, const data_ptr_t base_row_ptr,
                                       const data_ptr_t base_heap_ptr, const idx_t count) {
 	const idx_t row_width = layout.GetRowWidth();
@@ -31861,6 +31874,8 @@ public:
 	vector<RowDataBlock> blocks;
 	//! The blocks that this collection currently has pinned
 	vector<BufferHandle> pinned_blocks;
+	//! Whether the blocks should stay pinned (necessary for e.g. a heap)
+	const bool keep_pinned;
 
 public:
 	idx_t AppendToBlock(RowDataBlock &block, BufferHandle &handle, vector<BlockAppendEntry> &append_entries,
@@ -31891,9 +31906,6 @@ public:
 
 private:
 	mutex rdc_lock;
-
-	//! Whether the blocks should stay pinned (necessary for e.g. a heap)
-	const bool keep_pinned;
 };
 
 } // namespace duckdb
@@ -34638,14 +34650,17 @@ private:
 	SBScanState read_state;
 	//! The total count of sorted_data
 	const idx_t total_count;
-	//! The global sort state
-	GlobalSortState &global_sort_state;
 	//! Addresses used to gather from the sorted data
 	Vector addresses = Vector(LogicalType::POINTER);
 	//! The number of rows scanned so far
 	idx_t total_scanned;
 	//! 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;
 };
 
 struct SBIterator {
@@ -36453,6 +36468,7 @@ void LocalSortState::SinkChunk(DataChunk &sort, DataChunk &payload) {
 		auto blob_data = blob_chunk.ToUnifiedFormat();
 		RowOperations::Scatter(blob_chunk, blob_data.get(), sort_layout->blob_layout, addresses, *blob_sorting_heap,
 		                       sel_ptr, blob_chunk.size());
+		D_ASSERT(blob_sorting_heap->keep_pinned);
 	}
 
 	// Finally, serialize payload data
@@ -36460,6 +36476,7 @@ void LocalSortState::SinkChunk(DataChunk &sort, DataChunk &payload) {
 	auto input_data = payload.ToUnifiedFormat();
 	RowOperations::Scatter(payload, input_data.get(), *payload_layout, addresses, *payload_heap, sel_ptr,
 	                       payload.size());
+	D_ASSERT(payload_heap->keep_pinned);
 }
 
 idx_t LocalSortState::SizeInBytes() const {
@@ -36548,6 +36565,7 @@ void LocalSortState::ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataColl
 		ordered_data_ptr += row_width;
 		sorting_ptr += sorting_entry_size;
 	}
+	ordered_data_block.block->SetSwizzling(sd.layout.AllConstant() ? nullptr : "LocalSortState::ReOrder.ordered_data");
 	// Replace the unordered data block with the re-ordered data block
 	sd.data_blocks.clear();
 	sd.data_blocks.push_back(move(ordered_data_block));
@@ -36555,6 +36573,7 @@ void LocalSortState::ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataColl
 	if (!sd.layout.AllConstant() && reorder_heap) {
 		// Swizzle the column pointers to offsets
 		RowOperations::SwizzleColumns(sd.layout, ordered_data_handle.Ptr(), count);
+		sd.data_blocks.back().block->SetSwizzling(nullptr);
 		// Create a single heap block to store the ordered heap
 		idx_t total_byte_offset = std::accumulate(heap.blocks.begin(), heap.blocks.end(), 0,
 		                                          [](idx_t a, const RowDataBlock &b) { return a + b.byte_offset; });
@@ -36785,9 +36804,11 @@ void SortedData::Unswizzle() {
 	for (idx_t i = 0; i < data_blocks.size(); i++) {
 		auto &data_block = data_blocks[i];
 		auto &heap_block = heap_blocks[i];
+		D_ASSERT(data_block.block->IsSwizzled());
 		auto data_handle_p = buffer_manager.Pin(data_block.block);
 		auto heap_handle_p = buffer_manager.Pin(heap_block.block);
 		RowOperations::UnswizzlePointers(layout, data_handle_p.Ptr(), heap_handle_p.Ptr(), data_block.count);
+		data_block.block->SetSwizzling("SortedData::Unswizzle");
 		state.heap_blocks.push_back(move(heap_block));
 		state.pinned_blocks.push_back(move(heap_handle_p));
 	}
@@ -37003,7 +37024,9 @@ void SBScanState::SetIndices(idx_t block_idx_to, idx_t 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()), global_sort_state(global_sort_state), total_scanned(0), flush(flush_p) {
+      total_count(sorted_data.Count()), total_scanned(0), flush(flush_p),
+      unswizzling(!sorted_data.layout.AllConstant() && global_sort_state.external) {
+	ValidateUnscannedBlock();
 }
 
 PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, bool flush_p)
@@ -37013,9 +37036,16 @@ PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, bool 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), global_sort_state(global_sort_state), total_scanned(0),
-      flush(false) {
+      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();
+}
+
+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());
+	}
 }
 
 void PayloadScanner::Scan(DataChunk &chunk) {
@@ -37028,6 +37058,9 @@ void PayloadScanner::Scan(DataChunk &chunk) {
 	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();
@@ -37046,14 +37079,16 @@ void PayloadScanner::Scan(DataChunk &chunk) {
 			row_ptr += row_width;
 		}
 		// Unswizzle the offsets back to pointers (if needed)
-		if (!sorted_data.layout.AllConstant() && global_sort_state.external) {
+		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;
 	}
@@ -44492,6 +44527,7 @@ namespace duckdb {
 
 class BufferHandle;
 class RowDataCollection;
+struct RowDataBlock;
 class DataChunk;
 
 //! Used to scan the data into DataChunks after sorting
@@ -44513,6 +44549,9 @@ public:
 
 		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
@@ -44543,6 +44582,8 @@ public:
 	//! 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);
 
@@ -44565,6 +44606,11 @@ private:
 	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
@@ -44584,21 +44630,19 @@ void RowDataCollectionScanner::AlignHeapBlocks(RowDataCollection &swizzled_block
 		return;
 	}
 
-	// The main data blocks can just be moved
-	swizzled_block_collection.Merge(block_collection);
-	block_collection.Clear();
-
 	if (layout.AllConstant()) {
-		// No heap blocks!
+		// No heap blocks! Just merge fixed-size data
+		swizzled_block_collection.Merge(block_collection);
 		return;
 	}
 
 	// We create one heap block per data block and swizzle the pointers
-	auto &buffer_manager = swizzled_block_collection.buffer_manager;
+	D_ASSERT(string_heap.keep_pinned == swizzled_string_heap.keep_pinned);
+	auto &buffer_manager = block_collection.buffer_manager;
 	auto &heap_blocks = string_heap.blocks;
 	idx_t heap_block_idx = 0;
 	idx_t heap_block_remaining = heap_blocks[heap_block_idx].count;
-	for (auto &data_block : swizzled_block_collection.blocks) {
+	for (auto &data_block : block_collection.blocks) {
 		if (heap_block_remaining == 0) {
 			heap_block_remaining = heap_blocks[++heap_block_idx].count;
 		}
@@ -44606,27 +44650,44 @@ void RowDataCollectionScanner::AlignHeapBlocks(RowDataCollection &swizzled_block
 		// Pin the data block and swizzle the pointers within the rows
 		auto data_handle = buffer_manager.Pin(data_block.block);
 		auto data_ptr = data_handle.Ptr();
-		RowOperations::SwizzleColumns(layout, data_ptr, data_block.count);
+		if (!string_heap.keep_pinned) {
+			D_ASSERT(!data_block.block->IsSwizzled());
+			RowOperations::SwizzleColumns(layout, data_ptr, data_block.count);
+			data_block.block->SetSwizzling(nullptr);
+		}
+		// At this point the data block is pinned and the heap pointer is valid
+		// so we can copy heap data as needed
 
 		// We want to copy as little of the heap data as possible, check how the data and heap blocks line up
 		if (heap_block_remaining >= data_block.count) {
 			// Easy: current heap block contains all strings for this data block, just copy (reference) the block
 			swizzled_string_heap.blocks.emplace_back(RowDataBlock(heap_blocks[heap_block_idx]));
-			swizzled_string_heap.blocks.back().count = 0;
-
-			// Swizzle the heap pointer
-			auto heap_handle = buffer_manager.Pin(swizzled_string_heap.blocks.back().block);
-			auto heap_ptr = Load<data_ptr_t>(data_ptr + layout.GetHeapPointerOffset());
-			auto heap_offset = heap_ptr - heap_handle.Ptr();
-			RowOperations::SwizzleHeapPointer(layout, data_ptr, heap_ptr, data_block.count, heap_offset);
+			swizzled_string_heap.blocks.back().count = data_block.count;
+
+			// Swizzle the heap pointer if we are not pinning the heap
+			auto &heap_block = swizzled_string_heap.blocks.back().block;
+			auto heap_handle = buffer_manager.Pin(heap_block);
+			if (!swizzled_string_heap.keep_pinned) {
+				auto heap_ptr = Load<data_ptr_t>(data_ptr + layout.GetHeapPointerOffset());
+				auto heap_offset = heap_ptr - heap_handle.Ptr();
+				RowOperations::SwizzleHeapPointer(layout, data_ptr, heap_ptr, data_block.count, heap_offset);
+			} else {
+				swizzled_string_heap.pinned_blocks.emplace_back(move(heap_handle));
+			}
 
 			// Update counter
 			heap_block_remaining -= data_block.count;
 		} else {
 			// Strings for this data block are spread over the current heap block and the next (and possibly more)
+			if (string_heap.keep_pinned) {
+				// The heap is changing underneath the data block,
+				// so swizzle the string pointers to make them portable.
+				RowOperations::SwizzleColumns(layout, data_ptr, data_block.count);
+			}
 			idx_t data_block_remaining = data_block.count;
 			vector<std::pair<data_ptr_t, idx_t>> ptrs_and_sizes;
 			idx_t total_size = 0;
+			const auto base_row_ptr = data_ptr;
 			while (data_block_remaining > 0) {
 				if (heap_block_remaining == 0) {
 					heap_block_remaining = heap_blocks[++heap_block_idx].count;
@@ -44656,12 +44717,21 @@ void RowDataCollectionScanner::AlignHeapBlocks(RowDataCollection &swizzled_block
 			    RowDataBlock(buffer_manager, MaxValue<idx_t>(total_size, (idx_t)Storage::BLOCK_SIZE), 1));
 			auto new_heap_handle = buffer_manager.Pin(swizzled_string_heap.blocks.back().block);
 			auto new_heap_ptr = new_heap_handle.Ptr();
+			if (swizzled_string_heap.keep_pinned) {
+				// Since the heap blocks are pinned, we can unswizzle the data again.
+				swizzled_string_heap.pinned_blocks.emplace_back(move(new_heap_handle));
+				RowOperations::UnswizzlePointers(layout, base_row_ptr, new_heap_ptr, data_block.count);
+				RowOperations::UnswizzleHeapPointer(layout, base_row_ptr, new_heap_ptr, data_block.count);
+			}
 			for (auto &ptr_and_size : ptrs_and_sizes) {
 				memcpy(new_heap_ptr, ptr_and_size.first, ptr_and_size.second);
 				new_heap_ptr += ptr_and_size.second;
 			}
 		}
 	}
+
+	// We're done with variable-sized data, now just merge the fixed-size data
+	swizzled_block_collection.Merge(block_collection);
 	D_ASSERT(swizzled_block_collection.blocks.size() == swizzled_string_heap.blocks.size());
 
 	// Update counts and cleanup
@@ -44691,11 +44761,28 @@ void RowDataCollectionScanner::ScanState::PinData() {
 RowDataCollectionScanner::RowDataCollectionScanner(RowDataCollection &rows_p, RowDataCollection &heap_p,
                                                    const RowLayout &layout_p, bool external_p, bool flush_p)
     : rows(rows_p), heap(heap_p), layout(layout_p), read_state(*this), total_count(rows.count), total_scanned(0),
-      external(external_p), flush(flush_p) {
+      external(external_p), flush(flush_p), unswizzling(!layout.AllConstant() && external && !heap.keep_pinned) {
 
-	if (!layout.AllConstant() && external) {
+	if (unswizzling) {
 		D_ASSERT(rows.blocks.size() == heap.blocks.size());
 	}
+
+	ValidateUnscannedBlock();
+}
+
+void RowDataCollectionScanner::SwizzleBlock(RowDataBlock &data_block, RowDataBlock &heap_block) {
+	// Pin the data block and swizzle the pointers within the rows
+	D_ASSERT(!data_block.block->IsSwizzled());
+	auto data_handle = rows.buffer_manager.Pin(data_block.block);
+	auto data_ptr = data_handle.Ptr();
+	RowOperations::SwizzleColumns(layout, data_ptr, data_block.count);
+	data_block.block->SetSwizzling(nullptr);
+
+	// Swizzle the heap pointers
+	auto heap_handle = heap.buffer_manager.Pin(heap_block.block);
+	auto heap_ptr = Load<data_ptr_t>(data_ptr + layout.GetHeapPointerOffset());
+	auto heap_offset = heap_ptr - heap_handle.Ptr();
+	RowOperations::SwizzleHeapPointer(layout, data_ptr, heap_ptr, data_block.count, heap_offset);
 }
 
 void RowDataCollectionScanner::ReSwizzle() {
@@ -44703,27 +44790,23 @@ void RowDataCollectionScanner::ReSwizzle() {
 		return;
 	}
 
-	if (layout.AllConstant() || !external) {
-		// No heap blocks!
+	if (!unswizzling) {
+		// No swizzled blocks!
 		return;
 	}
 
 	D_ASSERT(rows.blocks.size() == heap.blocks.size());
+	for (idx_t i = 0; i < rows.blocks.size(); ++i) {
+		auto &data_block = rows.blocks[i];
+		if (data_block.block && !data_block.block->IsSwizzled()) {
+			SwizzleBlock(data_block, heap.blocks[i]);
+		}
+	}
+}
 
-	// We create one heap block per data block and swizzle the pointers
-	idx_t heap_block_idx = 0;
-	for (auto &data_block : rows.blocks) {
-		// Pin the data block and swizzle the pointers within the rows
-		auto data_handle = rows.buffer_manager.Pin(data_block.block);
-		auto data_ptr = data_handle.Ptr();
-		RowOperations::SwizzleColumns(layout, data_ptr, data_block.count);
-
-		// Swizzle the heap pointers
-		auto &heap_block = heap.blocks[heap_block_idx++];
-		auto heap_handle = heap.buffer_manager.Pin(heap_block.block);
-		auto heap_ptr = Load<data_ptr_t>(data_ptr + layout.GetHeapPointerOffset());
-		auto heap_offset = heap_ptr - heap_handle.Ptr();
-		RowOperations::SwizzleHeapPointer(layout, data_ptr, heap_ptr, data_block.count, heap_offset);
+void RowDataCollectionScanner::ValidateUnscannedBlock() const {
+	if (unswizzling && read_state.block_idx < rows.blocks.size()) {
+		D_ASSERT(rows.blocks[read_state.block_idx].block->IsSwizzled());
 	}
 }
 
@@ -44733,19 +44816,13 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 		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) {
-			rows.blocks[i].block = nullptr;
-			if (!layout.AllConstant() && external) {
-				heap.blocks[i].block = nullptr;
-			}
-		}
-	}
 	const idx_t &row_width = 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);
+
+	// We must pin ALL blocks we are going to gather from
+	vector<BufferHandle> pinned_blocks;
 	while (scanned < count) {
 		read_state.PinData();
 		auto &data_block = rows.blocks[read_state.block_idx];
@@ -44758,14 +44835,22 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 			row_ptr += row_width;
 		}
 		// Unswizzle the offsets back to pointers (if needed)
-		if (!layout.AllConstant() && external) {
+		if (unswizzling) {
 			RowOperations::UnswizzlePointers(layout, data_ptr, read_state.heap_handle.Ptr(), next);
+			rows.blocks[read_state.block_idx].block->SetSwizzling("RowDataCollectionScanner::Scan");
 		}
 		// Update state indices
 		read_state.entry_idx += next;
 		if (read_state.entry_idx == data_block.count) {
+			// Pin completed blocks so we don't lose them
+			pinned_blocks.emplace_back(rows.buffer_manager.Pin(data_block.block));
+			if (unswizzling) {
+				auto &heap_block = heap.blocks[read_state.block_idx];
+				pinned_blocks.emplace_back(heap.buffer_manager.Pin(heap_block.block));
+			}
 			read_state.block_idx++;
 			read_state.entry_idx = 0;
+			ValidateUnscannedBlock();
 		}
 		scanned += next;
 	}
@@ -44779,6 +44864,27 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 	chunk.SetCardinality(count);
 	chunk.Verify();
 	total_scanned += scanned;
+
+	//	Switch to a new set of pinned blocks
+	read_state.pinned_blocks.swap(pinned_blocks);
+
+	if (flush) {
+		// Release blocks we have passed.
+		for (idx_t i = 0; i < read_state.block_idx; ++i) {
+			rows.blocks[i].block = nullptr;
+			if (unswizzling) {
+				heap.blocks[i].block = nullptr;
+			}
+		}
+	} else if (unswizzling) {
+		// Reswizzle blocks we have passed so they can be flushed safely.
+		for (idx_t i = 0; i < read_state.block_idx; ++i) {
+			auto &data_block = rows.blocks[i];
+			if (data_block.block && !data_block.block->IsSwizzled()) {
+				SwizzleBlock(data_block, heap.blocks[i]);
+			}
+		}
+	}
 }
 
 } // namespace duckdb
@@ -63120,10 +63226,10 @@ void WindowLocalSinkState::Group(WindowGlobalSinkState &gstate) {
 	}
 
 	auto &payload_data = *ungrouped->local_sort->payload_data;
-	auto rows = payload_data.CloneEmpty();
+	auto rows = payload_data.CloneEmpty(payload_data.keep_pinned);
 
 	auto &payload_heap = *ungrouped->local_sort->payload_heap;
-	auto heap = payload_heap.CloneEmpty();
+	auto heap = payload_heap.CloneEmpty(payload_heap.keep_pinned);
 
 	RowDataCollectionScanner::AlignHeapBlocks(*rows, *heap, payload_data, payload_heap, payload_layout);
 	RowDataCollectionScanner scanner(*rows, *heap, payload_layout, true);
@@ -63146,7 +63252,7 @@ void WindowLocalSinkState::Sink(DataChunk &input_chunk, WindowGlobalSinkState &g
 
 	// OVER()
 	if (over_chunk.ColumnCount() == 0) {
-		//	No sorts, so build row chunks
+		//	No sorts, so build paged row chunks
 		if (!rows) {
 			const auto entry_size = payload_layout.GetRowWidth();
 			const auto capacity = MaxValue<idx_t>(STANDARD_VECTOR_SIZE, (Storage::BLOCK_SIZE / entry_size) + 1);
@@ -63157,16 +63263,17 @@ void WindowLocalSinkState::Sink(DataChunk &input_chunk, WindowGlobalSinkState &g
 		const auto row_sel = FlatVector::IncrementalSelectionVector();
 		Vector addresses(LogicalType::POINTER);
 		auto key_locations = FlatVector::GetData<data_ptr_t>(addresses);
+		const auto prev_rows_blocks = rows->blocks.size();
 		auto handles = rows->Build(row_count, key_locations, nullptr, row_sel);
-		vector<UnifiedVectorFormat> input_data;
-		input_data.reserve(input_chunk.ColumnCount());
-		for (idx_t i = 0; i < input_chunk.ColumnCount(); i++) {
-			UnifiedVectorFormat pdata;
-			input_chunk.data[i].ToUnifiedFormat(row_count, pdata);
-			input_data.emplace_back(move(pdata));
-		}
-		RowOperations::Scatter(input_chunk, input_data.data(), payload_layout, addresses, *strings, *row_sel,
-		                       row_count);
+		auto input_data = input_chunk.ToUnifiedFormat();
+		RowOperations::Scatter(input_chunk, input_data.get(), payload_layout, addresses, *strings, *row_sel, row_count);
+		// Mark that row blocks contain pointers (heap blocks are pinned)
+		if (!payload_layout.AllConstant()) {
+			D_ASSERT(strings->keep_pinned);
+			for (size_t i = prev_rows_blocks; i < rows->blocks.size(); ++i) {
+				rows->blocks[i].block->SetSwizzling("WindowLocalSinkState::Sink");
+			}
+		}
 		return;
 	}
 
@@ -64433,8 +64540,8 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 		partition_mask.SetValidUnsafe(0);
 		order_mask.SetValidUnsafe(0);
 		//	No partition - align the heap blocks with the row blocks
-		rows = gstate.rows->CloneEmpty();
-		heap = gstate.strings->CloneEmpty();
+		rows = gstate.rows->CloneEmpty(gstate.rows->keep_pinned);
+		heap = gstate.strings->CloneEmpty(gstate.strings->keep_pinned);
 		RowDataCollectionScanner::AlignHeapBlocks(*rows, *heap, *gstate.rows, *gstate.strings, layout);
 		external = true;
 	} else if (hash_bin < gstate.hash_groups.size() && gstate.hash_groups[hash_bin]) {
@@ -71726,7 +71833,7 @@ PhysicalRangeJoin::GlobalSortedTable::GlobalSortedTable(ClientContext &context,
       memory_per_thread(0) {
 	D_ASSERT(orders.size() == 1);
 
-	// Set external (can be force with the PRAGMA)
+	// Set external (can be forced with the PRAGMA)
 	auto &config = ClientConfig::GetConfig(context);
 	global_sort_state.external = config.force_external;
 	memory_per_thread = PhysicalRangeJoin::GetMaxThreadMemory(context);
@@ -71973,6 +72080,7 @@ void PhysicalRangeJoin::SliceSortedPayload(DataChunk &payload, GlobalSortState &
 	if (!sorted_data.layout.AllConstant() && state.external) {
 		RowOperations::UnswizzlePointers(sorted_data.layout, data_ptr, read_state.payload_heap_handle.Ptr(),
 		                                 addr_count);
+		sorted_data.data_blocks[read_state.block_idx].block->SetSwizzling("PhysicalRangeJoin::SliceSortedPayload");
 	}
 
 	// Deserialize the payload data
@@ -185207,7 +185315,8 @@ struct BufferAllocatorData : PrivateAllocatorData {
 };
 
 BlockHandle::BlockHandle(DatabaseInstance &db, block_id_t block_id_p)
-    : db(db), readers(0), block_id(block_id_p), buffer(nullptr), eviction_timestamp(0), can_destroy(false) {
+    : db(db), readers(0), block_id(block_id_p), buffer(nullptr), eviction_timestamp(0), can_destroy(false),
+      unswizzled(nullptr) {
 	eviction_timestamp = 0;
 	state = BlockState::BLOCK_UNLOADED;
 	memory_usage = Storage::BLOCK_ALLOC_SIZE;
@@ -185215,7 +185324,7 @@ BlockHandle::BlockHandle(DatabaseInstance &db, block_id_t block_id_p)
 
 BlockHandle::BlockHandle(DatabaseInstance &db, block_id_t block_id_p, unique_ptr<FileBuffer> buffer_p,
                          bool can_destroy_p, idx_t block_size)
-    : db(db), readers(0), block_id(block_id_p), eviction_timestamp(0), can_destroy(can_destroy_p) {
+    : db(db), readers(0), block_id(block_id_p), eviction_timestamp(0), can_destroy(can_destroy_p), unswizzled(nullptr) {
 	D_ASSERT(block_size >= Storage::BLOCK_SIZE);
 	buffer = move(buffer_p);
 	state = BlockState::BLOCK_LOADED;
@@ -185224,6 +185333,8 @@ BlockHandle::BlockHandle(DatabaseInstance &db, block_id_t block_id_p, unique_ptr
 
 BlockHandle::~BlockHandle() {
 	auto &buffer_manager = BufferManager::GetBufferManager(db);
+	// being destroyed, so any unswizzled pointers are just binary junk now.
+	unswizzled = nullptr;
 	// no references remain to this block: erase
 	if (state == BlockState::BLOCK_LOADED) {
 		// the block is still loaded in memory: erase it
@@ -185301,6 +185412,7 @@ unique_ptr<FileBuffer> BlockHandle::UnloadAndTakeBlock() {
 		// already unloaded: nothing to do
 		return nullptr;
 	}
+	D_ASSERT(!unswizzled);
 	D_ASSERT(CanUnload());
 	D_ASSERT(memory_usage >= Storage::BLOCK_ALLOC_SIZE);
 

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 "c0a4ab96c"
-#define DUCKDB_VERSION "v0.4.1-dev1777"
+#define DUCKDB_SOURCE_ID "005bf35e9"
+#define DUCKDB_VERSION "v0.4.1-dev1784"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -22829,6 +22829,14 @@ public:
 		return readers;
 	}
 
+	inline bool IsSwizzled() const {
+		return !unswizzled;
+	}
+
+	inline void SetSwizzling(const char *unswizzler) {
+		unswizzled = unswizzler;
+	}
+
 private:
 	static BufferHandle Load(shared_ptr<BlockHandle> &handle, unique_ptr<FileBuffer> buffer = nullptr);
 	unique_ptr<FileBuffer> UnloadAndTakeBlock();
@@ -22851,6 +22859,8 @@ private:
 	const bool can_destroy;
 	//! The memory usage of the block
 	idx_t memory_usage;
+	//! Does the block contain any memory pointers?
+	const char *unswizzled;
 };
 
 } // namespace duckdb