duckdb::StorageManager Class Reference

StorageManager is responsible for managing the physical storage of a persistent database. More...

Inheritance diagram for duckdb::StorageManager:

Collaboration diagram for duckdb::StorageManager:

Public Member Functions
	StorageManager (AttachedDatabase &db, string path, AttachOptions &options)
void	Initialize (QueryContext context)
DatabaseInstance &	GetDatabase ()
AttachedDatabase &	GetAttached () const
idx_t	GetWALSize ()
	Gets the size of the WAL, or zero, if there is no WAL.
bool	HasWAL () const
void	AddWALSize (idx_t size)
void	SetWALSize (idx_t size)
idx_t	GetWALEntriesCount () const
	Gets the number of WAL entries since last checkpoint.
void	ResetWALEntriesCount ()
void	IncrementWALEntriesCount ()
optional_ptr< WriteAheadLog >	GetWAL ()
	Gets the WAL of the StorageManager, or nullptr, if there is no WAL.
bool	WALStartCheckpoint (MetaBlockPointer meta_block, CheckpointOptions &options)
	Write that we started a checkpoint to the WAL if there is one - returns whether or not there is a WAL.
void	WALFinishCheckpoint (lock_guard< mutex > &wal_lock)
	Finishes a checkpoint.
unique_ptr< lock_guard< mutex > >	GetWALLock ()
string	GetDBPath () const
	Returns the database file path.
bool	IsLoaded () const
string	GetWALPath (const string &suffix=".wal")
	The path to the WAL, derived from the database file path.
string	GetCheckpointWALPath ()
	The path to the WAL that is used while a checkpoint is running.
string	GetRecoveryWALPath ()
	The path to the WAL that is used while recovering from a crash involving the checkpoint WAL.
bool	InMemory () const
virtual bool	AutomaticCheckpoint (idx_t estimated_wal_bytes)=0
virtual unique_ptr< StorageCommitState >	GenStorageCommitState (WriteAheadLog &wal)=0
virtual bool	IsCheckpointClean (MetaBlockPointer checkpoint_id)=0
virtual void	CreateCheckpoint (QueryContext context, CheckpointOptions options=CheckpointOptions())=0
virtual DatabaseSize	GetDatabaseSize ()=0
virtual vector< MetadataBlockInfo >	GetMetadataInfo ()=0
virtual shared_ptr< TableIOManager >	GetTableIOManager (BoundCreateTableInfo *info)=0
virtual BlockManager &	GetBlockManager ()=0
virtual void	Destroy ()
void	SetStorageVersion (idx_t version)
bool	HasStorageVersion () const
idx_t	GetStorageVersion () const
bool	CompressionIsEnabled () const
EncryptionTypes::CipherType	GetCipher () const
void	SetCipher (EncryptionTypes::CipherType cipher_p)
void	SetEncryptionVersion (EncryptionTypes::EncryptionVersion version)
bool	IsEncrypted () const
EncryptionTypes::EncryptionVersion	GetEncryptionVersion () const
template<class TARGET >
TARGET &	Cast ()
template<class TARGET >
const TARGET &	Cast () const

Static Public Member Functions
static StorageManager &	Get (AttachedDatabase &db)
static StorageManager &	Get (Catalog &catalog)

Protected Member Functions
virtual void	LoadDatabase (QueryContext context)=0

Protected Attributes
AttachedDatabase &	db
	The attached database managed by this storage manager.
string	path
	The path of the database.
string	wal_path
	The WAL path.
unique_ptr< WriteAheadLog >	wal
	The WriteAheadLog of the storage manager.
mutex	wal_lock
	Mutex used to control writes to the WAL.
bool	read_only
	Whether or not the database is opened in read-only mode.
bool	load_complete = false
optional_idx	storage_version
	The serialization compatibility version when reading and writing from this database.
atomic< idx_t >	wal_size
atomic< idx_t >	wal_entries_count
StorageOptions	storage_options
	Storage options passed in through configuration.

Detailed Description

StorageManager is responsible for managing the physical storage of a persistent database.

Member Function Documentation

Initialize()

void duckdb::StorageManager::Initialize

(

QueryContext

context

)

Initialize a database or load an existing database from the database file path. The block_alloc_size is either set, or invalid. If invalid, then DuckDB defaults to the default_block_alloc_size (DBConfig), or the file's block allocation size, if it is an existing database.

GetAttached()

AttachedDatabase & duckdb::StorageManager::GetAttached ( ) const

inline

                                          {
        return db;
    }

GetDBPath()

string duckdb::StorageManager::GetDBPath ( ) const

inline

Returns the database file path.

                             {
        return path;
    }

IsLoaded()

bool duckdb::StorageManager::IsLoaded ( ) const

inline

                          {
        return load_complete;
    }

SetStorageVersion()

void duckdb::StorageManager::SetStorageVersion ( idx_t  version )

inline

                                          {
        storage_version = version;
    }

HasStorageVersion()

bool duckdb::StorageManager::HasStorageVersion ( ) const

inline

                                   {
        return storage_version.IsValid();
    }

GetStorageVersion()

idx_t duckdb::StorageManager::GetStorageVersion ( ) const

inline

                                    {
        D_ASSERT(HasStorageVersion());
        return storage_version.GetIndex();
    }

CompressionIsEnabled()

bool duckdb::StorageManager::CompressionIsEnabled ( ) const

inline

                                      {
        return storage_options.compress_in_memory == CompressInMemory::COMPRESS;
    }

GetCipher()

EncryptionTypes::CipherType duckdb::StorageManager::GetCipher ( ) const

inline

                                                {
        return storage_options.encryption_cipher;
    }

SetCipher()

void duckdb::StorageManager::SetCipher ( EncryptionTypes::CipherType  cipher_p )

inline

                                                       {
        D_ASSERT(cipher_p != EncryptionTypes::INVALID);
        if (cipher_p == EncryptionTypes::CBC) {
            throw InvalidInputException("CBC cipher is disabled");
        }
        storage_options.encryption_cipher = cipher_p;
    }

SetEncryptionVersion()

void duckdb::StorageManager::SetEncryptionVersion ( EncryptionTypes::EncryptionVersion  version )

inline

                                                                        {
        storage_options.encryption_version = version;
    }

IsEncrypted()

bool duckdb::StorageManager::IsEncrypted ( ) const

inline

                             {
        return storage_options.encryption;
    }

GetEncryptionVersion()

EncryptionTypes::EncryptionVersion duckdb::StorageManager::GetEncryptionVersion ( ) const

inline

                                                                  {
        return storage_options.encryption_version;
    }

Cast() [1/2]

template<class TARGET >

TARGET & duckdb::StorageManager::Cast ( )

inline

                   {
        DynamicCastCheck<TARGET>(this);
        return reinterpret_cast<TARGET &>(*this);
    }

Cast() [2/2]

template<class TARGET >

const TARGET & duckdb::StorageManager::Cast ( ) const

inline

                               {
        DynamicCastCheck<TARGET>(this);
        return reinterpret_cast<const TARGET &>(*this);
    }

Member Data Documentation

load_complete

bool duckdb::StorageManager::load_complete = false

protected

When loading a database, we do not yet set the wal-field. Therefore, GetWriteAheadLog must return nullptr when loading a database

wal_size

atomic<idx_t> duckdb::StorageManager::wal_size

protected

Estimated size of changes for determining automatic checkpointing on in-memory databases and databases without a WAL.

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.cpp