actsasflinn-ruby-tokyotyrant 0.1.8 → 0.1.9

data/ext/tokyo_tyrant_module.h

@@ -3,6 +3,8 @@
 
 #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

@@ -108,8 +108,8 @@ static VALUE cQuery_searchcount(VALUE vself){
 
 static VALUE cQuery_get(VALUE vself){
   int i, num, ksiz;
-  const char *name, *col, *pkey;
-  VALUE vqry, vary, vcols, vpkey;
+  const char *name, *col;
+  VALUE vqry, vary, vcols, vpkey, vname;
   RDBQRY *qry;
   TCLIST *res;
   TCMAP *cols;
@@ -120,7 +120,7 @@ static VALUE cQuery_get(VALUE vself){
   num = tclistnum(res);
   vary = rb_ary_new2(num);
   vpkey = rb_iv_get(vself, "@pkey");
-  pkey = vpkey == Qnil ? "__id" : STR2CSTR(StringValueEx(vpkey));
+  if(vpkey == Qnil) vpkey = rb_str_new2("__id");
   for(i = 0; i < num; i++){
     vcols = rb_hash_new();
     cols = tcrdbqryrescols(res, i);
@@ -128,8 +128,8 @@ static VALUE cQuery_get(VALUE vself){
       tcmapiterinit(cols);
       while((name = tcmapiternext(cols, &ksiz)) != NULL){
         col = tcmapget2(cols, name);
-        if (ksiz == 0) name = pkey;
-        rb_hash_aset(vcols, ID2SYM(rb_intern(name)), rb_str_new2(col));
+        vname = ksiz == 0 ? vpkey : rb_str_new2(name);
+        rb_hash_aset(vcols, vname, rb_str_new2(col));
       }
     }
     tcmapdel(cols);

data/ext/tokyo_tyrant_table.c

@@ -1,11 +1,9 @@
 #include <tokyo_tyrant_table.h>
 
 static VALUE cTable_put_method(VALUE vself, VALUE vkey, VALUE vcols, int method){
-  int ecode;
   bool res;
   TCMAP *cols;
-  TCRDB *db;
-  Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db);
+  TCRDB *db = mTokyoTyrant_getdb(vself);
 
   vkey = StringValueEx(vkey);
   Check_Type(vcols, T_HASH);
@@ -27,12 +25,8 @@ static VALUE cTable_put_method(VALUE vself, VALUE vkey, VALUE vcols, int method)
       break;
   }
 
-  if(!res){
-    ecode = tcrdbecode(db);
-    rb_raise(eTokyoTyrantError, "put error: %s\n", tcrdberrmsg(ecode));
-  }
+  if(!res) mTokyoTyrant_exception(vself);
   tcmapdel(cols);
-
   return Qtrue;
 }
 
@@ -43,9 +37,8 @@ static VALUE cTable_put(VALUE vself, VALUE vkey, VALUE vcols){
 static VALUE cTable_mput(VALUE vself, VALUE vhash){
   int i, num, j;
   VALUE vary, vkeys, vkey, vval;
-  TCRDB *db;
   TCLIST *list, *result;
-  Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db);
+  TCRDB *db = mTokyoTyrant_getdb(vself);
 
   vkeys = rb_funcall(vhash, rb_intern("keys"), 0);
   num = RARRAY_LEN(vkeys);
@@ -86,8 +79,7 @@ static VALUE cTable_putcat(VALUE vself, VALUE vkey, VALUE vcols){
 }
 
 static VALUE cTable_out(VALUE vself, VALUE vkey){
-  TCRDB *db;
-  Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db);
+  TCRDB *db = mTokyoTyrant_getdb(vself);
   vkey = StringValueEx(vkey);
 
   return tcrdbtblout(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey)) ? Qtrue : Qfalse;
@@ -96,20 +88,17 @@ static VALUE cTable_out(VALUE vself, VALUE vkey){
 static VALUE cTable_get(VALUE vself, VALUE vkey){
   VALUE vcols;
   int ecode;
-  TCRDB *db;
   TCMAP *cols;
-  Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db);
+  TCRDB *db = mTokyoTyrant_getdb(vself);
 
   vkey = StringValueEx(vkey);
   if(!(cols = tcrdbtblget(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey)))){
     if ((ecode = tcrdbecode(db))) {
-      if (ecode != TTENOREC) {
-        rb_raise(eTokyoTyrantError, "get error: %s", tcrdberrmsg(ecode));
-      }
+      if (ecode != TTENOREC) mTokyoTyrant_exception(vself);
     }
     return Qnil;
   } else {
-    vcols = maptovhashsym(cols);
+    vcols = maptovhash(cols);
   }
 
   tcmapdel(cols);
@@ -120,9 +109,8 @@ static VALUE cTable_mget(int argc, VALUE *argv, VALUE vself){
   const char *kbuf;
   int ksiz, vsiz;
   VALUE vkeys, vhash, vcols, vvalue;
-  TCRDB *db;
   TCMAP *recs, *cols;
-  Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db);
+  TCRDB *db = mTokyoTyrant_getdb(vself);
   rb_scan_args(argc, argv, "*", &vkeys);
 
   // I really hope there is a better way to do this
@@ -135,6 +123,7 @@ static VALUE cTable_mget(int argc, VALUE *argv, VALUE vself){
       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;
@@ -149,7 +138,7 @@ static VALUE cTable_mget(int argc, VALUE *argv, VALUE vself){
   while((kbuf = tcmapiternext(recs, &ksiz)) != NULL){
     const char *vbuf = tcmapiterval(kbuf, &vsiz);
     cols = tcstrsplit4(vbuf, vsiz);
-    vcols = maptovhashsym(cols);
+    vcols = maptovhash(cols);
     tcmapdel(cols);
     rb_hash_aset(vhash, StringRaw(kbuf, ksiz), vcols);
   }
@@ -158,8 +147,7 @@ static VALUE cTable_mget(int argc, VALUE *argv, VALUE vself){
 }
 
 static VALUE cTable_setindex(VALUE vself, VALUE vname, VALUE vtype){
-  TCRDB *db;
-  Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db);
+  TCRDB *db = mTokyoTyrant_getdb(vself);
   vname = StringValueEx(vname);
   if (TYPE(vtype) == T_SYMBOL) vtype = rb_str_new2(rb_id2name(SYM2ID(vtype)));
 
@@ -173,20 +161,18 @@ static VALUE cTable_setindex(VALUE vself, VALUE vname, VALUE vtype){
 }
 
 static VALUE cTable_genuid(VALUE vself){
-  TCRDB *db;
-  Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db);
+  TCRDB *db = mTokyoTyrant_getdb(vself);
   return LL2NUM(tcrdbtblgenuid(db));
 }
 
 static VALUE cTable_fetch(int argc, VALUE *argv, VALUE vself){
   VALUE vkey, vdef, vval;
-  TCRDB *db;
   TCMAP *cols;
+  TCRDB *db = mTokyoTyrant_getdb(vself);
   rb_scan_args(argc, argv, "11", &vkey, &vdef);
   vkey = StringValueEx(vkey);
-  Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db);
   if((cols = tcrdbtblget(db, RSTRING_PTR(vkey), RSTRING_LEN(vkey))) != NULL){
-    vval = maptovhashsym(cols);
+    vval = maptovhash(cols);
     tcmapdel(cols);
   } else {
     vval = vdef;
@@ -196,17 +182,16 @@ static VALUE cTable_fetch(int argc, VALUE *argv, VALUE vself){
 
 static VALUE cTable_each(VALUE vself){
   VALUE vrv;
-  TCRDB *db;
   TCMAP *cols;
   char *kbuf;
   int ksiz;
   if(rb_block_given_p() != Qtrue) rb_raise(rb_eArgError, "no block given");
-  Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db);
+  TCRDB *db = mTokyoTyrant_getdb(vself);
   vrv = Qnil;
   tcrdbiterinit(db);
   while((kbuf = tcrdbiternext(db, &ksiz)) != NULL){
     if((cols = tcrdbtblget(db, kbuf, ksiz)) != NULL){
-      vrv = rb_yield_values(2, rb_str_new(kbuf, ksiz), maptovhashsym(cols));
+      vrv = rb_yield_values(2, rb_str_new(kbuf, ksiz), maptovhash(cols));
       tcmapdel(cols);
     } else {
       vrv = rb_yield_values(2, rb_str_new(kbuf, ksiz), Qnil);
@@ -218,17 +203,16 @@ static VALUE cTable_each(VALUE vself){
 
 static VALUE cTable_each_value(VALUE vself){
   VALUE vrv;
-  TCRDB *db;
   TCMAP *cols;
   char *kbuf;
   int ksiz;
   if(rb_block_given_p() != Qtrue) rb_raise(rb_eArgError, "no block given");
-  Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db);
+  TCRDB *db = mTokyoTyrant_getdb(vself);
   vrv = Qnil;
   tcrdbiterinit(db);
   while((kbuf = tcrdbiternext(db, &ksiz)) != NULL){
     if((cols = tcrdbtblget(db, kbuf, ksiz)) != NULL){
-      vrv = rb_yield(maptovhashsym(cols));
+      vrv = rb_yield(maptovhash(cols));
       tcmapdel(cols);
     } else {
       vrv = rb_yield(Qnil);
@@ -240,16 +224,15 @@ static VALUE cTable_each_value(VALUE vself){
 
 static VALUE cTable_values(VALUE vself){
   VALUE vary;
-  TCRDB *db;
   TCMAP *cols;
   char *kxstr;
   int ksiz;
-  Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db);
+  TCRDB *db = mTokyoTyrant_getdb(vself);
   vary = rb_ary_new2(tcrdbrnum(db));
   tcrdbiterinit(db);
   while((kxstr = tcrdbiternext(db, &ksiz)) != NULL){
     cols = tcrdbtblget(db, kxstr, ksiz);
-    rb_ary_push(vary, maptovhashsym(cols));
+    rb_ary_push(vary, maptovhash(cols));
     tcmapdel(cols);
     tcfree(kxstr);
   }

data/spec/ext.lua

@@ -0,0 +1,4 @@
+-- echo back the key and the value
+function echo(key, value)
+   return key .. "\t" .. value
+end

data/spec/start_tyrants.sh

@@ -5,6 +5,7 @@
 #
 
 TMP=`pwd`/tmp
+SPEC=`pwd`/spec
   # so that tt doesn't complain about relative paths...
 
 [ -d $TMP ] || mkdir $TMP
@@ -14,6 +15,7 @@ ttserver \
   -port 45000 \
   -pid $TMP/t_spec.pid -rts $TMP/t_spec.rts \
   -log $TMP/t.log \
+  -ext $SPEC/ext.lua \
   $TMP/tyrant.tch
 
 ttserver \
@@ -21,5 +23,6 @@ ttserver \
   -port 45001 \
   -pid $TMP/tt_spec.pid -rts $TMP/tt_spec.rts \
   -log $TMP/tt.log \
+  -ext $SPEC/ext.lua \
   $TMP/tyrant_table.tct
 

data/spec/tokyo_tyrant_query_spec.rb

@@ -28,8 +28,8 @@ describe TokyoTyrant::Query, "with an open database" do
 
   it "should get ordered keys for search conditions with default order" do
     q = @db.query
-    q.addcond(:type, :streq, 'Spinach')
-    q.setorder(:variety)
+    q.addcond('type', :streq, 'Spinach')
+    q.setorder('variety')
     q.search.should == ["3332", "34173"]
   end
 
@@ -66,29 +66,29 @@ describe TokyoTyrant::Query, "with an open database" do
   it "should get records for search conditions" do
     q = @db.query
     q.addcond('type', :streq, 'Garlic')
-    res = q.get.sort{ |x,y| x[:variety] <=> y[:variety] }
-    res.should == [{ :__id => "4609", :variety => "Elephant", :code => "4609", :type => "Garlic" },
-                   { :__id => "3401", :variety => "One-clove types", :code => "3401", :type => "Garlic" },
-                   { :__id => "3052", :variety => "String", :code => "3052", :type => "Garlic" }]
+    res = q.get.sort{ |x,y| x['variety'] <=> y['variety'] }
+    res.should == [{ '__id' => "4609", 'variety' => "Elephant", 'code' => "4609", 'type' => "Garlic" },
+                   { '__id' => "3401", 'variety' => "One-clove types", 'code' => "3401", 'type' => "Garlic" },
+                   { '__id' => "3052", 'variety' => "String", 'code' => "3052", 'type' => "Garlic" }]
   end
 
   it "should remove records for conditions" do
     q = @db.query
-    q.addcond(:type, :streq, 'Orange')
+    q.addcond('type', :streq, 'Orange')
     q.search.size.should == 11
     q.searchout.should.be.true
     q.search.size.should == 0
   end
 
   it "should chain search options" do
-    res = @db.query.condition(:type, :streq, 'Cucumber').order_by(:variety, :strdesc).limit(3).search
+    res = @db.query.condition('type', :streq, 'Cucumber').order_by('variety', :strdesc).limit(3).search
     res.should == ["4596", "4595", "4594"]
   end
 
   it "should query with a block" do
     res = @db.query do |q|
-      q.condition(:type, :streq, 'Cucumber')
-      q.order_by(:variety, :strdesc)
+      q.condition('type', :streq, 'Cucumber')
+      q.order_by('variety', :strdesc)
       q.limit(3)
     end
     res.should == ["4596", "4595", "4594"]
@@ -96,28 +96,28 @@ describe TokyoTyrant::Query, "with an open database" do
 
   it "should find with a block" do
     res = @db.find do |q|
-      q.condition(:type, :streq, 'Cucumber')
-      q.order_by(:variety, :strdesc)
+      q.condition('type', :streq, 'Cucumber')
+      q.order_by('variety', :strdesc)
       q.limit(3)
     end
-    res.should == [{:type=>"Cucumber", :variety=>"Pickling / Gherkin", :__id=>"4596", :code=>"4596"},
-                   {:type=>"Cucumber", :variety=>"Lemon", :__id=>"4595", :code=>"4595"},
-                   {:type=>"Cucumber", :variety=>"Japanese / White", :__id=>"4594", :code=>"4594"}]
+    res.should == [{'type'=>"Cucumber", 'variety'=>"Pickling / Gherkin", '__id'=>"4596", 'code'=>"4596"},
+                   {'type'=>"Cucumber", 'variety'=>"Lemon", '__id'=>"4595", 'code'=>"4595"},
+                   {'type'=>"Cucumber", 'variety'=>"Japanese / White", '__id'=>"4594", 'code'=>"4594"}]
   end
 
   it "should show query count" do
-    res = @db.prepare_query{ |q| q.condition(:type, :streq, 'Cucumber') }.count
+    res = @db.prepare_query{ |q| q.condition('type', :streq, 'Cucumber') }.count
     res.should == 5
   end
 
   it "should allow a custom pkey for a result set" do
     q = @db.query
-    q.condition(:type, :streq, 'Cucumber')
+    q.condition('type', :streq, 'Cucumber')
     q.set_pkey(:pk)
-    q.get.should == [{:type=>"Cucumber", :code=>"4592", :pk=>"4592", :variety=>"Armenian"},
-                     {:type=>"Cucumber", :code=>"4593", :pk=>"4593", :variety=>"English / Hot House / Long Seedless / Telegraph / Continental"},
-                     {:type=>"Cucumber", :code=>"4594", :pk=>"4594", :variety=>"Japanese / White"},
-                     {:type=>"Cucumber", :code=>"4595", :pk=>"4595", :variety=>"Lemon"},
-                     {:type=>"Cucumber", :code=>"4596", :pk=>"4596", :variety=>"Pickling / Gherkin"}]
+    q.get.should == [{'type'=>"Cucumber", 'code'=>"4592", :pk=>"4592", 'variety'=>"Armenian"},
+                     {'type'=>"Cucumber", 'code'=>"4593", :pk=>"4593", 'variety'=>"English / Hot House / Long Seedless / Telegraph / Continental"},
+                     {'type'=>"Cucumber", 'code'=>"4594", :pk=>"4594", 'variety'=>"Japanese / White"},
+                     {'type'=>"Cucumber", 'code'=>"4595", :pk=>"4595", 'variety'=>"Lemon"},
+                     {'type'=>"Cucumber", 'code'=>"4596", :pk=>"4596", 'variety'=>"Pickling / Gherkin"}]
   end
 end

data/spec/tokyo_tyrant_spec.rb

@@ -25,6 +25,10 @@ describe TokyoTyrant::DB, "with an open database" do
     @db.server.should == '127.0.0.1:45000'
   end
 
+  it "should optimize" do
+    @db.optimize.should.be.true
+  end
+
   it "should save a value" do
     @db[:salad] = 'bacon bits'
     @db[:salad].should == 'bacon bits'
@@ -35,6 +39,12 @@ describe TokyoTyrant::DB, "with an open database" do
     @db[:salad].should == 'bacon bits'
   end
 
+  it "should accept binary data" do
+    s = "mango#{0.chr}salsa"
+    @db.put(s, s).should.be.true
+    @db[s].should.equal(s)
+  end
+
   it "should save multiple values" do
     h = { 'pizza' => 'old forge style',
           'sandwich' => 'peanut butter jelly',
@@ -211,6 +221,14 @@ describe TokyoTyrant::DB, "with an open database" do
     @db.get_int(key).should == 2
   end
 
+  it "should increment integer values" do
+    key = 'counter'
+    @db.out(key)
+    @db.increment(key).should == 1
+    @db.increment(key, 2).should == 3
+    @db.get_int(key).should == 3
+  end
+
   it "should add serialized double values" do
     key = 'counter'
     @db.out(key)
@@ -218,4 +236,8 @@ describe TokyoTyrant::DB, "with an open database" do
     @db.add_double(key, 1.0).should.be.close?(2.0, 0.005)
     @db.get_double(key).should.be.close?(2.0, 0.005)
   end
+
+  it "should run lua extensions" do
+    @db.ext('echo', 'hello', 'world').should == "hello\tworld"
+  end
 end

data/spec/tokyo_tyrant_table_spec.rb

@@ -25,23 +25,34 @@ describe TokyoTyrant::Table, "with an open database" do
     @db.server.should == '127.0.0.1:45001'
   end
 
+  it "should optimize" do
+    @db.optimize.should.be.true
+  end
+
   it "should save a value" do
-    value = { :lettuce => 'Red Leaf', :dressing => 'ranch', :extra => 'bacon bits' }
+    value = { 'lettuce' => 'Red Leaf', 'dressing' => 'ranch', 'extra' => 'bacon bits' }
     @db[:salad] = value
     @db[:salad].should == value
   end
   
   it "should return a value" do
-    value = { :lettuce => 'Red Leaf', :dressing => 'ranch', :extra => 'bacon bits' }
+    value = { 'lettuce' => 'Red Leaf', 'dressing' => 'ranch', 'extra' => 'bacon bits' }
     @db[:salad] = value
     @db[:salad].should == value
   end
 
+  it "should accept binary data" do
+    s = "mango#{0.chr}salsa"
+    h = { s => s }
+    @db.put(s, h).should.be.true
+    @db[s].should.equal(h)
+  end
+
   it "should save multiple values" do
-    h = { 'pizza' => { :best => 'old forge style', :ok => 'new york style', :worst => 'chicago style' },
-          'sandwich' => { :best => 'peanut butter jelly', :ok => 'turkey', :worst => 'olive loaf' },
-          'yogurt' => { :best => 'greek', :ok => 'organic', :worst => '+hfcs' },
-          'coffee' => { :best => 'black', :ok => 'espresso', :worst => 'latte' } }
+    h = { 'pizza' => { 'best' => 'old forge style', 'ok' => 'new york style', 'worst' => 'chicago style' },
+          'sandwich' => { 'best' => 'peanut butter jelly', 'ok' => 'turkey', 'worst' => 'olive loaf' },
+          'yogurt' => { 'best' => 'greek', 'ok' => 'organic', 'worst' => '+hfcs' },
+          'coffee' => { 'best' => 'black', 'ok' => 'espresso', 'worst' => 'latte' } }
 
     @db.mput(h).should.be.empty
     h.each_pair do |k,v|
@@ -50,10 +61,10 @@ describe TokyoTyrant::Table, "with an open database" do
   end
 
   it "should delete multiple values" do
-    h = { 'pizza' => { :best => 'old forge style', :ok => 'new york style', :worst => 'chicago style' },
-          'sandwich' => { :best => 'peanut butter jelly', :ok => 'turkey', :worst => 'olive loaf' },
-          'yogurt' => { :best => 'greek', :ok => 'organic', :worst => '+hfcs' },
-          'coffee' => { :best => 'black', :ok => 'espresso', :worst => 'latte' } }
+    h = { 'pizza' => { 'best' => 'old forge style', 'ok' => 'new york style', 'worst' => 'chicago style' },
+          'sandwich' => { 'best' => 'peanut butter jelly', 'ok' => 'turkey', 'worst' => 'olive loaf' },
+          'yogurt' => { 'best' => 'greek', 'ok' => 'organic', 'worst' => '+hfcs' },
+          'coffee' => { 'best' => 'black', 'ok' => 'espresso', 'worst' => 'latte' } }
 
     @db.mput(h)
     @db.outlist('coffee', 'yogurt').should.be.empty
@@ -61,10 +72,10 @@ describe TokyoTyrant::Table, "with an open database" do
   end
 
   it "should get multiple values" do
-    h = { 'pizza' => { :best => 'old forge style', :ok => 'new york style', :worst => 'chicago style' },
-          'sandwich' => { :best => 'peanut butter jelly', :ok => 'turkey', :worst => 'olive loaf' },
-          'yogurt' => { :best => 'greek', :ok => 'organic', :worst => '+hfcs' },
-          'coffee' => { :best => 'black', :ok => 'espresso', :worst => 'latte' } }
+    h = { 'pizza' => { 'best' => 'old forge style', 'ok' => 'new york style', 'worst' => 'chicago style' },
+          'sandwich' => { 'best' => 'peanut butter jelly', 'ok' => 'turkey', 'worst' => 'olive loaf' },
+          'yogurt' => { 'best' => 'greek', 'ok' => 'organic', 'worst' => '+hfcs' },
+          'coffee' => { 'best' => 'black', 'ok' => 'espresso', 'worst' => 'latte' } }
 
     @db.mput(h)
     @db.mget(h.keys).should == h
@@ -72,7 +83,7 @@ describe TokyoTyrant::Table, "with an open database" do
 
   it "should out a value" do
     k = :tomato
-    @db[k] = { :color => 'red', :variety => 'beefy' }
+    @db[k] = { 'color' => 'red', 'variety' => 'beefy' }
     @db.out(k).should.be.true
     @db[k].should.be.nil
     @db.out(k).should.be.false
@@ -80,17 +91,17 @@ describe TokyoTyrant::Table, "with an open database" do
 
   it "should check a key" do
     k = :fruit
-    @db[k] = { :name => 'banana', :code => '4011' }
+    @db[k] = { 'name' => 'banana', 'code' => '4011' }
     @db.check(k).should.be.true
     @db.out(k)
     @db.check(k).should.be.false
   end
 
   it "should iterate" do
-    @db[:cheese] = { :melty => 'gouda', :sharp => 'cheddar', :stringy => 'mozerella' }
-    @db[:grapes] = { :sour => 'green', :big => 'red', :wine => 'purple' }
-    @db[:oranges] = { :juicy => 'florida', :yellow => 'california' }
-    @db[:crackers] = { :wheat => 'triscuit', :snack => 'ritz', :soup => 'saltine' }
+    @db[:cheese] = { 'melty' => 'gouda', 'sharp' => 'cheddar', 'stringy' => 'mozerella' }
+    @db[:grapes] = { 'sour' => 'green', 'big' => 'red', 'wine' => 'purple' }
+    @db[:oranges] = { 'juicy' => 'florida', 'yellow' => 'california' }
+    @db[:crackers] = { 'wheat' => 'triscuit', 'snack' => 'ritz', 'soup' => 'saltine' }
 
     @db.iterinit.should.be.true
     @db.iternext.should == 'cheese'
@@ -101,20 +112,20 @@ describe TokyoTyrant::Table, "with an open database" do
   end
 
   it "should get forward matching keys" do
-    @db['apples/royalgala'] = { :code => '4173', :color => 'red-yellow' }
-    @db['apples/grannysmith'] = { :code => '4139', :color => 'green' }
-    @db['bananas/yellow'] = { :code => '4011', :color => 'yellow' }
-    @db['oranges/shamouti'] = { :code => '3027', :color => 'orange' }
-    @db['grapefruit/deepred'] = { :code => '4288', :color => 'yellow/pink' }
+    @db['apples/royalgala'] = { 'code' => '4173', 'color' => 'red-yellow' }
+    @db['apples/grannysmith'] = { 'code' => '4139', 'color' => 'green' }
+    @db['bananas/yellow'] = { 'code' => '4011', 'color' => 'yellow' }
+    @db['oranges/shamouti'] = { 'code' => '3027', 'color' => 'orange' }
+    @db['grapefruit/deepred'] = { 'code' => '4288', 'color' => 'yellow/pink' }
     @db.fwmkeys('apples').sort.should == ["apples/grannysmith", "apples/royalgala"]
   end
 
   it "should delete forward matching keys" do
-    @db['apples/royalgala'] = { :code => '4173', :color => 'red-yellow' }
-    @db['apples/grannysmith'] = { :code => '4139', :color => 'green' }
-    @db['bananas/yellow'] = { :code => '4011', :color => 'yellow' }
-    @db['oranges/shamouti'] = { :code => '3027', :color => 'orange' }
-    @db['grapefruit/deepred'] = { :code => '4288', :color => 'yellow/pink' }
+    @db['apples/royalgala'] = { 'code' => '4173', 'color' => 'red-yellow' }
+    @db['apples/grannysmith'] = { 'code' => '4139', 'color' => 'green' }
+    @db['bananas/yellow'] = { 'code' => '4011', 'color' => 'yellow' }
+    @db['oranges/shamouti'] = { 'code' => '3027', 'color' => 'orange' }
+    @db['grapefruit/deepred'] = { 'code' => '4288', 'color' => 'yellow/pink' }
     @db.delete_keys_with_prefix('apples').should == nil
     @db.fwmkeys('apples').should.be.empty
     @db.keys.sort.should == ['bananas/yellow', 'grapefruit/deepred', 'oranges/shamouti']
@@ -122,9 +133,9 @@ describe TokyoTyrant::Table, "with an open database" do
 
   it "should get all keys" do
     keys = %w[appetizers entree dessert]
-    values = [{ :cheap => 'chips', :expensive => 'sample everything platter' },
-              { :cheap => 'hoagie', :expensive => 'steak' },
-              { :cheap => 'water ice', :expensive => 'cheesecake' }]
+    values = [{ 'cheap' => 'chips', 'expensive' => 'sample everything platter' },
+              { 'cheap' => 'hoagie', 'expensive' => 'steak' },
+              { 'cheap' => 'water ice', 'expensive' => 'cheesecake' }]
 
     keys.each_with_index do |k,i|
       @db[k] = values[i]
@@ -134,9 +145,9 @@ describe TokyoTyrant::Table, "with an open database" do
 
   it "should get all values" do
     keys = %w[appetizers entree dessert]
-    values = [{ :cheap => 'chips', :expensive => 'sample everything platter' },
-              { :cheap => 'hoagie', :expensive => 'steak' },
-              { :cheap => 'water ice', :expensive => 'cheesecake' }]
+    values = [{ 'cheap' => 'chips', 'expensive' => 'sample everything platter' },
+              { 'cheap' => 'hoagie', 'expensive' => 'steak' },
+              { 'cheap' => 'water ice', 'expensive' => 'cheesecake' }]
 
     keys.each_with_index do |k,i|
       @db[k] = values[i]
@@ -145,36 +156,36 @@ describe TokyoTyrant::Table, "with an open database" do
   end
 
   it "should vanish all records" do
-    @db['chocolate'] = { :type => 'dark' }
-    @db['tea'] = { :type => 'earl grey' }
+    @db['chocolate'] = { 'type' => 'dark' }
+    @db['tea'] = { 'type' => 'earl grey' }
     @db.empty?.should.be.false
     @db.vanish.should.be.true
     @db.empty?.should.be.true
   end
 
   it "should count records" do
-    @db['hummus'] = { :ingredients => 'chickpeas,garlic' }
-    @db['falafel'] = { :ingredients => 'chickpeas,herbs' }
+    @db['hummus'] = { 'ingredients' => 'chickpeas,garlic' }
+    @db['falafel'] = { 'ingredients' => 'chickpeas,herbs' }
     @db.rnum.should == 2
   end
 
   it "should report db size" do
-    @db['rootbeer'] = { :gourmet => 'Virgils', :natural => 'Hansens' }
+    @db['rootbeer'] = { 'gourmet' => 'Virgils', 'natural' => 'Hansens' }
     @db.db_size.should.not == 0
   end
 
   it "should fetch a record" do
     @db.out('beer')
-    @db.fetch('beer', { :import => 'heineken' }).should == { :import => 'heineken' }
-    @db['beer'] = { :import => 'heineken' }
-    @db.fetch('beer', { :import => 'becks' }).should == { :import => 'heineken' }
+    @db.fetch('beer', { 'import' => 'heineken' }).should == { 'import' => 'heineken' }
+    @db['beer'] = { 'import' => 'heineken' }
+    @db.fetch('beer', { 'import' => 'becks' }).should == { 'import' => 'heineken' }
   end
 
   it "should iterate through records" do
     keys = %w[grapejuice tacoshells rice]
-    values = [{ :purple => 'Kedem', :green => 'Juicy Juice' },
-              { :crunchy => 'Ortega', :soft => 'Taco Bell' },
-              { :brown => 'Instant', :white => 'Uncle Ben' }]
+    values = [{ 'purple' => 'Kedem', 'green' => 'Juicy Juice' },
+              { 'crunchy' => 'Ortega', 'soft' => 'Taco Bell' },
+              { 'brown' => 'Instant', 'white' => 'Uncle Ben' }]
     keys.each_with_index{ |k,i| @db[k] = values[i] }
 
     i = 0
@@ -187,7 +198,7 @@ describe TokyoTyrant::Table, "with an open database" do
 
   it "should iterate through keys" do
     keys = %w[burritos fajitas tacos tostas enchiladas]
-    values = Array.new(keys.size, { :tasty => 'yes' })
+    values = Array.new(keys.size, { 'tasty' => 'yes' })
     keys.each_with_index{ |k,i| @db[k] = values[i] }
 
     i = 0
@@ -199,11 +210,11 @@ describe TokyoTyrant::Table, "with an open database" do
 
   it "should iterate through values" do
     keys = %w[falafel humus couscous tabbouleh tzatziki]
-    values = [{ :ingredient => 'chickpeas' },
-              { :ingredient => 'chickpeas' },
-              { :ingredient => 'semolina' },
-              { :ingredient => 'bulgar' },
-              { :ingredient => 'yogurt' }]
+    values = [{ 'ingredient' => 'chickpeas' },
+              { 'ingredient' => 'chickpeas' },
+              { 'ingredient' => 'semolina' },
+              { 'ingredient' => 'bulgar' },
+              { 'ingredient' => 'yogurt' }]
 
     keys.each_with_index{ |k,i| @db[k] = values[i] }
 
@@ -217,29 +228,43 @@ describe TokyoTyrant::Table, "with an open database" do
   it "should add serialized integer values" do
     key = 'counter'
     @db.out(key)
-    @db[key] = { :title => 'Bean Counter' }
+    @db[key] = { 'title' => 'Bean Counter' }
     @db.add_int(key, 1).should == 1
     @db.add_int(key, 1).should == 2
     @db.get_int(key).should == 2
-    @db[key].should == { :title => 'Bean Counter', :_num => "2" }
+    @db[key].should == { 'title' => 'Bean Counter', '_num' => "2" }
+  end
+
+  it "should increment integer values" do
+    key = 'counter'
+    @db.out(key)
+    @db[key] = { 'title' => 'Bean Counter' }
+    @db.increment(key).should == 1
+    @db.increment(key, 2).should == 3
+    @db.get_int(key).should == 3
+    @db[key].should == { 'title' => 'Bean Counter', '_num' => "3" }
   end
 
   it "should add serialized double values" do
     key = 'counter'
     @db.out(key)
-    @db[key] = { :title => 'Bean Counter' }
+    @db[key] = { 'title' => 'Bean Counter' }
     @db.add_double(key, 1.0).should.be.close?(1.0, 0.005)
     @db.add_double(key, 1.0).should.be.close?(2.0, 0.005)
     @db.get_double(key).should.be.close?(2.0, 0.005)
-    @db[key].should == { :title => 'Bean Counter', :_num => "2" }
+    @db[key].should == { 'title' => 'Bean Counter', '_num' => "2" }
   end
 
   it "should set an index" do
     key = 'counter'
     50.times do |i|
-      @db["key#{i}"] = { :title => %w{rice beans corn}.sort_by{rand}.first,
-                         :description => 'a whole protein' }
+      @db["key#{i}"] = { 'title' => %w{rice beans corn}.sort_by{rand}.first,
+                         'description' => 'a whole protein' }
     end
-    @db.set_index(:title, :lexical).should.be.true
+    @db.set_index('title', :lexical).should.be.true
+  end
+
+  it "should run lua extensions" do
+    @db.ext('echo', 'hello', 'world').should == "hello\tworld"
   end
 end