duckdb 0.5.2-dev275.0 → 0.5.2-dev289.0

package/package.json

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

package/src/duckdb.cpp

@@ -28634,7 +28634,7 @@ struct PartitionFunctor {
 	                                 RowDataCollection &string_heap, RowDataBlock &data_block,
 	                                 const data_ptr_t data_ptr, RowDataBlock &heap_block, BufferHandle &heap_handle) {
 		D_ASSERT(!layout.AllConstant());
-		D_ASSERT(heap_block.block->BlockId() == heap_handle.GetBlockId());
+		D_ASSERT(heap_block.block == heap_handle.GetBlockHandle());
 		D_ASSERT(data_block.count >= heap_block.count);
 		const auto count = data_block.count - heap_block.count;
 		if (count == 0) {
@@ -37411,7 +37411,7 @@ void SBScanState::PinRadix(idx_t block_idx_to) {
 	auto &radix_sorting_data = sb->radix_sorting_data;
 	D_ASSERT(block_idx_to < radix_sorting_data.size());
 	auto &block = radix_sorting_data[block_idx_to];
-	if (!radix_handle.IsValid() || radix_handle.GetBlockId() != block->block->BlockId()) {
+	if (!radix_handle.IsValid() || radix_handle.GetBlockHandle() != block->block) {
 		radix_handle = buffer_manager.Pin(block->block);
 	}
 }
@@ -37422,14 +37422,14 @@ void SBScanState::PinData(SortedData &sd) {
 	auto &heap_handle = sd.type == SortedDataType::BLOB ? blob_sorting_heap_handle : payload_heap_handle;
 
 	auto &data_block = sd.data_blocks[block_idx];
-	if (!data_handle.IsValid() || data_handle.GetBlockId() != data_block->block->BlockId()) {
+	if (!data_handle.IsValid() || data_handle.GetBlockHandle() != data_block->block) {
 		data_handle = buffer_manager.Pin(data_block->block);
 	}
 	if (sd.layout.AllConstant() || !state.external) {
 		return;
 	}
 	auto &heap_block = sd.heap_blocks[block_idx];
-	if (!heap_handle.IsValid() || heap_handle.GetBlockId() != heap_block->block->BlockId()) {
+	if (!heap_handle.IsValid() || heap_handle.GetBlockHandle() != heap_block->block) {
 		heap_handle = buffer_manager.Pin(heap_block->block);
 	}
 }
@@ -37441,7 +37441,7 @@ data_ptr_t SBScanState::RadixPtr() const {
 data_ptr_t SBScanState::DataPtr(SortedData &sd) const {
 	auto &data_handle = sd.type == SortedDataType::BLOB ? blob_sorting_data_handle : payload_data_handle;
 	D_ASSERT(sd.data_blocks[block_idx]->block->Readers() != 0 &&
-	         data_handle.GetBlockId() == sd.data_blocks[block_idx]->block->BlockId());
+	         data_handle.GetBlockHandle() == sd.data_blocks[block_idx]->block);
 	return data_handle.Ptr() + entry_idx * sd.layout.GetRowWidth();
 }
 
@@ -37453,7 +37453,7 @@ data_ptr_t SBScanState::BaseHeapPtr(SortedData &sd) const {
 	auto &heap_handle = sd.type == SortedDataType::BLOB ? blob_sorting_heap_handle : payload_heap_handle;
 	D_ASSERT(!sd.layout.AllConstant() && state.external);
 	D_ASSERT(sd.heap_blocks[block_idx]->block->Readers() != 0 &&
-	         heap_handle.GetBlockId() == sd.heap_blocks[block_idx]->block->BlockId());
+	         heap_handle.GetBlockHandle() == sd.heap_blocks[block_idx]->block);
 	return heap_handle.Ptr();
 }
 
@@ -45233,7 +45233,7 @@ void RowDataCollectionScanner::ScanState::PinData() {
 	auto &rows = scanner.rows;
 	D_ASSERT(block_idx < rows.blocks.size());
 	auto &data_block = rows.blocks[block_idx];
-	if (!data_handle.IsValid() || data_handle.GetBlockId() != data_block->block->BlockId()) {
+	if (!data_handle.IsValid() || data_handle.GetBlockHandle() != data_block->block) {
 		data_handle = rows.buffer_manager.Pin(data_block->block);
 	}
 	if (scanner.layout.AllConstant() || !scanner.external) {
@@ -45243,7 +45243,7 @@ void RowDataCollectionScanner::ScanState::PinData() {
 	auto &heap = scanner.heap;
 	D_ASSERT(block_idx < heap.blocks.size());
 	auto &heap_block = heap.blocks[block_idx];
-	if (!heap_handle.IsValid() || heap_handle.GetBlockId() != heap_block->block->BlockId()) {
+	if (!heap_handle.IsValid() || heap_handle.GetBlockHandle() != heap_block->block) {
 		heap_handle = heap.buffer_manager.Pin(heap_block->block);
 	}
 }
@@ -191560,17 +191560,11 @@ data_ptr_t BufferHandle::Ptr() {
 	return node->buffer;
 }
 
-block_id_t BufferHandle::GetBlockId() const {
-	D_ASSERT(handle);
-	return handle->BlockId();
-}
-
 void BufferHandle::Destroy() {
 	if (!handle || !IsValid()) {
 		return;
 	}
-	auto &buffer_manager = BufferManager::GetBufferManager(handle->db);
-	buffer_manager.Unpin(handle);
+	handle->block_manager.buffer_manager.Unpin(handle);
 	handle.reset();
 	node = nullptr;
 }
@@ -191586,27 +191580,6 @@ FileBuffer &BufferHandle::GetFileBuffer() {
 
 
 
-
-namespace duckdb {
-
-ManagedBuffer::ManagedBuffer(DatabaseInstance &db, idx_t size, bool can_destroy, block_id_t id)
-    : FileBuffer(Allocator::Get(db), FileBufferType::MANAGED_BUFFER, size), db(db), can_destroy(can_destroy), id(id) {
-	D_ASSERT(id >= MAXIMUM_BLOCK);
-	D_ASSERT(size >= Storage::BLOCK_SIZE);
-}
-
-ManagedBuffer::ManagedBuffer(DatabaseInstance &db, FileBuffer &source, bool can_destroy, block_id_t id)
-    : FileBuffer(source, FileBufferType::MANAGED_BUFFER), db(db), can_destroy(can_destroy), id(id) {
-	D_ASSERT(id >= MAXIMUM_BLOCK);
-	D_ASSERT(size >= Storage::BLOCK_SIZE);
-}
-
-} // namespace duckdb
-
-
-
-
-
 //===----------------------------------------------------------------------===//
 //						 DuckDB
 //
@@ -191682,6 +191655,68 @@ public:
 #endif
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/in_memory_block_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+//! InMemoryBlockManager is an implementation for a BlockManager
+class InMemoryBlockManager : public BlockManager {
+public:
+	using BlockManager::BlockManager;
+
+	// LCOV_EXCL_START
+	void StartCheckpoint() override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
+	unique_ptr<Block> CreateBlock(block_id_t block_id) override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
+	block_id_t GetFreeBlockId() override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
+	bool IsRootBlock(block_id_t root) override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
+	void MarkBlockAsModified(block_id_t block_id) override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
+	void IncreaseBlockReferenceCount(block_id_t block_id) override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
+	block_id_t GetMetaBlock() override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
+	void Read(Block &block) override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
+	void Write(FileBuffer &block, block_id_t block_id) override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
+	void WriteHeader(DatabaseHeader header) override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
+	idx_t TotalBlocks() override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
+	idx_t FreeBlocks() override {
+		throw InternalException("Cannot perform IO in in-memory database!");
+	}
+	// LCOV_EXCL_STOP
+};
+} // namespace duckdb
+
 
 namespace duckdb {
 
@@ -191692,17 +191727,18 @@ struct BufferAllocatorData : PrivateAllocatorData {
 	BufferManager &manager;
 };
 
-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),
-      unswizzled(nullptr) {
+BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p)
+    : block_manager(block_manager), 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;
 }
 
-BlockHandle::BlockHandle(DatabaseInstance &db, block_id_t block_id_p, unique_ptr<FileBuffer> buffer_p,
+BlockHandle::BlockHandle(BlockManager &block_manager, 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), unswizzled(nullptr) {
+    : block_manager(block_manager), 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;
@@ -191710,16 +191746,16 @@ 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;
+	auto &buffer_manager = block_manager.buffer_manager;
 	// no references remain to this block: erase
 	if (state == BlockState::BLOCK_LOADED) {
 		// the block is still loaded in memory: erase it
 		buffer.reset();
 		buffer_manager.current_memory -= memory_usage;
 	}
-	buffer_manager.UnregisterBlock(block_id, can_destroy);
+	block_manager.UnregisterBlock(block_id, can_destroy);
 }
 
 unique_ptr<Block> AllocateBlock(Allocator &allocator, unique_ptr<FileBuffer> reusable_buffer, block_id_t block_id) {
@@ -191740,23 +191776,13 @@ unique_ptr<Block> AllocateBlock(Allocator &allocator, unique_ptr<FileBuffer> reu
 	}
 }
 
-unique_ptr<ManagedBuffer> AllocateManagedBuffer(DatabaseInstance &db, unique_ptr<FileBuffer> reusable_buffer,
-                                                idx_t size, bool can_destroy, block_id_t id) {
+unique_ptr<FileBuffer> AllocateManagedBuffer(DatabaseInstance &db, unique_ptr<FileBuffer> reusable_buffer, idx_t size) {
 	if (reusable_buffer) {
-		// re-usable buffer: re-use it
-		if (reusable_buffer->type == FileBufferType::MANAGED_BUFFER) {
-			// we can reuse the buffer entirely
-			auto &managed = (ManagedBuffer &)*reusable_buffer;
-			managed.id = id;
-			managed.can_destroy = can_destroy;
-			return unique_ptr_cast<FileBuffer, ManagedBuffer>(move(reusable_buffer));
-		}
-		auto buffer = make_unique<ManagedBuffer>(db, *reusable_buffer, can_destroy, id);
-		reusable_buffer.reset();
-		return buffer;
+		auto tmp = move(reusable_buffer);
+		return make_unique<FileBuffer>(*tmp, FileBufferType::MANAGED_BUFFER);
 	} else {
 		// no re-usable buffer: allocate a new buffer
-		return make_unique<ManagedBuffer>(db, size, can_destroy, id);
+		return make_unique<FileBuffer>(Allocator::Get(db), FileBufferType::MANAGED_BUFFER, size);
 	}
 }
 
@@ -191767,17 +191793,17 @@ BufferHandle BlockHandle::Load(shared_ptr<BlockHandle> &handle, unique_ptr<FileB
 		return BufferHandle(handle, handle->buffer.get());
 	}
 
-	auto &buffer_manager = BufferManager::GetBufferManager(handle->db);
-	auto &block_manager = BlockManager::GetBlockManager(handle->db);
+	auto &block_manager = handle->block_manager;
 	if (handle->block_id < MAXIMUM_BLOCK) {
-		auto block = AllocateBlock(Allocator::Get(handle->db), move(reusable_buffer), handle->block_id);
+		auto block = AllocateBlock(Allocator::Get(block_manager.buffer_manager.GetDatabase()), move(reusable_buffer),
+		                           handle->block_id);
 		block_manager.Read(*block);
 		handle->buffer = move(block);
 	} else {
 		if (handle->can_destroy) {
 			return BufferHandle();
 		} else {
-			handle->buffer = buffer_manager.ReadTemporaryBuffer(handle->block_id, move(reusable_buffer));
+			handle->buffer = block_manager.buffer_manager.ReadTemporaryBuffer(handle->block_id, move(reusable_buffer));
 		}
 	}
 	handle->state = BlockState::BLOCK_LOADED;
@@ -191785,7 +191811,6 @@ BufferHandle BlockHandle::Load(shared_ptr<BlockHandle> &handle, unique_ptr<FileB
 }
 
 unique_ptr<FileBuffer> BlockHandle::UnloadAndTakeBlock() {
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
 	if (state == BlockState::BLOCK_UNLOADED) {
 		// already unloaded: nothing to do
 		return nullptr;
@@ -191796,9 +191821,9 @@ unique_ptr<FileBuffer> BlockHandle::UnloadAndTakeBlock() {
 
 	if (block_id >= MAXIMUM_BLOCK && !can_destroy) {
 		// temporary block that cannot be destroyed: write to temporary file
-		buffer_manager.WriteTemporaryBuffer((ManagedBuffer &)*buffer);
+		block_manager.buffer_manager.WriteTemporaryBuffer(block_id, *buffer);
 	}
-	buffer_manager.current_memory -= memory_usage;
+	block_manager.buffer_manager.current_memory -= memory_usage;
 	state = BlockState::BLOCK_UNLOADED;
 	return move(buffer);
 }
@@ -191817,8 +191842,7 @@ bool BlockHandle::CanUnload() {
 		// there are active readers
 		return false;
 	}
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	if (block_id >= MAXIMUM_BLOCK && !can_destroy && buffer_manager.temp_directory.empty()) {
+	if (block_id >= MAXIMUM_BLOCK && !can_destroy && block_manager.buffer_manager.temp_directory.empty()) {
 		// in order to unload this block we need to write it to a temporary buffer
 		// however, no temporary directory is specified!
 		// hence we cannot unload the block
@@ -191894,12 +191918,13 @@ BufferManager::BufferManager(DatabaseInstance &db, string tmp, idx_t maximum_mem
       queue(make_unique<EvictionQueue>()), temporary_id(MAXIMUM_BLOCK),
       buffer_allocator(BufferAllocatorAllocate, BufferAllocatorFree, BufferAllocatorRealloc,
                        make_unique<BufferAllocatorData>(*this)) {
+	temp_block_manager = make_unique<InMemoryBlockManager>(*this);
 }
 
 BufferManager::~BufferManager() {
 }
 
-shared_ptr<BlockHandle> BufferManager::RegisterBlock(block_id_t block_id) {
+shared_ptr<BlockHandle> BlockManager::RegisterBlock(block_id_t block_id) {
 	lock_guard<mutex> lock(blocks_lock);
 	// check if the block already exists
 	auto entry = blocks.find(block_id);
@@ -191912,17 +191937,16 @@ shared_ptr<BlockHandle> BufferManager::RegisterBlock(block_id_t block_id) {
 		}
 	}
 	// create a new block pointer for this block
-	auto result = make_shared<BlockHandle>(db, block_id);
+	auto result = make_shared<BlockHandle>(*this, block_id);
 	// register the block pointer in the set of blocks as a weak pointer
 	blocks[block_id] = weak_ptr<BlockHandle>(result);
 	return result;
 }
 
-shared_ptr<BlockHandle> BufferManager::ConvertToPersistent(BlockManager &block_manager, block_id_t block_id,
-                                                           shared_ptr<BlockHandle> old_block) {
+shared_ptr<BlockHandle> BlockManager::ConvertToPersistent(block_id_t block_id, shared_ptr<BlockHandle> old_block) {
 
 	// pin the old block to ensure we have it loaded in memory
-	auto old_handle = Pin(old_block);
+	auto old_handle = buffer_manager.Pin(old_block);
 	D_ASSERT(old_block->state == BlockState::BLOCK_LOADED);
 	D_ASSERT(old_block->buffer);
 
@@ -191943,9 +191967,9 @@ shared_ptr<BlockHandle> BufferManager::ConvertToPersistent(BlockManager &block_m
 	old_block.reset();
 
 	// persist the new block to disk
-	block_manager.Write(*new_block->buffer, block_id);
+	Write(*new_block->buffer, block_id);
 
-	AddToEvictionQueue(new_block);
+	buffer_manager.AddToEvictionQueue(new_block);
 
 	return new_block;
 }
@@ -191959,11 +191983,10 @@ shared_ptr<BlockHandle> BufferManager::RegisterMemory(idx_t block_size, bool can
 		                           GetUsedMemory(), GetMaxMemory(), InMemoryWarning());
 	}
 
-	auto temp_id = ++temporary_id;
-	auto buffer = AllocateManagedBuffer(db, move(reusable_buffer), block_size, can_destroy, temp_id);
+	auto buffer = AllocateManagedBuffer(db, move(reusable_buffer), block_size);
 
 	// create a new block pointer for this block
-	return make_shared<BlockHandle>(db, temp_id, move(buffer), can_destroy, block_size);
+	return make_shared<BlockHandle>(*temp_block_manager, ++temporary_id, move(buffer), can_destroy, block_size);
 }
 
 BufferHandle BufferManager::Allocate(idx_t block_size) {
@@ -192095,12 +192118,12 @@ void BufferManager::PurgeQueue() {
 	}
 }
 
-void BufferManager::UnregisterBlock(block_id_t block_id, bool can_destroy) {
+void BlockManager::UnregisterBlock(block_id_t block_id, bool can_destroy) {
 	if (block_id >= MAXIMUM_BLOCK) {
 		// in-memory buffer: destroy the buffer
 		if (!can_destroy) {
 			// buffer could have been offloaded to disk: remove the file
-			DeleteTemporaryFile(block_id);
+			buffer_manager.DeleteTemporaryFile(block_id);
 		}
 	} else {
 		lock_guard<mutex> lock(blocks_lock);
@@ -192108,6 +192131,7 @@ void BufferManager::UnregisterBlock(block_id_t block_id, bool can_destroy) {
 		blocks.erase(block_id);
 	}
 }
+
 void BufferManager::SetLimit(idx_t limit) {
 	lock_guard<mutex> l_lock(limit_lock);
 	// try to evict until the limit is reached
@@ -192132,10 +192156,9 @@ void BufferManager::SetLimit(idx_t limit) {
 //===--------------------------------------------------------------------===//
 // Temporary File Management
 //===--------------------------------------------------------------------===//
-unique_ptr<ManagedBuffer> ReadTemporaryBufferInternal(DatabaseInstance &db, FileHandle &handle, idx_t position,
-                                                      idx_t size, block_id_t id,
-                                                      unique_ptr<FileBuffer> reusable_buffer) {
-	auto buffer = AllocateManagedBuffer(db, move(reusable_buffer), size, false, id);
+unique_ptr<FileBuffer> ReadTemporaryBufferInternal(DatabaseInstance &db, FileHandle &handle, idx_t position, idx_t size,
+                                                   unique_ptr<FileBuffer> reusable_buffer) {
+	auto buffer = AllocateManagedBuffer(db, move(reusable_buffer), size);
 	buffer->Read(handle, position);
 	return buffer;
 }
@@ -192249,14 +192272,14 @@ public:
 		return TemporaryFileIndex(file_index, block_index);
 	}
 
-	void WriteTemporaryFile(ManagedBuffer &buffer, TemporaryFileIndex index) {
+	void WriteTemporaryFile(FileBuffer &buffer, TemporaryFileIndex index) {
 		D_ASSERT(buffer.size == Storage::BLOCK_SIZE);
 		buffer.Write(*handle, GetPositionInFile(index.block_index));
 	}
 
 	unique_ptr<FileBuffer> ReadTemporaryBuffer(block_id_t id, idx_t block_index,
 	                                           unique_ptr<FileBuffer> reusable_buffer) {
-		auto buffer = ReadTemporaryBufferInternal(db, *handle, GetPositionInFile(block_index), Storage::BLOCK_SIZE, id,
+		auto buffer = ReadTemporaryBufferInternal(db, *handle, GetPositionInFile(block_index), Storage::BLOCK_SIZE,
 		                                          move(reusable_buffer));
 		{
 			// remove the block (and potentially truncate the temp file)
@@ -192264,7 +192287,7 @@ public:
 			D_ASSERT(handle);
 			RemoveTempBlockIndex(lock, block_index);
 		}
-		return move(buffer);
+		return buffer;
 	}
 
 	bool DeleteIfEmpty() {
@@ -192328,7 +192351,7 @@ public:
 		lock_guard<mutex> lock;
 	};
 
-	void WriteTemporaryBuffer(ManagedBuffer &buffer) {
+	void WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer) {
 		D_ASSERT(buffer.size == Storage::BLOCK_SIZE);
 		TemporaryFileIndex index;
 		TemporaryFileHandle *handle = nullptr;
@@ -192353,8 +192376,8 @@ public:
 
 				index = handle->TryGetBlockIndex();
 			}
-			D_ASSERT(used_blocks.find(buffer.id) == used_blocks.end());
-			used_blocks[buffer.id] = index;
+			D_ASSERT(used_blocks.find(block_id) == used_blocks.end());
+			used_blocks[block_id] = index;
 		}
 		D_ASSERT(handle);
 		D_ASSERT(index.IsValid());
@@ -192464,16 +192487,16 @@ void BufferManager::RequireTemporaryDirectory() {
 	}
 }
 
-void BufferManager::WriteTemporaryBuffer(ManagedBuffer &buffer) {
+void BufferManager::WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer) {
 	RequireTemporaryDirectory();
 	if (buffer.size == Storage::BLOCK_SIZE) {
-		temp_directory_handle->GetTempFile().WriteTemporaryBuffer(buffer);
+		temp_directory_handle->GetTempFile().WriteTemporaryBuffer(block_id, buffer);
 		return;
 	}
 
 	D_ASSERT(buffer.size > Storage::BLOCK_SIZE);
 	// get the path to write to
-	auto path = GetTemporaryPath(buffer.id);
+	auto path = GetTemporaryPath(block_id);
 	// create the file and write the size followed by the buffer contents
 	auto &fs = FileSystem::GetFileSystem(db);
 	auto handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE);
@@ -192495,11 +192518,11 @@ unique_ptr<FileBuffer> BufferManager::ReadTemporaryBuffer(block_id_t id, unique_
 	handle->Read(&block_size, sizeof(idx_t), 0);
 
 	// now allocate a buffer of this size and read the data into that buffer
-	auto buffer = ReadTemporaryBufferInternal(db, *handle, sizeof(idx_t), block_size, id, move(reusable_buffer));
+	auto buffer = ReadTemporaryBufferInternal(db, *handle, sizeof(idx_t), block_size, move(reusable_buffer));
 
 	handle.reset();
 	DeleteTemporaryFile(id);
-	return move(buffer);
+	return buffer;
 }
 
 void BufferManager::DeleteTemporaryFile(block_id_t id) {
@@ -193527,12 +193550,11 @@ void CheckpointManager::FlushPartialSegments() {
 }
 
 void PartialBlock::FlushToDisk(DatabaseInstance &db) {
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
 	auto &block_manager = BlockManager::GetBlockManager(db);
 
 	// the data for the block might already exists in-memory of our block
 	// instead of copying the data we alter some metadata so the buffer points to an on-disk block
-	block = buffer_manager.ConvertToPersistent(block_manager, block_id, move(block));
+	block = block_manager.ConvertToPersistent(block_id, move(block));
 
 	// now set this block as the block for all segments
 	for (auto &seg : segments) {
@@ -197750,12 +197772,13 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V
 	D_ASSERT(block != INVALID_BLOCK);
 	D_ASSERT(offset < Storage::BLOCK_SIZE);
 
+	auto &block_manager = BlockManager::GetBlockManager(segment.db);
 	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
 	auto &state = (UncompressedStringSegmentState &)*segment.GetSegmentState();
 	if (block < MAXIMUM_BLOCK) {
 		// read the overflow string from disk
 		// pin the initial handle and read the length
-		auto block_handle = buffer_manager.RegisterBlock(block);
+		auto block_handle = block_manager.RegisterBlock(block);
 		auto handle = buffer_manager.Pin(block_handle);
 
 		// read header
@@ -197785,7 +197808,7 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V
 				if (remaining > 0) {
 					// read the next block
 					block_id_t next_block = Load<block_id_t>(handle.Ptr() + offset);
-					block_handle = buffer_manager.RegisterBlock(next_block);
+					block_handle = block_manager.RegisterBlock(next_block);
 					handle = buffer_manager.Pin(block_handle);
 					offset = 0;
 				}
@@ -199911,7 +199934,7 @@ void MetaBlockReader::ReadNewBlock(block_id_t id) {
 	auto &buffer_manager = BufferManager::GetBufferManager(db);
 
 	block_manager.MarkBlockAsModified(id);
-	block = buffer_manager.RegisterBlock(id);
+	block = block_manager.RegisterBlock(id);
 	handle = buffer_manager.Pin(block);
 
 	next_block = Load<block_id_t>(handle.Ptr());
@@ -200103,6 +200126,7 @@ private:
 
 
 
+
 #include <algorithm>
 #include <cstring>
 
@@ -200178,7 +200202,7 @@ T DeserializeHeaderStructure(data_ptr_t ptr) {
 
 SingleFileBlockManager::SingleFileBlockManager(DatabaseInstance &db, string path_p, bool read_only, bool create_new,
                                                bool use_direct_io)
-    : db(db), path(move(path_p)),
+    : BlockManager(BufferManager::GetBufferManager(db)), db(db), path(move(path_p)),
       header_buffer(Allocator::Get(db), FileBufferType::MANAGED_BUFFER, Storage::FILE_HEADER_SIZE), iteration_count(0),
       read_only(read_only), use_direct_io(use_direct_io) {
 	uint8_t flags;
@@ -201613,65 +201637,6 @@ void StorageLock::ReleaseSharedLock() {
 } // namespace duckdb
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/in_memory_block_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! InMemoryBlockManager is an implementation for a BlockManager
-class InMemoryBlockManager : public BlockManager {
-public:
-	// LCOV_EXCL_START
-	void StartCheckpoint() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	unique_ptr<Block> CreateBlock(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	block_id_t GetFreeBlockId() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	bool IsRootBlock(block_id_t root) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	void MarkBlockAsModified(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	void IncreaseBlockReferenceCount(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	block_id_t GetMetaBlock() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	void Read(Block &block) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	void Write(FileBuffer &block, block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	void WriteHeader(DatabaseHeader header) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	idx_t TotalBlocks() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	idx_t FreeBlocks() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	// LCOV_EXCL_STOP
-};
-} // namespace duckdb
 
 
 
@@ -201748,7 +201713,7 @@ void StorageManager::Initialize() {
 		// create or load the database from disk, if not in-memory mode
 		LoadDatabase();
 	} else {
-		block_manager = make_unique<InMemoryBlockManager>();
+		block_manager = make_unique<InMemoryBlockManager>(*buffer_manager);
 	}
 }
 
@@ -203234,6 +203199,7 @@ ColumnSegment::ColumnSegment(DatabaseInstance &db, LogicalType type_p, ColumnSeg
       segment_type(segment_type), function(function_p), stats(type, move(statistics)), block_id(block_id_p),
       offset(offset_p) {
 	D_ASSERT(function);
+	auto &block_manager = BlockManager::GetBlockManager(db);
 	auto &buffer_manager = BufferManager::GetBufferManager(db);
 	if (block_id == INVALID_BLOCK) {
 		// no block id specified
@@ -203245,7 +203211,7 @@ ColumnSegment::ColumnSegment(DatabaseInstance &db, LogicalType type_p, ColumnSeg
 		}
 	} else {
 		D_ASSERT(segment_type == ColumnSegmentType::PERSISTENT);
-		this->block = buffer_manager.RegisterBlock(block_id);
+		this->block = block_manager.RegisterBlock(block_id);
 	}
 	if (function->init_segment) {
 		segment_state = function->init_segment(*this, block_id);
@@ -203339,12 +203305,11 @@ void ColumnSegment::ConvertToPersistent(block_id_t block_id_p) {
 		block.reset();
 	} else {
 		// non-constant block: write the block to disk
-		auto &buffer_manager = BufferManager::GetBufferManager(db);
 		auto &block_manager = BlockManager::GetBlockManager(db);
 
 		// the data for the block already exists in-memory of our block
 		// instead of copying the data we alter some metadata so the buffer points to an on-disk block
-		block = buffer_manager.ConvertToPersistent(block_manager, block_id, move(block));
+		block = block_manager.ConvertToPersistent(block_id, move(block));
 	}
 
 	segment_state.reset();