dbm — Interfaces to Unix “databases”

Source code: Lib/dbm/__init__.py

dbm is a generic interface to variants of the DBM database:

If none of these modules are installed, the slow-but-simple implementation in module dbm.dumb will be used. There is a third party interface to the Oracle Berkeley DB.

Note

None of the underlying modules will automatically shrink the disk space used by the database file. However, dbm.sqlite3, dbm.gnu and dbm.dumb provide a reorganize() method that can be used for this purpose.

exception dbm.error

A tuple containing the exceptions that can be raised by each of the supported modules, with a unique exception also named dbm.error as the first item — the latter is used when dbm.error is raised.

dbm.whichdb(filename)

This function attempts to guess which of the several simple database modules available — dbm.sqlite3, dbm.gnu, dbm.ndbm, or dbm.dumb — should be used to open a given file.

Return one of the following values:

  • None if the file can’t be opened because it’s unreadable or doesn’t exist

  • the empty string ('') if the file’s format can’t be guessed

  • a string containing the required module name, such as 'dbm.ndbm' or 'dbm.gnu'

Changed in version 3.11: filename accepts a path-like object.

dbm.open(file, flag='r', mode=0o666)

Open a database and return the corresponding database object.

Parameters:

  • file (path-like object) –

    The database file to open.

    If the database file already exists, the whichdb() function is used to determine its type and the appropriate module is used; if it does not exist, the first submodule listed above that can be imported is used.

  • flag (str) –

    • 'r' (default): Open existing database for reading only.

    • 'w': Open existing database for reading and writing.

    • 'c': Open database for reading and writing, creating it if it doesn’t exist.

    • 'n': Always create a new, empty database, open for reading and writing.

  • mode (int) – The Unix file access mode of the file (default: octal 0o666), used only when the database has to be created.

Changed in version 3.11: file accepts a path-like object.

The object returned by open() supports the basic functionality of mutable mappings; keys and their corresponding values can be stored, retrieved, and deleted, and iteration, the in operator and methods keys(), get(), setdefault() and clear() are available. The keys() method returns a list instead of a view object. The setdefault() method requires two arguments.

Key and values are always stored as bytes. This means that when strings are used they are implicitly converted to the default encoding before being stored. For detailed information about accepted types, see Key and value types.

These objects also support being used in a with statement, which will automatically close them when done.

Changed in version 3.2: get() and setdefault() methods are now available for all dbm backends.

Changed in version 3.4: Added native support for the context management protocol to the objects returned by open().

Changed in version 3.8: Deleting a key from a read-only database raises a database module specific exception instead of KeyError.

Changed in version 3.13: clear() methods are now available for all dbm backends.

Key and value types

The accepted types for keys and values vary by backend. Keys and values are handled the same way, except where noted below:

Storage format:

All keys and values are stored as bytes objects in the database. When retrieving, you’ll always get bytes back, regardless of the original type stored.

Type conversion examples:

  • db['key'] = 'string' stored as b'string'

  • db['key'] = bytearray(b'data') stored as b'data' (dbm.dumb and dbm.sqlite3 only)

  • db['key'] = 42 stored as b'42' (dbm.sqlite3 only)

  • db['key'] = 3.14 stored as b'3.14' (dbm.sqlite3 only)

  • db['key'] = True stored as b'1' (dbm.sqlite3 only)

  • db['key'] = False stored as b'0' (dbm.sqlite3 only)

  • db['key'] = memoryview(b'data') stored as b'data' (dbm.sqlite3 only)

  • db['key'] = array.array('i', [1, 2, 3]) stored as bytes (for example, on little-endian: b'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00') (dbm.sqlite3 only)

The following example records some hostnames and a corresponding title, and then prints out the contents of the database:

import dbm

# Open database, creating it if necessary.
with dbm.open('cache', 'c') as db:

    # Record some values
    db[b'hello'] = b'there'
    db['www.python.org'] = 'Python Website'
    db['www.cnn.com'] = 'Cable News Network'

    # Note that the keys are considered bytes now.
    assert db[b'www.python.org'] == b'Python Website'
    # Notice how the value is now in bytes.
    assert db['www.cnn.com'] == b'Cable News Network'

    # Often-used methods of the dict interface work too.
    print(db.get('python.org', b'not present'))

    # Storing a non-string key or value behavior depends on the backend:
    # - Traditional backends (ndbm, gnu, dumb) will raise a TypeError
    # - The sqlite3 backend accepts it and converts to bytes
    db['www.yahoo.com'] = 4

# db is automatically closed when leaving the with statement.

See also

Module shelve

Persistence module which stores non-string data.

The individual submodules are described in the following sections.

dbm.sqlite3 — SQLite backend for dbm

Added in version 3.13.