heroku-tokyotyrant 0.4

data/ext/tokyocabinet-1.4.41/bros/cdbtest.c

@@ -0,0 +1,219 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <cdb.h>
+
+#undef TRUE
+#define TRUE           1                 /* boolean true */
+#undef FALSE
+#define FALSE          0                 /* boolean false */
+
+#define RECBUFSIZ      32                /* buffer for records */
+
+
+/* global variables */
+const char *progname;                    /* program name */
+int showprgr;                            /* whether to show progression */
+
+
+/* function prototypes */
+int main(int argc, char **argv);
+void usage(void);
+int runwrite(int argc, char **argv);
+int runread(int argc, char **argv);
+int dowrite(char *name, int rnum);
+int doread(char *name, int rnum);
+
+
+/* main routine */
+int main(int argc, char **argv){
+  int rv;
+  progname = argv[0];
+  showprgr = TRUE;
+  if(getenv("HIDEPRGR")) showprgr = FALSE;
+  if(argc < 2) usage();
+  rv = 0;
+  if(!strcmp(argv[1], "write")){
+    rv = runwrite(argc, argv);
+  } else if(!strcmp(argv[1], "read")){
+    rv = runread(argc, argv);
+  } else {
+    usage();
+  }
+  return rv;
+}
+
+
+/* print the usage and exit */
+void usage(void){
+  fprintf(stderr, "%s: test cases for Constant Database\n", progname);
+  fprintf(stderr, "\n");
+  fprintf(stderr, "usage:\n");
+  fprintf(stderr, "  %s write name rnum\n", progname);
+  fprintf(stderr, "  %s read name rnum\n", progname);
+  fprintf(stderr, "\n");
+  exit(1);
+}
+
+
+/* parse arguments of write command */
+int runwrite(int argc, char **argv){
+  char *name, *rstr;
+  int i, rnum, rv;
+  name = NULL;
+  rstr = NULL;
+  rnum = 0;
+  for(i = 2; i < argc; i++){
+    if(!name && argv[i][0] == '-'){
+      usage();
+    } else if(!name){
+      name = argv[i];
+    } else if(!rstr){
+      rstr = argv[i];
+    } else {
+      usage();
+    }
+  }
+  if(!name || !rstr) usage();
+  rnum = atoi(rstr);
+  if(rnum < 1) usage();
+  rv = dowrite(name, rnum);
+  return rv;
+}
+
+
+/* parse arguments of read command */
+int runread(int argc, char **argv){
+  char *name, *rstr;
+  int i, rnum, rv;
+  name = NULL;
+  rstr = NULL;
+  rnum = 0;
+  for(i = 2; i < argc; i++){
+    if(!name && argv[i][0] == '-'){
+      usage();
+    } else if(!name){
+      name = argv[i];
+    } else if(!rstr){
+      rstr = argv[i];
+    } else {
+      usage();
+    }
+  }
+  if(!name || !rstr) usage();
+  rnum = atoi(rstr);
+  if(rnum < 1) usage();
+  rv = doread(name, rnum);
+  return rv;
+}
+
+
+/* perform write command */
+int dowrite(char *name, int rnum){
+  struct cdb_make cdb;
+  int i, fd, err, len;
+  char buf[32];
+  if(showprgr) printf("<Writing Test>\n  name=%s  rnum=%d\n\n", name, rnum);
+  /* open a database */
+  if((fd = open(name, O_RDWR | O_CREAT | O_TRUNC, 0644)) == -1){
+    perror("open");
+    return 1;
+  }
+  if(cdb_make_start(&cdb, fd) == -1){
+    perror("cdb_make_start");
+    close(fd);
+    return 1;
+  }
+  err = FALSE;
+  /* loop for each record */
+  for(i = 1; i <= rnum; i++){
+    /* store a record */
+    len = sprintf(buf, "%08d", i);
+    if(cdb_make_add(&cdb, buf, len, buf, len) == -1){
+      perror("cdb_add");
+      err = TRUE;
+      break;
+    }
+    /* print progression */
+    if(showprgr && rnum > 250 && i % (rnum / 250) == 0){
+      putchar('.');
+      fflush(stdout);
+      if(i == rnum || i % (rnum / 10) == 0){
+        printf(" (%08d)\n", i);
+        fflush(stdout);
+      }
+    }
+  }
+  /* close the database */
+  if(cdb_make_finish(&cdb) == -1){
+    perror("cdb_make_finish");
+    close(fd);
+    return 1;
+  }
+  if(close(fd) == -1){
+    perror("close");
+    return 1;
+  }
+  if(showprgr && !err) printf("ok\n\n");
+  return err ? 1 : 0;
+}
+
+
+/* perform read command */
+int doread(char *name, int rnum){
+  struct cdb cdb;
+  int i, fd, err, len;
+  char buf[RECBUFSIZ], *val;
+  if(showprgr) printf("<Reading Test>\n  name=%s  rnum=%d\n\n", name, rnum);
+  /* open a database */
+  if((fd = open(name, O_RDONLY, 0644)) == -1){
+    perror("open");
+    return 1;
+  }
+  cdb_init(&cdb, fd);
+  err = FALSE;
+  /* loop for each record */
+  for(i = 1; i <= rnum; i++){
+    /* retrieve a record */
+    len = sprintf(buf, "%08d", i);
+    if(cdb_find(&cdb, buf, len) == 0){
+      perror("cdb_find");
+      err = TRUE;
+      break;
+    }
+    len = cdb_datalen(&cdb);
+    if(!(val = malloc(len + 1))){
+      perror("malloc");
+      err = TRUE;
+      break;
+    }
+    cdb_read(&cdb, val, len, cdb_datapos(&cdb));
+    free(val);
+    /* print progression */
+    if(showprgr && rnum > 250 && i % (rnum / 250) == 0){
+      putchar('.');
+      fflush(stdout);
+      if(i == rnum || i % (rnum / 10) == 0){
+        printf(" (%08d)\n", i);
+        fflush(stdout);
+      }
+    }
+  }
+  /* close the database */
+  cdb_free(&cdb);
+  if(close(fd) == -1){
+    perror("close");
+    return 1;
+  }
+  if(showprgr && !err) printf("ok\n\n");
+  return err ? 1 : 0;
+}
+
+
+
+/* END OF FILE */

data/ext/tokyocabinet-1.4.41/bros/cmpsqltctest.c

@@ -0,0 +1,186 @@
+/*************************************************************************************************
+ * Comparison test of SQLite and Tokyo Cabinet
+ *************************************************************************************************/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <assert.h>
+#include <sqlite3.h>
+#include <tctdb.h>
+
+#define SQLFILE    "casket.sql"
+#define TCTFILE    "casket.tct"
+#define SQLBUFSIZ   1024
+#define SAMPLENUM   10
+#define RECORDNUM   1000000
+
+
+/* function prototypes */
+int main(int argc, char **argv);
+static void test_sqlite(void);
+static void test_tctdb(void);
+static int myrand(void);
+static int callback(void *opq, int argc, char **argv, char **colname);
+
+
+/* main routine */
+int main(int argc, char **argv){
+  test_sqlite();
+  test_tctdb();
+  return 0;
+}
+
+
+/* perform SQLite test */
+static void test_sqlite(void){
+  double sum = 0.0;
+  for(int i = 1; i <= SAMPLENUM; i++){
+    unlink(SQLFILE);
+    sync(); sync();
+    printf("SQLite write sample:%d ... ", i);
+    fflush(stdout);
+    double stime = tctime();
+    sqlite3 *db;
+    if(sqlite3_open(SQLFILE, &db) != 0) assert(!__LINE__);
+    char sql[SQLBUFSIZ], *errmsg;
+    sprintf(sql, "CREATE TABLE tbl ( k TEXT PRIMARY KEY, a TEXT, b INTEGER,"
+            " c TEXT, d INTEGER );");
+    if(sqlite3_exec(db, sql, callback, 0, &errmsg) != SQLITE_OK) assert(!__LINE__);
+    sprintf(sql, "CREATE INDEX tbl_s ON tbl ( a );");
+    if(sqlite3_exec(db, sql, callback, 0, &errmsg) != SQLITE_OK) assert(!__LINE__);
+    sprintf(sql, "CREATE INDEX tbl_n ON tbl ( b );");
+    if(sqlite3_exec(db, sql, callback, 0, &errmsg) != SQLITE_OK) assert(!__LINE__);
+    sprintf(sql, "PRAGMA cache_size = %d;", RECORDNUM);
+    if(sqlite3_exec(db, sql, callback, 0, &errmsg) != SQLITE_OK) assert(!__LINE__);
+    sprintf(sql, "BEGIN TRANSACTION;");
+    if(sqlite3_exec(db, sql, callback, 0, &errmsg) != SQLITE_OK) assert(!__LINE__);
+    for(int j = 1; j <= RECORDNUM; j++){
+      sprintf(sql, "INSERT INTO tbl VALUES ( '%08d', '%08d', %d, '%08d', %d );",
+            j, j, myrand() % RECORDNUM, myrand() % RECORDNUM, j);
+      if(sqlite3_exec(db, sql, callback, 0, &errmsg) != SQLITE_OK) assert(!__LINE__);
+    }
+    sprintf(sql, "END TRANSACTION;");
+    if(sqlite3_exec(db, sql, callback, 0, &errmsg) != SQLITE_OK) assert(!__LINE__);
+    sqlite3_close(db);
+    double etime = tctime() - stime;
+    printf("%.6f\n", etime);
+    sum += etime;
+  }
+  printf("SQLite write average: %.6f\n", sum / SAMPLENUM);
+  sum = 0.0;
+  for(int i = 1; i <= SAMPLENUM; i++){
+    sync(); sync();
+    printf("SQLite read sample:%d ... ", i);
+    fflush(stdout);
+    double stime = tctime();
+    sqlite3 *db;
+    if(sqlite3_open(SQLFILE, &db) != 0) assert(!__LINE__);
+    char sql[SQLBUFSIZ], *errmsg;
+    sprintf(sql, "PRAGMA cache_size = %d;", RECORDNUM);
+    if(sqlite3_exec(db, sql, callback, 0, &errmsg) != SQLITE_OK) assert(!__LINE__);
+    for(int j = 1; j <= RECORDNUM; j++){
+      sprintf(sql, "SELECT * FROM tbl WHERE a = '%08d';", myrand() % RECORDNUM + 1);
+      if(sqlite3_exec(db, sql, callback, 0, &errmsg) != SQLITE_OK) assert(!__LINE__);
+    }
+    sqlite3_close(db);
+    double etime = tctime() - stime;
+    printf("%.6f\n", etime);
+    sum += etime;
+  }
+  printf("SQLite read average: %.6f\n", sum / SAMPLENUM);
+}
+
+
+/* perform TCHDB test */
+static void test_tctdb(void){
+  double sum = 0.0;
+  for(int i = 1; i <= SAMPLENUM; i++){
+    unlink(TCTFILE);
+    sync(); sync();
+    printf("TCTDB write sample:%d ... ", i);
+    fflush(stdout);
+    double stime = tctime();
+    TCTDB *tdb = tctdbnew();
+    if(!tctdbtune(tdb, RECORDNUM * 2, -1, -1, 0)) assert(!__LINE__);
+    if(!tctdbsetcache(tdb, 0, RECORDNUM, RECORDNUM)) assert(!__LINE__);
+    if(!tctdbopen(tdb, TCTFILE, TDBOWRITER | TDBOCREAT | TDBOTRUNC)) assert(!__LINE__);
+    if(!tctdbsetindex(tdb, "a", TDBITLEXICAL)) assert(!__LINE__);
+    if(!tctdbsetindex(tdb, "b", TDBITDECIMAL)) assert(!__LINE__);
+    if(!tctdbtranbegin(tdb)) assert(!__LINE__);
+    char buf[SQLBUFSIZ];
+    int size;
+    for(int j = 1; j <= RECORDNUM; j++){
+      TCMAP *cols = tcmapnew2(7);
+      size = sprintf(buf, "%08d", j);
+      tcmapput(cols, "a", 1, buf, size);
+      size = sprintf(buf, "%d", myrand() % RECORDNUM);
+      tcmapput(cols, "b", 1, buf, size);
+      size = sprintf(buf, "%08d", myrand() % RECORDNUM);
+      tcmapput(cols, "c", 1, buf, size);
+      size = sprintf(buf, "%d", j);
+      tcmapput(cols, "d", 1, buf, size);
+      size = sprintf(buf, "%08d", j);
+      if(!tctdbput(tdb, buf, size, cols)) assert(!__LINE__);
+      tcmapdel(cols);
+    }
+    if(!tctdbtrancommit(tdb)) assert(!__LINE__);
+    if(!tctdbclose(tdb)) assert(!__LINE__);
+    tctdbdel(tdb);
+    double etime = tctime() - stime;
+    printf("%.6f\n", etime);
+    sum += etime;
+  }
+  printf("TCTDB write average: %.6f\n", sum / SAMPLENUM);
+  sum = 0.0;
+  for(int i = 1; i <= SAMPLENUM; i++){
+    sync(); sync();
+    printf("TCTDB read sample:%d ... ", i);
+    fflush(stdout);
+    double stime = tctime();
+    TCTDB *tdb = tctdbnew();
+    if(!tctdbsetcache(tdb, 0, RECORDNUM, RECORDNUM)) assert(!__LINE__);
+    if(!tctdbopen(tdb, TCTFILE, TDBOREADER)) assert(!__LINE__);
+    char buf[SQLBUFSIZ];
+    for(int j = 1; j <= RECORDNUM; j++){
+      TDBQRY *qry = tctdbqrynew(tdb);
+      sprintf(buf, "%08d", myrand() % RECORDNUM + 1);
+      tctdbqryaddcond(qry, "a", TDBQCSTREQ, buf);
+      TCLIST *res = tctdbqrysearch(qry);
+      for(int k = 0; k < tclistnum(res); k++){
+        int ksiz;
+        const char *kbuf = tclistval(res, k, &ksiz);
+        TCMAP *cols = tctdbget(tdb, kbuf, ksiz);
+        if(!cols) assert(!__LINE__);
+        tcmapdel(cols);
+      }
+      tclistdel(res);
+      tctdbqrydel(qry);
+    }
+    if(!tctdbclose(tdb)) assert(!__LINE__);
+    double etime = tctime() - stime;
+    printf("%.6f\n", etime);
+    sum += etime;
+  }
+  printf("TCTDB read average: %.6f\n", sum / SAMPLENUM);
+}
+
+
+/* generate a random number */
+static int myrand(void){
+  static int cnt = 0;
+  return (lrand48() + cnt++) & 0x7FFFFFFF;
+}
+
+
+/* iterator of SQLite */
+static int callback(void *opq, int argc, char **argv, char **colname){
+  return 0;
+}
+
+
+
+/* END OF FILE */

data/ext/tokyocabinet-1.4.41/bros/gdbmtest.c

@@ -0,0 +1,216 @@
+/*************************************************************************************************
+ * Writing test of GNU Database Manager
+ *************************************************************************************************/
+
+
+#include <gdbm.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#undef TRUE
+#define TRUE           1                 /* boolean true */
+#undef FALSE
+#define FALSE          0                 /* boolean false */
+
+#define RECBUFSIZ      32                /* buffer for records */
+#define CACHESIZE      16                /* cache size */
+
+
+/* global variables */
+const char *progname;                    /* program name */
+int showprgr;                            /* whether to show progression */
+
+
+/* function prototypes */
+int main(int argc, char **argv);
+void usage(void);
+int runwrite(int argc, char **argv);
+int runread(int argc, char **argv);
+int dowrite(char *name, int rnum);
+int doread(char *name, int rnum);
+
+
+/* main routine */
+int main(int argc, char **argv){
+  int rv;
+  progname = argv[0];
+  showprgr = TRUE;
+  if(getenv("HIDEPRGR")) showprgr = FALSE;
+  if(argc < 2) usage();
+  rv = 0;
+  if(!strcmp(argv[1], "write")){
+    rv = runwrite(argc, argv);
+  } else if(!strcmp(argv[1], "read")){
+    rv = runread(argc, argv);
+  } else {
+    usage();
+  }
+  return rv;
+}
+
+
+/* print the usage and exit */
+void usage(void){
+  fprintf(stderr, "%s: test cases for GNU Database Manager\n", progname);
+  fprintf(stderr, "\n");
+  fprintf(stderr, "usage:\n");
+  fprintf(stderr, "  %s write name rnum\n", progname);
+  fprintf(stderr, "  %s read name rnum\n", progname);
+  fprintf(stderr, "\n");
+  exit(1);
+}
+
+
+/* parse arguments of write command */
+int runwrite(int argc, char **argv){
+  char *name, *rstr;
+  int i, rnum, rv;
+  name = NULL;
+  rstr = NULL;
+  rnum = 0;
+  for(i = 2; i < argc; i++){
+    if(!name && argv[i][0] == '-'){
+      usage();
+    } else if(!name){
+      name = argv[i];
+    } else if(!rstr){
+      rstr = argv[i];
+    } else {
+      usage();
+    }
+  }
+  if(!name || !rstr) usage();
+  rnum = atoi(rstr);
+  if(rnum < 1) usage();
+  rv = dowrite(name, rnum);
+  return rv;
+}
+
+
+/* parse arguments of read command */
+int runread(int argc, char **argv){
+  char *name, *rstr;
+  int i, rnum, rv;
+  name = NULL;
+  rstr = NULL;
+  rnum = 0;
+  for(i = 2; i < argc; i++){
+    if(!name && argv[i][0] == '-'){
+      usage();
+    } else if(!name){
+      name = argv[i];
+    } else if(!rstr){
+      rstr = argv[i];
+    } else {
+      usage();
+    }
+  }
+  if(!name || !rstr) usage();
+  rnum = atoi(rstr);
+  if(rnum < 1) usage();
+  rv = doread(name, rnum);
+  return rv;
+}
+
+
+/* perform write command */
+int dowrite(char *name, int rnum){
+  GDBM_FILE dbf;
+  datum key, content;
+  int i, err, optval, len;
+  char buf[RECBUFSIZ];
+  if(showprgr) printf("<Writing Test>\n  name=%s  rnum=%d\n\n", name, rnum);
+  /* open a database */
+  if(!(dbf = gdbm_open(name, 0, GDBM_NEWDB, 00644, NULL))){
+    fprintf(stderr, "gdbm_open failed\n");
+    return 1;
+  }
+  optval = CACHESIZE;
+  if(gdbm_setopt(dbf, GDBM_CACHESIZE, &optval, sizeof(int)) != 0){
+    fprintf(stderr, "gdbm_setopt failed\n");
+    gdbm_close(dbf);
+    return 1;
+  }
+  err = FALSE;
+  /* loop for each record */
+  for(i = 1; i <= rnum; i++){
+    len = sprintf(buf, "%08d", i);
+    key.dptr = buf;
+    key.dsize = len;
+    content.dptr = buf;
+    content.dsize = len;
+    /* store a record */
+    if(gdbm_store(dbf, key, content, GDBM_REPLACE) != 0){
+      fprintf(stderr, "gdbm_store failed\n");
+      err = TRUE;
+      break;
+    }
+    /* print progression */
+    if(showprgr && rnum > 250 && i % (rnum / 250) == 0){
+      putchar('.');
+      fflush(stdout);
+      if(i == rnum || i % (rnum / 10) == 0){
+        printf(" (%08d)\n", i);
+        fflush(stdout);
+      }
+    }
+  }
+  /* close the database */
+  gdbm_close(dbf);
+  if(showprgr && !err) printf("ok\n\n");
+  return err ? 1 : 0;
+}
+
+
+/* perform read command */
+int doread(char *name, int rnum){
+  GDBM_FILE dbf;
+  datum key, content;
+  int i, err, optval, len;
+  char buf[RECBUFSIZ];
+  if(showprgr) printf("<Reading Test>\n  name=%s  rnum=%d\n\n", name, rnum);
+  /* open a database */
+  if(!(dbf = gdbm_open(name, 0, GDBM_READER, 00644, NULL))){
+    fprintf(stderr, "gdbm_open failed\n");
+    return 1;
+  }
+  optval = CACHESIZE;
+  if(gdbm_setopt(dbf, GDBM_CACHESIZE, &optval, sizeof(int)) != 0){
+    fprintf(stderr, "gdbm_setopt failed\n");
+    gdbm_close(dbf);
+    return 1;
+  }
+  err = FALSE;
+  /* loop for each record */
+  for(i = 1; i <= rnum; i++){
+    /* retrieve a record */
+    len = sprintf(buf, "%08d", i);
+    key.dptr = buf;
+    key.dsize = len;
+    content = gdbm_fetch(dbf, key);
+    if(!content.dptr){
+      fprintf(stderr, "gdbm_fetch failed\n");
+      err = TRUE;
+      break;
+    }
+    free(content.dptr);
+    /* print progression */
+    if(showprgr && rnum > 250 && i % (rnum / 250) == 0){
+      putchar('.');
+      fflush(stdout);
+      if(i == rnum || i % (rnum / 10) == 0){
+        printf(" (%08d)\n", i);
+        fflush(stdout);
+      }
+    }
+  }
+  /* close the database */
+  gdbm_close(dbf);
+  if(showprgr && !err) printf("ok\n\n");
+  return err ? 1 : 0;
+}
+
+
+
+/* END OF FILE */