Point Reads

/**
 * Key/data structure -- a Data-Base Thang
 *
 * That's the actual comment from the BerkeleyDB source code.
 */
struct DBT {
  void   *data;    ///< Key/data
  u_int32_t size;  ///< Key/data length

  u_int32_t ulen;  ///< Only used with DB_DBT_USERMEM
  u_int32_t dlen;  ///< Only used with DB_DBT_PARTIAL
  u_int32_t doff;  ///< Only used with DB_DBT_PARTIAL

  void *app_data;  ///< Applications are allowed to associate opaque data.

  u_int32_t flags; ///< Unused
}

struct DB {
  /**
   * Get the value for a key.
   *
   * It is the user's responsibility to manage the memory pointed to by
   * `key`, and ensure that it is valid for the lifetime of the call.
   *
   * `data` should be zero-initialized upon calling get(), and it is the
   * library's responsibility to manage the memory pointed to by data->data.
   * This memory will remain valid until the next call to the library which
   * returns a DBT to the user.
   *
   * @param db The opened DB in which to fetch a key.
   * @param txn The transaction within which this get operation is scoped.
   *            For us, this must be NULL.
   * @param key A DBT owned by the user to describe the kv-pair to fetch.
   * @param data A zero-initialized DBT, which will be written to with
   *             the data and size of the associated data.
   * @param flags Ignored for us.
   * @return 0, if the key was found
   *         DB_NOTFOUND, if the key was not found
   */
  int (*get)(DB *db, DB_TXN *txn, DBT *key, DBT *data, u_int32_t flags);

  // The default mode of operation is that the library is responsible for
  // freeing or reusing any returned state when the next call to any data
  // returning operation is made.  The way that this works is that the DB
  // struct has members which let you store what had been returned to a
  // user previously, so that you can remember what pointers had been
  // returned on a previous call.  There's more to remember for other APIs
  // but for now, we only need to remember what was returned in the `data`
  // argument to `get`.
  DBT  my_rdata;  ///< My Remembered Data.
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <db.h>

#define DATABASE "testdata.bdb"

void test_get(DB* dbp, const char* keystr) {
    DBT key, data;

    // Zero-initialize key/data pair
    memset(&key, 0, sizeof(DBT));
    memset(&data, 0, sizeof(DBT));
    key.data = (char*)keystr;
    key.size = strlen(key.data);

    // Get data from the database
    int rc = dbp->get(dbp, NULL, &key, &data, 0);
    if (rc == 0)
        printf("key: %s, data: %s\n", (char *)key.data, (char *)data.data);
    else if (rc == DB_NOTFOUND)
        printf("key not found\n");
    else
        printf("Unknown error: %d\n", rc);
}

int main() {
    DB *dbp;
    int ret;

    // Initialize DB structure
    if ((ret = db_create(&dbp, NULL, 0)) != 0) {
        fprintf(stderr, "db_create: %s\n", db_strerror(ret));
        exit(1);
    }

    // Open the database
    if ((ret = dbp->open(dbp, NULL, DATABASE, NULL, DB_BTREE, DB_CREATE, 0664)) != 0) {
        fprintf(stderr, "dbp->open: %d\n", ret);
        goto err;
    }

    test_get(dbp, "bbbbbbbbbbbbbbbbbbbb");
    test_get(dbp, "kjshdfkhjdsfhdsj");
    test_get(dbp, "ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss");

err:
    if (dbp != NULL)
        dbp->close(dbp, 0);

    return 0;
}

key: bbbbbbbbbbbbbbbbbbbb, data: bbbbbbbbbbbbbbbbbbbb
key not found
key: ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss, data: ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss