duckdb 0.10.3-dev0.0 → 0.10.3-dev13.0

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

@@ -12,7 +12,6 @@
 #include "duckdb/common/types/constraint_conflict_info.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/unordered_set.hpp"
-#include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/storage/table_storage_info.hpp"
@@ -29,127 +28,64 @@ struct IndexScanState;
 
 //! The index is an abstract base class that serves as the basis for indexes
 class Index {
-public:
-	Index(const string &name, const string &index_type, IndexConstraintType index_constraint_type,
-	      const vector<column_t> &column_ids, TableIOManager &table_io_manager,
-	      const vector<unique_ptr<Expression>> &unbound_expressions, AttachedDatabase &db);
-	virtual ~Index() = default;
+protected:
+	Index(const vector<column_t> &column_ids, TableIOManager &table_io_manager, AttachedDatabase &db);
 
-	//! The name of the index
-	string name;
-	//! The index type (ART, B+-tree, Skip-List, ...)
-	string index_type;
-	//! The index constraint type
-	IndexConstraintType index_constraint_type;
 	//! The logical column ids of the indexed table
 	vector<column_t> column_ids;
-
-	//! Associated table io manager
-	TableIOManager &table_io_manager;
 	//! Unordered set of column_ids used by the index
 	unordered_set<column_t> column_id_set;
-	//! Unbound expressions used by the index during optimizations
-	vector<unique_ptr<Expression>> unbound_expressions;
-	//! The physical types stored in the index
-	vector<PhysicalType> types;
-	//! The logical types of the expressions
-	vector<LogicalType> logical_types;
 
+public:
+	//! Associated table io manager
+	TableIOManager &table_io_manager;
 	//! Attached database instance
 	AttachedDatabase &db;
 
 public:
-	//! Returns true if the index is a unknown index, and false otherwise
-	virtual bool IsUnknown() {
-		return false;
-	}
+	virtual ~Index() = default;
 
-	//! Obtain a lock on the index
-	void InitializeLock(IndexLock &state);
-	//! Called when data is appended to the index. The lock obtained from InitializeLock must be held
-	virtual ErrorData Append(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
-	//! Obtains a lock and calls Append while holding that lock
-	ErrorData Append(DataChunk &entries, Vector &row_identifiers);
-	//! Verify that data can be appended to the index without a constraint violation
-	virtual void VerifyAppend(DataChunk &chunk) = 0;
-	//! Verify that data can be appended to the index without a constraint violation using the conflict manager
-	virtual void VerifyAppend(DataChunk &chunk, ConflictManager &conflict_manager) = 0;
-	//! Performs constraint checking for a chunk of input data
-	virtual void CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) = 0;
-
-	//! Deletes all data from the index. The lock obtained from InitializeLock must be held
-	virtual void CommitDrop(IndexLock &index_lock) = 0;
-	//! Deletes all data from the index
-	void CommitDrop();
-	//! Delete a chunk of entries from the index. The lock obtained from InitializeLock must be held
-	virtual void Delete(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
-	//! Obtains a lock and calls Delete while holding that lock
-	void Delete(DataChunk &entries, Vector &row_identifiers);
-
-	//! Insert a chunk of entries into the index
-	virtual ErrorData Insert(IndexLock &lock, DataChunk &input, Vector &row_identifiers) = 0;
-
-	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
-	//! index must also be locked during the merge
-	virtual bool MergeIndexes(IndexLock &state, Index &other_index) = 0;
-	//! Obtains a lock and calls MergeIndexes while holding that lock
-	bool MergeIndexes(Index &other_index);
-
-	//! Traverses an ART and vacuums the qualifying nodes. The lock obtained from InitializeLock must be held
-	virtual void Vacuum(IndexLock &state) = 0;
-	//! Obtains a lock and calls Vacuum while holding that lock
-	void Vacuum();
-
-	//! Returns the in-memory usage of the index. The lock obtained from InitializeLock must be held
-	virtual idx_t GetInMemorySize(IndexLock &state) = 0;
-	//! Returns the in-memory usage of the index
-	idx_t GetInMemorySize();
-
-	//! Returns the string representation of an index, or only traverses and verifies the index
-	virtual string VerifyAndToString(IndexLock &state, const bool only_verify) = 0;
-	//! Obtains a lock and calls VerifyAndToString while holding that lock
-	string VerifyAndToString(const bool only_verify);
-
-	//! Returns true if the index is affected by updates on the specified column IDs, and false otherwise
-	bool IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const;
+	//! Returns true if the index is a bound index, and false otherwise
+	virtual bool IsBound() const = 0;
+
+	//! The index type (ART, B+-tree, Skip-List, ...)
+	virtual const string &GetIndexType() const = 0;
+
+	//! The name of the index
+	virtual const string &GetIndexName() const = 0;
+
+	//! The index constraint type
+	virtual IndexConstraintType GetConstraintType() const = 0;
 
 	//! Returns unique flag
-	bool IsUnique() {
+	bool IsUnique() const {
+		auto index_constraint_type = GetConstraintType();
 		return (index_constraint_type == IndexConstraintType::UNIQUE ||
 		        index_constraint_type == IndexConstraintType::PRIMARY);
 	}
+
 	//! Returns primary key flag
-	bool IsPrimary() {
+	bool IsPrimary() const {
+		auto index_constraint_type = GetConstraintType();
 		return (index_constraint_type == IndexConstraintType::PRIMARY);
 	}
+
 	//! Returns foreign key flag
-	bool IsForeign() {
+	bool IsForeign() const {
+		auto index_constraint_type = GetConstraintType();
 		return (index_constraint_type == IndexConstraintType::FOREIGN);
 	}
 
-	//! Returns all index storage information for serialization
-	virtual IndexStorageInfo GetStorageInfo(const bool get_buffers);
-
-	//! Execute the index expressions on an input chunk
-	void ExecuteExpressions(DataChunk &input, DataChunk &result);
-	static string AppendRowError(DataChunk &input, idx_t index);
-
-	//! Throw a constraint violation exception
-	virtual string GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t failed_index,
-	                                             DataChunk &input) = 0;
-
-protected:
-	//! Lock used for any changes to the index
-	mutex lock;
+	const vector<column_t> &GetColumnIds() const {
+		return column_ids;
+	}
 
-private:
-	//! Bound expressions used during expression execution
-	vector<unique_ptr<Expression>> bound_expressions;
-	//! Expression executor to execute the index expressions
-	ExpressionExecutor executor;
+	const unordered_set<column_t> &GetColumnIdSet() const {
+		return column_id_set;
+	}
 
-	//! Bind the unbound expressions of the index
-	unique_ptr<Expression> BindExpression(unique_ptr<Expression> expr);
+	// All indexes can be dropped, even if they are unbound
+	virtual void CommitDrop() = 0;
 
 public:
 	template <class TARGET>

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

@@ -43,7 +43,7 @@ public:
 		if (!object || object->GetObjectType() != T::ObjectType()) {
 			return nullptr;
 		}
-		return std::static_pointer_cast<T, ObjectCacheEntry>(object);
+		return shared_ptr_cast<ObjectCacheEntry, T>(object);
 	}
 
 	template <class T, class... ARGS>
@@ -52,7 +52,7 @@ public:
 
 		auto entry = cache.find(key);
 		if (entry == cache.end()) {
-			auto value = make_shared<T>(args...);
+			auto value = make_shared_ptr<T>(args...);
 			cache[key] = value;
 			return value;
 		}
@@ -60,7 +60,7 @@ public:
 		if (!object || object->GetObjectType() != T::ObjectType()) {
 			return nullptr;
 		}
-		return std::static_pointer_cast<T, ObjectCacheEntry>(object);
+		return shared_ptr_cast<ObjectCacheEntry, T>(object);
 	}
 
 	void Put(string key, shared_ptr<ObjectCacheEntry> value) {

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

@@ -26,7 +26,7 @@ public:
 	//! Final flush of the optimistic writer - fully flushes the partial block manager
 	void FinalFlush();
 	//! Flushes a specific row group to disk
-	void FlushToDisk(RowGroup *row_group);
+	void FlushToDisk(RowGroup &row_group);
 	//! Merge the partially written blocks from one optimistic writer into another
 	void Merge(OptimisticDataWriter &other);
 	//! Rollback

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

@@ -85,7 +85,7 @@ struct PartialBlockAllocation {
 	unique_ptr<PartialBlock> partial_block;
 };
 
-enum class CheckpointType { FULL_CHECKPOINT, APPEND_TO_TABLE };
+enum class PartialBlockType { FULL_CHECKPOINT, APPEND_TO_TABLE };
 
 //! Enables sharing blocks across some scope. Scope is whatever we want to share
 //! blocks across. It may be an entire checkpoint or just a single row group.
@@ -101,7 +101,7 @@ public:
 	static constexpr const idx_t MAX_BLOCK_MAP_SIZE = 1u << 31;
 
 public:
-	PartialBlockManager(BlockManager &block_manager, CheckpointType checkpoint_type,
+	PartialBlockManager(BlockManager &block_manager, PartialBlockType partial_block_type,
 	                    uint32_t max_partial_block_size = DEFAULT_MAX_PARTIAL_BLOCK_SIZE,
 	                    uint32_t max_use_count = DEFAULT_MAX_USE_COUNT);
 	virtual ~PartialBlockManager();
@@ -130,7 +130,7 @@ public:
 
 protected:
 	BlockManager &block_manager;
-	CheckpointType checkpoint_type;
+	PartialBlockType partial_block_type;
 	mutex partial_block_lock;
 	//! A map of (available space -> PartialBlock) for partially filled blocks
 	//! This is a multimap because there might be outstanding partial blocks with

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

@@ -50,6 +50,8 @@ public:
 
 	idx_t GetUsedMemory() const final;
 	idx_t GetMaxMemory() const final;
+	idx_t GetUsedSwap() final;
+	optional_idx GetMaxSwap() const final;
 
 	//! Allocate an in-memory buffer with a single pin.
 	//! The allocated memory is released when the buffer handle is destroyed.
@@ -64,7 +66,8 @@ public:
 
 	//! 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) final;
+	void SetMemoryLimit(idx_t limit = (idx_t)-1) final;
+	void SetSwapLimit(optional_idx limit = optional_idx()) final;
 
 	//! Returns informaton about memory usage
 	vector<MemoryInformation> GetMemoryUsageInfo() const override;
@@ -73,14 +76,14 @@ public:
 	vector<TemporaryFileInformation> GetTemporaryFiles() final;
 
 	const string &GetTemporaryDirectory() const final {
-		return temp_directory;
+		return temporary_directory.path;
 	}
 
 	void SetTemporaryDirectory(const string &new_dir) final;
 
 	DUCKDB_API Allocator &GetBufferAllocator() final;
 
-	DatabaseInstance &GetDatabase() {
+	DatabaseInstance &GetDatabase() override {
 		return db;
 	}
 
@@ -136,17 +139,27 @@ protected:
 	//! overwrites the data within with garbage. Any readers that do not hold the pin will notice
 	void VerifyZeroReaders(shared_ptr<BlockHandle> &handle);
 
+protected:
+	// These are stored here because temp_directory creation is lazy
+	// so we need to store information related to the temporary directory before it's created
+	struct TemporaryFileData {
+		//! The directory name where temporary files are stored
+		string path;
+		//! Lock for creating the temp handle (marked mutable so 'GetMaxSwap' can be const)
+		mutable mutex lock;
+		//! Handle for the temporary directory
+		unique_ptr<TemporaryDirectoryHandle> handle;
+		//! The maximum swap space that can be used
+		optional_idx maximum_swap_space = optional_idx();
+	};
+
 protected:
 	//! The database instance
 	DatabaseInstance &db;
 	//! 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;
+	//! The variables related to temporary file management
+	TemporaryFileData temporary_directory;
 	//! The temporary id used for managed buffers
 	atomic<block_id_t> temporary_id;
 	//! Allocator associated with the buffer manager, that passes all allocations through this buffer manager

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

@@ -11,6 +11,7 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/enums/access_mode.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
+#include "duckdb/storage/storage_manager.hpp"
 
 namespace duckdb {
 class AttachedDatabase;
@@ -40,6 +41,12 @@ public:
 
 	virtual ~StorageExtension() {
 	}
+
+	virtual void OnCheckpointStart(AttachedDatabase &db, CheckpointOptions checkpoint_options) {
+	}
+
+	virtual void OnCheckpointEnd(AttachedDatabase &db, CheckpointOptions checkpoint_options) {
+	}
 };
 
 } // namespace duckdb

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

@@ -29,7 +29,7 @@ using block_id_t = int64_t;
 
 struct Storage {
 	//! The size of a hard disk sector, only really needed for Direct IO
-	constexpr static idx_t SECTOR_SIZE = 4096;
+	constexpr static idx_t SECTOR_SIZE = 4096U;
 	//! Block header size for blocks written to the storage
 	constexpr static idx_t BLOCK_HEADER_SIZE = sizeof(uint64_t);
 	//! Size of a memory slot managed by the StorageManager. This is the quantum of allocation for Blocks on DuckDB. We
@@ -39,7 +39,7 @@ struct Storage {
 	constexpr static idx_t BLOCK_SIZE = BLOCK_ALLOC_SIZE - BLOCK_HEADER_SIZE;
 	//! The size of the headers. This should be small and written more or less atomically by the hard disk. We default
 	//! to the page size, which is 4KB. (1 << 12)
-	constexpr static idx_t FILE_HEADER_SIZE = 4096;
+	constexpr static idx_t FILE_HEADER_SIZE = 4096U;
 	//! The number of rows per row group (must be a multiple of the vector size)
 	constexpr static const idx_t ROW_GROUP_SIZE = STANDARD_ROW_GROUPS_SIZE;
 	//! The number of vectors per row group
@@ -48,7 +48,10 @@ struct Storage {
 
 //! The version number of the database storage format
 extern const uint64_t VERSION_NUMBER;
-const char *GetDuckDBVersion(idx_t version_number);
+string GetDuckDBVersion(idx_t version_number);
+optional_idx GetStorageVersion(const char *version_string);
+optional_idx GetSerializationVersion(const char *version_string);
+vector<string> GetSerializationCandidates();
 
 //! The MainHeader is the first header in the storage file. The MainHeader is typically written only once for a database
 //! file.

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

@@ -11,42 +11,46 @@
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/atomic.hpp"
 #include "duckdb/common/mutex.hpp"
+#include "duckdb/common/shared_ptr.hpp"
 
 namespace duckdb {
-class StorageLock;
+struct StorageLockInternals;
 
 enum class StorageLockType { SHARED = 0, EXCLUSIVE = 1 };
 
 class StorageLockKey {
 public:
-	StorageLockKey(StorageLock &lock, StorageLockType type);
+	StorageLockKey(shared_ptr<StorageLockInternals> internals, StorageLockType type);
 	~StorageLockKey();
 
+	StorageLockType GetType() const {
+		return type;
+	}
+
 private:
-	StorageLock &lock;
+	shared_ptr<StorageLockInternals> internals;
 	StorageLockType type;
 };
 
 class StorageLock {
-	friend class StorageLockKey;
-
 public:
 	StorageLock();
+	~StorageLock();
 
 	//! Get an exclusive lock
 	unique_ptr<StorageLockKey> GetExclusiveLock();
 	//! Get a shared lock
 	unique_ptr<StorageLockKey> GetSharedLock();
+	//! Try to get an exclusive lock - if we cannot get it immediately we return `nullptr`
+	unique_ptr<StorageLockKey> TryGetExclusiveLock();
+	//! This is a special method that only exists for checkpointing
+	//! This method takes a shared lock, and returns an exclusive lock if the parameter is the only active shared lock
+	//! If this method succeeds, we have **both** a shared and exclusive lock active (which normally is not allowed)
+	//! But this behavior is required for checkpointing
+	unique_ptr<StorageLockKey> TryUpgradeCheckpointLock(StorageLockKey &lock);
 
 private:
-	mutex exclusive_lock;
-	atomic<idx_t> read_count;
-
-private:
-	//! Release an exclusive lock
-	void ReleaseExclusiveLock();
-	//! Release a shared lock
-	void ReleaseSharedLock();
+	shared_ptr<StorageLockInternals> internals;
 };
 
 } // namespace duckdb

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

@@ -14,6 +14,7 @@
 #include "duckdb/storage/table_io_manager.hpp"
 #include "duckdb/storage/write_ahead_log.hpp"
 #include "duckdb/storage/database_size.hpp"
+#include "duckdb/common/enums/checkpoint_type.hpp"
 
 namespace duckdb {
 class BlockManager;
@@ -34,6 +35,17 @@ public:
 	virtual void FlushCommit() = 0;
 };
 
+struct CheckpointOptions {
+	CheckpointOptions()
+	    : wal_action(CheckpointWALAction::DONT_DELETE_WAL), action(CheckpointAction::CHECKPOINT_IF_REQUIRED),
+	      type(CheckpointType::FULL_CHECKPOINT) {
+	}
+
+	CheckpointWALAction wal_action;
+	CheckpointAction action;
+	CheckpointType type;
+};
+
 //! StorageManager is responsible for managing the physical storage of the
 //! database on disk
 class StorageManager {
@@ -46,20 +58,27 @@ public:
 	static StorageManager &Get(Catalog &catalog);
 
 	//! Initialize a database or load an existing database from the given path
-	void Initialize(optional_ptr<ClientContext> context);
+	void Initialize();
 
 	DatabaseInstance &GetDatabase();
 	AttachedDatabase &GetAttached() {
 		return db;
 	}
 
-	//! Get the WAL of the StorageManager, returns nullptr if in-memory
-	optional_ptr<WriteAheadLog> GetWriteAheadLog();
+	//! Gets the size of the WAL, or zero, if there is no WAL.
+	int64_t GetWALSize();
+	//! Gets the WAL of the StorageManager, or nullptr, if there is no WAL.
+	optional_ptr<WriteAheadLog> GetWAL();
+	//! Deletes the WAL file, and resets the unique pointer.
+	void ResetWAL();
 
 	//! Returns the database file path
-	string GetDBPath() {
+	string GetDBPath() const {
 		return path;
 	}
+	bool IsLoaded() const {
+		return load_complete;
+	}
 	//! The path to the WAL, derived from the database file path
 	string GetWALPath();
 	bool InMemory();
@@ -67,13 +86,13 @@ public:
 	virtual bool AutomaticCheckpoint(idx_t estimated_wal_bytes) = 0;
 	virtual unique_ptr<StorageCommitState> GenStorageCommitState(Transaction &transaction, bool checkpoint) = 0;
 	virtual bool IsCheckpointClean(MetaBlockPointer checkpoint_id) = 0;
-	virtual void CreateCheckpoint(bool delete_wal = false, bool force_checkpoint = false) = 0;
+	virtual void CreateCheckpoint(CheckpointOptions options = CheckpointOptions()) = 0;
 	virtual DatabaseSize GetDatabaseSize() = 0;
 	virtual vector<MetadataBlockInfo> GetMetadataInfo() = 0;
 	virtual shared_ptr<TableIOManager> GetTableIOManager(BoundCreateTableInfo *info) = 0;
 
 protected:
-	virtual void LoadDatabase(optional_ptr<ClientContext> context = nullptr) = 0;
+	virtual void LoadDatabase() = 0;
 
 protected:
 	//! The database this storage manager belongs to
@@ -115,12 +134,12 @@ public:
 	bool AutomaticCheckpoint(idx_t estimated_wal_bytes) override;
 	unique_ptr<StorageCommitState> GenStorageCommitState(Transaction &transaction, bool checkpoint) override;
 	bool IsCheckpointClean(MetaBlockPointer checkpoint_id) override;
-	void CreateCheckpoint(bool delete_wal, bool force_checkpoint) override;
+	void CreateCheckpoint(CheckpointOptions options) override;
 	DatabaseSize GetDatabaseSize() override;
 	vector<MetadataBlockInfo> GetMetadataInfo() override;
 	shared_ptr<TableIOManager> GetTableIOManager(BoundCreateTableInfo *info) override;
 
 protected:
-	void LoadDatabase(optional_ptr<ClientContext> context = nullptr) override;
+	void LoadDatabase() override;
 };
 } // namespace duckdb

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

@@ -149,8 +149,9 @@ public:
 
 				// place the dictionary offset into the set of vectors
 				// note: for overflow strings we write negative value
+
 				D_ASSERT(*dictionary_size <= int32_t(Storage::BLOCK_SIZE));
-				result_data[target_idx] = -(*dictionary_size);
+				result_data[target_idx] = -NumericCast<int32_t>((*dictionary_size));
 			} else {
 				// string fits in block, append to dictionary and increment dictionary position
 				D_ASSERT(string_length < NumericLimits<uint16_t>::Maximum());
@@ -162,7 +163,7 @@ public:
 
 				// place the dictionary offset into the set of vectors
 				D_ASSERT(*dictionary_size <= int32_t(Storage::BLOCK_SIZE));
-				result_data[target_idx] = *dictionary_size;
+				result_data[target_idx] = NumericCast<int32_t>(*dictionary_size);
 			}
 			D_ASSERT(RemainingSpace(segment, handle) <= Storage::BLOCK_SIZE);
 #ifdef DEBUG

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

@@ -14,6 +14,7 @@
 #include "duckdb/common/vector.hpp"
 #include "duckdb/function/compression_function.hpp"
 #include "duckdb/transaction/transaction_data.hpp"
+#include "duckdb/planner/bound_constraint.hpp"
 
 namespace duckdb {
 class ColumnSegment;
@@ -21,6 +22,7 @@ class DataTable;
 class LocalTableStorage;
 class RowGroup;
 class UpdateSegment;
+class TableCatalogEntry;
 
 struct TableAppendState;
 
@@ -69,9 +71,19 @@ struct TableAppendState {
 	TransactionData transaction;
 };
 
+struct ConstraintState {
+	explicit ConstraintState(TableCatalogEntry &table_p, const vector<unique_ptr<BoundConstraint>> &bound_constraints)
+	    : table(table_p), bound_constraints(bound_constraints) {
+	}
+
+	TableCatalogEntry &table;
+	const vector<unique_ptr<BoundConstraint>> &bound_constraints;
+};
+
 struct LocalAppendState {
 	TableAppendState append_state;
 	LocalTableStorage *storage;
+	unique_ptr<ConstraintState> constraint_state;
 };
 
 } // namespace duckdb

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

@@ -31,8 +31,10 @@ public:
 	void InitializeScan(ColumnScanState &state) override;
 	void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override;
 
-	idx_t Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result) override;
-	idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates) override;
+	idx_t Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
+	           idx_t scan_count) override;
+	idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates,
+	                    idx_t scan_count) override;
 	idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count) override;
 
 	void Skip(ColumnScanState &state, idx_t count = STANDARD_VECTOR_SIZE) override;
@@ -53,8 +55,7 @@ public:
 
 	unique_ptr<ColumnCheckpointState> CreateCheckpointState(RowGroup &row_group,
 	                                                        PartialBlockManager &partial_block_manager) override;
-	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, PartialBlockManager &partial_block_manager,
-	                                             ColumnCheckpointInfo &checkpoint_info) override;
+	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, ColumnCheckpointInfo &info) override;
 
 	void DeserializeColumn(Deserializer &source, BaseStatistics &target_stats) override;