/*************************************************************************************************

 * The test cases of the stash database

 *                                                               Copyright (C) 2009-2012 FAL Labs

 * This file is part of Kyoto Cabinet.

 * 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

 * 3 of the License, or any later version.

 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;

 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * See the GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License along with this program.

 * If not, see <http://www.gnu.org/licenses/>.

 *************************************************************************************************/

#include <kcstashdb.h>

#include "cmdcommon.h"

// global variables

const char* g_progname;                  // program name

uint32_t g_randseed;                     // random seed

int64_t g_memusage;                      // memory usage

// function prototypes

int main(int argc, char** argv);

static void usage();

static void dberrprint(kc::BasicDB* db, int32_t line, const char* func);

static void dbmetaprint(kc::BasicDB* db, bool verbose);

static int32_t runorder(int argc, char** argv);

static int32_t runqueue(int argc, char** argv);

static int32_t runwicked(int argc, char** argv);

static int32_t runtran(int argc, char** argv);

static int32_t procorder(int64_t rnum, int32_t thnum, bool rnd, bool etc, bool tran,

                         int64_t bnum, bool lv);

static int32_t procqueue(int64_t rnum, int32_t thnum, int32_t itnum, bool rnd,

                         int64_t bnum, bool lv);

static int32_t procwicked(int64_t rnum, int32_t thnum, int32_t itnum, int64_t bnum, bool lv);

static int32_t proctran(int64_t rnum, int32_t thnum, int32_t itnum, int64_t bnum, bool lv);

// main routine

int main(int argc, char** argv) {

  g_progname = argv[0];

  const char* ebuf = kc::getenv("KCRNDSEED");

  g_randseed = ebuf ? (uint32_t)kc::atoi(ebuf) : (uint32_t)(kc::time() * 1000);

  mysrand(g_randseed);

  g_memusage = memusage();

  kc::setstdiobin();

  if (argc < 2) usage();

  int32_t rv = 0;

  if (!std::strcmp(argv[1], "order")) {

    rv = runorder(argc, argv);

  } else if (!std::strcmp(argv[1], "queue")) {

    rv = runqueue(argc, argv);

  } else if (!std::strcmp(argv[1], "wicked")) {

    rv = runwicked(argc, argv);

  } else if (!std::strcmp(argv[1], "tran")) {

    rv = runtran(argc, argv);

  } else {

    usage();

  }

  if (rv != 0) {

    oprintf("FAILED: KCRNDSEED=%u PID=%ld", g_randseed, (long)kc::getpid());

    for (int32_t i = 0; i < argc; i++) {

      oprintf(" %s", argv[i]);

    }

    oprintf("\n\n");

  }

  return rv;

}

// print the usage and exit

static void usage() {

  eprintf("%s: test cases of the stash database of Kyoto Cabinet\n", g_progname);

  eprintf("\n");

  eprintf("usage:\n");

  eprintf("  %s order [-th num] [-rnd] [-etc] [-tran] [-bnum num] [-lv] rnum\n",

          g_progname);

  eprintf("  %s queue [-th num] [-it num] [-rnd] [-bnum num] [-lv] rnum\n", g_progname);

  eprintf("  %s wicked [-th num] [-it num] [-bnum num] [-lv] rnum\n", g_progname);

  eprintf("  %s tran [-th num] [-it num] [-bnum num] [-lv] rnum\n", g_progname);

  eprintf("\n");

  std::exit(1);

}

// print the error message of a database

static void dberrprint(kc::BasicDB* db, int32_t line, const char* func) {

  const kc::BasicDB::Error& err = db->error();

  oprintf("%s: %d: %s: %s: %d: %s: %s\n",

          g_progname, line, func, db->path().c_str(), err.code(), err.name(), err.message());

}

// print members of a database

static void dbmetaprint(kc::BasicDB* db, bool verbose) {

  if (verbose) {

    std::map<std::string, std::string> status;

    status["opaque"] = "";

    status["bnum_used"] = "";

    if (db->status(&status)) {

      uint32_t type = kc::atoi(status["type"].c_str());

      oprintf("type: %s (%s) (type=0x%02X)\n",

              kc::BasicDB::typecname(type), kc::BasicDB::typestring(type), type);

      uint32_t rtype = kc::atoi(status["realtype"].c_str());

      if (rtype > 0 && rtype != type)

        oprintf("real type: %s (%s) (realtype=0x%02X)\n",

                kc::BasicDB::typecname(rtype), kc::BasicDB::typestring(rtype), rtype);

      if (status["opaque"].size() >= 16) {

        const char* opaque = status["opaque"].c_str();

        oprintf("opaque:");

        if (std::count(opaque, opaque + 16, 0) != 16) {

          for (int32_t i = 0; i < 16; i++) {

            oprintf(" %02X", ((unsigned char*)opaque)[i]);

          }

        } else {

          oprintf(" 0");

        }

        oprintf("\n");

      }

      int64_t bnum = kc::atoi(status["bnum"].c_str());

      int64_t bnumused = kc::atoi(status["bnum_used"].c_str());

      int64_t count = kc::atoi(status["count"].c_str());

      double load = 0;

      if (count > 0 && bnumused > 0) load = (double)count / bnumused;

      oprintf("buckets: %lld (used=%lld) (load=%.2f)\n",

              (long long)bnum, (long long)bnumused, load);

      std::string cntstr = unitnumstr(count);

      oprintf("count: %lld (%s)\n", count, cntstr.c_str());

      int64_t size = kc::atoi(status["size"].c_str());

      std::string sizestr = unitnumstrbyte(size);

      oprintf("size: %lld (%s)\n", size, sizestr.c_str());

    }

  } else {

    oprintf("count: %lld\n", (long long)db->count());

    oprintf("size: %lld\n", (long long)db->size());

  }

  int64_t musage = memusage();

  if (musage > 0) oprintf("memory: %lld\n", (long long)(musage - g_memusage));

}

// parse arguments of order command

static int32_t runorder(int argc, char** argv) {

  bool argbrk = false;

  const char* rstr = NULL;

  int32_t thnum = 1;

  bool rnd = false;

  bool etc = false;

  bool tran = false;

  int64_t bnum = -1;

  bool lv = false;

  for (int32_t i = 2; i < argc; i++) {

    if (!argbrk && argv[i][0] == '-') {

      if (!std::strcmp(argv[i], "--")) {

        argbrk = true;

      } else if (!std::strcmp(argv[i], "-th")) {

        if (++i >= argc) usage();

        thnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-rnd")) {

        rnd = true;

      } else if (!std::strcmp(argv[i], "-etc")) {

        etc = true;

      } else if (!std::strcmp(argv[i], "-tran")) {

        tran = true;

      } else if (!std::strcmp(argv[i], "-bnum")) {

        if (++i >= argc) usage();

        bnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-lv")) {

        lv = true;

      } else {

        usage();

      }

    } else if (!rstr) {

      argbrk = true;

      rstr = argv[i];

    } else {

      usage();

    }

  }

  if (!rstr) usage();

  int64_t rnum = kc::atoix(rstr);

  if (rnum < 1 || thnum < 1) usage();

  if (thnum > THREADMAX) thnum = THREADMAX;

  int32_t rv = procorder(rnum, thnum, rnd, etc, tran, bnum, lv);

  return rv;

}

// parse arguments of queue command

static int32_t runqueue(int argc, char** argv) {

  bool argbrk = false;

  const char* rstr = NULL;

  int32_t thnum = 1;

  int32_t itnum = 1;

  bool rnd = false;

  int64_t bnum = -1;

  bool lv = false;

  for (int32_t i = 2; i < argc; i++) {

    if (!argbrk && argv[i][0] == '-') {

      if (!std::strcmp(argv[i], "--")) {

        argbrk = true;

      } else if (!std::strcmp(argv[i], "-th")) {

        if (++i >= argc) usage();

        thnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-it")) {

        if (++i >= argc) usage();

        itnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-rnd")) {

        rnd = true;

      } else if (!std::strcmp(argv[i], "-bnum")) {

        if (++i >= argc) usage();

        bnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-lv")) {

        lv = true;

      } else {

        usage();

      }

    } else if (!rstr) {

      argbrk = true;

      rstr = argv[i];

    } else {

      usage();

    }

  }

  if (!rstr) usage();

  int64_t rnum = kc::atoix(rstr);

  if (rnum < 1 || thnum < 1 || itnum < 1) usage();

  if (thnum > THREADMAX) thnum = THREADMAX;

  int32_t rv = procqueue(rnum, thnum, itnum, rnd, bnum, lv);

  return rv;

}

// parse arguments of wicked command

static int32_t runwicked(int argc, char** argv) {

  bool argbrk = false;

  const char* rstr = NULL;

  int32_t thnum = 1;

  int32_t itnum = 1;

  int64_t bnum = -1;

  bool lv = false;

  for (int32_t i = 2; i < argc; i++) {

    if (!argbrk && argv[i][0] == '-') {

      if (!std::strcmp(argv[i], "--")) {

        argbrk = true;

      } else if (!std::strcmp(argv[i], "-th")) {

        if (++i >= argc) usage();

        thnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-it")) {

        if (++i >= argc) usage();

        itnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-bnum")) {

        if (++i >= argc) usage();

        bnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-lv")) {

        lv = true;

      } else {

        usage();

      }

    } else if (!rstr) {

      argbrk = true;

      rstr = argv[i];

    } else {

      usage();

    }

  }

  if (!rstr) usage();

  int64_t rnum = kc::atoix(rstr);

  if (rnum < 1 || thnum < 1 || itnum < 1) usage();

  if (thnum > THREADMAX) thnum = THREADMAX;

  int32_t rv = procwicked(rnum, thnum, itnum, bnum, lv);

  return rv;

}

// parse arguments of tran command

static int32_t runtran(int argc, char** argv) {

  bool argbrk = false;

  const char* rstr = NULL;

  int32_t thnum = 1;

  int32_t itnum = 1;

  int64_t bnum = -1;

  bool lv = false;

  for (int32_t i = 2; i < argc; i++) {

    if (!argbrk && argv[i][0] == '-') {

      if (!std::strcmp(argv[i], "--")) {

        argbrk = true;

      } else if (!std::strcmp(argv[i], "-th")) {

        if (++i >= argc) usage();

        thnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-it")) {

        if (++i >= argc) usage();

        itnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-bnum")) {

        if (++i >= argc) usage();

        bnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-lv")) {

        lv = true;

      } else {

        usage();

      }

    } else if (!rstr) {

      argbrk = true;

      rstr = argv[i];

    } else {

      usage();

    }

  }

  if (!rstr) usage();

  int64_t rnum = kc::atoix(rstr);

  if (rnum < 1 || thnum < 1 || itnum < 1) usage();

  if (thnum > THREADMAX) thnum = THREADMAX;

  int32_t rv = proctran(rnum, thnum, itnum, bnum, lv);

  return rv;

}

// perform order command

static int32_t procorder(int64_t rnum, int32_t thnum, bool rnd, bool etc, bool tran,

                         int64_t bnum, bool lv) {

  oprintf("<In-order Test>\n  seed=%u  rnum=%lld  thnum=%d  rnd=%d  etc=%d  tran=%d"

          "  bnum=%lld  lv=%d\n\n",

          g_randseed, (long long)rnum, thnum, rnd, etc, tran, (long long)bnum, lv);

  bool err = false;

  kc::StashDB db;

  oprintf("opening the database:\n");

  double stime = kc::time();

  db.tune_logger(stdlogger(g_progname, &std::cout),

                 lv ? kc::UINT32MAX : kc::BasicDB::Logger::WARN | kc::BasicDB::Logger::ERROR);

  if (bnum > 0) db.tune_buckets(bnum);

  if (!db.open(":", kc::StashDB::OWRITER | kc::StashDB::OCREATE | kc::StashDB::OTRUNCATE)) {

    dberrprint(&db, __LINE__, "DB::open");

    err = true;

  }

  double etime = kc::time();

  dbmetaprint(&db, false);

  oprintf("time: %.3f\n", etime - stime);

  oprintf("setting records:\n");

  stime = kc::time();

  class ThreadSet : public kc::Thread {

   public:

    void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,

                   bool rnd, bool tran) {

      id_ = id;

      db_ = db;

      rnum_ = rnum;

      thnum_ = thnum;

      err_ = false;

      rnd_ = rnd;

      tran_ = tran;

    }

    bool error() {

      return err_;

    }

    void run() {

      int64_t base = id_ * rnum_;

      int64_t range = rnum_ * thnum_;

      for (int64_t i = 1; !err_ && i <= rnum_; i++) {

        if (tran_ && !db_->begin_transaction(false)) {

          dberrprint(db_, __LINE__, "DB::begin_transaction");

          err_ = true;

        }

        char kbuf[RECBUFSIZ];

        size_t ksiz = std::sprintf(kbuf, "%08lld",

                                   (long long)(rnd_ ? myrand(range) + 1 : base + i));

        if (!db_->set(kbuf, ksiz, kbuf, ksiz)) {

          dberrprint(db_, __LINE__, "DB::set");

          err_ = true;

        }

        if (rnd_ && i % 8 == 0) {

          switch (myrand(8)) {

            case 0: {

              if (!db_->set(kbuf, ksiz, kbuf, ksiz)) {

                dberrprint(db_, __LINE__, "DB::set");

                err_ = true;

              }

              break;

            }

            case 1: {

              if (!db_->append(kbuf, ksiz, kbuf, ksiz)) {

                dberrprint(db_, __LINE__, "DB::append");

                err_ = true;

              }

              break;

            }

            case 2: {

              if (!db_->remove(kbuf, ksiz) && db_->error() != kc::BasicDB::Error::NOREC) {

                dberrprint(db_, __LINE__, "DB::remove");

                err_ = true;

              }

              break;

            }

            case 3: {

              kc::DB::Cursor* cur = db_->cursor();

              if (cur->jump(kbuf, ksiz)) {

                switch (myrand(8)) {

                  default: {

                    size_t rsiz;

                    char* rbuf = cur->get_key(&rsiz, myrand(10) == 0);

                    if (rbuf) {

                      delete[] rbuf;

                    } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                      dberrprint(db_, __LINE__, "Cursor::get_key");

                      err_ = true;

                    }

                    break;

                  }

                  case 1: {

                    size_t rsiz;

                    char* rbuf = cur->get_value(&rsiz, myrand(10) == 0);

                    if (rbuf) {

                      delete[] rbuf;

                    } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                      dberrprint(db_, __LINE__, "Cursor::get_value");

                      err_ = true;

                    }

                    break;

                  }

                  case 2: {

                    size_t rksiz;

                    const char* rvbuf;

                    size_t rvsiz;

                    char* rkbuf = cur->get(&rksiz, &rvbuf, &rvsiz, myrand(10) == 0);

                    if (rkbuf) {

                      delete[] rkbuf;

                    } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                      dberrprint(db_, __LINE__, "Cursor::get");

                      err_ = true;

                    }

                    break;

                  }

                  case 3: {

                    std::string key, value;

                    if (!cur->get(&key, &value, myrand(10) == 0) &&

                        db_->error() != kc::BasicDB::Error::NOREC) {

                      dberrprint(db_, __LINE__, "Cursor::get");

                      err_ = true;

                    }

                    break;

                  }

                  case 4: {

                    if (myrand(8) == 0 && !cur->remove() &&

                        db_->error() != kc::BasicDB::Error::NOREC) {

                      dberrprint(db_, __LINE__, "Cursor::remove");

                      err_ = true;

                    }

                    break;

                  }

                }

              } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                dberrprint(db_, __LINE__, "Cursor::jump");

                err_ = true;

              }

              delete cur;

              break;

            }

            default: {

              size_t vsiz;

              char* vbuf = db_->get(kbuf, ksiz, &vsiz);

              if (vbuf) {

                delete[] vbuf;

              } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                dberrprint(db_, __LINE__, "DB::get");

                err_ = true;

              }

              break;

            }

          }

        }

        if (tran_ && !db_->end_transaction(true)) {

          dberrprint(db_, __LINE__, "DB::end_transaction");

          err_ = true;

        }

        if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {

          oputchar('.');

          if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);

        }

      }

    }

   private:

    int32_t id_;

    kc::BasicDB* db_;

    int64_t rnum_;

    int32_t thnum_;

    bool err_;

    bool rnd_;

    bool tran_;

  };

  ThreadSet threadsets[THREADMAX];

  if (thnum < 2) {

    threadsets[0].setparams(0, &db, rnum, thnum, rnd, tran);

    threadsets[0].run();

    if (threadsets[0].error()) err = true;

  } else {

    for (int32_t i = 0; i < thnum; i++) {

      threadsets[i].setparams(i, &db, rnum, thnum, rnd, tran);

      threadsets[i].start();

    }

    for (int32_t i = 0; i < thnum; i++) {

      threadsets[i].join();

      if (threadsets[i].error()) err = true;

    }

  }

  etime = kc::time();

  dbmetaprint(&db, false);

  oprintf("time: %.3f\n", etime - stime);

  if (etc) {

    oprintf("adding records:\n");

    stime = kc::time();

    class ThreadAdd : public kc::Thread {

     public:

      void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,

                     bool rnd, bool tran) {

        id_ = id;

        db_ = db;

        rnum_ = rnum;

        thnum_ = thnum;

        err_ = false;

        rnd_ = rnd;

        tran_ = tran;

      }

      bool error() {

        return err_;

      }

      void run() {

        int64_t base = id_ * rnum_;

        int64_t range = rnum_ * thnum_;

        for (int64_t i = 1; !err_ && i <= rnum_; i++) {

          if (tran_ && !db_->begin_transaction(false)) {

            dberrprint(db_, __LINE__, "DB::begin_transaction");

            err_ = true;

          }

          char kbuf[RECBUFSIZ];

          size_t ksiz = std::sprintf(kbuf, "%08lld",

                                     (long long)(rnd_ ? myrand(range) + 1 : base + i));

          if (!db_->add(kbuf, ksiz, kbuf, ksiz) &&

              db_->error() != kc::BasicDB::Error::DUPREC) {

            dberrprint(db_, __LINE__, "DB::add");

            err_ = true;

          }

          if (tran_ && !db_->end_transaction(true)) {

            dberrprint(db_, __LINE__, "DB::end_transaction");

            err_ = true;

          }

          if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {

            oputchar('.');

            if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);

          }

        }

      }

     private:

      int32_t id_;

      kc::BasicDB* db_;

      int64_t rnum_;

      int32_t thnum_;

      bool err_;

      bool rnd_;

      bool tran_;

    };

    ThreadAdd threadadds[THREADMAX];

    if (thnum < 2) {

      threadadds[0].setparams(0, &db, rnum, thnum, rnd, tran);

      threadadds[0].run();

      if (threadadds[0].error()) err = true;

    } else {

      for (int32_t i = 0; i < thnum; i++) {

        threadadds[i].setparams(i, &db, rnum, thnum, rnd, tran);

        threadadds[i].start();

      }

      for (int32_t i = 0; i < thnum; i++) {

        threadadds[i].join();

        if (threadadds[i].error()) err = true;

      }

    }

    etime = kc::time();

    dbmetaprint(&db, false);

    oprintf("time: %.3f\n", etime - stime);

  }

  if (etc) {

    oprintf("appending records:\n");

    stime = kc::time();

    class ThreadAppend : public kc::Thread {

     public:

      void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,

                     bool rnd, bool tran) {

        id_ = id;

        db_ = db;

        rnum_ = rnum;

        thnum_ = thnum;

        err_ = false;

        rnd_ = rnd;

        tran_ = tran;

      }

      bool error() {

        return err_;

      }

      void run() {

        int64_t base = id_ * rnum_;

        int64_t range = rnum_ * thnum_;

        for (int64_t i = 1; !err_ && i <= rnum_; i++) {

          if (tran_ && !db_->begin_transaction(false)) {

            dberrprint(db_, __LINE__, "DB::begin_transaction");

            err_ = true;

          }

          char kbuf[RECBUFSIZ];

          size_t ksiz = std::sprintf(kbuf, "%08lld",

                                     (long long)(rnd_ ? myrand(range) + 1 : base + i));

          if (!db_->append(kbuf, ksiz, kbuf, ksiz)) {

            dberrprint(db_, __LINE__, "DB::append");

            err_ = true;

          }

          if (tran_ && !db_->end_transaction(true)) {

            dberrprint(db_, __LINE__, "DB::end_transaction");

            err_ = true;

          }

          if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {

            oputchar('.');

            if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);

          }

        }

      }

     private:

      int32_t id_;

      kc::BasicDB* db_;

      int64_t rnum_;

      int32_t thnum_;

      bool err_;

      bool rnd_;

      bool tran_;

    };

    ThreadAppend threadappends[THREADMAX];

    if (thnum < 2) {

      threadappends[0].setparams(0, &db, rnum, thnum, rnd, tran);

      threadappends[0].run();

      if (threadappends[0].error()) err = true;

    } else {

      for (int32_t i = 0; i < thnum; i++) {

        threadappends[i].setparams(i, &db, rnum, thnum, rnd, tran);

        threadappends[i].start();

      }

      for (int32_t i = 0; i < thnum; i++) {

        threadappends[i].join();

        if (threadappends[i].error()) err = true;

      }

    }

    etime = kc::time();

    dbmetaprint(&db, false);

    oprintf("time: %.3f\n", etime - stime);

    char* opaque = db.opaque();

    if (opaque) {

      std::memcpy(opaque, "1234567890123456", 16);

      if (!db.synchronize_opaque()) {

        dberrprint(&db, __LINE__, "DB::synchronize_opaque");

        err = true;

      }

    } else {

      dberrprint(&db, __LINE__, "DB::opaque");

      err = true;

    }

  }

  oprintf("getting records:\n");

  stime = kc::time();

  class ThreadGet : public kc::Thread {

   public:

    void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,

                   bool rnd, bool tran) {

      id_ = id;

      db_ = db;

      rnum_ = rnum;

      thnum_ = thnum;

      err_ = false;

      rnd_ = rnd;

      tran_ = tran;

    }

    bool error() {

      return err_;

    }

    void run() {

      int64_t base = id_ * rnum_;

      int64_t range = rnum_ * thnum_;

      for (int64_t i = 1; !err_ && i <= rnum_; i++) {

        if (tran_ && !db_->begin_transaction(false)) {

          dberrprint(db_, __LINE__, "DB::begin_transaction");

          err_ = true;

        }

        char kbuf[RECBUFSIZ];

        size_t ksiz = std::sprintf(kbuf, "%08lld",

                                   (long long)(rnd_ ? myrand(range) + 1 : base + i));

        size_t vsiz;

        char* vbuf = db_->get(kbuf, ksiz, &vsiz);

        if (vbuf) {

          if (vsiz < ksiz || std::memcmp(vbuf, kbuf, ksiz)) {

            dberrprint(db_, __LINE__, "DB::get");

            err_ = true;

          }

          delete[] vbuf;

        } else if (!rnd_ || db_->error() != kc::BasicDB::Error::NOREC) {

          dberrprint(db_, __LINE__, "DB::get");

          err_ = true;

        }

        if (rnd_ && i % 8 == 0) {

          switch (myrand(8)) {

            case 0: {

              if (!db_->set(kbuf, ksiz, kbuf, ksiz)) {

                dberrprint(db_, __LINE__, "DB::set");

                err_ = true;

              }

              break;

            }

            case 1: {

              if (!db_->append(kbuf, ksiz, kbuf, ksiz)) {

                dberrprint(db_, __LINE__, "DB::append");

                err_ = true;

              }

              break;

            }

            case 2: {

              if (!db_->remove(kbuf, ksiz) &&

                  db_->error() != kc::BasicDB::Error::NOREC) {

                dberrprint(db_, __LINE__, "DB::remove");

                err_ = true;

              }

              break;

            }

            case 3: {

              kc::DB::Cursor* cur = db_->cursor();

              if (cur->jump(kbuf, ksiz)) {

                switch (myrand(8)) {

                  default: {

                    size_t rsiz;

                    char* rbuf = cur->get_key(&rsiz, myrand(10) == 0);

                    if (rbuf) {

                      delete[] rbuf;

                    } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                      dberrprint(db_, __LINE__, "Cursor::get_key");

                      err_ = true;

                    }

                    break;

                  }

                  case 1: {

                    size_t rsiz;

                    char* rbuf = cur->get_value(&rsiz, myrand(10) == 0);

                    if (rbuf) {

                      delete[] rbuf;

                    } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                      dberrprint(db_, __LINE__, "Cursor::get_value");

                      err_ = true;

                    }

                    break;

                  }

                  case 2: {

                    size_t rksiz;

                    const char* rvbuf;

                    size_t rvsiz;

                    char* rkbuf = cur->get(&rksiz, &rvbuf, &rvsiz, myrand(10) == 0);

                    if (rkbuf) {

                      delete[] rkbuf;

                    } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                      dberrprint(db_, __LINE__, "Cursor::get");

                      err_ = true;

                    }

                    break;

                  }

                  case 3: {

                    std::string key, value;

                    if (!cur->get(&key, &value, myrand(10) == 0) &&

                        db_->error() != kc::BasicDB::Error::NOREC) {

                      dberrprint(db_, __LINE__, "Cursor::get");

                      err_ = true;

                    }

                    break;

                  }

                  case 4: {

                    if (myrand(8) == 0 && !cur->remove() &&

                        db_->error() != kc::BasicDB::Error::NOREC) {

                      dberrprint(db_, __LINE__, "Cursor::remove");

                      err_ = true;

                    }

                    break;

                  }

                }

              } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                dberrprint(db_, __LINE__, "Cursor::jump");

                err_ = true;

              }

              delete cur;

              break;

            }

            default: {

              size_t vsiz;

              char* vbuf = db_->get(kbuf, ksiz, &vsiz);

              if (vbuf) {

                delete[] vbuf;

              } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                dberrprint(db_, __LINE__, "DB::get");

                err_ = true;

              }

              break;

            }

          }

        }

        if (tran_ && !db_->end_transaction(true)) {

          dberrprint(db_, __LINE__, "DB::end_transaction");

          err_ = true;

        }

        if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {

          oputchar('.');

          if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);

        }

      }

    }

   private:

    int32_t id_;

    kc::BasicDB* db_;

    int64_t rnum_;

    int32_t thnum_;

    bool err_;

    bool rnd_;

    bool tran_;

  };

  ThreadGet threadgets[THREADMAX];

  if (thnum < 2) {

    threadgets[0].setparams(0, &db, rnum, thnum, rnd, tran);

    threadgets[0].run();

    if (threadgets[0].error()) err = true;

  } else {

    for (int32_t i = 0; i < thnum; i++) {

      threadgets[i].setparams(i, &db, rnum, thnum, rnd, tran);

      threadgets[i].start();

    }

    for (int32_t i = 0; i < thnum; i++) {

      threadgets[i].join();

      if (threadgets[i].error()) err = true;

    }

  }

  etime = kc::time();

  dbmetaprint(&db, false);

  oprintf("time: %.3f\n", etime - stime);

  if (etc) {

    oprintf("getting records with a buffer:\n");

    stime = kc::time();

    class ThreadGetBuffer : public kc::Thread {

     public:

      void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,

                     bool rnd, bool tran) {

        id_ = id;

        db_ = db;

        rnum_ = rnum;

        thnum_ = thnum;

        err_ = false;

        rnd_ = rnd;

        tran_ = tran;

      }

      bool error() {

        return err_;

      }

      void run() {

        int64_t base = id_ * rnum_;

        int64_t range = rnum_ * thnum_;

        for (int64_t i = 1; !err_ && i <= rnum_; i++) {

          if (tran_ && !db_->begin_transaction(false)) {

            dberrprint(db_, __LINE__, "DB::begin_transaction");

            err_ = true;

          }

          char kbuf[RECBUFSIZ];

          size_t ksiz = std::sprintf(kbuf, "%08lld",

                                     (long long)(rnd_ ? myrand(range) + 1 : base + i));

          char vbuf[RECBUFSIZ];

          int32_t vsiz = db_->get(kbuf, ksiz, vbuf, sizeof(vbuf));

          if (vsiz >= 0) {

            if (vsiz < (int32_t)ksiz || std::memcmp(vbuf, kbuf, ksiz)) {

              dberrprint(db_, __LINE__, "DB::get");

              err_ = true;

            }

          } else if (!rnd_ || db_->error() != kc::BasicDB::Error::NOREC) {

            dberrprint(db_, __LINE__, "DB::get");