hamsterdb.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2013 Christoph Rupp (chris@crupp.de).
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * See files COPYING.* for License information.
 */

#ifndef HAM_HAMSTERDB_HPP__
#define HAM_HAMSTERDB_HPP__

#include <ham/hamsterdb.h>
#include <ham/hamsterdb_int.h>
#include <cstring>
#include <vector>

#if defined(_MSC_VER) && defined(_DEBUG) && !defined(_CRTDBG_MAP_ALLOC)
#  define _CRTDBG_MAP_ALLOC
#  include <crtdbg.h>
#endif

namespace hamsterdb {

class txn;
class db;
class env;

class error {
  public:
    error(ham_status_t st)
      : m_errno(st) {
    };

    ham_status_t get_errno() const {
        return (m_errno);
    }

    const char *get_string() const {
        return (ham_strerror(m_errno));
    }

private:
    ham_status_t m_errno;
};

class key {
  public:
    key(void *data = 0, ham_u16_t size = 0, ham_u32_t flags = 0) {
      memset(&m_key, 0, sizeof(m_key));
      m_key.data = data;
      m_key.size = size;
      m_key.flags = flags;
      if (m_key.size != size) // check for overflow
        throw error(HAM_INV_KEYSIZE);
    }

    key(const key &other)
      : m_key(other.m_key) {
    }

    key &operator=(const key &other) {
      if (&other != this)
        m_key = other.m_key;
      return (*this);
    }

    void *get_data() const {
      return (m_key.data);
    }

    void set_data(void *data) {
      m_key.data = data;
    }

    ham_u16_t get_size() const {
      return (m_key.size);
    }

    void set_size(ham_u16_t size) {
      m_key.size = size;
    }

    template <class T>
    void set(T &t) {
      set_data(&t);
      set_size(sizeof(t));
    }

    ham_u32_t get_flags() const {
      return (m_key.flags);
    }

    void set_flags(ham_u32_t flags) {
      m_key.flags = flags;
    }

    ham_key_t *get_handle() {
      return (&m_key);
    }

    int get_approximate_match_type() {
      return (ham_key_get_approximate_match_type(&m_key));
    }

private:
    ham_key_t m_key;
};

class record {
  public:
    record(void *data = 0, ham_u32_t size = 0, ham_u32_t flags = 0) {
      memset(&m_rec, 0, sizeof(m_rec));
      m_rec.data = data;
      m_rec.size = size;
      m_rec.flags = flags;
    }

    record(const record &other)
      : m_rec(other.m_rec) {
    }

    record &operator=(const record &other) {
      m_rec = other.m_rec;
      return (*this);
    }

    void *get_data() const {
      return (m_rec.data);
    }

    void set_data(void *data) {
      m_rec.data = data;
    }

    ham_u32_t get_size() const {
      return (m_rec.size);
    }

    void set_size(ham_u32_t size) {
      m_rec.size = size;
    }

    ham_u32_t get_flags() const {
      return (m_rec.flags);
    }

    void set_flags(ham_u32_t flags) {
      m_rec.flags = flags;
    }

    ham_record_t *get_handle() {
      return (&m_rec);
    }

  protected:
    ham_record_t m_rec;
};


class txn {
  public:
    txn(ham_txn_t *t = 0)
      : m_txn(t) {
    }

    void abort() {
      ham_status_t st = ham_txn_abort(m_txn, 0);
      if (st)
        throw error(st);
    }

    void commit() {
      ham_status_t st = ham_txn_commit(m_txn, 0);
      if (st)
        throw error(st);
    }

    std::string get_name() {
      const char *p = ham_txn_get_name(m_txn);
      return (p ? p : "");
    }

    ham_txn_t *get_handle() {
      return (m_txn);
    }

  protected:
    ham_txn_t *m_txn;
};


class db {
  public:
    static void set_errhandler(ham_errhandler_fun f) {
      ham_set_errhandler(f);
    }

    static void get_version(ham_u32_t *major, ham_u32_t *minor,
                  ham_u32_t *revision) {
      ham_get_version(major, minor, revision);
    }

    static void get_license(const char **licensee, const char **product) {
      ham_get_license(licensee, product);
    }

    db()
      : m_db(0) {
    }

    ~db() {
      close();
    }

    db &operator=(const db &other) {
      db &rhs = (db &)other;
      if (this == &other)
        return (*this);
      close();
      m_db = rhs.m_db;
      rhs.m_db = 0;
      return (*this);
    }

    ham_status_t get_error() {
      return (ham_db_get_error(m_db));
    }

    void set_prefix_compare_func(ham_prefix_compare_func_t foo) {
      ham_status_t st = ham_db_set_prefix_compare_func(m_db, foo);
      if (st)
        throw error(st);
    }

    void set_compare_func(ham_compare_func_t foo) {
      ham_status_t st = ham_db_set_compare_func(m_db, foo);
      if (st)
        throw error(st);
    }

    record find(txn *t, key *k, ham_u32_t flags = 0) {
      record r;
      ham_status_t st = ham_db_find(m_db,
                t ? t->get_handle() : 0,
                k ? k->get_handle() : 0,
                r.get_handle(), flags);
      if (st)
        throw error(st);
      return (r);
    }

    record find(key *k, ham_u32_t flags = 0) {
      return (find(0, k, flags));
    }

    void insert(txn *t, key *k, record *r, ham_u32_t flags = 0) {
      ham_status_t st = ham_db_insert(m_db,
                t ? t->get_handle() : 0,
                k ? k->get_handle() : 0,
                r ? r->get_handle() : 0, flags);
      if (st)
        throw error(st);
    }

    void insert(key *k, record *r, ham_u32_t flags=0) {
      insert(0, k, r, flags);
    }

    void erase(key *k, ham_u32_t flags = 0) {
      erase(0, k, flags);
    }

    void erase(txn *t, key *k, ham_u32_t flags = 0) {
      ham_status_t st = ham_db_erase(m_db,
                t ? t->get_handle() : 0,
                k ? k->get_handle() : 0, flags);
      if (st)
        throw error(st);
    }

    ham_u64_t get_key_count(ham_txn_t *txn = 0, ham_u32_t flags = 0) {
      ham_u64_t count = 0;
      ham_status_t st = ham_db_get_key_count(m_db, txn, flags, &count);
      if (st)
        throw error(st);
      return (count);
    }

    void get_parameters(ham_parameter_t *param) {
      ham_status_t st = ham_db_get_parameters(m_db, param);
      if (st)
        throw error(st);
    }

    void close(ham_u32_t flags = 0) {
      if (!m_db)
        return;
      // disable auto-cleanup; all objects will be destroyed when 
      // going out of scope
      flags &= ~HAM_AUTO_CLEANUP;
      ham_status_t st = ham_db_close(m_db, flags);
      if (st)
        throw error(st);
      m_db = 0;
    }

    ham_db_t *get_handle() {
      return (m_db);
    }

protected:
    friend class env;

    /* Copy Constructor. Is protected and should not be used. */
    db(ham_db_t *db)
      : m_db(db) {
    }

  private:
    ham_db_t *m_db;
};


class cursor {
  public:
    cursor(db *db = 0, txn *t = 0, ham_u32_t flags = 0)
      : m_cursor(0) {
      create(db, t, flags);
    }

    cursor(txn *t, db *db = 0, ham_u32_t flags = 0)
      : m_cursor(0) {
      create(db, t, flags);
    }

    ~cursor() {
      close();
    }

    void create(db *db, txn *t = 0, ham_u32_t flags = 0) {
      if (m_cursor)
        close();
      if (db) {
        ham_status_t st = ham_cursor_create(&m_cursor, db->get_handle(),
                    t ? t->get_handle() : 0, flags);
        if (st)
          throw error(st);
      }
    }

    cursor clone() {
      ham_cursor_t *dest;
      ham_status_t st = ham_cursor_clone(m_cursor, &dest);
      if (st)
        throw error(st);
      return (cursor(dest));
    }

    void move(key *k, record *r, ham_u32_t flags = 0) {
      ham_status_t st = ham_cursor_move(m_cursor, k ? k->get_handle() : 0,
                        r ? r->get_handle() : 0, flags);
      if (st)
        throw error(st);
    }

    void move_first(key *k = 0, record *r = 0) {
      move(k, r, HAM_CURSOR_FIRST);
    }

    void move_last(key *k = 0, record *r = 0) {
      move(k, r, HAM_CURSOR_LAST);
    }

    void move_next(key *k = 0, record *r = 0) {
      move(k, r, HAM_CURSOR_NEXT);
    }

    void move_previous(key *k = 0, record *r = 0) {
      move(k, r, HAM_CURSOR_PREVIOUS);
    }

    void overwrite(record *r, ham_u32_t flags = 0) {
      ham_status_t st = ham_cursor_overwrite(m_cursor,
                            r ? r->get_handle() : 0, flags);
      if (st)
        throw error(st);
    }

    void find(key *k, record *r = 0, ham_u32_t flags = 0) {
      ham_status_t st = ham_cursor_find(m_cursor, k->get_handle(),
                        (r ? r->get_handle() : 0), flags);
      if (st)
        throw error(st);
    }

    void insert(key *k, record *r, ham_u32_t flags = 0) {
      ham_status_t st = ham_cursor_insert(m_cursor, k ? k->get_handle() : 0,
                          r ? r->get_handle() : 0, flags);
      if (st)
        throw error(st);
    }

    void erase(ham_u32_t flags = 0) {
      ham_status_t st = ham_cursor_erase(m_cursor, flags);
      if (st)
        throw error(st);
    }

    ham_u32_t get_duplicate_count(ham_u32_t flags = 0) {
      ham_u32_t c;
      ham_status_t st = ham_cursor_get_duplicate_count(m_cursor, &c, flags);
      if (st)
        throw error(st);
      return (c);
    }

    ham_u64_t get_record_size() {
      ham_u64_t s;
      ham_status_t st = ham_cursor_get_record_size(m_cursor, &s);
      if (st)
        throw error(st);
      return (s);
    }

    void close() {
      if (!m_cursor)
        return;
      ham_status_t st = ham_cursor_close(m_cursor);
      if (st)
        throw error(st);
      m_cursor = 0;
    }

  protected:
    /* Copy Constructor. Is protected and should not be used. */
    cursor(ham_cursor_t *c) {
      m_cursor = c;
    }

  private:
    ham_cursor_t *m_cursor;
};

class env {
  public:
    env()
      : m_env(0) {
    }

    ~env() {
      close();
    }

    void create(const char *filename, ham_u32_t flags = 0,
                ham_u32_t mode = 0644, const ham_parameter_t *param = 0) {
      ham_status_t st = ham_env_create(&m_env, filename, flags, mode, param);
      if (st)
        throw error(st);
    }

    void open(const char *filename, ham_u32_t flags = 0,
                const ham_parameter_t *param = 0) {
      ham_status_t st = ham_env_open(&m_env, filename, flags, param);
      if (st)
        throw error(st);
    }

    void flush(ham_u32_t flags = 0) {
      ham_status_t st = ham_env_flush(m_env, flags);
      if (st)
        throw error(st);
    }

    db create_db(ham_u16_t name, ham_u32_t flags = 0,
                const ham_parameter_t *param = 0) {
      ham_db_t *dbh;

      ham_status_t st = ham_env_create_db(m_env, &dbh, name, flags, param);
      if (st)
        throw error(st);

      return (hamsterdb::db(dbh));
    }

    db open_db(ham_u16_t name, ham_u32_t flags = 0,
                const ham_parameter_t *param = 0) {
      ham_db_t *dbh;

      ham_status_t st = ham_env_open_db(m_env, &dbh, name, flags, param);
      if (st)
        throw error(st);

      return (hamsterdb::db(dbh));
    }

    void rename_db(ham_u16_t oldname, ham_u16_t newname, ham_u32_t flags = 0) {
      ham_status_t st = ham_env_rename_db(m_env, oldname, newname, flags);
      if (st)
        throw error(st);
    }

    void erase_db(ham_u16_t name, ham_u32_t flags = 0) {
      ham_status_t st = ham_env_erase_db(m_env, name, flags);
      if (st)
        throw error(st);
    }

    txn begin(const char *name = 0) {
      ham_txn_t *h;
      ham_status_t st = ham_txn_begin(&h, m_env, name, 0, 0);
      if (st)
        throw error(st);
      return (txn(h));
    }


    void close(ham_u32_t flags = 0) {
      if (!m_env)
        return;
      // disable auto-cleanup; all objects will be destroyed when 
      // going out of scope
      flags &= ~HAM_AUTO_CLEANUP;
      ham_status_t st = ham_env_close(m_env, flags);
      if (st)
        throw error(st);
      m_env = 0;
    }

    void get_parameters(ham_parameter_t *param) {
      ham_status_t st = ham_env_get_parameters(m_env, param);
      if (st)
        throw error(st);
    }

    std::vector<ham_u16_t> get_database_names() {
      ham_size_t count = 32;
      ham_status_t st;
      std::vector<ham_u16_t> v(count);

      for (;;) {
        st = ham_env_get_database_names(m_env, &v[0], &count);
        if (!st)
          break;
        if (st && st!=HAM_LIMITS_REACHED)
          throw error(st);
        count += 16;
        v.resize(count);
      }

      v.resize(count);
      return (v);
    }

  private:
    ham_env_t *m_env;
};

} // namespace hamsterdb

#endif // HAMSTERDB_HPP__