upscaledb.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2017 Christoph Rupp (chris@crupp.de).
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * See the file COPYING for License information.
 */

#ifndef UPS_UPSCALEDB_HPP
#define UPS_UPSCALEDB_HPP

#include <ups/upscaledb.h>
#include <ups/upscaledb_int.h>
#include <cstring>
#include <cassert>
#include <vector>

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

namespace upscaledb {

class txn;
class db;
class env;

class error {
  public:
    error(ups_status_t st)
      : _status(st) {
    };

    ups_status_t get_errno() const {
      return _status;
    }

    const char *get_string() const {
      return ups_strerror(_status);
    }

  private:
    ups_status_t _status;
};

class key {
  public:
    key(void *data = 0, uint16_t size = 0, uint32_t flags = 0) {
      ::memset(&_key, 0, sizeof(_key));
      _key.data = data;
      _key.size = size;
      _key.flags = flags;
    }

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

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

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

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

    uint16_t get_size() const {
      return _key.size;
    }

    void set_size(uint16_t size) {
      _key.size = size;
    }

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

    uint32_t get_flags() const {
      return _key.flags;
    }

    void set_flags(uint32_t flags) {
      _key.flags = flags;
    }

    ups_key_t *get_handle() {
      return &_key;
    }

  private:
    ups_key_t _key;
};

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

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

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

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

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

    uint32_t get_size() const {
      return _record.size;
    }

    void set_size(uint32_t size) {
      _record.size = size;
    }

    uint32_t get_flags() const {
      return _record.flags;
    }

    void set_flags(uint32_t flags) {
      _record.flags = flags;
    }

    ups_record_t *get_handle() {
      return &_record;
    }

  private:
    ups_record_t _record;
};


class txn {
  public:
    txn(ups_txn_t *t = 0)
      : _txn(t) {
    }

    void abort() {
      ups_status_t st = ups_txn_abort(_txn, 0);
      if (st)
        throw error(st);
    }

    void commit() {
      ups_status_t st = ups_txn_commit(_txn, 0);
      if (st)
        throw error(st);
    }

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

    ups_txn_t *get_handle() {
      return _txn;
    }

  private:
    ups_txn_t *_txn;
};


class db {
  public:
    static void set_errhandler(ups_error_handler_fun f) {
      ups_set_error_handler(f);
    }

    static void get_version(uint32_t *major, uint32_t *minor,
                  uint32_t *revision) {
      ups_get_version(major, minor, revision);
    }

    db()
      : _db(0) {
    }

    ~db() {
      try {
        close();
      }
      catch (error &ex) {
        assert(ex.get_errno() == 0); // this will fail!
      }
    }

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

    void set_compare_func(ups_compare_func_t foo) {
      ups_status_t st = ups_db_set_compare_func(_db, foo);
      if (st)
        throw error(st);
    }

    record find(txn *t, key *k, uint32_t flags = 0) {
      record r;
      ups_status_t st = ups_db_find(_db, t ? t->get_handle() : 0,
                      k ? k->get_handle() : 0, r.get_handle(), flags);
      if (st)
        throw error(st);
      return r;
    }

    record &find(txn *t, key *k, record *r, uint32_t flags = 0) {
      ups_status_t st = ups_db_find(_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, uint32_t flags = 0) {
      return find(0, k, flags);
    }

    void insert(txn *t, key *k, record *r, uint32_t flags = 0) {
      ups_status_t st = ups_db_insert(_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, uint32_t flags=0) {
      insert(0, k, r, flags);
    }

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

    void erase(txn *t, key *k, uint32_t flags = 0) {
      ups_status_t st = ups_db_erase(_db, t ? t->get_handle() : 0,
                      k ? k->get_handle() : 0, flags);
      if (st)
        throw error(st);
    }

    uint64_t count(ups_txn_t *txn = 0, uint32_t flags = 0) {
      uint64_t count = 0;
      ups_status_t st = ups_db_count(_db, txn, flags, &count);
      if (st)
        throw error(st);
      return count;
    }

    void get_parameters(ups_parameter_t *param) {
      ups_status_t st = ups_db_get_parameters(_db, param);
      if (st)
        throw error(st);
    }

    void close(uint32_t flags = 0) {
      if (!_db)
        return;
      flags &= ~UPS_AUTO_CLEANUP;
      ups_status_t st = ups_db_close(_db, flags);
      _db = 0;
      if (st)
        throw error(st);
    }

    ups_db_t *get_handle() {
      return _db;
    }

  protected:
    friend class env;

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

  private:
    ups_db_t *_db;
};


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

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

    ~cursor() {
      try {
        close();
      }
      catch (error &ex) {
        assert(ex.get_errno() == 0); // this will fail!
      }
    }

    void create(db *db, txn *t = 0, uint32_t flags = 0) {
      if (_cursor)
        close();
      if (db) {
        ups_status_t st = ups_cursor_create(&_cursor, db->get_handle(),
                    t ? t->get_handle() : 0, flags);
        if (st)
          throw error(st);
      }
    }

    cursor clone() {
      ups_cursor_t *dest;
      ups_status_t st = ups_cursor_clone(_cursor, &dest);
      if (st)
        throw error(st);
      return cursor(dest);
    }

    void move(key *k, record *r, uint32_t flags = 0) {
      ups_status_t st = ups_cursor_move(_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, UPS_CURSOR_FIRST);
    }

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

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

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

    void overwrite(record *r, uint32_t flags = 0) {
      ups_status_t st = ups_cursor_overwrite(_cursor,
                            r ? r->get_handle() : 0, flags);
      if (st)
        throw error(st);
    }

    void find(key *k, record *r = 0, uint32_t flags = 0) {
      ups_status_t st = ups_cursor_find(_cursor, k->get_handle(),
                        (r ? r->get_handle() : 0), flags);
      if (st)
        throw error(st);
    }

    void insert(key *k, record *r, uint32_t flags = 0) {
      ups_status_t st = ups_cursor_insert(_cursor, k ? k->get_handle() : 0,
                          r ? r->get_handle() : 0, flags);
      if (st)
        throw error(st);
    }

    void erase(uint32_t flags = 0) {
      ups_status_t st = ups_cursor_erase(_cursor, flags);
      if (st)
        throw error(st);
    }

    uint32_t get_duplicate_count(uint32_t flags = 0) {
      uint32_t c;
      ups_status_t st = ups_cursor_get_duplicate_count(_cursor, &c, flags);
      if (st)
        throw error(st);
      return c;
    }

    uint32_t get_record_size() {
      uint32_t s;
      ups_status_t st = ups_cursor_get_record_size(_cursor, &s);
      if (st)
        throw error(st);
      return s;
    }

    void close() {
      if (!_cursor)
        return;
      ups_status_t st = ups_cursor_close(_cursor);
      if (st)
        throw error(st);
      _cursor = 0;
    }

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

  private:
    ups_cursor_t *_cursor;
};

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

    ~env() {
      try {
        close();
      }
      catch (error &ex) {
        assert(ex.get_errno() == 0); // this will fail!
      }
    }

    void create(const char *filename, uint32_t flags = 0,
                uint32_t mode = 0644, const ups_parameter_t *param = 0) {
      ups_status_t st = ups_env_create(&_env, filename, flags, mode, param);
      if (st)
        throw error(st);
    }

    void open(const char *filename, uint32_t flags = 0,
                const ups_parameter_t *param = 0) {
      ups_status_t st = ups_env_open(&_env, filename, flags, param);
      if (st)
        throw error(st);
    }

    void flush(uint32_t flags = 0) {
      ups_status_t st = ups_env_flush(_env, flags);
      if (st)
        throw error(st);
    }

    db create_db(uint16_t name, uint32_t flags = 0,
                const ups_parameter_t *param = 0) {
      ups_db_t *dbh;

      ups_status_t st = ups_env_create_db(_env, &dbh, name, flags, param);
      if (st)
        throw error(st);

      return upscaledb::db(dbh);
    }

    db open_db(uint16_t name, uint32_t flags = 0,
                const ups_parameter_t *param = 0) {
      ups_db_t *dbh;

      ups_status_t st = ups_env_open_db(_env, &dbh, name, flags, param);
      if (st)
        throw error(st);

      return upscaledb::db(dbh);
    }

    void rename_db(uint16_t oldname, uint16_t newname, uint32_t flags = 0) {
      ups_status_t st = ups_env_rename_db(_env, oldname, newname, flags);
      if (st)
        throw error(st);
    }

    void erase_db(uint16_t name, uint32_t flags = 0) {
      ups_status_t st = ups_env_erase_db(_env, name, flags);
      if (st)
        throw error(st);
    }

    txn begin(const char *name = 0, uint32_t flags = 0) {
      ups_txn_t *h;
      ups_status_t st = ups_txn_begin(&h, _env, name, 0, flags);
      if (st)
        throw error(st);
      return txn(h);
    }


    void close(uint32_t flags = 0) {
      if (!_env)
        return;
      // disable auto-cleanup; all objects will be destroyed when 
      // going out of scope
      flags &= ~UPS_AUTO_CLEANUP;
      ups_status_t st = ups_env_close(_env, flags);
      if (st)
        throw error(st);
      _env = 0;
    }

    void get_parameters(ups_parameter_t *param) {
      ups_status_t st = ups_env_get_parameters(_env, param);
      if (st)
        throw error(st);
    }

    std::vector<uint16_t> get_database_names() {
      uint32_t count = 32;
      ups_status_t st;
      std::vector<uint16_t> v(count);

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

      v.resize(count);
      return v;
    }

  private:
    ups_env_t *_env;
};

} // namespace upscaledb

#endif // UPS_UPSCALEDB_HPP