ruby-tokyotyrant 0.3.0

data/ext/tokyo_tyrant_module.c

@@ -0,0 +1,453 @@
+#include <tokyo_tyrant_db.h>
+
+extern TCRDB *mTokyoTyrant_getdb(VALUE vself){
+  TCRDB *db;
+  Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db);
+  return db;
+}
+
+extern void mTokyoTyrant_exception(VALUE vself){
+  int ecode;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  ecode = tcrdbecode(db);
+  rb_raise(eTokyoTyrantError, tcrdberrmsg(ecode));
+}
+
+static void mTokyoTyrant_free(TCRDB *db){
+  tcrdbdel(db);
+}
+
+static VALUE mTokyoTyrant_server(VALUE vself){
+  return rb_iv_get(vself, "@server");
+}
+
+static VALUE mTokyoTyrant_close(VALUE vself){
+  int ecode;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  if(!tcrdbclose(db)){
+    ecode = tcrdbecode(db);
+    rb_raise(eTokyoTyrantError, "close error: %s", tcrdberrmsg(ecode));
+  }
+  return Qtrue;
+}
+
+static VALUE mTokyoTyrant_connect(VALUE vself){
+  VALUE host, port, timeout, retry, server;
+  int ecode;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  host = rb_iv_get(vself, "@host");
+  port = rb_iv_get(vself, "@port");
+  timeout = rb_iv_get(vself, "@timeout");
+  retry = rb_iv_get(vself, "@retry");
+
+  if((!tcrdbtune(db, NUM2DBL(timeout), retry == Qtrue ? RDBTRECON : 0)) ||
+     (!tcrdbopen(db, RSTRING_PTR(host), FIX2INT(port)))){
+    ecode = tcrdbecode(db);
+    rb_raise(eTokyoTyrantError, "open error: %s", tcrdberrmsg(ecode));
+  }
+
+  server = rb_str_new2(tcrdbexpr(db));
+  rb_iv_set(vself, "@server", server);
+
+  return Qtrue;
+}
+
+static VALUE mTokyoTyrant_reconnect(VALUE vself){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  if(db->fd != -1) mTokyoTyrant_close(vself);
+  db = tcrdbnew();
+  rb_iv_set(vself, RDBVNDATA, Data_Wrap_Struct(rb_cObject, 0, mTokyoTyrant_free, db));
+
+  return mTokyoTyrant_connect(vself);
+}
+
+static VALUE mTokyoTyrant_initialize(int argc, VALUE *argv, VALUE vself){
+  VALUE host, port, timeout, retry;
+  TCRDB *db;
+
+  rb_scan_args(argc, argv, "04", &host, &port, &timeout, &retry);
+  if(NIL_P(host)) host = rb_str_new2("127.0.0.1");
+  if(NIL_P(port)) port = INT2FIX(1978);
+  if(NIL_P(timeout)) timeout = rb_float_new(0.0);
+  if(NIL_P(retry)) retry = Qfalse;
+
+  rb_iv_set(vself, "@host", host);
+  rb_iv_set(vself, "@port", port);
+  rb_iv_set(vself, "@timeout", timeout);
+  rb_iv_set(vself, "@retry", retry);
+
+  db = tcrdbnew();
+  rb_iv_set(vself, RDBVNDATA, Data_Wrap_Struct(rb_cObject, 0, mTokyoTyrant_free, db));
+
+  return mTokyoTyrant_connect(vself);
+}
+
+static VALUE mTokyoTyrant_errmsg(int argc, VALUE *argv, VALUE vself){
+  VALUE vecode;
+  const char *msg;
+  int ecode;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  rb_scan_args(argc, argv, "01", &vecode);
+
+  ecode = (vecode == Qnil) ? tcrdbecode(db) : NUM2INT(vecode);
+  msg = tcrdberrmsg(ecode);
+  return rb_str_new2(msg);
+}
+
+static VALUE mTokyoTyrant_ecode(VALUE vself){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  return INT2NUM(tcrdbecode(db));
+}
+
+static VALUE mTokyoTyrant_out(VALUE vself, VALUE vkey){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  vkey = StringValueEx(vkey);
+  return tcrdbout(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey)) ? Qtrue : Qfalse;
+}
+
+// TODO: merge out and mout?
+static VALUE mTokyoTyrant_outlist(int argc, VALUE *argv, VALUE vself){
+  VALUE vkeys, vary, vvalue;
+  TCLIST *list, *result;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  rb_scan_args(argc, argv, "*", &vkeys);
+
+  // I really hope there is a better way to do this
+  if (RARRAY_LEN(vkeys) == 1) {
+    vvalue = rb_ary_entry(vkeys, 0);
+    switch (TYPE(vvalue)){
+      case T_STRING:
+      case T_FIXNUM:
+        break;
+      case T_ARRAY:
+        vkeys = vvalue;
+        break;
+      case T_OBJECT:
+        vkeys = rb_convert_type(vvalue, T_ARRAY, "Array", "to_a");
+        break;
+    }
+  }
+  Check_Type(vkeys, T_ARRAY);
+
+  list = varytolist(vkeys);
+  result = tcrdbmisc(db, "outlist", 0, list);
+  tclistdel(list);
+  vary = listtovary(result);
+  tclistdel(result);
+  return vary;
+}
+
+static VALUE mTokyoTyrant_check(VALUE vself, VALUE vkey){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  vkey = StringValueEx(vkey);
+  return tcrdbvsiz(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey)) >= 0 ? Qtrue : Qfalse;
+}
+
+static VALUE mTokyoTyrant_iterinit(VALUE vself){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  return tcrdbiterinit(db) ? Qtrue : Qfalse;
+}
+
+static VALUE mTokyoTyrant_iternext(VALUE vself){
+  VALUE vval;
+  char *vbuf;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  if(!(vbuf = tcrdbiternext2(db))) return Qnil;
+  vval = rb_str_new2(vbuf);
+  tcfree(vbuf);
+
+  return vval;
+}
+
+static VALUE mTokyoTyrant_fwmkeys(int argc, VALUE *argv, VALUE vself){
+  VALUE vprefix, vmax, vary;
+  TCLIST *keys;
+  int max;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  rb_scan_args(argc, argv, "11", &vprefix, &vmax);
+
+  vprefix = StringValueEx(vprefix);
+  max = (vmax == Qnil) ? -1 : NUM2INT(vmax);
+  keys = tcrdbfwmkeys(db, RSTRING_PTR(vprefix), RSTRING_LEN(vprefix), max);
+  vary = listtovary(keys);
+  tclistdel(keys);
+  return vary;
+}
+
+static VALUE mTokyoTyrant_delete_keys_with_prefix(int argc, VALUE *argv, VALUE vself){
+  VALUE vprefix, vmax;
+  TCLIST *keys;
+  int max;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  rb_scan_args(argc, argv, "11", &vprefix, &vmax);
+
+  vprefix = StringValueEx(vprefix);
+  max = (vmax == Qnil) ? -1 : NUM2INT(vmax);
+  keys = tcrdbfwmkeys(db, RSTRING_PTR(vprefix), RSTRING_LEN(vprefix), max);
+  tcrdbmisc(db, "outlist", 0, keys);
+  tclistdel(keys);
+  return Qnil;
+}
+
+static VALUE mTokyoTyrant_keys(VALUE vself){
+  /*
+  VALUE vary;
+  char *kxstr;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  vary = rb_ary_new2(tcrdbrnum(db));
+  tcrdbiterinit(db);
+  while((kxstr = tcrdbiternext2(db)) != NULL){
+    rb_ary_push(vary, rb_str_new2(kxstr));
+  }
+  return vary;
+  */
+
+  // Using forward matching keys with an empty string is 100x faster than iternext+get
+  VALUE vary;
+  TCLIST *keys;
+  char *prefix;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  prefix = "";
+  keys = tcrdbfwmkeys2(db, prefix, -1);
+  vary = listtovary(keys);
+  tclistdel(keys);
+  return vary;
+}
+
+static VALUE mTokyoTyrant_addint(VALUE vself, VALUE vkey, int inum){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  vkey = StringValueEx(vkey);
+
+  inum = tcrdbaddint(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey), inum);
+  return inum == INT_MIN ? Qnil : INT2NUM(inum);
+}
+
+static VALUE mTokyoTyrant_add_int(int argc, VALUE *argv, VALUE vself){
+  VALUE vkey, vnum;
+  int inum = 1;
+
+  rb_scan_args(argc, argv, "11", &vkey, &vnum);
+  vkey = StringValueEx(vkey);
+  if(NIL_P(vnum)) vnum = INT2NUM(inum);
+
+  return mTokyoTyrant_addint(vself, vkey, NUM2INT(vnum));
+}
+
+static VALUE mTokyoTyrant_get_int(VALUE vself, VALUE vkey){
+  return mTokyoTyrant_addint(vself, vkey, 0);
+}
+
+static VALUE mTokyoTyrant_adddouble(VALUE vself, VALUE vkey, double dnum){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  vkey = StringValueEx(vkey);
+  dnum = tcrdbadddouble(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey), dnum);
+  return isnan(dnum) ? Qnil : rb_float_new(dnum);
+}
+
+static VALUE mTokyoTyrant_add_double(int argc, VALUE *argv, VALUE vself){
+  VALUE vkey, vnum;
+  double dnum = 1.0;
+
+  rb_scan_args(argc, argv, "11", &vkey, &vnum);
+  vkey = StringValueEx(vkey);
+  if(NIL_P(vnum)) vnum = rb_float_new(dnum);
+
+  return mTokyoTyrant_adddouble(vself, vkey, NUM2DBL(vnum));
+}
+
+static VALUE mTokyoTyrant_get_double(VALUE vself, VALUE vkey){
+  return mTokyoTyrant_adddouble(vself, vkey, 0.0);
+}
+
+static VALUE mTokyoTyrant_sync(VALUE vself){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  return tcrdbsync(db) ? Qtrue : Qfalse;
+}
+
+static VALUE mTokyoTyrant_optimize(int argc, VALUE *argv, VALUE vself){
+  VALUE vparams;
+  const char *params = NULL;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  rb_scan_args(argc, argv, "01", &vparams);
+  if(NIL_P(vparams)) vparams = Qnil;
+  if(vparams != Qnil) params = RSTRING_PTR(vparams);
+
+  return tcrdboptimize(db, params) ? Qtrue : Qfalse;
+}
+
+static VALUE mTokyoTyrant_vanish(VALUE vself){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  return tcrdbvanish(db) ? Qtrue : Qfalse;
+}
+
+static VALUE mTokyoTyrant_copy(VALUE vself, VALUE path){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  Check_Type(path, T_STRING);
+  return tcrdbcopy(db, RSTRING_PTR(path)) ? Qtrue : Qfalse;
+}
+
+static VALUE mTokyoTyrant_restore(VALUE vself, VALUE vpath, VALUE vts, VALUE vopts){
+  uint64_t ts;
+  int opts;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  Check_Type(vpath, T_STRING);
+  ts = (uint64_t) FIX2INT(vts);
+  opts = FIX2INT(vopts);
+  return tcrdbrestore(db, RSTRING_PTR(vpath), ts, opts) ? Qtrue : Qfalse;
+}
+
+static VALUE mTokyoTyrant_setmst(VALUE vself, VALUE vhost, VALUE vport, VALUE vts, VALUE vopts){
+  uint64_t ts;
+  int opts;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  ts = (uint64_t) FIX2INT(vts);
+  opts = FIX2INT(vopts);
+  return tcrdbsetmst(db, RSTRING_PTR(vhost), FIX2INT(vport), ts, opts) ? Qtrue : Qfalse;
+}
+
+static VALUE mTokyoTyrant_rnum(VALUE vself){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  return LL2NUM(tcrdbrnum(db));
+}
+
+static VALUE mTokyoTyrant_empty(VALUE vself){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  return tcrdbrnum(db) < 1 ? Qtrue : Qfalse;
+}
+
+static VALUE mTokyoTyrant_size(VALUE vself){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  return LL2NUM(tcrdbsize(db));
+}
+
+static VALUE mTokyoTyrant_stat(VALUE vself){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  return rb_str_new2(tcrdbstat(db));
+}
+
+static VALUE mTokyoTyrant_misc(int argc, VALUE *argv, VALUE vself){
+  VALUE vname, vopts, vargs, vary;
+  TCLIST *list, *args;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  rb_scan_args(argc, argv, "13", &vname, &vopts, &vargs);
+
+  args = varytolist(vargs);
+  vname = StringValueEx(vname);
+
+  list = tcrdbmisc(db, RSTRING_PTR(vname), NUM2INT(vopts), args);
+  vary = listtovary(list);
+  tclistdel(list);
+  return vary;
+}
+
+static VALUE mTokyoTyrant_ext(VALUE vself, VALUE vext, VALUE vkey, VALUE vvalue){
+  int vsiz;
+  char *vbuf;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  vext = StringValueEx(vext);
+  vkey = StringValueEx(vkey);
+  vvalue = StringValueEx(vvalue);
+
+  if(!(vbuf = tcrdbext(db, RSTRING_PTR(vext), 0, RSTRING_PTR(vkey), RSTRING_LEN(vkey), RSTRING_PTR(vvalue), RSTRING_LEN(vvalue), &vsiz))){
+    return Qnil;
+  } else {
+    return rb_str_new(vbuf, vsiz);
+  }
+}
+
+static VALUE mTokyoTyrant_each_key(VALUE vself){
+  VALUE vrv;
+  char *kxstr;
+  if(rb_block_given_p() != Qtrue) rb_raise(rb_eArgError, "no block given");
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  vrv = Qnil;
+  tcrdbiterinit(db);
+  while((kxstr = tcrdbiternext2(db)) != NULL){
+    vrv = rb_yield_values(1, rb_str_new2(kxstr));
+  }
+  return vrv;
+}
+
+void init_mod(){
+  rb_define_const(mTokyoTyrant, "ESUCCESS", INT2NUM(TTESUCCESS));
+  rb_define_const(mTokyoTyrant, "EINVALID", INT2NUM(TTEINVALID));
+  rb_define_const(mTokyoTyrant, "ENOHOST", INT2NUM(TTENOHOST));
+  rb_define_const(mTokyoTyrant, "EREFUSED", INT2NUM(TTEREFUSED));
+  rb_define_const(mTokyoTyrant, "ESEND", INT2NUM(TTESEND));
+  rb_define_const(mTokyoTyrant, "ERECV", INT2NUM(TTERECV));
+  rb_define_const(mTokyoTyrant, "EKEEP", INT2NUM(TTEKEEP));
+  rb_define_const(mTokyoTyrant, "ENOREC", INT2NUM(TTENOREC));
+  rb_define_const(mTokyoTyrant, "EMISC", INT2NUM(TTEMISC));
+
+  rb_define_const(mTokyoTyrant, "ITLEXICAL", INT2NUM(RDBITLEXICAL));
+  rb_define_const(mTokyoTyrant, "ITDECIMAL", INT2NUM(RDBITDECIMAL));
+  rb_define_const(mTokyoTyrant, "ITVOID", INT2NUM(RDBITVOID));
+  rb_define_const(mTokyoTyrant, "ITKEEP", INT2NUM(RDBITKEEP));
+
+  rb_define_private_method(mTokyoTyrant, "initialize", mTokyoTyrant_initialize, -1);
+  rb_define_private_method(mTokyoTyrant, "connect", mTokyoTyrant_connect, 0);
+  rb_define_method(mTokyoTyrant, "reconnect", mTokyoTyrant_reconnect, 0);
+  rb_define_method(mTokyoTyrant, "server", mTokyoTyrant_server, 0);
+  rb_define_method(mTokyoTyrant, "close", mTokyoTyrant_close, 0);
+  rb_define_method(mTokyoTyrant, "errmsg", mTokyoTyrant_errmsg, -1);
+  rb_define_method(mTokyoTyrant, "ecode", mTokyoTyrant_ecode, 0);
+  rb_define_method(mTokyoTyrant, "out", mTokyoTyrant_out, 1);
+  rb_define_alias(mTokyoTyrant, "delete", "out");                 // Rufus Compat
+  rb_define_method(mTokyoTyrant, "outlist", mTokyoTyrant_outlist, -1);
+  rb_define_alias(mTokyoTyrant, "mdelete", "outlist");
+  rb_define_alias(mTokyoTyrant, "ldelete", "outlist");            // Rufus Compat
+  rb_define_method(mTokyoTyrant, "check", mTokyoTyrant_check, 1);
+  rb_define_alias(mTokyoTyrant, "has_key?", "check");
+  rb_define_alias(mTokyoTyrant, "key?", "check");
+  rb_define_alias(mTokyoTyrant, "include?", "check");
+  rb_define_alias(mTokyoTyrant, "member?", "check");
+  rb_define_method(mTokyoTyrant, "iterinit", mTokyoTyrant_iterinit, 0);
+  rb_define_method(mTokyoTyrant, "iternext", mTokyoTyrant_iternext, 0);
+  rb_define_method(mTokyoTyrant, "fwmkeys", mTokyoTyrant_fwmkeys, -1);
+  rb_define_method(mTokyoTyrant, "delete_keys_with_prefix", mTokyoTyrant_delete_keys_with_prefix, -1);// Rufus Compat
+  rb_define_alias(mTokyoTyrant, "dfwmkeys", "delete_keys_with_prefix");  
+  rb_define_method(mTokyoTyrant, "keys", mTokyoTyrant_keys, 0);
+  rb_define_method(mTokyoTyrant, "add_int", mTokyoTyrant_add_int, -1);
+  rb_define_alias(mTokyoTyrant, "addint", "add_int");
+  rb_define_alias(mTokyoTyrant, "increment", "add_int");
+  rb_define_method(mTokyoTyrant, "get_int", mTokyoTyrant_get_int, 1);
+  rb_define_method(mTokyoTyrant, "add_double", mTokyoTyrant_add_double, -1);
+  rb_define_alias(mTokyoTyrant, "adddouble", "add_double");
+  rb_define_method(mTokyoTyrant, "get_double", mTokyoTyrant_get_double, 1);
+  rb_define_method(mTokyoTyrant, "sync", mTokyoTyrant_sync, 0);
+  rb_define_method(mTokyoTyrant, "optimize", mTokyoTyrant_optimize, -1);
+  rb_define_method(mTokyoTyrant, "vanish", mTokyoTyrant_vanish, 0);
+  rb_define_alias(mTokyoTyrant, "clear", "vanish");
+  rb_define_method(mTokyoTyrant, "copy", mTokyoTyrant_copy, 1);
+  rb_define_method(mTokyoTyrant, "restore", mTokyoTyrant_restore, 2);
+  rb_define_method(mTokyoTyrant, "setmst", mTokyoTyrant_setmst, 2);
+  rb_define_method(mTokyoTyrant, "rnum", mTokyoTyrant_rnum, 0);
+  rb_define_alias(mTokyoTyrant, "count", "rnum");
+  rb_define_method(mTokyoTyrant, "empty?", mTokyoTyrant_empty, 0);
+  rb_define_alias(mTokyoTyrant, "size", "rnum");                    // Rufus Compat
+  rb_define_method(mTokyoTyrant, "db_size", mTokyoTyrant_size, 0);  // Rufus Compat
+  rb_define_alias(mTokyoTyrant, "length", "size");
+  rb_define_method(mTokyoTyrant, "stat", mTokyoTyrant_stat, 0);
+  rb_define_method(mTokyoTyrant, "misc", mTokyoTyrant_misc, -1);
+  rb_define_method(mTokyoTyrant, "ext", mTokyoTyrant_ext, 3);
+  rb_define_alias(mTokyoTyrant, "run", "ext");
+  rb_define_method(mTokyoTyrant, "each_key", mTokyoTyrant_each_key, 0);
+}

data/ext/tokyo_tyrant_module.h

@@ -0,0 +1,10 @@
+#ifndef RUBY_TOKYOTYRANT_MODULE
+#define RUBY_TOKYOTYRANT_MODULE
+
+#include <tokyo_tyrant.h>
+
+extern TCRDB *mTokyoTyrant_getdb(VALUE vself);
+extern void mTokyoTyrant_exception(VALUE vself);
+void init_mod();
+
+#endif

data/ext/tokyo_tyrant_query.c

@@ -0,0 +1,226 @@
+#include <tokyo_tyrant_query.h>
+
+static VALUE cQuery_initialize(VALUE vself, VALUE vrdb){
+  VALUE vqry;
+  TCRDB *db;
+  RDBQRY *qry;
+  Check_Type(vrdb, T_OBJECT);
+  vrdb = rb_iv_get(vrdb, RDBVNDATA);
+  Data_Get_Struct(vrdb, TCRDB, db);
+  qry = tcrdbqrynew(db);
+  vqry = Data_Wrap_Struct(rb_cObject, 0, tcrdbqrydel, qry);
+  rb_iv_set(vself, RDBQRYVNDATA, vqry);
+  rb_iv_set(vself, RDBVNDATA, vrdb);
+  return Qnil;
+}
+
+static VALUE cQuery_addcond(VALUE vself, VALUE vname, VALUE vop, VALUE vexpr){
+  VALUE vqry;
+  RDBQRY *qry;
+  vname = StringValueEx(vname);
+  vexpr = StringValueEx(vexpr);
+
+  if (TYPE(vop) == T_SYMBOL) vop = rb_str_new2(rb_id2name(SYM2ID(vop)));
+
+  if (TYPE(vop) == T_STRING){
+    vop = StringValueEx(vop);
+    vop = tctdbqrystrtocondop(RSTRING_PTR(vop));
+    vop = INT2NUM(vop);
+  }
+
+  vqry = rb_iv_get(vself, RDBQRYVNDATA);
+  Data_Get_Struct(vqry, RDBQRY, qry);
+  tcrdbqryaddcond(qry, RSTRING_PTR(vname), NUM2INT(vop), RSTRING_PTR(vexpr));
+  return vself;
+}
+
+static VALUE cQuery_setorder(int argc, VALUE *argv, VALUE vself){
+  VALUE vname, vtype;
+  int type;
+  VALUE vqry;
+  RDBQRY *qry;
+
+  rb_scan_args(argc, argv, "11", &vname, &vtype);
+  if(NIL_P(vtype)) vtype = INT2NUM(RDBQOSTRASC);
+
+  vname = StringValueEx(vname);
+
+  switch(TYPE(vtype)){
+    case T_SYMBOL:
+      vtype = rb_str_new2(rb_id2name(SYM2ID(vtype)));
+    case T_STRING:
+      vtype = StringValueEx(vtype);
+      type = tctdbqrystrtoordertype(RSTRING_PTR(vtype));
+      break;
+    case T_FIXNUM:
+      type = NUM2INT(vtype);
+      break;
+    default:
+      rb_raise(rb_eArgError, "type must be symbol, string or integer");
+      break;
+  }
+
+  vqry = rb_iv_get(vself, RDBQRYVNDATA);
+  Data_Get_Struct(vqry, RDBQRY, qry);
+  tcrdbqrysetorder(qry, RSTRING_PTR(vname), type);
+  return vself;
+}
+
+static VALUE cQuery_setlimit(int argc, VALUE *argv, VALUE vself){
+  VALUE vqry, vmax, vskip;
+  RDBQRY *qry;
+  vqry = rb_iv_get(vself, RDBQRYVNDATA);
+  Data_Get_Struct(vqry, RDBQRY, qry);
+  rb_scan_args(argc, argv, "11", &vmax, &vskip);
+  if(NIL_P(vskip)) vskip = INT2FIX(0);
+
+  tcrdbqrysetlimit(qry, NUM2INT(vmax), NUM2INT(vskip));
+  return vself;
+}
+
+static VALUE cQuery_search(VALUE vself){
+  VALUE vqry, vary;
+  RDBQRY *qry;
+  TCLIST *res;
+  vqry = rb_iv_get(vself, RDBQRYVNDATA);
+  Data_Get_Struct(vqry, RDBQRY, qry);
+  res = tcrdbqrysearch(qry);
+  vary = listtovary(res);
+  tclistdel(res);
+  return vary;
+}
+
+static VALUE cQuery_searchout(VALUE vself){
+  VALUE vqry;
+  RDBQRY *qry;
+  vqry = rb_iv_get(vself, RDBQRYVNDATA);
+  Data_Get_Struct(vqry, RDBQRY, qry);
+  return tcrdbqrysearchout(qry) ? Qtrue : Qfalse;
+}
+
+static VALUE cQuery_searchcount(VALUE vself){
+  VALUE vqry;
+  RDBQRY *qry;
+  vqry = rb_iv_get(vself, RDBQRYVNDATA);
+  Data_Get_Struct(vqry, RDBQRY, qry);
+  return LL2NUM(tcrdbqrysearchcount(qry));
+}
+
+static VALUE cQuery_get(VALUE vself){
+  int i, num, ksiz;
+  const char *name, *col;
+  VALUE vqry, vary, vcols, vpkey, vname;
+  RDBQRY *qry;
+  TCLIST *res;
+  TCMAP *cols;
+  vqry = rb_iv_get(vself, RDBQRYVNDATA);
+  Data_Get_Struct(vqry, RDBQRY, qry);
+
+  res = tcrdbqrysearchget(qry);
+  num = tclistnum(res);
+  vary = rb_ary_new2(num);
+  vpkey = rb_iv_get(vself, "@pkey");
+  if(vpkey == Qnil) vpkey = rb_str_new2("__id");
+  for(i = 0; i < num; i++){
+    vcols = rb_hash_new();
+    cols = tcrdbqryrescols(res, i);
+    if(cols){
+      tcmapiterinit(cols);
+      while((name = tcmapiternext(cols, &ksiz)) != NULL){
+        col = tcmapget2(cols, name);
+        vname = ksiz == 0 ? vpkey : rb_str_new2(name);
+        rb_hash_aset(vcols, vname, rb_str_new2(col));
+      }
+    }
+    tcmapdel(cols);
+    rb_ary_push(vary, vcols);
+  }
+  tclistdel(res);
+  return vary;
+}
+
+static VALUE cQuery_set_pkey(VALUE vself, VALUE vpkey) {
+  return rb_iv_set(vself, "@pkey", vpkey);
+}
+
+static VALUE cQuery_hint(VALUE vself){
+  VALUE vqry;
+  RDBQRY *qry;
+  vqry = rb_iv_get(vself, RDBQRYVNDATA);
+  Data_Get_Struct(vqry, RDBQRY, qry);
+  return rb_str_new2(tcrdbqryhint(qry));
+}
+
+static VALUE mQuery_parasearch(int argc, VALUE *argv, VALUE vself){
+  VALUE vqrys, vary, vcols;
+  TCMAP *cols;
+  int j, rsiz;
+
+  rb_scan_args(argc, argv, "*", &vqrys);
+
+  RDBQRY *qrys[argc];
+
+  for(j = 0; j < argc; j++){
+    VALUE vqry = rb_iv_get(rb_ary_entry(vqrys, j), RDBQRYVNDATA);
+    Data_Get_Struct(vqry, RDBQRY, qrys[j]);
+  }
+  TCLIST *res = tcrdbparasearch(qrys, argc);
+
+  rsiz = tclistnum(res);
+  vary = rb_ary_new2(rsiz);
+  for(j = 0; j < rsiz; j++){
+    cols = tcrdbqryrescols(res, j);
+    vcols = maptovhash(cols);
+    tcmapdel(cols);
+    rb_ary_push(vary, vcols);
+  }
+  tclistdel(res);
+
+  return vary;
+}
+
+void init_query(){
+  rb_define_const(cQuery, "CSTREQ", INT2NUM(RDBQCSTREQ));
+  rb_define_const(cQuery, "CSTRINC", INT2NUM(RDBQCSTRINC));
+  rb_define_const(cQuery, "CSTRBW", INT2NUM(RDBQCSTRBW));
+  rb_define_const(cQuery, "CSTREW", INT2NUM(RDBQCSTREW));
+  rb_define_const(cQuery, "CSTRAND", INT2NUM(RDBQCSTRAND));
+  rb_define_const(cQuery, "CSTROR", INT2NUM(RDBQCSTROR));
+  rb_define_const(cQuery, "CSTROREQ", INT2NUM(RDBQCSTROREQ));
+  rb_define_const(cQuery, "CSTRRX", INT2NUM(RDBQCSTRRX));
+  rb_define_const(cQuery, "CNUMEQ", INT2NUM(RDBQCNUMEQ));
+  rb_define_const(cQuery, "CNUMGT", INT2NUM(RDBQCNUMGT));
+  rb_define_const(cQuery, "CNUMGE", INT2NUM(RDBQCNUMGE));
+  rb_define_const(cQuery, "CNUMLT", INT2NUM(RDBQCNUMLT));
+  rb_define_const(cQuery, "CNUMLE", INT2NUM(RDBQCNUMLE));
+  rb_define_const(cQuery, "CNUMBT", INT2NUM(RDBQCNUMBT));
+  rb_define_const(cQuery, "CNUMOREQ", INT2NUM(RDBQCNUMOREQ));
+  rb_define_const(cQuery, "CNEGATE", INT2NUM(RDBQCNEGATE));
+  rb_define_const(cQuery, "CNOIDX", INT2NUM(RDBQCNOIDX));
+  rb_define_const(cQuery, "OSTRASC", INT2NUM(RDBQOSTRASC));
+  rb_define_const(cQuery, "OSTRDESC", INT2NUM(RDBQOSTRDESC));
+  rb_define_const(cQuery, "ONUMASC", INT2NUM(RDBQONUMASC));
+  rb_define_const(cQuery, "ONUMDESC", INT2NUM(RDBQONUMDESC));
+
+  rb_define_private_method(cQuery, "initialize", cQuery_initialize, 1);
+  rb_define_method(cQuery, "addcond", cQuery_addcond, 3);
+  rb_define_alias(cQuery, "add_condition", "addcond");
+  rb_define_alias(cQuery, "condition", "addcond");
+  rb_define_alias(cQuery, "add", "addcond");                    // Rufus Compat
+  rb_define_method(cQuery, "setorder", cQuery_setorder, -1);
+  rb_define_alias(cQuery, "order_by", "setorder");              // Rufus Compat
+  rb_define_method(cQuery, "setlimit", cQuery_setlimit, -1);
+  rb_define_alias(cQuery, "setmax", "setlimit");                 // Rufus Compat
+  rb_define_alias(cQuery, "limit", "setlimit");                 // Rufus Compat
+  rb_define_method(cQuery, "search", cQuery_search, 0);
+  rb_define_alias(cQuery, "run", "search");
+  rb_define_method(cQuery, "searchout", cQuery_searchout, 0);
+  rb_define_alias(cQuery, "delete", "searchout");               // Rufus Compat
+  rb_define_method(cQuery, "searchcount", cQuery_searchcount, 0);
+  rb_define_alias(cQuery, "count", "searchcount");              // Rufus Compat
+  rb_define_method(cQuery, "get", cQuery_get, 0);
+  rb_define_method(cQuery, "set_pkey", cQuery_set_pkey, 1);
+  rb_define_alias(cQuery, "pkey=", "set_pkey");
+  rb_define_method(cQuery, "hint", cQuery_hint, 0);
+  rb_define_module_function(cQuery, "parallel_search", mQuery_parasearch, -1);
+}

data/ext/tokyo_tyrant_query.h

@@ -0,0 +1,9 @@
+#ifndef RUBY_TOKYOTYRANT_QUERY
+#define RUBY_TOKYOTYRANT_QUERY
+
+#include <tokyo_tyrant.h>
+#include <ctype.h>
+
+void init_query();
+
+#endif