# cyrusdb API

## Intro

The `cyrusdb` API is a common interface to a key-value store, used throughout the Cyrus code. It allows a choice of different backends for different access patterns, while ensuring a consistent interface.

This document will describe the interface, and how to use the cyrusdb interface from within parts of Cyrus code, as well as how to implement your own backend

If you pass incorrect values to these APIs, you will get an assertion failure in most cases. That's generally considered safer than silenty breaking things. Exceptions are noted below.

## Code Layout

The implementation of each interface is in `lib/cyrusdb_NAME.c`, for example lib/cyrusdb_flat.c. General functions are in `lib/cyrusdb.c` and the interface in `lib/cyrusdb.h`.

## Configuration

The name of the backend for each of the main internal databases can be configured in imapd.conf, for example: `annotation_db: skiplist`. This is then read in imap/global.h and imap/global.c during startup, so that the global variable `config_annotation_db` gets set to the configured backend name:

        config_annotation_db = config_getstring(IMAPOPT_ANNOTATION_DB);

(Beware the misleading naming here: `config_annotation_db` is a string describing the backend used by the database, not, say, its location on disk.)

Internally, the main module for each database sets up struct of pointers to the cyrusdb functions it implements, which is registered in `lib/cyrusdb.c`

`lib/cyrus.c` provides backend-agnostic wrapper functions for interacting with cyrusdb databases.

## A full example

      struct db *db = NULL;
      struct txn *tid = NULL;
      const char *filename = NULL;
      int flags = CYRUSDB_CREATE;

      cyrus_init(alt_config, "toolname", 0);

      filename = config_getstring(IMAPOPT_ANNOTATION_DB_PATH);

      r = cyrusdb_open(config_annotation_db, filename, flags, &db);

      r = cyrusdb_fetch(db, key, keylen, &data, &datalen, &tid);

      r = cyrusdb_commit(db, tid);

      r = cyrusdb_close(db);

      cyrus_done();

Note that you always open a database first, and close it at the end. You must always call cyrus_init() and cyrus_done() to properly intialise and clean up the `cyrusdb` environments.

This example also uses a transaction, meaning that the database is locked in exclusive mode between the 'fetch' (the first use of the transaction) and the commit.

## About Transactions

The cyrusdb interface works in two modes - transactional and non-transactional. The value of the 'tid' parameter decides which mode is used. There are three possible values:

- NULL - non-transactional. Will create a temporary lock for the duration of the current action - either a write lock for "store" or a read lock for "fetch". If you call "foreach", the lock will be dropped between each record fetched
- Pointer to NULL - transactional, transaction not yet started. Will always take a write lock on the database, and update the pointer to point to the new transaction.
- Pointer to a valid transaction. Will keep using this transaction

If you are currently in a transaction, you MUST pass the same transaction to every database call. It is not possible to mix or nest transactions. There is one exception in the skiplist backend: If you pass NULL to a fetch or foreach while the database is in a transaction, it will silently do the read in the current transaction rather than returning an error

## API Reference

All functions follow the normal C API of returning '0' on success, and an error code on failure

### cyrusdb_init(void)

Is called once per process. Don't call this yourself, use `cyrus_init()`. No other calls will be made until this is called.

### cyrusdb_done(void)

The opposite of `cyrusdb_init()` - called once per process to do any cleaning up after all database usage is finished. Don't call this yourself, use `cyrus_done()`.

### cyrusdb_sync(const char *backend)

Perform a checkpoint of the database environment. Used by berkeley backend. Is called by `ctl_cyrusdb -c` on a regular basis

### cyrusdb_open(const char *backend, const char *fname, int flags, struct db **retdb)

Opens the database with the specified 'file name' (or other descriptor, for example the sql backend is not a filename), and if successful returns an opaque database structure

Flags:

- CYRUSDB_CREATE - create the database if it doesn't exist
- CYRUSDB_MBOXSORT - sort '.' first, so folder listing is correct

Errors:

- CYRUSDB_IOERROR - if there is any error reading the file, or any corruption detected while loading the file

### cyrusdb_close(struct db *db)

Close the named database. Will release any locks if they are still held, but it's bad practice to close without committing or aborting, so the backend should log an error

Errors:

- CYRUSDB_IOERROR - if there are any errors during close

### cyrusdb_fetch(struct db *db, const char *key, size_t keylen, const char **data, size_t *datalen, struct txn **tidptr)

### cyrusdb_fetchlock(struct db *db, const char *key, size_t keylen, const char **data, size_t *datalen, struct txn **tidptr)

Fetch the value for the exact key given by key and keylen. If data is not NULL, set datalen and return a valid pointer to the start of the value.

Fetchlock is identical to fetch, but gives a hint to the database that the record is likely to be modified soon.

NOTE: it is possible to store a key with a zero length data record, in which case *datalen will be set to zero, and *data will be set to a non-NULL value

It is an error to call fetch with a NULL key or a zero keylen

It is an error to call fetch with a NULL datalen and a non-NULL data, however it is acceptable to call with a NULL data and a non-NULL datalen if you are only interested in the length

Errors:

- CYRUSDB_IOERROR - if any error occurs reading from the database
- CYRUSDB_LOCKED - if tidptr is incorrect
- CYRUSDB_NOTFOUND - if there is no record that matches the key

### cyrusdb_foreach(struct db *db, const char *prefix, size_t prefixlen, foreach_p *goodp, foreach_p *procp, void *rock, struct txn **tidptr)

### cyrusdb_forone(struct db *db, const char *key, size_t keylen, foreach_p *goodp, foreach_p *procp, void *rock, struct txn **tidptr)

`cyrusdb_foreach()` iterates over all records matching the given prefix, in database order (which may be MBOXLIST sort, depending on the parameters given to open

It is legal to give a NULL pointer as prefix if prefixlen is zero, in which case it will return all records in the database. It is an error to give a non-zero prefixlen with a NULL prefix.

`cyrusdb_forone()` "iterates" over the single record matched by the given key. If you've already built callbacks for processing each record from a foreach, this lets you use the same interface to process a single record.

`goodp` - this function is only used for deciding if the record needs to be further processed. It can be used for basic filtering, and returns true (non-zero) to process, or zero to skip and move straight to the next record. Because goodp can't make any database changes, it doesn't break the lock, so it's faster to use goodp to filter records if you don't need to process all of them. NULL is a legal value for goodp, and means that all records will be processed.

`procp` - procp is the main callback function. If you use foreach in non-transactional mode, the database is unlocked before calling procp, and locked again afterwards. You are allowed to add, delete or modify values in the same database from within procp. If procp returns non-zero, the foreach loop breaks at this point, and the return value of the foreach becomes the return value of procp. If procp returns zero, the foreach loop will continue at the NEXT record by sort order, regardless of whether the current record has changed or been removed. procp MUST NOT be NULL.

Errors:

- procp_result - whatever your callback returns
- CYRUSDB_IOERROR - if any error occurs while reading
- CYRUSDB_LOCKED - if tidptr is incorrect

### cyrusdb_create(struct db *db, const char *key, size_t keylen, const char *data, size_t datalen, struct txn **tidptr)

### cyrusdb_store(struct db *db, const char *key, size_t keylen, const char *data, size_t datalen, struct txn **tidptr)

Create a new record or replace an existing one. The only difference between these two is that `cyrusdb_create` will return an error if the record already exists, while `cyrusdb_store` will replace it

If tidptr is NULL, create/store will take a write lock for the duration of the action.

Any failure during create/store will abort the current transaction as well as returning an error

It is legal to pass NULL for the data field ONLY if datalen is zero. It is not legal to pass NULL for key or zero for keylen

Errors:

- CYRUSDB_IOERROR - any error to write to the database
- CYRUSDB_LOCKED - if tidptr is incorrect
- CYRUSDB_EXISTS - if `cyrusdb_create` is called on an existing key
- CYRUSDB_AGAIN - if a deadlock is created. The current transaction has been aborted, but a retry may succeed

### cyrusdb_delete(struct db *db, const char *key, size_t keylen, struct txn **tidptr, int force)

Delete the given record from the database. If force is true, then succeed even if the record doesn't currently exist.

It is not legal to pass NULL for key or zero for keylen

Errors:

- CYRUSDB_IOERROR - any error to write to the database
- CYRUSDB_LOCKED - if tidptr is incorrect
- CYRUSDB_NOTFOUND - if force is not set and the key doesn't exist
- CYRUSDB_AGAIN - if a deadlock is created. The current transaction has been aborted, but a retry may succeed

### cyrusdb_commit(struct db *db, struct txn *tid)

Commit the current transaction. tid will not be valid after this call, regardless of success

If the commit fails, it will attempt to abort the transaction

Errors:

- CYRUSDB_IOERROR - any error to write to the database
- CYRUSDB_LOCKED - if tidptr is incorrect
- CYRUSDB_AGAIN - if a deadlock is created. The current transaction has been aborted, but a retry may succeed

### cyrusdb_abort(struct db *db, struct txn *tid)

Abort the current transaction. tid will not be valid after this call, regardless of success

Attempt to roll back all changes made in the current transaction.

Errors:

- CYRUSDB_IOERROR - any error to write to the database
- CYRUSDB_LOCKED - if tidptr is incorrect

### cyrusdb_dump(struct db *db, int detail)

Optional function to dump the internal structure of the database to stdout for debugging purposes. Don't use.

### cyrusdb_consistent(struct db *db)

Check if the DB is internally consistent. Looks pretty bogus, and isn't used anywhere. Don't use.