duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

package/src/duckdb/src/include/duckdb/planner/operator/logical_execute.hpp

@@ -34,7 +34,7 @@ public:
 
 protected:
 	void ResolveTypes() override {
-		// already resolved
+		types = prepared->types;
 	}
 	vector<ColumnBinding> GetColumnBindings() override {
 		return GenerateColumnBindings(0, types.size());

package/src/duckdb/src/include/duckdb/planner/operator/logical_explain.hpp

@@ -21,12 +21,14 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXPLAIN;
 
 public:
-	LogicalExplain(unique_ptr<LogicalOperator> plan, ExplainType explain_type)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPLAIN), explain_type(explain_type) {
+	LogicalExplain(unique_ptr<LogicalOperator> plan, ExplainType explain_type, ExplainFormat explain_format)
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPLAIN), explain_type(explain_type),
+	      explain_format(explain_format) {
 		children.push_back(std::move(plan));
 	}
 
 	ExplainType explain_type;
+	ExplainFormat explain_format;
 	string physical_plan;
 	string logical_plan_unopt;
 	string logical_plan_opt;

package/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp

@@ -14,6 +14,7 @@
 #include "duckdb/common/extra_operator_info.hpp"
 
 namespace duckdb {
+class DynamicTableFilterSet;
 
 //! LogicalGet represents a scan operation from a data source
 class LogicalGet : public LogicalOperator {
@@ -34,9 +35,7 @@ public:
 	vector<LogicalType> returned_types;
 	//! The names of ALL columns that can be returned by the table function
 	vector<string> names;
-	//! Bound column IDs
-	vector<column_t> column_ids;
-	//! Columns that are used outside of the scan
+	//! Columns that are used outside the scan
 	vector<idx_t> projection_ids;
 	//! Filters pushed down for table scan
 	TableFilterSet table_filters;
@@ -51,15 +50,22 @@ public:
 	//! For a table-in-out function, the set of projected input columns
 	vector<column_t> projected_input;
 	//! Currently stores File Filters (as strings) applied by hive partitioning/complex filter pushdown
-	//! Stored so the can be included in explain output
+	//! Stored so they can be included in explain output
 	ExtraOperatorInfo extra_info;
+	//! Contains a reference to dynamically generated table filters (through e.g. a join up in the tree)
+	shared_ptr<DynamicTableFilterSet> dynamic_filters;
 
 	string GetName() const override;
-	string ParamsToString() const override;
+	InsertionOrderPreservingMap<string> ParamsToString() const override;
 	//! Returns the underlying table that is being scanned, or nullptr if there is none
 	optional_ptr<TableCatalogEntry> GetTable() const;
 
 public:
+	void SetColumnIds(vector<column_t> &&column_ids);
+	void AddColumnId(column_t column_id);
+	void ClearColumnIds();
+	const vector<column_t> &GetColumnIds() const;
+	vector<column_t> &GetMutableColumnIds();
 	vector<ColumnBinding> GetColumnBindings() override;
 	idx_t EstimateCardinality(ClientContext &context) override;
 
@@ -77,5 +83,9 @@ protected:
 
 private:
 	LogicalGet();
+
+private:
+	//! Bound column IDs
+	vector<column_t> column_ids;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_materialized_cte.hpp

@@ -33,6 +33,7 @@ public:
 	string ctename;
 
 public:
+	InsertionOrderPreservingMap<string> ParamsToString() const override;
 	vector<ColumnBinding> GetColumnBindings() override {
 		return children[1]->GetColumnBindings();
 	}

package/src/duckdb/src/include/duckdb/planner/operator/logical_order.hpp

@@ -32,7 +32,7 @@ public:
 	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
-	string ParamsToString() const override;
+	InsertionOrderPreservingMap<string> ParamsToString() const override;
 
 protected:
 	void ResolveTypes() override;

package/src/duckdb/src/include/duckdb/planner/subquery/flatten_dependent_join.hpp

@@ -29,7 +29,8 @@ struct FlattenDependentJoins {
 	bool MarkSubtreeCorrelated(LogicalOperator &op);
 
 	//! Push the dependent join down a LogicalOperator
-	unique_ptr<LogicalOperator> PushDownDependentJoin(unique_ptr<LogicalOperator> plan);
+	unique_ptr<LogicalOperator> PushDownDependentJoin(unique_ptr<LogicalOperator> plan,
+	                                                  bool propagates_null_values = true);
 
 	Binder &binder;
 	ColumnBinding base_binding;

package/src/duckdb/src/include/duckdb/planner/table_filter.hpp

@@ -9,12 +9,18 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/enums/filter_propagate_result.hpp"
+#include "duckdb/common/mutex.hpp"
+#include "duckdb/common/reference_map.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/enums/filter_propagate_result.hpp"
+#include "duckdb/planner/column_binding.hpp"
 
 namespace duckdb {
 class BaseStatistics;
+class Expression;
+class PhysicalOperator;
+class PhysicalTableScan;
 
 enum class TableFilterType : uint8_t {
 	CONSTANT_COMPARISON = 0, // constant comparison (e.g. =C, >C, >=C, <C, <=C)
@@ -39,9 +45,11 @@ public:
 	//! Returns true if the statistics indicate that the segment can contain values that satisfy that filter
 	virtual FilterPropagateResult CheckStatistics(BaseStatistics &stats) = 0;
 	virtual string ToString(const string &column_name) = 0;
+	virtual unique_ptr<TableFilter> Copy() const = 0;
 	virtual bool Equals(const TableFilter &other) const {
 		return filter_type != other.filter_type;
 	}
+	virtual unique_ptr<Expression> ToExpression(const Expression &column) const = 0;
 
 	virtual void Serialize(Serializer &serializer) const;
 	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
@@ -69,7 +77,7 @@ public:
 	unordered_map<idx_t, unique_ptr<TableFilter>> filters;
 
 public:
-	void PushFilter(idx_t table_index, unique_ptr<TableFilter> filter);
+	void PushFilter(idx_t column_index, unique_ptr<TableFilter> filter);
 
 	bool Equals(TableFilterSet &other) {
 		if (filters.size() != other.filters.size()) {
@@ -100,4 +108,18 @@ public:
 	static TableFilterSet Deserialize(Deserializer &deserializer);
 };
 
+class DynamicTableFilterSet {
+public:
+	void ClearFilters(const PhysicalOperator &op);
+	void PushFilter(const PhysicalOperator &op, idx_t column_index, unique_ptr<TableFilter> filter);
+
+	bool HasFilters() const;
+	unique_ptr<TableFilterSet> GetFinalTableFilters(const PhysicalTableScan &scan,
+	                                                optional_ptr<TableFilterSet> existing_filters) const;
+
+private:
+	mutable mutex lock;
+	reference_map_t<const PhysicalOperator, unique_ptr<TableFilterSet>> filters;
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/tableref/bound_delimgetref.hpp

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/tableref/bound_delimgetref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/bound_tableref.hpp"
+
+namespace duckdb {
+
+class BoundDelimGetRef : public BoundTableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::DELIM_GET;
+
+public:
+	BoundDelimGetRef(idx_t bind_index, const vector<LogicalType> &column_types_p)
+	    : BoundTableRef(TableReferenceType::DELIM_GET), bind_index(bind_index), column_types(column_types_p) {
+	}
+	idx_t bind_index;
+	vector<LogicalType> column_types;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/tableref/bound_joinref.hpp

@@ -36,6 +36,10 @@ public:
 	unique_ptr<BoundTableRef> right;
 	//! The join condition
 	unique_ptr<Expression> condition;
+	//! Duplicate Eliminated Columns (if any)
+	vector<unique_ptr<Expression>> duplicate_eliminated_columns;
+	//! If the delim is flipped
+	bool delim_flipped;
 	//! The join type
 	JoinType type;
 	//! Join condition type
@@ -44,5 +48,7 @@ public:
 	bool lateral;
 	//! The correlated columns of the right-side with the left-side
 	vector<CorrelatedColumnInfo> correlated_columns;
+	//! The mark index, for mark joins generated by the relational API
+	idx_t mark_index {};
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/tableref/bound_subqueryref.hpp

@@ -26,7 +26,7 @@ public:
 
 	//! The binder used to bind the subquery
 	shared_ptr<Binder> binder;
-	//! The bound subquery node
+	//! The bound subquery node (if any)
 	unique_ptr<BoundQueryNode> subquery;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/tableref/bound_table_function.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/planner/bound_tableref.hpp"
 #include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/planner/tableref/bound_subqueryref.hpp"
 
 namespace duckdb {
 
@@ -24,6 +25,7 @@ public:
 	}
 
 	unique_ptr<LogicalOperator> get;
+	unique_ptr<BoundSubqueryRef> subquery;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/tableref/list.hpp

@@ -7,3 +7,5 @@
 #include "duckdb/planner/tableref/bound_column_data_ref.hpp"
 #include "duckdb/planner/tableref/bound_table_function.hpp"
 #include "duckdb/planner/tableref/bound_pivotref.hpp"
+#include "duckdb/parser/tableref/delimgetref.hpp"
+#include "duckdb/planner/tableref/bound_delimgetref.hpp"

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

@@ -26,6 +26,7 @@ struct ArenaChunk {
 
 class ArenaAllocator {
 	static constexpr const idx_t ARENA_ALLOCATOR_INITIAL_CAPACITY = 2048;
+	static constexpr const idx_t ARENA_ALLOCATOR_MAX_CAPACITY = 1ULL << 24ULL; // 16MB
 
 public:
 	DUCKDB_API explicit ArenaAllocator(Allocator &allocator, idx_t initial_capacity = ARENA_ALLOCATOR_INITIAL_CAPACITY);
@@ -62,7 +63,7 @@ public:
 private:
 	//! Internal allocator that is used by the arena allocator
 	Allocator &allocator;
-	idx_t current_capacity;
+	idx_t initial_capacity;
 	unsafe_unique_ptr<ArenaChunk> head;
 	ArenaChunk *tail;
 	//! An allocator wrapper using this arena allocator

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

@@ -9,8 +9,8 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
-#include "duckdb/storage/storage_info.hpp"
 #include "duckdb/common/file_buffer.hpp"
+#include "duckdb/storage/storage_info.hpp"
 
 namespace duckdb {
 
@@ -19,7 +19,7 @@ class Deserializer;
 
 class Block : public FileBuffer {
 public:
-	Block(Allocator &allocator, block_id_t id);
+	Block(Allocator &allocator, const block_id_t id, const idx_t block_size);
 	Block(Allocator &allocator, block_id_t id, uint32_t internal_size);
 	Block(FileBuffer &source, block_id_t id);
 
@@ -34,6 +34,7 @@ struct BlockPointer {
 
 	block_id_t block_id;
 	uint32_t offset;
+	uint32_t unused_padding {0};
 
 	bool IsValid() const {
 		return block_id != INVALID_BLOCK;
@@ -51,6 +52,7 @@ struct MetaBlockPointer {
 
 	idx_t block_pointer;
 	uint32_t offset;
+	uint32_t unused_padding {0};
 
 	bool IsValid() const {
 		return block_pointer != DConstants::INVALID_INDEX;

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/mutex.hpp"
+#include "duckdb/common/optional_idx.hpp"
 #include "duckdb/storage/block.hpp"
 #include "duckdb/storage/storage_info.hpp"
 #include "duckdb/common/unordered_map.hpp"
@@ -22,10 +23,11 @@ class DatabaseInstance;
 class MetadataManager;
 
 //! BlockManager is an abstract representation to manage blocks on DuckDB. When writing or reading blocks, the
-//! BlockManager creates and accesses blocks. The concrete types implements how blocks are stored.
+//! BlockManager creates and accesses blocks. The concrete types implement specific block storage strategies.
 class BlockManager {
 public:
-	explicit BlockManager(BufferManager &buffer_manager);
+	BlockManager() = delete;
+	BlockManager(BufferManager &buffer_manager, const optional_idx block_alloc_size_p);
 	virtual ~BlockManager() = default;
 
 	//! The buffer manager
@@ -37,10 +39,13 @@ public:
 	virtual unique_ptr<Block> CreateBlock(block_id_t block_id, FileBuffer *source_buffer) = 0;
 	//! Return the next free block id
 	virtual block_id_t GetFreeBlockId() = 0;
+	virtual block_id_t PeekFreeBlockId() = 0;
 	//! Returns whether or not a specified block is the root block
 	virtual bool IsRootBlock(MetaBlockPointer root) = 0;
 	//! Mark a block as "free"; free blocks are immediately added to the free list and can be immediately overwritten
 	virtual void MarkBlockAsFree(block_id_t block_id) = 0;
+	//! Mark a block as "used"; either the block is removed from the free list, or the reference count is incremented
+	virtual void MarkBlockAsUsed(block_id_t block_id) = 0;
 	//! Mark a block as "modified"; modified blocks are added to the free list after a checkpoint (i.e. their data is
 	//! assumed to be rewritten)
 	virtual void MarkBlockAsModified(block_id_t block_id) = 0;
@@ -51,6 +56,8 @@ public:
 	virtual idx_t GetMetaBlock() = 0;
 	//! Read the content of the block from disk
 	virtual void Read(Block &block) = 0;
+	//! Read the content of the block from disk
+	virtual void ReadBlocks(FileBuffer &buffer, block_id_t start_block, idx_t block_count) = 0;
 	//! Writes the block to disk
 	virtual void Write(FileBuffer &block, block_id_t block_id) = 0;
 	//! Writes the block to disk
@@ -64,7 +71,15 @@ public:
 	virtual idx_t TotalBlocks() = 0;
 	//! Returns the number of free blocks
 	virtual idx_t FreeBlocks() = 0;
+	//! Whether or not the attached database is a remote file (e.g. attached over s3/https)
+	virtual bool IsRemote() {
+		return false;
+	}
+	//! Whether or not the attached database is in-memory
+	virtual bool InMemory() = 0;
 
+	//! Sync changes made to the block manager
+	virtual void FileSync() = 0;
 	//! Truncate the underlying database file after a checkpoint
 	virtual void Truncate();
 
@@ -73,9 +88,35 @@ public:
 	//! Convert an existing in-memory buffer into a persistent disk-backed block
 	shared_ptr<BlockHandle> ConvertToPersistent(block_id_t block_id, shared_ptr<BlockHandle> old_block);
 
-	void UnregisterBlock(block_id_t block_id, bool can_destroy);
+	void UnregisterBlock(block_id_t block_id);
 
+	//! Returns a reference to the metadata manager of this block manager.
 	MetadataManager &GetMetadataManager();
+	//! Returns the block allocation size of this block manager.
+	inline idx_t GetBlockAllocSize() const {
+		return block_alloc_size.GetIndex();
+	}
+	//! Returns the possibly invalid block allocation size of this block manager.
+	inline optional_idx GetOptionalBlockAllocSize() const {
+		return block_alloc_size;
+	}
+	//! Returns the block size of this block manager.
+	inline idx_t GetBlockSize() const {
+		return block_alloc_size.GetIndex() - Storage::DEFAULT_BLOCK_HEADER_SIZE;
+	}
+	//! Sets the block allocation size. This should only happen when initializing an existing database.
+	//! When initializing an existing database, we construct the block manager before reading the file header,
+	//! which contains the file's actual block allocation size.
+	void SetBlockAllocSize(const optional_idx block_alloc_size_p) {
+		if (block_alloc_size.IsValid()) {
+			throw InternalException("the block allocation size must be set once");
+		}
+		block_alloc_size = block_alloc_size_p.GetIndex();
+	}
+
+	//! Verify the block usage count
+	virtual void VerifyBlocks(const unordered_map<block_id_t, idx_t> &block_usage_count) {
+	}
 
 private:
 	//! The lock for the set of blocks
@@ -84,5 +125,9 @@ private:
 	unordered_map<block_id_t, weak_ptr<BlockHandle>> blocks;
 	//! The metadata manager
 	unique_ptr<MetadataManager> metadata_manager;
+	//! The allocation size of blocks managed by this block manager. Defaults to DEFAULT_BLOCK_ALLOC_SIZE
+	//! for in-memory block managers. Default to default_block_alloc_size for file-backed block managers.
+	//! This is NOT the actual memory available on a block (block_size).
+	optional_idx block_alloc_size;
 };
 } // namespace duckdb

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

@@ -10,13 +10,15 @@
 
 #include "duckdb/common/atomic.hpp"
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/enums/destroy_buffer_upon.hpp"
+#include "duckdb/common/enums/memory_tag.hpp"
+#include "duckdb/common/file_buffer.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/storage/storage_info.hpp"
-#include "duckdb/common/file_buffer.hpp"
-#include "duckdb/common/enums/memory_tag.hpp"
 
 namespace duckdb {
+
 class BlockManager;
 class BufferHandle;
 class BufferPool;
@@ -59,11 +61,12 @@ class BlockHandle {
 	friend class BufferManager;
 	friend class StandardBufferManager;
 	friend class BufferPool;
+	friend struct EvictionQueue;
 
 public:
 	BlockHandle(BlockManager &block_manager, block_id_t block_id, MemoryTag tag);
 	BlockHandle(BlockManager &block_manager, block_id_t block_id, MemoryTag tag, unique_ptr<FileBuffer> buffer,
-	            bool can_destroy, idx_t block_size, BufferPoolReservation &&reservation);
+	            DestroyBufferUpon destroy_buffer_upon, idx_t block_size, BufferPoolReservation &&reservation);
 	~BlockHandle();
 
 	BlockManager &block_manager;
@@ -93,8 +96,17 @@ public:
 		unswizzled = unswizzler;
 	}
 
-	inline void SetCanDestroy(bool can_destroy_p) {
-		can_destroy = can_destroy_p;
+	inline void SetDestroyBufferUpon(DestroyBufferUpon destroy_buffer_upon_p) {
+		lock_guard<mutex> guard(lock);
+		destroy_buffer_upon = destroy_buffer_upon_p;
+	}
+
+	inline bool MustAddToEvictionQueue() const {
+		return destroy_buffer_upon != DestroyBufferUpon::UNPIN;
+	}
+
+	inline bool MustWriteToTemporaryFile() const {
+		return destroy_buffer_upon == DestroyBufferUpon::BLOCK;
 	}
 
 	inline const idx_t &GetMemoryUsage() const {
@@ -106,6 +118,8 @@ public:
 
 private:
 	static BufferHandle Load(shared_ptr<BlockHandle> &handle, unique_ptr<FileBuffer> buffer = nullptr);
+	static BufferHandle LoadFromBuffer(shared_ptr<BlockHandle> &handle, data_ptr_t data,
+	                                   unique_ptr<FileBuffer> reusable_buffer);
 	unique_ptr<FileBuffer> UnloadAndTakeBlock();
 	void Unload();
 	bool CanUnload();
@@ -126,8 +140,8 @@ private:
 	atomic<idx_t> eviction_seq_num;
 	//! LRU timestamp (for age-based eviction)
 	atomic<int64_t> lru_timestamp_msec;
-	//! Whether or not the buffer can be destroyed (only used for temporary buffers)
-	bool can_destroy;
+	//! When to destroy the data buffer
+	DestroyBufferUpon destroy_buffer_upon;
 	//! The memory usage of the block (when loaded). If we are pinning/loading
 	//! an unloaded block, this tells us how much memory to reserve.
 	idx_t memory_usage;

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

@@ -8,8 +8,11 @@
 
 #pragma once
 
+#include "duckdb/common/array.hpp"
+#include "duckdb/common/enums/memory_tag.hpp"
 #include "duckdb/common/file_buffer.hpp"
 #include "duckdb/common/mutex.hpp"
+#include "duckdb/common/typedefs.hpp"
 #include "duckdb/storage/buffer/block_handle.hpp"
 
 namespace duckdb {
@@ -45,6 +48,9 @@ public:
 	//! blocks can be evicted
 	void SetLimit(idx_t limit, const char *exception_postscript);
 
+	//! If bulk deallocation larger than this occurs, flush outstanding allocations
+	void SetAllocatorBulkDeallocationFlushThreshold(idx_t threshold);
+
 	void UpdateUsedMemory(MemoryTag tag, int64_t size);
 
 	idx_t GetUsedMemory() const;
@@ -68,74 +74,82 @@ protected:
 	};
 	virtual EvictionResult EvictBlocks(MemoryTag tag, idx_t extra_memory, idx_t memory_limit,
 	                                   unique_ptr<FileBuffer> *buffer = nullptr);
+	virtual EvictionResult EvictBlocksInternal(EvictionQueue &queue, MemoryTag tag, idx_t extra_memory,
+	                                           idx_t memory_limit, unique_ptr<FileBuffer> *buffer = nullptr);
 
 	//! Purge all blocks that haven't been pinned within the last N seconds
 	idx_t PurgeAgedBlocks(uint32_t max_age_sec);
-
-	//! Iterate over all purgable blocks and invoke the callback. If the callback returns true
-	//! iteration continues.
-	//! - Callback signature is: bool((BufferEvictionNode &, const std::shared_ptr<BlockHandle> &)
-	//! - Callback is invoked while holding the corresponding BlockHandle mutex.
-	template <typename FN>
-	void IterateUnloadableBlocks(FN fn);
-
-	//! Tries to dequeue an element from the eviction queue, but only after acquiring the purge queue lock.
-	bool TryDequeueWithLock(BufferEvictionNode &node);
-	//! Bulk purge dead nodes from the eviction queue. Then, enqueue those that are still alive.
-	void PurgeIteration(const idx_t purge_size);
+	idx_t PurgeAgedBlocksInternal(EvictionQueue &queue, uint32_t max_age_sec, int64_t now, int64_t limit);
 	//! Garbage collect dead nodes in the eviction queue.
-	void PurgeQueue();
+	void PurgeQueue(FileBufferType type);
 	//! Add a buffer handle to the eviction queue. Returns true, if the queue is
 	//! ready to be purged, and false otherwise.
 	bool AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
-
-	//! Increment the dead node counter in the purge queue.
-	inline void IncrementDeadNodes() {
-		total_dead_nodes++;
-	}
-	//! Decrement the dead node counter in the purge queue.
-	inline void DecrementDeadNodes() {
-		total_dead_nodes--;
-	}
+	//! Gets the eviction queue for the specified type
+	EvictionQueue &GetEvictionQueueForType(FileBufferType type);
+	//! Increments the dead nodes for the queue with specified type
+	void IncrementDeadNodes(FileBufferType type);
 
 protected:
+	enum class MemoryUsageCaches {
+		FLUSH,
+		NO_FLUSH,
+	};
+
+	struct MemoryUsage {
+		//! The maximum difference between memory statistics and actual usage is 2MB (64 * 32k)
+		static constexpr idx_t MEMORY_USAGE_CACHE_COUNT = 64;
+		static constexpr idx_t MEMORY_USAGE_CACHE_THRESHOLD = 32 << 10;
+		static constexpr idx_t TOTAL_MEMORY_USAGE_INDEX = MEMORY_TAG_COUNT;
+		using MemoryUsageCounters = array<atomic<int64_t>, MEMORY_TAG_COUNT + 1>;
+
+		//! global memory usage counters
+		MemoryUsageCounters memory_usage;
+		//! cache memory usage to improve performance
+		array<MemoryUsageCounters, MEMORY_USAGE_CACHE_COUNT> memory_usage_caches;
+
+		MemoryUsage();
+
+		idx_t GetUsedMemory(MemoryUsageCaches cache) {
+			return GetUsedMemory(TOTAL_MEMORY_USAGE_INDEX, cache);
+		}
+
+		idx_t GetUsedMemory(MemoryTag tag, MemoryUsageCaches cache) {
+			return GetUsedMemory((idx_t)tag, cache);
+		}
+
+		idx_t GetUsedMemory(idx_t index, MemoryUsageCaches cache) {
+			if (cache == MemoryUsageCaches::NO_FLUSH) {
+				auto used_memory = memory_usage[index].load(std::memory_order_relaxed);
+				return used_memory > 0 ? static_cast<idx_t>(used_memory) : 0;
+			}
+			int64_t cached = 0;
+			for (auto &cache : memory_usage_caches) {
+				cached += cache[index].exchange(0, std::memory_order_relaxed);
+			}
+			auto used_memory = memory_usage[index].fetch_add(cached, std::memory_order_relaxed) + cached;
+			return used_memory > 0 ? static_cast<idx_t>(used_memory) : 0;
+		}
+
+		void UpdateUsedMemory(MemoryTag tag, int64_t size);
+	};
+
 	//! 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;
+	//! If bulk deallocation larger than this occurs, flush outstanding allocations
+	atomic<idx_t> allocator_bulk_deallocation_flush_threshold;
 	//! Record timestamps of buffer manager unpin() events. Usable by custom eviction policies.
 	bool track_eviction_timestamps;
-	//! Eviction queue
-	unique_ptr<EvictionQueue> queue;
+	//! Eviction queues
+	vector<unique_ptr<EvictionQueue>> queues;
 	//! Memory manager for concurrently used temporary memory, e.g., for physical operators
 	unique_ptr<TemporaryMemoryManager> temporary_memory_manager;
-	//! Memory usage per tag
-	atomic<idx_t> memory_usage_per_tag[MEMORY_TAG_COUNT];
-
-	//! We trigger a purge of the eviction queue every INSERT_INTERVAL insertions
-	constexpr static idx_t INSERT_INTERVAL = 4096;
-	//! We multiply the base purge size by this value.
-	constexpr static idx_t PURGE_SIZE_MULTIPLIER = 2;
-	//! We multiply the purge size by this value to determine early-outs. This is the minimum queue size.
-	//! We never purge below this point.
-	constexpr static idx_t EARLY_OUT_MULTIPLIER = 4;
-	//! We multiply the approximate alive nodes by this value to test whether our total dead nodes
-	//! exceed their allowed ratio. Must be greater than 1.
-	constexpr static idx_t ALIVE_NODE_MULTIPLIER = 4;
-
-	//! Total number of insertions into the eviction queue. This guides the schedule for calling PurgeQueue.
-	atomic<idx_t> evict_queue_insertions;
-	//! Total dead nodes in the eviction queue. There are two scenarios in which a node dies: (1) we destroy its block
-	//! handle, or (2) we insert a newer version into the eviction queue.
-	atomic<idx_t> total_dead_nodes;
-	//! Locked, if a queue purge is currently active or we're trying to forcefully evict a node.
-	//! Only lets a single thread enter the purge phase.
-	mutex purge_lock;
-
-	//! A pre-allocated vector of eviction nodes. We reuse this to keep the allocation overhead of purges small.
-	vector<BufferEvictionNode> purge_nodes;
+	//! To improve performance, MemoryUsage maintains counter caches based on current cpu or thread id,
+	//! and only updates the global counter when the cache value exceeds a threshold.
+	//! Therefore, the statistics may have slight differences from the actual memory usage.
+	mutable MemoryUsage memory_usage;
 };
 
 } // namespace duckdb