ruby-tokyotyrant 0.3.0

data/ext/extconf.rb

@@ -0,0 +1,39 @@
+# ENV["RC_ARCHS"] = `uname -m`.chomp if `uname -sr` =~ /^Darwin/
+#
+# require 'mkmf'
+#
+
+if RUBY_PLATFORM =~ /darwin/
+  ENV["RC_ARCHS"] = `uname -m`.chomp if `uname -sr` =~ /^Darwin/
+
+  # On PowerPC the defaults are fine
+  ENV["RC_ARCHS"] = '' if `uname -m` =~ /^Power Macintosh/
+end
+
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'tokyo_tyrant'
+
+dir_config("tokyo_tyrant")
+
+# NOTE: use GCC flags unless Visual C compiler is used
+$CFLAGS << ' -Wall ' unless RUBY_PLATFORM =~ /mswin/
+
+if RUBY_VERSION < '1.8.6'
+  $CFLAGS << ' -DRUBY_LESS_THAN_186'
+end
+
+# Do the work
+
+find_library(*['tokyotyrant', "tcrdbnew", dir_config('libtokyotyrant').last].compact) or
+  raise "shared library 'libtokyotyrant' not found"
+
+['tctdb.h',
+ 'tcrdb.h'].each do |header|
+  find_header(*[header, dir_config('libtokyotyrant').first].compact) or
+    raise "header file '#{header}' not  found"
+end
+
+create_makefile 'tokyo_tyrant'

data/ext/tokyo_tyrant.c

@@ -0,0 +1,147 @@
+#include <tokyo_tyrant.h>
+
+extern VALUE StringRaw(const char *buf, int bsiz){
+  VALUE vval;
+  int i;
+  vval = rb_str_buf_new2("");
+  char s[5];
+
+  for(i=0;i<bsiz;i++){
+    char c = *buf++;
+    s[0] = c;
+    rb_str_buf_cat(vval, s, 1);
+  }
+//    buf -= bsiz;
+//    rb_str_buf_cat2(vval, "");
+  return vval;
+}
+
+extern VALUE StringValueEx(VALUE vobj){
+  if (rb_respond_to(vobj, rb_intern("to_tokyo_tyrant"))) {
+    return rb_convert_type(vobj, T_STRING, "String", "to_tokyo_tyrant");
+  } else if (rb_respond_to(vobj, rb_intern("to_s"))) {
+    return rb_convert_type(vobj, T_STRING, "String", "to_s");
+  } else {
+    rb_raise(rb_eArgError, "can't stringify object");
+  }
+  return StringValue(vobj);
+}
+
+extern TCLIST *varytolist(VALUE vary){
+  VALUE vval;
+  TCLIST *list;
+  int i, num;
+  num = RARRAY_LEN(vary);
+  list = tclistnew2(num);
+  for(i = 0; i < num; i++){
+    vval = rb_ary_entry(vary, i);
+    vval = StringValueEx(vval);
+    tclistpush(list, RSTRING_PTR(vval), RSTRING_LEN(vval));
+  }
+  return list;
+}
+
+extern VALUE listtovary(TCLIST *list){
+  VALUE vary;
+  const char *vbuf;
+  int i, num, vsiz;
+  num = tclistnum(list);
+  vary = rb_ary_new2(num);
+  for(i = 0; i < num; i++){
+    vbuf = tclistval(list, i, &vsiz);
+    rb_ary_push(vary, rb_str_new(vbuf, vsiz));
+  }
+  return vary;
+}
+
+extern TCMAP *vhashtomap(VALUE vhash){
+  VALUE vkeys, vkey, vval;
+  TCMAP *map;
+  int i, num;
+  map = tcmapnew2(31);
+  vkeys = rb_funcall(vhash, rb_intern("keys"), 0);
+  num = RARRAY_LEN(vkeys);
+  for(i = 0; i < num; i++){
+    vkey = rb_ary_entry(vkeys, i);
+    vval = rb_hash_aref(vhash, vkey);
+    vkey = StringValueEx(vkey);
+    vval = StringValueEx(vval);
+    tcmapput(map, RSTRING_PTR(vkey), RSTRING_LEN(vkey), RSTRING_PTR(vval), RSTRING_LEN(vval));
+  }
+  return map;
+}
+
+extern VALUE maptovhash(TCMAP *map){
+  const char *kbuf;
+  int ksiz, vsiz;
+  VALUE vhash;
+  vhash = rb_hash_new();
+  tcmapiterinit(map);
+  while((kbuf = tcmapiternext(map, &ksiz)) != NULL){
+    const char *vbuf = tcmapiterval(kbuf, &vsiz);
+    rb_hash_aset(vhash, rb_str_new(kbuf, ksiz), StringRaw(vbuf, vsiz));
+  }
+  return vhash;
+}
+
+extern TCMAP *varytomap(VALUE vary){
+  int i;
+  TCLIST *keys;
+  TCMAP *recs = tcmapnew();
+  keys = varytolist(vary);
+  for(i = 0; i < tclistnum(keys); i++){
+    int ksiz;
+    const char *kbuf = tclistval(keys, i, &ksiz);
+    tcmapput(recs, kbuf, ksiz, "", 0);
+  }
+  tclistdel(keys);
+  return recs;
+}
+
+extern TCLIST *vhashtolist(VALUE vhash){
+  /*
+  Seems like something like this might work just as well
+  vary = rb_hash_to_a(vhash);
+  vary = rb_ary_flatten(vary);
+  args = varytolist(vary);
+  */
+
+  VALUE vkeys, vkey, vval;
+  TCLIST *list;
+  int i, num;
+  vkeys = rb_funcall(vhash, rb_intern("keys"), 0);
+  num = RARRAY_LEN(vkeys);
+  list = tclistnew2(num);
+  for(i = 0; i < num; i++){
+    vkey = rb_ary_entry(vkeys, i);
+    vval = rb_hash_aref(vhash, vkey);
+    vkey = StringValueEx(vkey);
+    vval = StringValueEx(vval);
+    tclistpush(list, RSTRING_PTR(vkey), RSTRING_LEN(vkey));
+    tclistpush(list, RSTRING_PTR(vval), RSTRING_LEN(vval));
+  }
+  return list;
+}
+
+VALUE mTokyoTyrant;
+VALUE eTokyoTyrantError;
+VALUE cDB;
+VALUE cTable;
+VALUE cQuery;
+
+void Init_tokyo_tyrant(){
+  mTokyoTyrant = rb_define_module("TokyoTyrant");
+  eTokyoTyrantError = rb_define_class("TokyoTyrantError", rb_eStandardError);
+  init_mod();
+
+  cDB = rb_define_class_under(mTokyoTyrant, "DB", rb_cObject);
+  rb_include_module(cDB, mTokyoTyrant);
+  init_db();
+
+  cTable = rb_define_class_under(mTokyoTyrant, "Table", rb_cObject);
+  rb_include_module(cTable, mTokyoTyrant);
+  init_table();
+
+  cQuery = rb_define_class_under(mTokyoTyrant, "Query", rb_cObject);
+  init_query();
+}

data/ext/tokyo_tyrant.h

@@ -0,0 +1,48 @@
+#ifndef RUBY_TOKYOTYRANT
+#define RUBY_TOKYOTYRANT
+
+#include <ruby.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#include <locale.h>
+#include <tcrdb.h>
+#include <tokyo_tyrant_module.h>
+#include <tokyo_tyrant_db.h>
+#include <tokyo_tyrant_table.h>
+#include <tokyo_tyrant_query.h>
+
+#define RDBVNDATA "@rdb"
+#define RDBQRYVNDATA "@rdbquery"
+#define NUMBUFSIZ 32
+#define TTPUT      0
+#define TTPUTKEEP  1
+#define TTPUTCAT   2
+#define TTPUTNR    3
+
+#if !defined(RSTRING_PTR)
+#define RSTRING_PTR(TC_s) (RSTRING(TC_s)->ptr)
+#endif
+#if !defined(RSTRING_LEN)
+#define RSTRING_LEN(TC_s) (RSTRING(TC_s)->len)
+#endif
+#if !defined(RARRAY_LEN)
+#define RARRAY_LEN(TC_a) (RARRAY(TC_a)->len)
+#endif
+
+extern VALUE mTokyoTyrant;
+extern VALUE eTokyoTyrantError;
+extern VALUE cDB;
+extern VALUE cTable;
+extern VALUE cQuery;
+
+extern VALUE StringRaw(const char *buf, int bsiz);
+extern VALUE StringValueEx(VALUE vobj);
+extern TCLIST *varytolist(VALUE vary);
+extern VALUE listtovary(TCLIST *list);
+extern TCMAP *vhashtomap(VALUE vhash);
+extern VALUE maptovhash(TCMAP *map);
+extern TCMAP *varytomap(VALUE vhash);
+extern TCLIST *vhashtolist(VALUE vhash);
+
+#endif

data/ext/tokyo_tyrant_db.c

@@ -0,0 +1,227 @@
+#include <tokyo_tyrant_db.h>
+
+static VALUE cDB_put_method(VALUE vself, VALUE vkey, VALUE vstr, int method){
+  bool res;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  vkey = StringValueEx(vkey);
+  vstr = StringValueEx(vstr);
+
+  switch(method){
+    case TTPUT:
+      res = tcrdbput(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey), RSTRING_PTR(vstr), RSTRING_LEN(vstr));
+      break;
+    case TTPUTKEEP:
+      res = tcrdbputkeep(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey), RSTRING_PTR(vstr), RSTRING_LEN(vstr));
+      break;
+    case TTPUTCAT:
+      res = tcrdbputcat(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey), RSTRING_PTR(vstr), RSTRING_LEN(vstr));
+      break;
+    case TTPUTNR:
+      res = tcrdbputnr(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey), RSTRING_PTR(vstr), RSTRING_LEN(vstr));
+      break;
+    default:
+      res = false;
+      break;
+  }
+
+  if(!res) mTokyoTyrant_exception(vself);
+
+  return Qtrue;
+}
+
+static VALUE cDB_put(VALUE vself, VALUE vkey, VALUE vstr){
+  return cDB_put_method(vself, vkey, vstr, TTPUT);
+}
+
+static VALUE cDB_mput(VALUE vself, VALUE vhash){
+  VALUE vary;
+  TCLIST *list, *args;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  args = vhashtolist(vhash);
+  list = tcrdbmisc(db, "putlist", 0, args);
+  vary = listtovary(list);
+  tclistdel(args);
+  tclistdel(list);
+  return vary;
+}
+
+static VALUE cDB_putkeep(VALUE vself, VALUE vkey, VALUE vstr){
+  return cDB_put_method(vself, vkey, vstr, TTPUTKEEP);  
+}
+
+static VALUE cDB_putcat(VALUE vself, VALUE vkey, VALUE vstr){
+  return cDB_put_method(vself, vkey, vstr, TTPUTCAT);
+}
+
+static VALUE cDB_putnr(VALUE vself, VALUE vkey, VALUE vstr){
+  return cDB_put_method(vself, vkey, vstr, TTPUTNR);
+}
+
+static VALUE cDB_putshl(VALUE vself, VALUE vkey, VALUE vstr, VALUE vwidth){
+  bool res;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  vkey = StringValueEx(vkey);
+  vstr = StringValueEx(vstr);
+
+  res = tcrdbputshl(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey), RSTRING_PTR(vstr), RSTRING_LEN(vstr), FIXNUM_P(vwidth));
+
+  if(!res) mTokyoTyrant_exception(vself);
+
+  return Qtrue;
+}
+
+static VALUE cDB_get(VALUE vself, VALUE vkey){
+  VALUE vval;
+  char *buf;
+  int bsiz, ecode;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  // this is ugly
+  vkey = StringValueEx(vkey);
+  if(!(buf = tcrdbget(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey), &bsiz))){
+    if ((ecode = tcrdbecode(db))) {
+      if (ecode != TTENOREC) mTokyoTyrant_exception(vself);
+    }
+    return Qnil;
+  } else {
+    vval = StringRaw(buf, bsiz);
+  }
+
+  tcfree(buf);
+  return vval;
+}
+
+static VALUE cDB_mget(int argc, VALUE *argv, VALUE vself){
+  VALUE vkeys, vhash, vvalue;
+  TCMAP *recs;
+  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_STRUCT: // range is not a T_STRUCT instead of a T_OBJECT in ruby1.9?
+      case T_OBJECT:
+        vkeys = rb_convert_type(vvalue, T_ARRAY, "Array", "to_a");
+        break;
+    }
+  }
+
+  Check_Type(vkeys, T_ARRAY);
+
+  recs = varytomap(vkeys);
+  if(!tcrdbget3(db, recs)) return Qnil;
+  vhash = maptovhash(recs);
+  tcmapdel(recs);
+  return vhash;
+}
+
+static VALUE cDB_vsiz(VALUE vself, VALUE vkey){
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+
+  vkey = StringValueEx(vkey);
+  return INT2NUM(tcrdbvsiz(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey)));
+}
+
+static VALUE cDB_fetch(int argc, VALUE *argv, VALUE vself){
+  VALUE vkey, vrv, vforce;
+  rb_scan_args(argc, argv, "11", &vkey, &vforce);
+  if(rb_block_given_p() != Qtrue) rb_raise(rb_eArgError, "no block given");
+  if(vforce == Qnil) vforce = Qfalse;
+
+  if(vforce != Qfalse || (vrv = cDB_get(vself, vkey)) == Qnil){
+    vrv = rb_yield(vkey);
+    cDB_put(vself, vkey, vrv);
+  }
+  return vrv;
+}
+
+static VALUE cDB_each(VALUE vself){
+  VALUE vrv;
+  if(rb_block_given_p() != Qtrue) rb_raise(rb_eArgError, "no block given");
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  vrv = Qnil;
+  tcrdbiterinit(db);
+  int ksiz;
+  char *kbuf;
+  while((kbuf = tcrdbiternext(db, &ksiz)) != NULL){
+    int vsiz;
+    char *vbuf = tcrdbget(db, kbuf, ksiz, &vsiz);
+    vrv = rb_yield_values(2, rb_str_new2(kbuf), StringRaw(vbuf, vsiz));
+    tcfree(vbuf);
+    tcfree(kbuf);
+  }
+  return vrv;
+}
+
+static VALUE cDB_each_value(VALUE vself){
+  VALUE vrv;
+  if(rb_block_given_p() != Qtrue) rb_raise(rb_eArgError, "no block given");
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  vrv = Qnil;
+  tcrdbiterinit(db);
+  int ksiz;
+  char *kbuf;
+  while((kbuf = tcrdbiternext(db, &ksiz)) != NULL){
+    int vsiz;
+    char *vbuf = tcrdbget(db, kbuf, ksiz, &vsiz);
+    vrv = rb_yield_values(1, StringRaw(vbuf, vsiz));
+    tcfree(vbuf);
+    tcfree(kbuf);
+  }
+  return vrv;
+}
+
+static VALUE cDB_values(VALUE vself){
+  VALUE vary;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
+  vary = rb_ary_new2(tcrdbrnum(db));
+  tcrdbiterinit(db);
+  int ksiz;
+  char *kbuf;
+  while((kbuf = tcrdbiternext(db, &ksiz)) != NULL){
+    int vsiz;
+    char *vbuf = tcrdbget(db, kbuf, ksiz, &vsiz);
+    rb_ary_push(vary, StringRaw(vbuf, vsiz));
+    tcfree(vbuf);
+    tcfree(kbuf);
+  }
+  return vary;
+}
+
+void init_db(){
+  rb_define_method(cDB, "mput", cDB_mput, 1);
+  rb_define_alias(cDB, "lput", "mput");       // Rufus Compat
+  rb_define_method(cDB, "put", cDB_put, 2);
+  rb_define_alias(cDB, "[]=", "put");
+  rb_define_method(cDB, "putkeep", cDB_putkeep, 2);
+  rb_define_method(cDB, "putcat", cDB_putcat, 2);
+  rb_define_method(cDB, "putshl", cDB_putshl, 3);
+  rb_define_method(cDB, "putnr", cDB_putnr, 2);
+  rb_define_method(cDB, "get", cDB_get, 1);
+  rb_define_alias(cDB, "[]", "get");
+  rb_define_method(cDB, "mget", cDB_mget, -1);
+  rb_define_alias(cDB, "lget", "mget");       // Rufus Compat
+  rb_define_method(cDB, "vsiz", cDB_vsiz, 1);
+  /*
+  rb_define_method(cDB, "check_value", cDB_check_value, 1);
+  rb_define_alias(cDB, "has_value?", "check_value");
+  rb_define_alias(cDB, "value?", "check_value");
+  */
+
+  rb_define_method(cDB, "fetch", cDB_fetch, -1);
+  rb_define_method(cDB, "each", cDB_each, 0);
+  rb_define_alias(cDB, "each_pair", "each");
+  rb_define_method(cDB, "each_value", cDB_each_value, 0);
+  rb_define_method(cDB, "values", cDB_values, 0);
+}

data/ext/tokyo_tyrant_db.h

@@ -0,0 +1,8 @@
+#ifndef RUBY_TOKYOTYRANT_DB
+#define RUBY_TOKYOTYRANT_DB
+
+#include <tokyo_tyrant.h>
+
+void init_db();
+
+#endif