duckdb 0.7.2-dev1684.0 → 0.7.2-dev1734.0

package/src/duckdb/src/function/table/system/duckdb_extensions.cpp

@@ -75,7 +75,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 		}
 		installed_extensions[info.name] = std::move(info);
 	}
-
+#ifndef WASM_LOADABLE_EXTENSIONS
 	// scan the install directory for installed extensions
 	auto ext_directory = ExtensionHelper::ExtensionDirectory(context);
 	fs.ListFiles(ext_directory, [&](const string &path, bool is_directory) {
@@ -96,7 +96,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 			entry->second.installed = true;
 		}
 	});
-
+#endif
 	// now check the list of currently loaded extensions
 	auto &loaded_extensions = db.LoadedExtensions();
 	for (auto &ext_name : loaded_extensions) {

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev1684"
+#define DUCKDB_VERSION "0.7.2-dev1734"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "754ff32005"
+#define DUCKDB_SOURCE_ID "e8610c85fb"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -0,0 +1,247 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/sort/partition_state.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/sort/sort.hpp"
+#include "duckdb/common/types/partitioned_column_data.hpp"
+#include "duckdb/common/radix_partitioning.hpp"
+#include "duckdb/parallel/base_pipeline_event.hpp"
+
+namespace duckdb {
+
+class PartitionGlobalHashGroup {
+public:
+	using GlobalSortStatePtr = unique_ptr<GlobalSortState>;
+	using LocalSortStatePtr = unique_ptr<LocalSortState>;
+	using Orders = vector<BoundOrderByNode>;
+	using Types = vector<LogicalType>;
+
+	PartitionGlobalHashGroup(BufferManager &buffer_manager, const Orders &partitions, const Orders &orders,
+	                         const Types &payload_types, bool external);
+
+	void ComputeMasks(ValidityMask &partition_mask, ValidityMask &order_mask);
+
+	GlobalSortStatePtr global_sort;
+	atomic<idx_t> count;
+
+	// Mask computation
+	SortLayout partition_layout;
+};
+
+class PartitionGlobalSinkState {
+public:
+	using HashGroupPtr = unique_ptr<PartitionGlobalHashGroup>;
+	using Orders = vector<BoundOrderByNode>;
+	using Types = vector<LogicalType>;
+
+	using GroupingPartition = unique_ptr<PartitionedColumnData>;
+	using GroupingAppend = unique_ptr<PartitionedColumnDataAppendState>;
+
+	PartitionGlobalSinkState(ClientContext &context, const vector<unique_ptr<Expression>> &partitions_p,
+	                         const vector<BoundOrderByNode> &orders_p, const Types &payload_types,
+	                         const vector<unique_ptr<BaseStatistics>> &partitions_stats, idx_t estimated_cardinality);
+
+	void UpdateLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append);
+	void CombineLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append);
+
+	void BuildSortState(ColumnDataCollection &group_data, PartitionGlobalHashGroup &global_sort);
+
+	ClientContext &context;
+	BufferManager &buffer_manager;
+	Allocator &allocator;
+	mutex lock;
+
+	// OVER(PARTITION BY...) (hash grouping)
+	unique_ptr<RadixPartitionedColumnData> grouping_data;
+	//! Payload plus hash column
+	Types grouping_types;
+
+	// OVER(...) (sorting)
+	Orders partitions;
+	Orders orders;
+	const Types payload_types;
+	vector<HashGroupPtr> hash_groups;
+	bool external;
+
+	// OVER() (no sorting)
+	unique_ptr<RowDataCollection> rows;
+	unique_ptr<RowDataCollection> strings;
+
+	// Threading
+	idx_t memory_per_thread;
+	atomic<idx_t> count;
+
+private:
+	void ResizeGroupingData(idx_t cardinality);
+	void SyncLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append);
+};
+
+class PartitionLocalSinkState {
+public:
+	PartitionLocalSinkState(ClientContext &context, PartitionGlobalSinkState &gstate_p);
+
+	// Global state
+	PartitionGlobalSinkState &gstate;
+	Allocator &allocator;
+
+	// OVER(PARTITION BY...) (hash grouping)
+	ExpressionExecutor executor;
+	DataChunk group_chunk;
+	DataChunk payload_chunk;
+	unique_ptr<PartitionedColumnData> local_partition;
+	unique_ptr<PartitionedColumnDataAppendState> local_append;
+
+	// OVER(...) (sorting)
+	size_t sort_cols;
+
+	// OVER() (no sorting)
+	RowLayout payload_layout;
+	unique_ptr<RowDataCollection> rows;
+	unique_ptr<RowDataCollection> strings;
+
+	//! Compute the hash values
+	void Hash(DataChunk &input_chunk, Vector &hash_vector);
+	//! Sink an input chunk
+	void Sink(DataChunk &input_chunk);
+	//! Merge the state into the global state.
+	void Combine();
+};
+
+enum class PartitionSortStage : uint8_t { INIT, PREPARE, MERGE, SORTED };
+
+class PartitionLocalMergeState;
+
+class PartitionGlobalMergeState {
+public:
+	using GroupDataPtr = unique_ptr<ColumnDataCollection>;
+
+	explicit PartitionGlobalMergeState(PartitionGlobalSinkState &sink, GroupDataPtr group_data);
+
+	bool IsSorted() const {
+		lock_guard<mutex> guard(lock);
+		return stage == PartitionSortStage::SORTED;
+	}
+
+	bool AssignTask(PartitionLocalMergeState &local_state);
+	bool TryPrepareNextStage();
+	void CompleteTask();
+
+	PartitionGlobalSinkState &sink;
+	GroupDataPtr group_data;
+	PartitionGlobalHashGroup *hash_group;
+	GlobalSortState *global_sort;
+
+private:
+	mutable mutex lock;
+	PartitionSortStage stage;
+	idx_t total_tasks;
+	idx_t tasks_assigned;
+	idx_t tasks_completed;
+};
+
+class PartitionLocalMergeState {
+public:
+	PartitionLocalMergeState() : merge_state(nullptr), stage(PartitionSortStage::INIT) {
+		finished = true;
+	}
+
+	bool TaskFinished() {
+		return finished;
+	}
+
+	void Prepare();
+	void Merge();
+
+	void ExecuteTask();
+
+	PartitionGlobalMergeState *merge_state;
+	PartitionSortStage stage;
+	atomic<bool> finished;
+};
+
+class PartitionGlobalMergeStates {
+public:
+	using PartitionGlobalMergeStatePtr = unique_ptr<PartitionGlobalMergeState>;
+
+	explicit PartitionGlobalMergeStates(PartitionGlobalSinkState &sink);
+
+	vector<PartitionGlobalMergeStatePtr> states;
+};
+
+class PartitionMergeEvent : public BasePipelineEvent {
+public:
+	PartitionMergeEvent(PartitionGlobalSinkState &gstate_p, Pipeline &pipeline_p)
+	    : BasePipelineEvent(pipeline_p), gstate(gstate_p), merge_states(gstate_p) {
+	}
+
+	PartitionGlobalSinkState &gstate;
+	PartitionGlobalMergeStates merge_states;
+
+public:
+	void Schedule() override;
+};
+
+class PartitionGlobalSourceState {
+public:
+	explicit PartitionGlobalSourceState(PartitionGlobalSinkState &gsink_p) : gsink(gsink_p), next_bin(0) {
+	}
+
+	PartitionGlobalSinkState &gsink;
+	//! The output read position.
+	atomic<idx_t> next_bin;
+
+public:
+	idx_t MaxThreads() {
+		// If there is only one partition, we have to process it on one thread.
+		if (!gsink.grouping_data) {
+			return 1;
+		}
+
+		// If there is not a lot of data, process serially.
+		if (gsink.count < STANDARD_ROW_GROUPS_SIZE) {
+			return 1;
+		}
+
+		return gsink.hash_groups.size();
+	}
+};
+
+// Per-thread read state
+class PartitionLocalSourceState {
+public:
+	using HashGroupPtr = unique_ptr<PartitionGlobalHashGroup>;
+
+	explicit PartitionLocalSourceState(PartitionGlobalSinkState &gstate_p);
+
+	void MaterializeSortedData();
+	idx_t GeneratePartition(const idx_t hash_bin);
+
+	PartitionGlobalSinkState &gstate;
+
+	//! The read partition
+	idx_t hash_bin;
+	HashGroupPtr hash_group;
+
+	//! The generated input chunks
+	unique_ptr<RowDataCollection> rows;
+	unique_ptr<RowDataCollection> heap;
+	RowLayout layout;
+	//! The partition boundary mask
+	vector<validity_t> partition_bits;
+	ValidityMask partition_mask;
+	//! The order boundary mask
+	vector<validity_t> order_bits;
+	ValidityMask order_mask;
+	//! The read cursor
+	unique_ptr<RowDataCollectionScanner> scanner;
+	//! Buffer for the inputs
+	DataChunk input_chunk;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp

@@ -12,14 +12,13 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/storage/storage_info.hpp"
+#include "duckdb/common/file_buffer.hpp"
 
 namespace duckdb {
 class BlockManager;
 class BufferHandle;
-class BufferManager;
 class BufferPool;
 class DatabaseInstance;
-class FileBuffer;
 
 enum class BlockState : uint8_t { BLOCK_UNLOADED = 0, BLOCK_LOADED = 1 };
 

package/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool.hpp

@@ -0,0 +1,77 @@
+#pragma once
+
+#include "duckdb/common/mutex.hpp"
+#include "duckdb/common/file_buffer.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
+
+namespace duckdb {
+
+struct EvictionQueue;
+
+struct BufferEvictionNode {
+	BufferEvictionNode() {
+	}
+	BufferEvictionNode(weak_ptr<BlockHandle> handle_p, idx_t timestamp_p)
+	    : handle(std::move(handle_p)), timestamp(timestamp_p) {
+		D_ASSERT(!handle.expired());
+	}
+
+	weak_ptr<BlockHandle> handle;
+	idx_t timestamp;
+
+	bool CanUnload(BlockHandle &handle_p);
+
+	shared_ptr<BlockHandle> TryGetBlockHandle();
+};
+
+//! The BufferPool is in charge of handling memory management for one or more databases. It defines memory limits
+//! and implements priority eviction among all users of the pool.
+class BufferPool {
+	friend class BlockHandle;
+	friend class BlockManager;
+	friend class BufferManager;
+
+public:
+	explicit BufferPool(idx_t maximum_memory);
+	virtual ~BufferPool();
+
+	//! Set a new memory limit to the buffer pool, throws an exception if the new limit is too low and not enough
+	//! blocks can be evicted
+	void SetLimit(idx_t limit, const char *exception_postscript);
+
+	idx_t GetUsedMemory();
+
+	idx_t GetMaxMemory();
+
+protected:
+	//! Evict blocks until the currently used memory + extra_memory fit, returns false if this was not possible
+	//! (i.e. not enough blocks could be evicted)
+	//! If the "buffer" argument is specified AND the system can find a buffer to re-use for the given allocation size
+	//! "buffer" will be made to point to the re-usable memory. Note that this is not guaranteed.
+	//! Returns a pair. result.first indicates if eviction was successful. result.second contains the
+	//! reservation handle, which can be moved to the BlockHandle that will own the reservation.
+	struct EvictionResult {
+		bool success;
+		TempBufferPoolReservation reservation;
+	};
+	virtual EvictionResult EvictBlocks(idx_t extra_memory, idx_t memory_limit,
+	                                   unique_ptr<FileBuffer> *buffer = nullptr);
+
+	//! Garbage collect eviction queue
+	void PurgeQueue();
+	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
+
+private:
+	//! The lock for changing the memory limit
+	mutex limit_lock;
+	//! The current amount of memory that is occupied by the buffer manager (in bytes)
+	atomic<idx_t> current_memory;
+	//! The maximum amount of memory that the buffer manager can keep (in bytes)
+	atomic<idx_t> maximum_memory;
+	//! Eviction queue
+	unique_ptr<EvictionQueue> queue;
+	//! Total number of insertions into the eviction queue. This guides the schedule for calling PurgeQueue.
+	atomic<uint32_t> queue_insertions;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/buffer/temporary_file_information.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+
+struct TemporaryFileInformation {
+	string path;
+	idx_t size;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/buffer_manager.hpp

@@ -16,6 +16,8 @@
 #include "duckdb/storage/block_manager.hpp"
 #include "duckdb/storage/buffer/block_handle.hpp"
 #include "duckdb/storage/buffer/buffer_handle.hpp"
+#include "duckdb/storage/buffer/buffer_pool.hpp"
+#include "duckdb/storage/buffer/temporary_file_information.hpp"
 
 namespace duckdb {
 class BlockManager;
@@ -23,65 +25,7 @@ class DatabaseInstance;
 class TemporaryDirectoryHandle;
 struct EvictionQueue;
 
-//! The BufferPool is in charge of handling memory management for one or more databases. It defines memory limits
-//! and implements priority eviction among all users of the pool.
-class BufferPool {
-	friend class BlockHandle;
-	friend class BlockManager;
-	friend class BufferManager;
-
-public:
-	explicit BufferPool(idx_t maximum_memory);
-	virtual ~BufferPool();
-
-	//! Set a new memory limit to the buffer pool, throws an exception if the new limit is too low and not enough
-	//! blocks can be evicted
-	void SetLimit(idx_t limit, const char *exception_postscript);
-
-	idx_t GetUsedMemory() {
-		return current_memory;
-	}
-	idx_t GetMaxMemory() {
-		return maximum_memory;
-	}
-
-protected:
-	//! Evict blocks until the currently used memory + extra_memory fit, returns false if this was not possible
-	//! (i.e. not enough blocks could be evicted)
-	//! If the "buffer" argument is specified AND the system can find a buffer to re-use for the given allocation size
-	//! "buffer" will be made to point to the re-usable memory. Note that this is not guaranteed.
-	//! Returns a pair. result.first indicates if eviction was successful. result.second contains the
-	//! reservation handle, which can be moved to the BlockHandle that will own the reservation.
-	struct EvictionResult {
-		bool success;
-		TempBufferPoolReservation reservation;
-	};
-	virtual EvictionResult EvictBlocks(idx_t extra_memory, idx_t memory_limit,
-	                                   unique_ptr<FileBuffer> *buffer = nullptr);
-
-	//! Garbage collect eviction queue
-	void PurgeQueue();
-	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
-
-private:
-	//! The lock for changing the memory limit
-	mutex limit_lock;
-	//! The current amount of memory that is occupied by the buffer manager (in bytes)
-	atomic<idx_t> current_memory;
-	//! The maximum amount of memory that the buffer manager can keep (in bytes)
-	atomic<idx_t> maximum_memory;
-	//! Eviction queue
-	unique_ptr<EvictionQueue> queue;
-	//! Total number of insertions into the eviction queue. This guides the schedule for calling PurgeQueue.
-	atomic<uint32_t> queue_insertions;
-};
-
-struct TemporaryFileInformation {
-	string path;
-	idx_t size;
-};
-
-//! The BufferManager is in charge of handling memory management for a singke database. It cooperatively shares a
+//! The BufferManager is in charge of handling memory management for a single database. It cooperatively shares a
 //! BufferPool with other BufferManagers, belonging to different databases. It hands out memory buffers that can
 //! be used by the database internally, and offers configuration options specific to a database, which need not be
 //! shared by the BufferPool, including whether to support swapping temp buffers to disk, and where to swap them to.

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -39,6 +39,9 @@ const vector<string> ExtensionHelper::PathComponents() {
 }
 
 string ExtensionHelper::ExtensionDirectory(DBConfig &config, FileSystem &fs, FileOpener *opener) {
+#ifdef WASM_LOADABLE_EXTENSIONS
+	static_assertion(0, "ExtensionDirectory functionality is not supported in duckdb-wasm");
+#endif
 	string extension_directory;
 	if (!config.options.extension_directory.empty()) { // create the extension directory if not present
 		extension_directory = config.options.extension_directory;
@@ -111,11 +114,19 @@ bool ExtensionHelper::CreateSuggestions(const string &extension_name, string &me
 }
 
 void ExtensionHelper::InstallExtension(DBConfig &config, FileSystem &fs, const string &extension, bool force_install) {
+#ifdef WASM_LOADABLE_EXTENSIONS
+	// Install is currently a no-op
+	return;
+#endif
 	string local_path = ExtensionDirectory(config, fs, nullptr);
 	InstallExtensionInternal(config, nullptr, fs, local_path, extension, force_install);
 }
 
 void ExtensionHelper::InstallExtension(ClientContext &context, const string &extension, bool force_install) {
+#ifdef WASM_LOADABLE_EXTENSIONS
+	// Install is currently a no-op
+	return;
+#endif
 	auto &config = DBConfig::GetConfig(context);
 	auto &fs = FileSystem::GetFileSystem(context);
 	string local_path = ExtensionDirectory(context);

package/src/duckdb/src/main/extension/extension_load.cpp

@@ -4,6 +4,10 @@
 #include "duckdb/main/error_manager.hpp"
 #include "mbedtls_wrapper.hpp"
 
+#ifdef WASM_LOADABLE_EXTENSIONS
+#include <emscripten.h>
+#endif
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -86,13 +90,35 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileOpener *opener, const
 			throw IOException(config.error_manager->FormatException(ErrorType::UNSIGNED_EXTENSION, filename));
 		}
 	}
-	auto lib_hdl = dlopen(filename.c_str(), RTLD_NOW | RTLD_LOCAL);
+	auto basename = fs.ExtractBaseName(filename);
+
+#ifdef WASM_LOADABLE_EXTENSIONS
+	EM_ASM(
+	    {
+		    // Next few lines should argubly in separate JavaScript-land function call
+		    // TODO: move them out / have them configurable
+		    const xhr = new XMLHttpRequest();
+		    xhr.open("GET", UTF8ToString($0), false);
+		    xhr.responseType = "arraybuffer";
+		    xhr.send(null);
+		    var uInt8Array = xhr.response;
+		    WebAssembly.validate(uInt8Array);
+		    console.log('Loading extension ', UTF8ToString($1));
+
+		    // Here we add the uInt8Array to Emscripten's filesystem, for it to be found by dlopen
+		    FS.writeFile(UTF8ToString($1), new Uint8Array(uInt8Array));
+	    },
+	    filename.c_str(), basename.c_str());
+	auto dopen_from = basename;
+#else
+	auto dopen_from = filename;
+#endif
+
+	auto lib_hdl = dlopen(dopen_from.c_str(), RTLD_NOW | RTLD_LOCAL);
 	if (!lib_hdl) {
 		throw IOException("Extension \"%s\" could not be loaded: %s", filename, GetDLError());
 	}
 
-	auto basename = fs.ExtractBaseName(filename);
-
 	ext_version_fun_t version_fun;
 	auto version_fun_name = basename + "_version";
 

package/src/duckdb/src/storage/buffer/block_handle.cpp

@@ -0,0 +1,128 @@
+#include "duckdb/storage/buffer/block_handle.hpp"
+#include "duckdb/storage/block.hpp"
+#include "duckdb/storage/block_manager.hpp"
+#include "duckdb/storage/buffer/buffer_handle.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/common/file_buffer.hpp"
+
+namespace duckdb {
+
+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(BlockManager &block_manager, block_id_t block_id_p, unique_ptr<FileBuffer> buffer_p,
+                         bool can_destroy_p, idx_t block_size, BufferPoolReservation &&reservation)
+    : block_manager(block_manager), readers(0), block_id(block_id_p), eviction_timestamp(0), can_destroy(can_destroy_p),
+      unswizzled(nullptr) {
+	buffer = std::move(buffer_p);
+	state = BlockState::BLOCK_LOADED;
+	memory_usage = block_size;
+	memory_charge = std::move(reservation);
+}
+
+BlockHandle::~BlockHandle() { // NOLINT: allow internal exceptions
+	// 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 (buffer && state == BlockState::BLOCK_LOADED) {
+		D_ASSERT(memory_charge.size > 0);
+		// the block is still loaded in memory: erase it
+		buffer.reset();
+		memory_charge.Resize(buffer_manager.buffer_pool.current_memory, 0);
+	} else {
+		D_ASSERT(memory_charge.size == 0);
+	}
+	buffer_manager.buffer_pool.PurgeQueue();
+	block_manager.UnregisterBlock(block_id, can_destroy);
+}
+
+unique_ptr<Block> AllocateBlock(BlockManager &block_manager, unique_ptr<FileBuffer> reusable_buffer,
+                                block_id_t block_id) {
+	if (reusable_buffer) {
+		// re-usable buffer: re-use it
+		if (reusable_buffer->type == FileBufferType::BLOCK) {
+			// we can reuse the buffer entirely
+			auto &block = (Block &)*reusable_buffer;
+			block.id = block_id;
+			return unique_ptr_cast<FileBuffer, Block>(std::move(reusable_buffer));
+		}
+		auto block = block_manager.CreateBlock(block_id, reusable_buffer.get());
+		reusable_buffer.reset();
+		return block;
+	} else {
+		// no re-usable buffer: allocate a new block
+		return block_manager.CreateBlock(block_id, nullptr);
+	}
+}
+
+BufferHandle BlockHandle::Load(shared_ptr<BlockHandle> &handle, unique_ptr<FileBuffer> reusable_buffer) {
+	if (handle->state == BlockState::BLOCK_LOADED) {
+		// already loaded
+		D_ASSERT(handle->buffer);
+		return BufferHandle(handle, handle->buffer.get());
+	}
+
+	auto &block_manager = handle->block_manager;
+	if (handle->block_id < MAXIMUM_BLOCK) {
+		auto block = AllocateBlock(block_manager, std::move(reusable_buffer), handle->block_id);
+		block_manager.Read(*block);
+		handle->buffer = std::move(block);
+	} else {
+		if (handle->can_destroy) {
+			return BufferHandle();
+		} else {
+			handle->buffer =
+			    block_manager.buffer_manager.ReadTemporaryBuffer(handle->block_id, std::move(reusable_buffer));
+		}
+	}
+	handle->state = BlockState::BLOCK_LOADED;
+	return BufferHandle(handle, handle->buffer.get());
+}
+
+unique_ptr<FileBuffer> BlockHandle::UnloadAndTakeBlock() {
+	if (state == BlockState::BLOCK_UNLOADED) {
+		// already unloaded: nothing to do
+		return nullptr;
+	}
+	D_ASSERT(!unswizzled);
+	D_ASSERT(CanUnload());
+
+	if (block_id >= MAXIMUM_BLOCK && !can_destroy) {
+		// temporary block that cannot be destroyed: write to temporary file
+		block_manager.buffer_manager.WriteTemporaryBuffer(block_id, *buffer);
+	}
+	memory_charge.Resize(block_manager.buffer_manager.buffer_pool.current_memory, 0);
+	state = BlockState::BLOCK_UNLOADED;
+	return std::move(buffer);
+}
+
+void BlockHandle::Unload() {
+	auto block = UnloadAndTakeBlock();
+	block.reset();
+}
+
+bool BlockHandle::CanUnload() {
+	if (state == BlockState::BLOCK_UNLOADED) {
+		// already unloaded
+		return false;
+	}
+	if (readers > 0) {
+		// there are active readers
+		return false;
+	}
+	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
+		return false;
+	}
+	return true;
+}
+
+} // namespace duckdb