duckdb 1.3.4 → 1.4.1-dev2.0

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

@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/logical_operator_deep_copy.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/planner/bound_tokens.hpp"
+#include "duckdb/planner/logical_tokens.hpp"
+
+#include "duckdb/planner/logical_operator_visitor.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/bound_parameter_map.hpp"
+
+namespace duckdb {
+
+//! While it is possible to copy a logical plan using `Copy()`, both, the original and the copy
+//! are—by design—identical. This includes any table_idx values etc. This is bad, when we try
+//! to use part of a logical plan multiple times in the same plan.
+//! The LogicalOperatorDeepCopy first copies a LogicalOperator, but then traverses the entire plan
+//! and replaces all table indexes. We store a map from the original table index to the new index,
+//! which we use in the TableBindingReplacer to correct all column accesses.
+class LogicalOperatorDeepCopy : public LogicalOperatorVisitor {
+public:
+	LogicalOperatorDeepCopy(Binder &binder, optional_ptr<bound_parameter_map_t> parameter_data);
+
+	unique_ptr<LogicalOperator> DeepCopy(unique_ptr<LogicalOperator> &op);
+
+private:
+	void VisitOperator(LogicalOperator &op) override;
+
+private:
+	// Single-field version
+	template <typename T>
+	void ReplaceTableIndex(LogicalOperator &op);
+	// Multi-field version
+	template <typename T>
+	void ReplaceTableIndexMulti(LogicalOperator &op);
+
+private:
+	Binder &binder;
+	std::unordered_map<idx_t, idx_t> table_idx_replacements;
+	optional_ptr<bound_parameter_map_t> parameter_data;
+};
+
+//! The TableBindingReplacer updates table bindings, utility for optimizers
+class TableBindingReplacer : LogicalOperatorVisitor {
+public:
+	TableBindingReplacer(std::unordered_map<idx_t, idx_t> &table_idx_replacements,
+	                     optional_ptr<bound_parameter_map_t> parameter_data);
+
+public:
+	//! Update each operator of the plan
+	void VisitOperator(LogicalOperator &op) override;
+	//! Visit an expression and update its column bindings
+	void VisitExpression(unique_ptr<Expression> *expression) override;
+
+public:
+	//! Contains all bindings that need to be updated
+	const std::unordered_map<idx_t, idx_t> &table_idx_replacements;
+	optional_ptr<bound_parameter_map_t> parameter_data;
+};
+} // namespace duckdb

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

@@ -39,6 +39,7 @@ class LogicalGet;
 class LogicalInsert;
 class LogicalJoin;
 class LogicalLimit;
+class LogicalMergeInto;
 class LogicalOrder;
 class LogicalPivot;
 class LogicalPositionalJoin;

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

@@ -28,6 +28,7 @@
 #include "duckdb/planner/operator/logical_join.hpp"
 #include "duckdb/planner/operator/logical_limit.hpp"
 #include "duckdb/planner/operator/logical_materialized_cte.hpp"
+#include "duckdb/planner/operator/logical_merge_into.hpp"
 #include "duckdb/planner/operator/logical_order.hpp"
 #include "duckdb/planner/operator/logical_pivot.hpp"
 #include "duckdb/planner/operator/logical_positional_join.hpp"

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

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/common/enums/tuple_data_layout_enums.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/column_binding.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
@@ -38,6 +39,8 @@ public:
 	vector<unsafe_vector<idx_t>> grouping_functions;
 	//! Group statistics (optional)
 	vector<unique_ptr<BaseStatistics>> group_stats;
+	//! Whether the inputs to all expression are non-NULL
+	TupleDataValidityType distinct_validity;
 
 public:
 	InsertionOrderPreservingMap<string> ParamsToString() const override;

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

@@ -35,6 +35,6 @@ public:
 	string ctename;
 	idx_t table_index;
 	idx_t column_count;
-	vector<CorrelatedColumnInfo> correlated_columns;
+	CorrelatedColumns correlated_columns;
 };
 } // namespace duckdb

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

@@ -23,7 +23,7 @@ public:
 	              CTEMaterialize materialized_cte, bool is_recurring = false)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_CTE_REF), table_index(table_index), cte_index(cte_index),
 	      correlated_columns(0), materialized_cte(materialized_cte), is_recurring(is_recurring) {
-		D_ASSERT(types.size() > 0);
+		D_ASSERT(!types.empty());
 		chunk_types = std::move(types);
 		bound_columns = std::move(colnames);
 	}

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

@@ -27,7 +27,7 @@ public:
 
 public:
 	explicit LogicalDependentJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-	                              vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
+	                              CorrelatedColumns correlated_columns, JoinType type,
 	                              unique_ptr<Expression> condition);
 
 	explicit LogicalDependentJoin(JoinType type);
@@ -35,7 +35,7 @@ public:
 	//! The conditions of the join
 	unique_ptr<Expression> join_condition;
 	//! The list of columns that have correlations with the right
-	vector<CorrelatedColumnInfo> correlated_columns;
+	CorrelatedColumns correlated_columns;
 
 	SubqueryType subquery_type = SubqueryType::INVALID;
 	bool perform_delim = true;
@@ -51,7 +51,7 @@ public:
 
 public:
 	static unique_ptr<LogicalOperator> Create(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-	                                          vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
+	                                          CorrelatedColumns correlated_columns, JoinType type,
 	                                          unique_ptr<Expression> condition);
 };
 } // namespace duckdb

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

@@ -58,6 +58,8 @@ public:
 	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;
+	//! Information for WITH ORDINALITY
+	optional_idx ordinality_idx;
 
 	string GetName() const override;
 	InsertionOrderPreservingMap<string> ParamsToString() const override;

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

@@ -17,28 +17,8 @@ class TableCatalogEntry;
 
 class Index;
 
-//! LogicalInsert represents an insertion of data into a base table
-class LogicalInsert : public LogicalOperator {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INSERT;
-
-public:
-	LogicalInsert(TableCatalogEntry &table, idx_t table_index);
-
-	vector<vector<unique_ptr<Expression>>> insert_values;
-	//! The insertion map ([table_index -> index in result, or DConstants::INVALID_INDEX if not specified])
-	physical_index_vector_t<idx_t> column_index_map;
-	//! The expected types for the INSERT statement (obtained from the column types)
-	vector<LogicalType> expected_types;
-	//! The base table to insert into
-	TableCatalogEntry &table;
-	idx_t table_index;
-	//! if returning option is used, return actual chunk to projection
-	bool return_chunk;
-	//! The default statements used by the table
-	vector<unique_ptr<Expression>> bound_defaults;
-	//! The constraints used by the table
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
+struct BoundOnConflictInfo {
+	BoundOnConflictInfo();
 
 	//! Which action to take on conflict
 	OnConflictAction action_type;
@@ -62,6 +42,32 @@ public:
 	vector<column_t> source_columns;
 	//! True, if the INSERT OR REPLACE requires delete + insert.
 	bool update_is_del_and_insert;
+};
+
+//! LogicalInsert represents an insertion of data into a base table
+class LogicalInsert : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INSERT;
+
+public:
+	LogicalInsert(TableCatalogEntry &table, idx_t table_index);
+
+	vector<vector<unique_ptr<Expression>>> insert_values;
+	//! The insertion map ([table_index -> index in result, or DConstants::INVALID_INDEX if not specified])
+	physical_index_vector_t<idx_t> column_index_map;
+	//! The expected types for the INSERT statement (obtained from the column types)
+	vector<LogicalType> expected_types;
+	//! The base table to insert into
+	TableCatalogEntry &table;
+	idx_t table_index;
+	//! if returning option is used, return actual chunk to projection
+	bool return_chunk;
+	//! The default statements used by the table
+	vector<unique_ptr<Expression>> bound_defaults;
+	//! The constraints used by the table
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
+
+	BoundOnConflictInfo on_conflict_info;
 
 public:
 	void Serialize(Serializer &serializer) const override;

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

@@ -25,7 +25,7 @@ public:
 
 	// Gets the set of table references that are reachable from this node
 	static void GetTableReferences(LogicalOperator &op, unordered_set<idx_t> &bindings);
-	static void GetExpressionBindings(Expression &expr, unordered_set<idx_t> &bindings);
+	static void GetExpressionBindings(const Expression &expr, unordered_set<idx_t> &bindings);
 
 	bool HasProjectionMap() const override {
 		return !left_projection_map.empty() || !right_projection_map.empty();

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

@@ -22,11 +22,14 @@ public:
 
 public:
 	LogicalMaterializedCTE(string ctename_p, idx_t table_index, idx_t column_count, unique_ptr<LogicalOperator> cte,
-	                       unique_ptr<LogicalOperator> child)
+	                       unique_ptr<LogicalOperator> child, CTEMaterialize materialize)
 	    : LogicalCTE(std::move(ctename_p), table_index, column_count, std::move(cte), std::move(child),
-	                 LogicalOperatorType::LOGICAL_MATERIALIZED_CTE) {
+	                 LogicalOperatorType::LOGICAL_MATERIALIZED_CTE),
+	      materialize(materialize) {
 	}
 
+	CTEMaterialize materialize = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
+
 public:
 	InsertionOrderPreservingMap<string> ParamsToString() const override;
 	vector<ColumnBinding> GetColumnBindings() override {

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

@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/operator/logical_merge_into.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/common/enums/merge_action_type.hpp"
+#include "duckdb/common/index_vector.hpp"
+
+namespace duckdb {
+class TableCatalogEntry;
+class LogicalGet;
+class LogicalProjection;
+
+class BoundMergeIntoAction {
+public:
+	//! The merge action type
+	MergeActionType action_type;
+	//! Condition - or NULL if this should always be performed for the given action
+	unique_ptr<Expression> condition;
+	//! The set of referenced physical columns (for UPDATE)
+	vector<PhysicalIndex> columns;
+	//! Set of expressions for INSERT or UPDATE
+	vector<unique_ptr<Expression>> expressions;
+	//! Column index map (for INSERT)
+	physical_index_vector_t<idx_t> column_index_map;
+	//! Whether or not an UPDATE is a DELETE + INSERT
+	bool update_is_del_and_insert = false;
+
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<BoundMergeIntoAction> Deserialize(Deserializer &deserializer);
+};
+
+class LogicalMergeInto : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_MERGE_INTO;
+
+public:
+	explicit LogicalMergeInto(TableCatalogEntry &table);
+
+	//! The base table to merge into
+	TableCatalogEntry &table;
+	//! projection index
+	idx_t table_index;
+	vector<unique_ptr<Expression>> bound_defaults;
+	idx_t row_id_start;
+	optional_idx source_marker;
+	//! Bound constraints
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
+	//! Whether or not to return the input data
+	bool return_chunk = false;
+
+	map<MergeActionCondition, vector<unique_ptr<BoundMergeIntoAction>>> actions;
+
+public:
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
+
+	idx_t EstimateCardinality(ClientContext &context) override;
+	vector<idx_t> GetTableIndex() const override;
+
+protected:
+	vector<ColumnBinding> GetColumnBindings() override;
+	void ResolveTypes() override;
+
+private:
+	LogicalMergeInto(ClientContext &context, const unique_ptr<CreateInfo> &table_info);
+};
+
+} // namespace duckdb

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

@@ -36,6 +36,8 @@ public:
 	vector<unique_ptr<Expression>> key_targets;
 
 public:
+	InsertionOrderPreservingMap<string> ParamsToString() const override;
+
 	vector<ColumnBinding> GetColumnBindings() override {
 		return GenerateColumnBindings(table_index, column_count);
 	}

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

@@ -26,7 +26,7 @@ public:
 
 	//! The base table to update
 	TableCatalogEntry &table;
-	//! table catalog index
+	//! projection index
 	idx_t table_index;
 	//! if returning option is used, return the update chunk
 	bool return_chunk;

package/src/duckdb/src/include/duckdb/planner/query_node/bound_cte_node.hpp

@@ -35,6 +35,8 @@ public:
 	//! The binder used by the child side of the CTE
 	shared_ptr<Binder> child_binder;
 
+	CTEMaterialize materialized = CTEMaterialize::CTE_MATERIALIZE_DEFAULT;
+
 public:
 	idx_t GetRootIndex() override {
 		return child->GetRootIndex();

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

@@ -18,7 +18,7 @@ namespace duckdb {
 //! The FlattenDependentJoins class is responsible for pushing the dependent join down into the plan to create a
 //! flattened subquery
 struct FlattenDependentJoins {
-	FlattenDependentJoins(Binder &binder, const vector<CorrelatedColumnInfo> &correlated, bool perform_delim = true,
+	FlattenDependentJoins(Binder &binder, const CorrelatedColumns &correlated, bool perform_delim = true,
 	                      bool any_join = false, optional_ptr<FlattenDependentJoins> parent = nullptr);
 
 	static unique_ptr<LogicalOperator> DecorrelateIndependent(Binder &binder, unique_ptr<LogicalOperator> plan);
@@ -47,7 +47,7 @@ public:
 	reference_map_t<LogicalOperator, bool> has_correlated_expressions;
 	column_binding_map_t<idx_t> correlated_map;
 	column_binding_map_t<idx_t> replacement_map;
-	const vector<CorrelatedColumnInfo> &correlated_columns;
+	const CorrelatedColumns &correlated_columns;
 	vector<LogicalType> delim_types;
 
 	bool perform_delim;

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

@@ -16,7 +16,7 @@ namespace duckdb {
 //! Helper class to recursively detect correlated expressions inside a single LogicalOperator
 class HasCorrelatedExpressions : public LogicalOperatorVisitor {
 public:
-	explicit HasCorrelatedExpressions(const vector<CorrelatedColumnInfo> &correlated, bool lateral = false,
+	explicit HasCorrelatedExpressions(const CorrelatedColumns &correlated, bool lateral = false,
 	                                  idx_t lateral_depth = 0);
 
 	void VisitOperator(LogicalOperator &op) override;
@@ -28,7 +28,7 @@ protected:
 	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
 	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override;
 
-	const vector<CorrelatedColumnInfo> &correlated_columns;
+	const CorrelatedColumns &correlated_columns;
 	// Tracks number of nested laterals
 	idx_t lateral_depth;
 };

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

@@ -17,13 +17,13 @@ namespace duckdb {
 //! Helper class to rewrite correlated cte scans within a single LogicalOperator
 class RewriteCTEScan : public LogicalOperatorVisitor {
 public:
-	RewriteCTEScan(idx_t table_index, const vector<CorrelatedColumnInfo> &correlated_columns);
+	RewriteCTEScan(idx_t table_index, const CorrelatedColumns &correlated_columns);
 
 	void VisitOperator(LogicalOperator &op) override;
 
 private:
 	idx_t table_index;
-	const vector<CorrelatedColumnInfo> &correlated_columns;
+	const CorrelatedColumns &correlated_columns;
 };
 
 } // namespace duckdb

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

@@ -47,7 +47,7 @@ public:
 	//! Whether or not this is a lateral join
 	bool lateral;
 	//! The correlated columns of the right-side with the left-side
-	vector<CorrelatedColumnInfo> correlated_columns;
+	CorrelatedColumns correlated_columns;
 	//! The mark index, for mark joins generated by the relational API
 	idx_t mark_index {};
 };

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/allocator.hpp"
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/types/string.hpp"
 
 namespace duckdb {
 
@@ -77,6 +78,31 @@ public:
 		return arena_allocator;
 	}
 
+	template <class T, class... ARGS>
+	T *Make(ARGS &&... args) {
+		auto mem = AllocateAligned(sizeof(T));
+		return new (mem) T(std::forward<ARGS>(args)...);
+	}
+
+	String MakeString(const char *data, const size_t len) {
+		data_ptr_t mem = nullptr;
+
+		D_ASSERT(len < NumericLimits<uint32_t>::Maximum());
+		const auto size = static_cast<uint32_t>(len);
+		if (!String::CanBeInlined(size)) {
+			// If the string can't be inlined, we allocate it on the arena allocator
+			mem = AllocateAligned(sizeof(char) * size + 1); // +1 for null terminator
+			memcpy(mem, data, size);
+			mem[size] = '\0';
+		}
+
+		return String::Reference(mem ? reinterpret_cast<char *>(mem) : data, size);
+	}
+
+	String MakeString(const std::string &data) {
+		return MakeString(data.c_str(), data.size());
+	}
+
 private:
 	void AllocateNewBlock(idx_t min_size);
 

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

@@ -22,7 +22,7 @@ public:
 	Block(Allocator &allocator, const block_id_t id, const idx_t block_size, const idx_t block_header_size);
 	Block(Allocator &allocator, block_id_t id, uint32_t internal_size, idx_t block_header_size);
 	Block(Allocator &allocator, const block_id_t id, BlockManager &block_manager);
-	Block(FileBuffer &source, block_id_t id);
+	Block(FileBuffer &source, block_id_t id, idx_t block_header_size);
 
 	block_id_t id;
 };

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

@@ -11,11 +11,12 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/optional_idx.hpp"
+#include "duckdb/common/unordered_map.hpp"
 #include "duckdb/storage/block.hpp"
 #include "duckdb/storage/storage_info.hpp"
-#include "duckdb/common/unordered_map.hpp"
 
 namespace duckdb {
+
 class BlockHandle;
 class BufferHandle;
 class BufferManager;
@@ -57,17 +58,19 @@ public:
 	//! Get the first meta block id
 	virtual idx_t GetMetaBlock() = 0;
 	//! Read the content of the block from disk
-	virtual void Read(Block &block) = 0;
+	virtual void Read(QueryContext context, 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
+	//! Writes the block to disk.
 	virtual void Write(FileBuffer &block, block_id_t block_id) = 0;
-	//! Writes the block to disk
+	virtual void Write(QueryContext context, FileBuffer &block, block_id_t block_id);
+	//! Writes the block to disk.
 	void Write(Block &block) {
 		Write(block, block.id);
 	}
 	//! Write the header; should be the final step of a checkpoint
-	virtual void WriteHeader(DatabaseHeader header) = 0;
+	virtual void WriteHeader(QueryContext context, DatabaseHeader header) = 0;
 
 	//! Returns the number of total blocks
 	virtual idx_t TotalBlocks() = 0;
@@ -88,9 +91,10 @@ public:
 	//! Register a block with the given block id in the base file
 	shared_ptr<BlockHandle> RegisterBlock(block_id_t block_id);
 	//! 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,
-	                                            BufferHandle old_handle);
-	shared_ptr<BlockHandle> ConvertToPersistent(block_id_t block_id, shared_ptr<BlockHandle> old_block);
+	shared_ptr<BlockHandle> ConvertToPersistent(QueryContext context, block_id_t block_id,
+	                                            shared_ptr<BlockHandle> old_block, BufferHandle old_handle);
+	shared_ptr<BlockHandle> ConvertToPersistent(QueryContext context, block_id_t block_id,
+	                                            shared_ptr<BlockHandle> old_block);
 
 	void UnregisterBlock(BlockHandle &block);
 	//! UnregisterBlock, only accepts non-temporary block ids
@@ -143,6 +147,18 @@ public:
 	virtual void VerifyBlocks(const unordered_map<block_id_t, idx_t> &block_usage_count) {
 	}
 
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+
 private:
 	//! The lock for the set of blocks
 	mutex blocks_lock;

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

@@ -162,7 +162,9 @@ public:
 
 	//! Resize the actual buffer
 	void ResizeBuffer(BlockLock &, idx_t block_size, int64_t memory_delta);
-	BufferHandle Load(unique_ptr<FileBuffer> buffer = nullptr);
+
+	BufferHandle Load(QueryContext context, unique_ptr<FileBuffer> buffer = nullptr);
+
 	BufferHandle LoadFromBuffer(BlockLock &l, data_ptr_t data, unique_ptr<FileBuffer> reusable_buffer,
 	                            BufferPoolReservation reservation);
 	unique_ptr<FileBuffer> UnloadAndTakeBlock(BlockLock &);