duckdb 1.3.4 → 1.4.1-dev2.0

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

@@ -15,6 +15,7 @@
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/storage/buffer/temporary_file_information.hpp"
 #include "duckdb/storage/storage_lock.hpp"
+#include "duckdb/common/types/timestamp.hpp"
 
 namespace duckdb {
 
@@ -62,11 +63,11 @@ public:
 		void Verify(const unique_ptr<StorageLockKey> &guard) const;
 		//! Whether the CachedFile is still valid given the current modified/version tag
 		bool IsValid(const unique_ptr<StorageLockKey> &guard, bool validate, const string &current_version_tag,
-		             time_t current_last_modified);
+		             timestamp_t current_last_modified);
 
 		//! Get reference to properties (must hold the lock)
 		idx_t &FileSize(const unique_ptr<StorageLockKey> &guard);
-		time_t &LastModified(const unique_ptr<StorageLockKey> &guard);
+		timestamp_t &LastModified(const unique_ptr<StorageLockKey> &guard);
 		string &VersionTag(const unique_ptr<StorageLockKey> &guard);
 		bool &CanSeek(const unique_ptr<StorageLockKey> &guard);
 		bool &OnDiskFile(const unique_ptr<StorageLockKey> &guard);
@@ -80,7 +81,7 @@ public:
 		map<idx_t, shared_ptr<CachedFileRange>> ranges;
 
 		idx_t file_size;
-		time_t last_modified;
+		timestamp_t last_modified;
 		string version_tag;
 		bool can_seek;
 		bool on_disk_file;
@@ -101,8 +102,8 @@ public:
 	//! Gets the cached file, or creates it if is not yet present
 	CachedFile &GetOrCreateCachedFile(const string &path);
 
-	DUCKDB_API static bool IsValid(bool validate, const string &cached_version_tag, time_t cached_last_modified,
-	                               const string &current_version_tag, time_t current_last_modified);
+	DUCKDB_API static bool IsValid(bool validate, const string &cached_version_tag, timestamp_t cached_last_modified,
+	                               const string &current_version_tag, timestamp_t current_last_modified);
 
 private:
 	//! The BufferManager used to cache files

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/main/client_context.hpp"
 #include "duckdb/storage/block_manager.hpp"
 
 namespace duckdb {
@@ -50,7 +51,8 @@ public:
 	idx_t GetMetaBlock() override {
 		throw InternalException("Cannot perform IO in in-memory database - GetMetaBlock!");
 	}
-	void Read(Block &block) override {
+
+	void Read(QueryContext context, Block &block) override {
 		throw InternalException("Cannot perform IO in in-memory database - Read!");
 	}
 	void ReadBlocks(FileBuffer &buffer, block_id_t start_block, idx_t block_count) override {
@@ -59,7 +61,10 @@ public:
 	void Write(FileBuffer &block, block_id_t block_id) override {
 		throw InternalException("Cannot perform IO in in-memory database - Write!");
 	}
-	void WriteHeader(DatabaseHeader header) override {
+	void Write(QueryContext context, FileBuffer &block, block_id_t block_id) override {
+		throw InternalException("Cannot perform IO in in-memory database - Write with client context!");
+	}
+	void WriteHeader(QueryContext context, DatabaseHeader header) override {
 		throw InternalException("Cannot perform IO in in-memory database - WriteHeader!");
 	}
 	bool InMemory() override {

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

@@ -12,6 +12,7 @@
 
 namespace duckdb {
 class FileSystem;
+class QueryContext;
 
 enum class DataFileType : uint8_t {
 	FILE_DOES_NOT_EXIST, // file does not exist
@@ -23,7 +24,7 @@ enum class DataFileType : uint8_t {
 
 class MagicBytes {
 public:
-	static DataFileType CheckMagicBytes(FileSystem &fs, const string &path);
+	static DataFileType CheckMagicBytes(QueryContext context, FileSystem &fs, const string &path);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/metadata/metadata_manager.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/storage/block.hpp"
 #include "duckdb/storage/block_manager.hpp"
+#include "duckdb/common/atomic.hpp"
 #include "duckdb/common/set.hpp"
 #include "duckdb/storage/buffer/buffer_handle.hpp"
 
@@ -19,15 +20,27 @@ class DatabaseInstance;
 struct MetadataBlockInfo;
 
 struct MetadataBlock {
+	MetadataBlock();
+	// disable copy constructors
+	MetadataBlock(const MetadataBlock &other) = delete;
+	MetadataBlock &operator=(const MetadataBlock &) = delete;
+	//! enable move constructors
+	DUCKDB_API MetadataBlock(MetadataBlock &&other) noexcept;
+	DUCKDB_API MetadataBlock &operator=(MetadataBlock &&) noexcept;
+
 	shared_ptr<BlockHandle> block;
 	block_id_t block_id;
 	vector<uint8_t> free_blocks;
+	atomic<bool> dirty;
 
 	void Write(WriteStream &sink);
 	static MetadataBlock Read(ReadStream &source);
 
 	idx_t FreeBlocksToInteger();
 	void FreeBlocksFromInteger(idx_t blocks);
+	static vector<uint8_t> BlocksFromInteger(idx_t free_list);
+
+	string ToString() const;
 };
 
 struct MetadataPointer {
@@ -52,6 +65,8 @@ public:
 	MetadataHandle AllocateHandle();
 	MetadataHandle Pin(const MetadataPointer &pointer);
 
+	MetadataHandle Pin(QueryContext context, const MetadataPointer &pointer);
+
 	MetaBlockPointer GetDiskPointer(const MetadataPointer &pointer, uint32_t offset = 0);
 	MetadataPointer FromDiskPointer(MetaBlockPointer pointer);
 	MetadataPointer RegisterDiskPointer(MetaBlockPointer pointer);
@@ -77,17 +92,19 @@ public:
 protected:
 	BlockManager &block_manager;
 	BufferManager &buffer_manager;
+	mutable mutex block_lock;
 	unordered_map<block_id_t, MetadataBlock> blocks;
 	unordered_map<block_id_t, idx_t> modified_blocks;
 
 protected:
-	block_id_t AllocateNewBlock();
-	block_id_t PeekNextBlockId();
-	block_id_t GetNextBlockId();
-
-	void AddBlock(MetadataBlock new_block, bool if_exists = false);
-	void AddAndRegisterBlock(MetadataBlock block);
-	void ConvertToTransient(MetadataBlock &block);
+	block_id_t AllocateNewBlock(unique_lock<mutex> &block_lock);
+	block_id_t PeekNextBlockId() const;
+	block_id_t GetNextBlockId() const;
+
+	void AddBlock(unique_lock<mutex> &block_lock, MetadataBlock new_block, bool if_exists = false);
+	void AddAndRegisterBlock(unique_lock<mutex> &block_lock, MetadataBlock block);
+	void ConvertToTransient(unique_lock<mutex> &block_lock, MetadataBlock &block);
+	MetadataPointer FromDiskPointerInternal(unique_lock<mutex> &block_lock, MetaBlockPointer pointer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/metadata/metadata_reader.hpp

@@ -27,11 +27,16 @@ public:
 	//! Read content of size read_size into the buffer
 	void ReadData(data_ptr_t buffer, idx_t read_size) override;
 
+	void ReadData(QueryContext context, data_ptr_t buffer, idx_t read_size) override;
+
 	MetaBlockPointer GetMetaBlockPointer();
 
 	MetadataManager &GetMetadataManager() {
 		return manager;
 	}
+	//! Gets a list of all remaining blocks to be read by this metadata reader - consumes all blocks
+	//! If "last_block" is specified, we stop when reaching that block
+	vector<MetaBlockPointer> GetRemainingBlocks(MetaBlockPointer last_block = MetaBlockPointer());
 
 private:
 	data_ptr_t BasePtr();
@@ -39,6 +44,8 @@ private:
 
 	void ReadNextBlock();
 
+	void ReadNextBlock(QueryContext context);
+
 	MetadataPointer FromDiskPointer(MetaBlockPointer pointer);
 
 private:

package/src/duckdb/src/include/duckdb/storage/metadata/metadata_writer.hpp

@@ -30,6 +30,7 @@ public:
 	MetadataManager &GetManager() {
 		return manager;
 	}
+	void SetWrittenPointers(optional_ptr<vector<MetaBlockPointer>> written_pointers);
 
 protected:
 	virtual MetadataHandle NextHandle();

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

@@ -15,7 +15,7 @@ class PartialBlockManager;
 
 class OptimisticDataWriter {
 public:
-	explicit OptimisticDataWriter(DataTable &table);
+	OptimisticDataWriter(ClientContext &context, DataTable &table);
 	OptimisticDataWriter(DataTable &table, OptimisticDataWriter &parent);
 	~OptimisticDataWriter();
 
@@ -32,14 +32,21 @@ public:
 	//! Rollback
 	void Rollback();
 
+	//! Return the client context.
+	ClientContext &GetClientContext() {
+		return context;
+	}
+
 private:
 	//! Prepare a write to disk
 	bool PrepareWrite();
 
 private:
-	//! The table
+	//! The client context in which we're writing the data.
+	ClientContext &context;
+	//! The table.
 	DataTable &table;
-	//! The partial block manager, if any was created.
+	//! The partial block manager, if any.
 	unique_ptr<PartialBlockManager> partial_manager;
 };
 

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

@@ -60,8 +60,9 @@ struct PartialBlock {
 public:
 	//! Add regions that need zero-initialization to avoid leaking memory
 	void AddUninitializedRegion(const idx_t start, const idx_t end);
+	virtual void AddSegmentToTail(ColumnData &data, ColumnSegment &segment, uint32_t offset_in_block);
 	//! Flush the block to disk and zero-initialize any free space and uninitialized regions
-	virtual void Flush(const idx_t free_space_left) = 0;
+	virtual void Flush(QueryContext context, const idx_t free_space_left) = 0;
 	void FlushInternal(const idx_t free_space_left);
 	virtual void Merge(PartialBlock &other, idx_t offset, idx_t other_size) = 0;
 	virtual void Clear() = 0;
@@ -85,7 +86,7 @@ struct PartialBlockAllocation {
 	unique_ptr<PartialBlock> partial_block;
 };
 
-enum class PartialBlockType { FULL_CHECKPOINT, APPEND_TO_TABLE };
+enum class PartialBlockType { FULL_CHECKPOINT, APPEND_TO_TABLE, IN_MEMORY_CHECKPOINT };
 
 //! 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.
@@ -99,7 +100,7 @@ public:
 	static constexpr const idx_t MAX_BLOCK_MAP_SIZE = 1u << 31;
 
 public:
-	PartialBlockManager(BlockManager &block_manager, PartialBlockType partial_block_type,
+	PartialBlockManager(QueryContext context, BlockManager &block_manager, PartialBlockType partial_block_type,
 	                    optional_idx max_partial_block_size = optional_idx(),
 	                    uint32_t max_use_count = DEFAULT_MAX_USE_COUNT);
 	virtual ~PartialBlockManager();
@@ -122,14 +123,24 @@ public:
 	//! Flush any remaining partial blocks to disk
 	void FlushPartialBlocks();
 
+	unique_ptr<PartialBlock> CreatePartialBlock(ColumnData &data, ColumnSegment &segment, PartialBlockState state,
+	                                            BlockManager &block_manager);
+
 	unique_lock<mutex> GetLock() {
 		return unique_lock<mutex>(partial_block_lock);
 	}
 
 	//! Returns a reference to the underlying block manager.
 	BlockManager &GetBlockManager() const;
+	//! Returns the optional client context.
+	optional_ptr<ClientContext> GetClientContext() const;
 
 protected:
+	//! The optional client context in which we use the partial block manager.
+	//! The SingleFileCheckpointWriter contains a partial block manager, and the destructor of
+	//! AttachedDatabase invokes CreateCheckpoint with that checkpoint writer.
+	//! Thus, we're using the optional client context instead of a reference.
+	optional_ptr<ClientContext> context;
 	BlockManager &block_manager;
 	PartialBlockType partial_block_type;
 	mutex partial_block_lock;

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

@@ -16,12 +16,30 @@
 #include "duckdb/common/set.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/common/encryption_functions.hpp"
 
 namespace duckdb {
 
 class DatabaseInstance;
 struct MetadataHandle;
 
+struct EncryptionOptions {
+	//! indicates whether the db is encrypted
+	bool encryption_enabled = false;
+	//! Whether Additional Authenticated Data is used
+	bool additional_authenticated_data = false;
+	//! derived encryption key id
+	string derived_key_id;
+	// //! Cipher used for encryption
+	// EncryptionTypes::CipherType cipher = EncryptionTypes::CipherType::INVALID;
+	//! key derivation function (kdf) used
+	EncryptionTypes::KeyDerivationFunction kdf = EncryptionTypes::KeyDerivationFunction::SHA256;
+	//! Key Length
+	uint32_t key_length = MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH;
+	//! User key pointer (to StorageOptions)
+	shared_ptr<string> user_key;
+};
+
 struct StorageManagerOptions {
 	bool read_only = false;
 	bool use_direct_io = false;
@@ -30,13 +48,9 @@ struct StorageManagerOptions {
 	optional_idx storage_version;
 	optional_idx version_number;
 	optional_idx block_header_size;
-
-	//! indicates whether db is encrypted
-	bool encryption = false;
-
-	bool NeedsEncryption() const {
-		return encryption;
-	}
+	//! Unique database identifier and optional encryption salt.
+	data_t db_identifier[MainHeader::DB_IDENTIFIER_LEN];
+	EncryptionOptions encryption_options;
 };
 
 //! SingleFileBlockManager is an implementation for a BlockManager which manages blocks in a single file
@@ -45,14 +59,14 @@ class SingleFileBlockManager : public BlockManager {
 	static constexpr uint64_t BLOCK_START = Storage::FILE_HEADER_SIZE * 3;
 
 public:
-	SingleFileBlockManager(AttachedDatabase &db, const string &path, const StorageManagerOptions &options_p);
+	SingleFileBlockManager(AttachedDatabase &db_p, const string &path_p, const StorageManagerOptions &options_p);
 
 	FileOpenFlags GetFileFlags(bool create_new) const;
 	//! Creates a new database.
-	void CreateNewDatabase();
+	void CreateNewDatabase(QueryContext context);
 	//! Loads an existing database. We pass the provided block allocation size as a parameter
 	//! to detect inconsistencies with the file header.
-	void LoadExistingDatabase();
+	void LoadExistingDatabase(QueryContext context);
 
 	//! Creates a new Block using the specified block_id and returns a pointer
 	unique_ptr<Block> ConvertBlock(block_id_t block_id, FileBuffer &source_buffer) override;
@@ -74,13 +88,19 @@ public:
 	//! Return the meta block id
 	idx_t GetMetaBlock() override;
 	//! Read the content of the block from disk
-	void Read(Block &block) override;
+	void Read(QueryContext context, Block &block) override;
+
+	//! Read individual blocks
+	void ReadBlock(Block &block, bool skip_block_header = false) const;
+	void ReadBlock(data_ptr_t internal_buffer, uint64_t block_size, bool skip_block_header = false) const;
 	//! Read the content of a range of blocks into a buffer
 	void ReadBlocks(FileBuffer &buffer, block_id_t start_block, idx_t block_count) override;
-	//! Write the given block to disk
-	void Write(FileBuffer &block, block_id_t block_id) override;
+	//! Write the block to disk. Use Write with client context instead.
+	void Write(FileBuffer &buffer, block_id_t block_id) override;
+	//! Write the block to disk.
+	void Write(QueryContext context, FileBuffer &buffer, block_id_t block_id) override;
 	//! Write the header to disk, this is the final step of the checkpointing process
-	void WriteHeader(DatabaseHeader header) override;
+	void WriteHeader(QueryContext context, DatabaseHeader header) override;
 	//! Sync changes to the underlying file
 	void FileSync() override;
 	//! Truncate the underlying database file after a checkpoint
@@ -96,17 +116,43 @@ public:
 	//! Whether or not the attached database is a remote file
 	bool IsRemote() override;
 
+	//! Return the checkpoint iteration of the file.
+	uint64_t GetCheckpointIteration() const {
+		return iteration_count;
+	}
+	//! Return the version number of the file.
+	uint64_t GetVersionNumber() const;
+	//! Return the database identifier.
+	data_ptr_t GetDBIdentifier() {
+		return options.db_identifier;
+	}
+
 private:
 	//! Loads the free list of the file.
-	void LoadFreeList();
+	void LoadFreeList(QueryContext context);
+
 	//! Initializes the database header. We pass the provided block allocation size as a parameter
 	//!	to detect inconsistencies with the file header.
 	void Initialize(const DatabaseHeader &header, const optional_idx block_alloc_size);
 
-	void ReadAndChecksum(FileBuffer &handle, uint64_t location, bool skip_block_header = false) const;
-	void ChecksumAndWrite(FileBuffer &handle, uint64_t location, bool skip_block_header = false) const;
+	void CheckChecksum(FileBuffer &block, uint64_t location, uint64_t delta, bool skip_block_header = false) const;
+	void CheckChecksum(data_ptr_t start_ptr, uint64_t delta, bool skip_block_header = false) const;
+
+	void ReadAndChecksum(QueryContext context, FileBuffer &handle, uint64_t location,
+	                     bool skip_block_header = false) const;
+	void ChecksumAndWrite(QueryContext context, FileBuffer &handle, uint64_t location,
+	                      bool skip_block_header = false) const;
+
+	idx_t GetBlockLocation(block_id_t block_id) const;
+
+	// Encrypt, Store, Decrypt the canary
+	static void StoreEncryptedCanary(AttachedDatabase &db, MainHeader &main_header, const string &key_id);
+	static void StoreDBIdentifier(MainHeader &main_header, const data_ptr_t db_identifier);
+	void StoreEncryptionMetadata(MainHeader &main_header) const;
 
-	idx_t GetBlockLocation(block_id_t block_id);
+	//! Check and adding Encryption Keys
+	void CheckAndAddEncryptionKey(MainHeader &main_header, string &user_key);
+	void CheckAndAddEncryptionKey(MainHeader &main_header);
 
 	//! Return the blocks to which we will write the free list and modified blocks
 	vector<MetadataHandle> GetFreeListBlocks();
@@ -118,7 +164,6 @@ private:
 	void VerifyBlocks(const unordered_map<block_id_t, idx_t> &block_usage_count) override;
 
 	void AddStorageVersionTag();
-	uint64_t GetVersionNumber();
 
 private:
 	AttachedDatabase &db;
@@ -146,7 +191,7 @@ private:
 	block_id_t max_block;
 	//! The block id where the free list can be found
 	idx_t free_list_id;
-	//! The current header iteration count
+	//! The current header iteration count.
 	uint64_t iteration_count;
 	//! The storage manager options
 	StorageManagerOptions options;

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

@@ -40,9 +40,6 @@ public:
 
 public:
 	static unique_ptr<StandardBufferManager> CreateBufferManager(DatabaseInstance &db, string temp_directory);
-	static unique_ptr<FileBuffer> ReadTemporaryBufferInternal(BufferManager &buffer_manager, FileHandle &handle,
-	                                                          idx_t position, idx_t size,
-	                                                          unique_ptr<FileBuffer> reusable_buffer);
 
 	//! Registers a transient memory buffer.
 	shared_ptr<BlockHandle> RegisterTransientMemory(const idx_t size, BlockManager &block_manager) final;
@@ -59,7 +56,7 @@ public:
 	idx_t GetBlockAllocSize() const final;
 	//! Returns the block size for buffer-managed blocks.
 	idx_t GetBlockSize() const final;
-	idx_t GetTemporaryBlockHeaderSize() const final;
+	idx_t GetQueryMaxMemory() const final;
 
 	//! Allocate an in-memory buffer with a single pin.
 	//! The allocated memory is released when the buffer handle is destroyed.
@@ -72,8 +69,10 @@ public:
 
 	//! Reallocate an in-memory buffer that is pinned.
 	void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size) final;
-
 	BufferHandle Pin(shared_ptr<BlockHandle> &handle) final;
+
+	BufferHandle Pin(QueryContext context, shared_ptr<BlockHandle> &handle);
+
 	void Prefetch(vector<shared_ptr<BlockHandle>> &handles) final;
 	void Unpin(shared_ptr<BlockHandle> &handle) final;
 
@@ -107,6 +106,7 @@ public:
 	DUCKDB_API void ReserveMemory(idx_t size) final;
 	DUCKDB_API void FreeReservedMemory(idx_t size) final;
 	bool HasTemporaryDirectory() const final;
+	bool HasFilesInTemporaryDirectory() const final;
 
 protected:
 	//! Helper
@@ -137,7 +137,7 @@ protected:
 	//! Write a temporary buffer to disk
 	void WriteTemporaryBuffer(MemoryTag tag, block_id_t block_id, FileBuffer &buffer) final;
 	//! Read a temporary buffer from disk
-	unique_ptr<FileBuffer> ReadTemporaryBuffer(MemoryTag tag, BlockHandle &block,
+	unique_ptr<FileBuffer> ReadTemporaryBuffer(QueryContext context, MemoryTag tag, BlockHandle &block,
 	                                           unique_ptr<FileBuffer> buffer = nullptr) final;
 	//! Get the path of the temporary buffer
 	string GetTemporaryPath(block_id_t id);

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

@@ -83,7 +83,7 @@ public:
 	inline void SetHasNullFast() {
 		has_null = true;
 	}
-	//! Set that the CURRENT level can have valiod values
+	//! Set that the CURRENT level can have valid values
 	//! Note that this is not correct for nested types unless this information is propagated in a different manner
 	//! Use Set(StatsInfo::CAN_HAVE_VALID_VALUES) in the general case
 	inline void SetHasNoNullFast() {
@@ -104,7 +104,7 @@ public:
 	static BaseStatistics Deserialize(Deserializer &deserializer);
 
 	//! Verify that a vector does not violate the statistics
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const;
+	void Verify(Vector &vector, const SelectionVector &sel, idx_t count, bool ignore_has_null = false) const;
 	void Verify(Vector &vector, idx_t count) const;
 
 	string ToString() const;

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

@@ -71,6 +71,8 @@ struct StringStats {
 	                                                     ExpressionType comparison_type, const string &value);
 
 	DUCKDB_API static void Update(BaseStatistics &stats, const string_t &value);
+	DUCKDB_API static void SetMin(BaseStatistics &stats, const string_t &value);
+	DUCKDB_API static void SetMax(BaseStatistics &stats, const string_t &value);
 	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
 	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
 

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

@@ -25,10 +25,10 @@ struct StorageExtensionInfo {
 	}
 };
 
-typedef unique_ptr<Catalog> (*attach_function_t)(StorageExtensionInfo *storage_info, ClientContext &context,
-                                                 AttachedDatabase &db, const string &name, AttachInfo &info,
-                                                 AccessMode access_mode);
-typedef unique_ptr<TransactionManager> (*create_transaction_manager_t)(StorageExtensionInfo *storage_info,
+typedef unique_ptr<Catalog> (*attach_function_t)(optional_ptr<StorageExtensionInfo> storage_info,
+                                                 ClientContext &context, AttachedDatabase &db, const string &name,
+                                                 AttachInfo &info, AttachOptions &options);
+typedef unique_ptr<TransactionManager> (*create_transaction_manager_t)(optional_ptr<StorageExtensionInfo> storage_info,
                                                                        AttachedDatabase &db, Catalog &catalog);
 
 class StorageExtension {