duckdb 0.7.2-dev14.0 → 0.7.2-dev225.0

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

@@ -23,23 +23,75 @@ 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 buffer manager is in charge of handling memory management for the database. It hands out memory buffers that can
-//! be used by the database internally.
-//
-//! BlockIds are NOT unique within the context of a BufferManager. A buffer manager
-//! can be shared by many BlockManagers.
+//! The BufferManager is in charge of handling memory management for a singke 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.
 class BufferManager {
 	friend class BufferHandle;
 	friend class BlockHandle;
 	friend class BlockManager;
 
 public:
-	BufferManager(DatabaseInstance &db, string temp_directory, idx_t maximum_memory);
+	BufferManager(DatabaseInstance &db, string temp_directory);
 	virtual ~BufferManager();
 
 	//! Registers an in-memory buffer that cannot be unloaded until it is destroyed
@@ -58,21 +110,17 @@ public:
 	BufferHandle Pin(shared_ptr<BlockHandle> &handle);
 	void Unpin(shared_ptr<BlockHandle> &handle);
 
-	//! Set a new memory limit to the buffer manager, throws an exception if the new limit is too low and not enough
-	//! blocks can be evicted
-	void SetLimit(idx_t limit = (idx_t)-1);
-
 	DUCKDB_API static BufferManager &GetBufferManager(ClientContext &context);
 	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
 	DUCKDB_API static BufferManager &GetBufferManager(AttachedDatabase &db);
 
 	//! Returns the currently allocated memory
 	idx_t GetUsedMemory() {
-		return current_memory;
+		return buffer_pool.current_memory;
 	}
 	//! Returns the maximum available memory
 	idx_t GetMaxMemory() {
-		return maximum_memory;
+		return buffer_pool.maximum_memory;
 	}
 
 	//! Increases the currently allocated memory, but the actual allocation does not go through the buffer manager
@@ -92,6 +140,10 @@ public:
 		return db;
 	}
 
+	BufferPool &GetBufferPool() {
+		return buffer_pool;
+	}
+
 	static idx_t GetAllocSize(idx_t block_size) {
 		return AlignValue<idx_t, Storage::SECTOR_SIZE>(block_size + Storage::BLOCK_HEADER_SIZE);
 	}
@@ -103,6 +155,11 @@ public:
 	DUCKDB_API void ReserveMemory(idx_t size);
 	DUCKDB_API void FreeReservedMemory(idx_t size);
 
+	//! 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. (Sugar for calling method directly on the BufferPool.)
+	void SetLimit(idx_t limit = (idx_t)-1) {
+		buffer_pool.SetLimit(limit, InMemoryWarning());
+	}
 	//! Returns a list of all temporary files
 	vector<TemporaryFileInformation> GetTemporaryFiles();
 
@@ -113,25 +170,6 @@ private:
 	//! This needs to be private to prevent creating blocks without ever pinning them:
 	//! blocks that are never pinned are never added to the eviction queue
 	shared_ptr<BlockHandle> RegisterMemory(idx_t block_size, bool can_destroy);
-	//! 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;
-	};
-	EvictionResult EvictBlocks(idx_t extra_memory, idx_t memory_limit, unique_ptr<FileBuffer> *buffer = nullptr);
-
-	//! Helper
-	template <typename... ARGS>
-	TempBufferPoolReservation EvictBlocksOrThrow(idx_t extra_memory, idx_t limit, unique_ptr<FileBuffer> *buffer,
-	                                             ARGS...);
-
-	//! Garbage collect eviction queue
-	void PurgeQueue();
 
 	//! Write a temporary buffer to disk
 	void WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer);
@@ -144,9 +182,7 @@ private:
 
 	void RequireTemporaryDirectory();
 
-	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
-
-	string InMemoryWarning();
+	const char *InMemoryWarning();
 
 	static data_ptr_t BufferAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size);
 	static void BufferAllocatorFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size);
@@ -157,27 +193,23 @@ private:
 	//! overwrites the data within with garbage. Any readers that do not hold the pin will notice
 	void VerifyZeroReaders(shared_ptr<BlockHandle> &handle);
 
+	//! Helper
+	template <typename... ARGS>
+	TempBufferPoolReservation EvictBlocksOrThrow(idx_t extra_memory, unique_ptr<FileBuffer> *buffer, ARGS...);
+
 private:
 	//! The database instance
 	DatabaseInstance &db;
-	//! 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;
+	//! The buffer pool
+	BufferPool &buffer_pool;
 	//! The directory name where temporary files are stored
 	string temp_directory;
 	//! Lock for creating the temp handle
 	mutex temp_handle_lock;
 	//! Handle for the temporary directory
 	unique_ptr<TemporaryDirectoryHandle> temp_directory_handle;
-	//! Eviction queue
-	unique_ptr<EvictionQueue> queue;
 	//! The temporary id used for managed buffers
 	atomic<block_id_t> temporary_id;
-	//! Total number of insertions into the eviction queue. This guides the schedule for calling PurgeQueue.
-	atomic<uint32_t> queue_insertions;
 	//! Allocator associated with the buffer manager, that passes all allocations through this buffer manager
 	Allocator buffer_allocator;
 	//! Block manager for temp data

package/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp

@@ -39,6 +39,8 @@ public:
 	unique_ptr<BaseStatistics> validity_stats;
 	//! The approximate count distinct stats of the column (if any)
 	unique_ptr<BaseStatistics> distinct_stats;
+	idx_t distinct_count; // estimate that one may have even if distinct_stats==nullptr
+
 	//! Whether these are 'global' stats, i.e., over a whole table, or just over a segment
 	//! Some statistics are more expensive to keep, therefore we only keep them globally
 	StatisticsType stats_type;

package/src/duckdb/src/include/duckdb/storage/statistics/node_statistics.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/serializer.hpp"
 
 namespace duckdb {
 
@@ -23,6 +24,31 @@ public:
 	    : has_estimated_cardinality(true), estimated_cardinality(estimated_cardinality), has_max_cardinality(true),
 	      max_cardinality(max_cardinality) {
 	}
+	void Serialize(Serializer &serializer) const {
+		serializer.Write(has_estimated_cardinality);
+		if (has_estimated_cardinality) {
+			serializer.Write(estimated_cardinality);
+			serializer.Write(has_max_cardinality);
+			if (has_max_cardinality) {
+				serializer.Write(max_cardinality);
+			}
+		} else {
+			D_ASSERT(!has_max_cardinality);
+		}
+	}
+	static unique_ptr<NodeStatistics> Deserialize(Deserializer &source) {
+		bool has_estimated_cardinality = source.Read<bool>();
+		if (!has_estimated_cardinality) {
+			return make_unique<NodeStatistics>();
+		}
+		idx_t estimated_cardinality = source.Read<idx_t>();
+		bool has_max_cardinality = source.Read<bool>();
+		if (!has_max_cardinality) {
+			return make_unique<NodeStatistics>(estimated_cardinality);
+		}
+		idx_t max_cardinality = source.Read<idx_t>();
+		return make_unique<NodeStatistics>(estimated_cardinality, max_cardinality);
+	}
 
 	//! Whether or not the node has an estimated cardinality specified
 	bool has_estimated_cardinality;

package/src/duckdb/src/include/duckdb/storage/table/list_column_data.hpp

@@ -61,7 +61,7 @@ public:
 	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) override;
 
 private:
-	list_entry_t FetchListEntry(idx_t row_idx);
+	uint64_t FetchListOffset(idx_t row_idx);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp

@@ -64,6 +64,8 @@ struct ColumnScanState {
 	//! We initialize one SegmentScanState per segment, however, if scanning a DataChunk requires us to scan over more
 	//! than one Segment, we need to keep the scan states of the previous segments around
 	vector<unique_ptr<SegmentScanState>> previous_states;
+	//! The last read offset in the child state (used for LIST columns only)
+	idx_t last_offset = 0;
 
 public:
 	//! Move the scan state forward by "count" rows (including all child states)

package/src/duckdb/src/include/duckdb.h

@@ -35,7 +35,10 @@
 #endif
 #endif
 
-// duplicate of duckdb/common/constants.hpp
+// API versions
+// if no explicit API version is defined, the latest API version is used
+// Note that using older API versions (i.e. not using DUCKDB_API_LATEST) is deprecated.
+// These will not be supported long-term, and will be removed in future versions.
 #ifndef DUCKDB_API_0_3_1
 #define DUCKDB_API_0_3_1 1
 #endif
@@ -570,6 +573,14 @@ Use `duckdb_result_chunk_count` to figure out how many chunks there are in the r
 */
 DUCKDB_API duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_index);
 
+/*!
+Checks if the type of the internal result is StreamQueryResult.
+
+* result: The result object to check.
+* returns: Whether or not the result object is of the type StreamQueryResult
+*/
+DUCKDB_API bool duckdb_result_is_streaming(duckdb_result result);
+
 /*!
 Returns the number of data chunks present in the result.
 
@@ -1106,6 +1117,21 @@ Note that after calling `duckdb_pending_prepared`, the pending result should alw
 DUCKDB_API duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement,
                                                 duckdb_pending_result *out_result);
 
+/*!
+Executes the prepared statement with the given bound parameters, and returns a pending result.
+This pending result will create a streaming duckdb_result when executed.
+The pending result represents an intermediate structure for a query that is not yet fully executed.
+
+Note that after calling `duckdb_pending_prepared_streaming`, the pending result should always be destroyed using
+`duckdb_destroy_pending`, even if this function returns DuckDBError.
+
+* prepared_statement: The prepared statement to execute.
+* out_result: The pending query result.
+* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+*/
+DUCKDB_API duckdb_state duckdb_pending_prepared_streaming(duckdb_prepared_statement prepared_statement,
+                                                          duckdb_pending_result *out_result);
+
 /*!
 Closes the pending result and de-allocates all memory allocated for the result.
 
@@ -2319,6 +2345,28 @@ Returns true if execution of the current query is finished.
 */
 DUCKDB_API bool duckdb_execution_is_finished(duckdb_connection con);
 
+//===--------------------------------------------------------------------===//
+// Streaming Result Interface
+//===--------------------------------------------------------------------===//
+
+/*!
+Fetches a data chunk from the (streaming) duckdb_result. This function should be called repeatedly until the result is
+exhausted.
+
+The result must be destroyed with `duckdb_destroy_data_chunk`.
+
+This function can only be used on duckdb_results created with 'duckdb_pending_prepared_streaming'
+
+If this function is used, none of the other result functions can be used and vice versa (i.e. this function cannot be
+mixed with the legacy result functions or the materialized result functions).
+
+It is not known beforehand how many chunks will be returned by this result.
+
+* result: The result object to fetch the data chunk from.
+* returns: The resulting data chunk. Returns `NULL` if the result has an error.
+*/
+DUCKDB_API duckdb_data_chunk duckdb_stream_fetch_chunk(duckdb_result result);
+
 #ifdef __cplusplus
 }
 #endif

package/src/duckdb/src/include/duckdb.hpp

@@ -11,5 +11,4 @@
 #include "duckdb/main/connection.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/query_result.hpp"
-#include "duckdb/main/loadable_extension.hpp"
 #include "duckdb/main/appender.hpp"

package/src/duckdb/src/main/capi/pending-c.cpp

@@ -9,14 +9,16 @@ using duckdb::PendingQueryResult;
 using duckdb::PendingStatementWrapper;
 using duckdb::PreparedStatementWrapper;
 
-duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement, duckdb_pending_result *out_result) {
+duckdb_state duckdb_pending_prepared_internal(duckdb_prepared_statement prepared_statement,
+                                              duckdb_pending_result *out_result, bool allow_streaming) {
 	if (!prepared_statement || !out_result) {
 		return DuckDBError;
 	}
 	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
 	auto result = new PendingStatementWrapper();
+	result->allow_streaming = allow_streaming;
 	try {
-		result->statement = wrapper->statement->PendingQuery(wrapper->values, false);
+		result->statement = wrapper->statement->PendingQuery(wrapper->values, allow_streaming);
 	} catch (const duckdb::Exception &ex) {
 		result->statement = make_unique<PendingQueryResult>(duckdb::PreservedError(ex));
 	} catch (std::exception &ex) {
@@ -28,6 +30,15 @@ duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statemen
 	return return_value;
 }
 
+duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement, duckdb_pending_result *out_result) {
+	return duckdb_pending_prepared_internal(prepared_statement, out_result, false);
+}
+
+duckdb_state duckdb_pending_prepared_streaming(duckdb_prepared_statement prepared_statement,
+                                               duckdb_pending_result *out_result) {
+	return duckdb_pending_prepared_internal(prepared_statement, out_result, true);
+}
+
 void duckdb_destroy_pending(duckdb_pending_result *pending_result) {
 	if (!pending_result || !*pending_result) {
 		return;
@@ -90,7 +101,9 @@ duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb
 	if (!wrapper->statement) {
 		return DuckDBError;
 	}
-	auto result = wrapper->statement->Execute();
+
+	std::unique_ptr<duckdb::QueryResult> result;
+	result = wrapper->statement->Execute();
 	wrapper->statement.reset();
 	return duckdb_translate_result(std::move(result), out_result);
 }

package/src/duckdb/src/main/capi/result-c.cpp

@@ -292,6 +292,10 @@ bool deprecated_materialize_result(duckdb_result *result) {
 		// already used as a new result set
 		return false;
 	}
+	if (result_data->result_set_type == CAPIResultSetType::CAPI_RESULT_TYPE_STREAMING) {
+		// already used as a streaming result
+		return false;
+	}
 	// materialize as deprecated result set
 	result_data->result_set_type = CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED;
 	auto column_count = result_data->result->ColumnCount();
@@ -413,6 +417,10 @@ idx_t duckdb_row_count(duckdb_result *result) {
 		return 0;
 	}
 	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	if (result_data.result->type == duckdb::QueryResultType::STREAM_RESULT) {
+		// We can't know the row count beforehand
+		return 0;
+	}
 	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
 	return materialized.RowCount();
 }
@@ -463,7 +471,10 @@ idx_t duckdb_result_chunk_count(duckdb_result result) {
 	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
 		return 0;
 	}
-	D_ASSERT(result_data.result->type == duckdb::QueryResultType::MATERIALIZED_RESULT);
+	if (result_data.result->type != duckdb::QueryResultType::MATERIALIZED_RESULT) {
+		// Can't know beforehand how many chunks are returned.
+		return 0;
+	}
 	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
 	return materialized.Collection().ChunkCount();
 }
@@ -476,6 +487,10 @@ duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx)
 	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
 		return nullptr;
 	}
+	if (result_data.result->type != duckdb::QueryResultType::MATERIALIZED_RESULT) {
+		// This API is only supported for materialized query results
+		return nullptr;
+	}
 	result_data.result_set_type = duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_MATERIALIZED;
 	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
 	auto &collection = materialized.Collection();
@@ -487,3 +502,14 @@ duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx)
 	collection.FetchChunk(chunk_idx, *chunk);
 	return reinterpret_cast<duckdb_data_chunk>(chunk.release());
 }
+
+bool duckdb_result_is_streaming(duckdb_result result) {
+	if (!result.internal_data) {
+		return false;
+	}
+	if (duckdb_result_error(&result) != nullptr) {
+		return false;
+	}
+	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
+	return result_data.result->type == duckdb::QueryResultType::STREAM_RESULT;
+}

package/src/duckdb/src/main/capi/stream-c.cpp

@@ -0,0 +1,25 @@
+#include "duckdb/main/capi/capi_internal.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/common/allocator.hpp"
+
+duckdb_data_chunk duckdb_stream_fetch_chunk(duckdb_result result) {
+	if (!result.internal_data) {
+		return nullptr;
+	}
+	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
+	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
+		return nullptr;
+	}
+	if (result_data.result->type != duckdb::QueryResultType::STREAM_RESULT) {
+		// We can only fetch from a StreamQueryResult
+		return nullptr;
+	}
+	result_data.result_set_type = duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_STREAMING;
+	auto &streaming = (duckdb::StreamQueryResult &)*result_data.result;
+	if (!streaming.IsOpen()) {
+		return nullptr;
+	}
+	// FetchRaw ? Do we care about flattening them?
+	auto chunk = streaming.Fetch();
+	return reinterpret_cast<duckdb_data_chunk>(chunk.release());
+}

package/src/duckdb/src/main/client_context.cpp

@@ -813,12 +813,14 @@ unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_str
 
 	unique_ptr<QueryResult> result;
 	QueryResult *last_result = nullptr;
+	bool last_had_result = false;
 	for (idx_t i = 0; i < statements.size(); i++) {
 		auto &statement = statements[i];
 		bool is_last_statement = i + 1 == statements.size();
 		PendingQueryParameters parameters;
 		parameters.allow_stream_result = allow_stream_result && is_last_statement;
 		auto pending_query = PendingQueryInternal(*lock, std::move(statement), parameters);
+		auto has_result = pending_query->properties.return_type == StatementReturnType::QUERY_RESULT;
 		unique_ptr<QueryResult> current_result;
 		if (pending_query->HasError()) {
 			current_result = make_unique<MaterializedQueryResult>(pending_query->GetErrorObject());
@@ -826,12 +828,17 @@ unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_str
 			current_result = ExecutePendingQueryInternal(*lock, *pending_query);
 		}
 		// now append the result to the list of results
-		if (!last_result) {
+		if (!last_result || !last_had_result) {
 			// first result of the query
 			result = std::move(current_result);
 			last_result = result.get();
+			last_had_result = has_result;
 		} else {
 			// later results; attach to the result chain
+			// but only if there is a result
+			if (!has_result) {
+				continue;
+			}
 			last_result->next = std::move(current_result);
 			last_result = last_result->next.get();
 		}

package/src/duckdb/src/main/database.cpp

@@ -191,8 +191,7 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 	}
 
 	db_manager = make_unique<DatabaseManager>(*this);
-	buffer_manager =
-	    make_unique<BufferManager>(*this, config.options.temporary_directory, config.options.maximum_memory);
+	buffer_manager = make_unique<BufferManager>(*this, config.options.temporary_directory);
 	scheduler = make_unique<TaskScheduler>(*this);
 	object_cache = make_unique<ObjectCache>();
 	connection_manager = make_unique<ConnectionManager>();
@@ -271,6 +270,10 @@ BufferManager &DatabaseInstance::GetBufferManager() {
 	return *buffer_manager;
 }
 
+BufferPool &DatabaseInstance::GetBufferPool() {
+	return *config.buffer_pool;
+}
+
 DatabaseManager &DatabaseManager::Get(DatabaseInstance &db) {
 	return db.GetDatabaseManager();
 }
@@ -340,6 +343,11 @@ void DatabaseInstance::Configure(DBConfig &new_config) {
 	if (!config.default_allocator) {
 		config.default_allocator = Allocator::DefaultAllocatorReference();
 	}
+	if (new_config.buffer_pool) {
+		config.buffer_pool = std::move(new_config.buffer_pool);
+	} else {
+		config.buffer_pool = make_shared<BufferPool>(config.options.maximum_memory);
+	}
 }
 
 DBConfig &DBConfig::GetConfig(ClientContext &context) {