duckdb::MainHeader Class Reference

Public Member Functions
string	LibraryGitDesc ()
string	LibraryGitHash ()
bool	IsEncrypted () const
void	SetEncrypted ()
void	SetEncryptionVersion (uint8_t version)
void	SetEncryptionMetadata (data_ptr_t source)
uint8_t	GetEncryptionCipher () const
uint8_t	GetEncryptionVersion () const
void	SetDBIdentifier (data_ptr_t source)
void	SetEncryptedCanary (data_ptr_t source)
void	SetCanaryIV (data_ptr_t source)
void	SetCanaryTag (data_ptr_t source)
data_ptr_t	GetDBIdentifier ()
data_ptr_t	GetIV ()
data_ptr_t	GetTag ()
data_ptr_t	GetEncryptedCanary ()
void	Write (WriteStream &ser)

Static Public Member Functions
static void	CheckMagicBytes (QueryContext context, FileHandle &handle)
static bool	CompareDBIdentifiers (const data_ptr_t db_identifier_1, const data_ptr_t db_identifier_2)
static MainHeader	Read (ReadStream &source)

Public Attributes
uint64_t	version_number
	The (storage) version of the database.
uint64_t	flags [FLAG_COUNT]
	The set of flags used by the database.
uint8_t	encryption_version
	Encryption version.

Static Public Attributes
static constexpr idx_t	MAX_VERSION_SIZE = 32
static constexpr idx_t	MAGIC_BYTE_SIZE = 4
static constexpr idx_t	MAGIC_BYTE_OFFSET = Storage::DEFAULT_BLOCK_HEADER_SIZE
static constexpr idx_t	FLAG_COUNT = 4
static constexpr uint64_t	ENCRYPTED_DATABASE_FLAG = 1
	Indicates whether database is encrypted or not.
static constexpr uint64_t	DEFAULT_ENCRYPTION_KEY_LENGTH = 32
	The encryption key length.
static const char	MAGIC_BYTES []
	The magic bytes in front of the file should be "DUCK".
static const char	CANARY []
	The canary should be "DUCKKEY".
static constexpr idx_t	DB_IDENTIFIER_LEN = 16
	The length of the unique database identifier.
static constexpr idx_t	ENCRYPTION_METADATA_LEN = 8
	Optional metadata for encryption, if encryption flag is set.
static constexpr idx_t	CANARY_BYTE_SIZE = 8
	The canary is a known plaintext for detecting wrong keys early.
static constexpr uint64_t	AES_NONCE_LEN = 12
	Nonce, IV (nonce + counter) and tag length.
static constexpr uint64_t	AES_COUNTER_BYTES = 4
static constexpr uint64_t	AES_NONCE_LEN_DEPRECATED = 16
static constexpr uint64_t	AES_IV_LEN = 16
static constexpr uint64_t	AES_TAG_LEN = 16

Private Attributes
data_t	library_git_desc [MAX_VERSION_SIZE]
data_t	library_git_hash [MAX_VERSION_SIZE]
data_t	encryption_metadata [ENCRYPTION_METADATA_LEN]
data_t	db_identifier [DB_IDENTIFIER_LEN]
	The unique database identifier and optional encryption salt.
data_t	encrypted_canary [CANARY_BYTE_SIZE]
data_t	canary_iv [AES_NONCE_LEN]
data_t	canary_tag [AES_TAG_LEN]

Detailed Description

The MainHeader is the first header in the storage file. It is written only once for a database file.

Member Function Documentation

LibraryGitDesc()

string duckdb::MainHeader::LibraryGitDesc ( )

inline

                            {
        return string(char_ptr_cast(library_git_desc), 0, MAX_VERSION_SIZE);
    }

LibraryGitHash()

string duckdb::MainHeader::LibraryGitHash ( )

inline

                            {
        return string(char_ptr_cast(library_git_hash), 0, MAX_VERSION_SIZE);
    }

IsEncrypted()

bool duckdb::MainHeader::IsEncrypted ( ) const

inline

                             {
        return flags[0] & MainHeader::ENCRYPTED_DATABASE_FLAG;
    }

SetEncrypted()

void duckdb::MainHeader::SetEncrypted ( )

inline

                        {
        flags[0] |= MainHeader::ENCRYPTED_DATABASE_FLAG;
    }

SetEncryptionVersion()

void duckdb::MainHeader::SetEncryptionVersion ( uint8_t  version )

inline

                                               {
        encryption_version = version;
    }

SetEncryptionMetadata()

void duckdb::MainHeader::SetEncryptionMetadata ( data_ptr_t  source )

inline

                                                  {
        memset(encryption_metadata, 0, ENCRYPTION_METADATA_LEN);
        memcpy(encryption_metadata, source, ENCRYPTION_METADATA_LEN);
    }

GetEncryptionCipher()

uint8_t duckdb::MainHeader::GetEncryptionCipher ( ) const

inline

                                        {
        return encryption_metadata[2];
    }

GetEncryptionVersion()

uint8_t duckdb::MainHeader::GetEncryptionVersion ( ) const

inline

                                         {
        return encryption_metadata[3];
    }

SetDBIdentifier()

void duckdb::MainHeader::SetDBIdentifier ( data_ptr_t  source )

inline

                                            {
        memset(db_identifier, 0, DB_IDENTIFIER_LEN);
        memcpy(db_identifier, source, DB_IDENTIFIER_LEN);
    }

SetEncryptedCanary()

void duckdb::MainHeader::SetEncryptedCanary ( data_ptr_t  source )

inline

                                               {
        memset(encrypted_canary, 0, CANARY_BYTE_SIZE);
        memcpy(encrypted_canary, source, CANARY_BYTE_SIZE);
    }

SetCanaryIV()

void duckdb::MainHeader::SetCanaryIV ( data_ptr_t  source )

inline

                                        {
        memset(canary_iv, 0, AES_NONCE_LEN);
        memcpy(canary_iv, source, AES_NONCE_LEN);
    }

SetCanaryTag()

void duckdb::MainHeader::SetCanaryTag ( data_ptr_t  source )

inline

                                         {
        memset(canary_tag, 0, AES_TAG_LEN);
        memcpy(canary_tag, source, AES_TAG_LEN);
    }

GetDBIdentifier()

data_ptr_t duckdb::MainHeader::GetDBIdentifier ( )

inline

                                 {
        return db_identifier;
    }

GetIV()

data_ptr_t duckdb::MainHeader::GetIV ( )

inline

                       {
        return canary_iv;
    }

GetTag()

data_ptr_t duckdb::MainHeader::GetTag ( )

inline

                        {
        return canary_tag;
    }

CompareDBIdentifiers()

static bool duckdb::MainHeader::CompareDBIdentifiers ( const data_ptr_t  db_identifier_1, const data_ptr_t  db_identifier_2  )

inlinestatic

                                                                                                         {
        for (idx_t i = 0; i < DB_IDENTIFIER_LEN; i++) {
            if (db_identifier_1[i] != db_identifier_2[i]) {
                return false;
            }
        }
        return true;
    }

GetEncryptedCanary()

data_ptr_t duckdb::MainHeader::GetEncryptedCanary ( )

inline

                                    {
        return encrypted_canary;
    }

---

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

• external/duckdb/duckdb.hpp