rufus-tokyo 0.1.7 → 0.1.8

data/lib/rufus/tokyo/cabinet/lib.rb

@@ -28,178 +28,179 @@
 # jmettraux@gmail.com
 #
 
-module Rufus
-  module Tokyo
+module Rufus::Tokyo
 
-    #
-    # The libtokyocabinet.so methods get bound to this module
-    #
-    module CabinetLib #:nodoc#
-      extend FFI::Library
+  #
+  # The libtokyocabinet.so methods get bound to this module
+  #
+  module CabinetLib #:nodoc#
+    extend FFI::Library
 
-      #
-      # find Tokyo Cabinet lib
+    #
+    # find Tokyo Cabinet lib
 
-      paths = Array(ENV['TOKYO_CABINET_LIB'] || %w{
-        /opt/local/lib/libtokyocabinet.dylib
-        /usr/local/lib/libtokyocabinet.dylib
-        /usr/local/lib/libtokyocabinet.so
-      })
+    paths = Array(ENV['TOKYO_CABINET_LIB'] || %w{
+      /opt/local/lib/libtokyocabinet.dylib
+      /usr/local/lib/libtokyocabinet.dylib
+      /usr/local/lib/libtokyocabinet.so
+    })
 
-      path = paths.find { |path| File.exist?(path) }
+    path = paths.find { |path| File.exist?(path) }
 
-      raise(
-        "didn't find Tokyo Cabinet libs on your system. " +
-        "Please install Tokyo Cabinet (http://tokyocabinet.sf.net)"
-      ) unless path
+    raise(
+      "didn't find Tokyo Cabinet libs on your system. " +
+      "Please install Tokyo Cabinet (http://tokyocabinet.sf.net)"
+    ) unless path
 
-      ffi_lib(path)
+    ffi_lib(path)
 
-      class << self
-        alias :attfunc :attach_function
-      end
+    class << self
+      alias :attfunc :attach_function
+    end
 
-      #
-      # maybe put that in a standalone c_lib.rb
+    #
+    # maybe put that in a standalone c_lib.rb
 
-      # length of a string
-      #
-      attfunc :strlen, [ :string ], :int
+    # length of a string
+    #
+    attfunc :strlen, [ :string ], :int
 
-      # frees a mem zone (TC style)
-      #
-      attfunc :tcfree, [ :pointer ], :void
+    # frees a mem zone (TC style)
+    #
+    attfunc :tcfree, [ :pointer ], :void
 
-      #
-      # tcadb functions
-      #
-      # http://tokyocabinet.sourceforge.net/spex-en.html#tcadbapi
+    #
+    # tcadb functions
+    #
+    # http://tokyocabinet.sourceforge.net/spex-en.html#tcadbapi
 
-      attfunc :tcadbnew, [], :pointer
+    attfunc :tcadbnew, [], :pointer
 
-      attfunc :tcadbopen, [ :pointer, :string ], :int
-      attfunc :abs_close, :tcadbclose, [ :pointer ], :int
+    attfunc :tcadbopen, [ :pointer, :string ], :int
+    attfunc :abs_close, :tcadbclose, [ :pointer ], :int
 
-      attfunc :abs_del, :tcadbdel, [ :pointer ], :void
+    attfunc :abs_del, :tcadbdel, [ :pointer ], :void
 
-      attfunc :abs_rnum, :tcadbrnum, [ :pointer ], :uint64
-      attfunc :abs_size, :tcadbsize, [ :pointer ], :uint64
+    attfunc :abs_rnum, :tcadbrnum, [ :pointer ], :uint64
+    attfunc :abs_size, :tcadbsize, [ :pointer ], :uint64
 
-      attfunc :abs_put2, :tcadbput2, [ :pointer, :string, :string ], :int
-      attfunc :abs_get2, :tcadbget2, [ :pointer, :string ], :string
-      attfunc :abs_out2, :tcadbout2, [ :pointer, :string ], :int
+    attfunc :abs_put2, :tcadbput2, [ :pointer, :string, :string ], :int
+    attfunc :abs_get2, :tcadbget2, [ :pointer, :string ], :string
+    attfunc :abs_out2, :tcadbout2, [ :pointer, :string ], :int
 
-      attfunc :abs_iterinit, :tcadbiterinit, [ :pointer ], :int
-      attfunc :abs_iternext2, :tcadbiternext2, [ :pointer ], :string
+    attfunc :abs_iterinit, :tcadbiterinit, [ :pointer ], :int
+    attfunc :abs_iternext2, :tcadbiternext2, [ :pointer ], :string
 
-      attfunc :abs_vanish, :tcadbvanish, [ :pointer ], :int
+    attfunc :abs_vanish, :tcadbvanish, [ :pointer ], :int
 
-      attfunc :abs_sync, :tcadbsync, [ :pointer ], :int
-      attfunc :abs_copy, :tcadbcopy, [ :pointer, :string ], :int
+    attfunc :abs_sync, :tcadbsync, [ :pointer ], :int
+    attfunc :abs_copy, :tcadbcopy, [ :pointer, :string ], :int
 
-      attfunc :abs_fwmkeys2, :tcadbfwmkeys2, [ :pointer, :string, :int ], :pointer
+    attfunc :abs_fwmkeys2, :tcadbfwmkeys2, [ :pointer, :string, :int ], :pointer
 
-      #
-      # tctdb functions
-      #
-      # http://tokyocabinet.sourceforge.net/spex-en.html#tctdbapi
+    attfunc :tcadbmisc, [ :pointer, :string, :pointer ], :pointer
 
-      attfunc :tctdbnew, [], :pointer
-      attfunc :tctdbsetmutex, [ :pointer ], :int
-      attfunc :tctdbtune, [ :pointer, :uint64, :uint8, :uint8, :uint8 ], :int
-      attfunc :tctdbsetcache, [ :pointer, :uint32, :uint32, :uint32 ], :int
-      attfunc :tctdbsetxmsiz, [ :pointer, :uint64 ], :int
+    #
+    # tctdb functions
+    #
+    # http://tokyocabinet.sourceforge.net/spex-en.html#tctdbapi
 
-      attfunc :tctdbopen, [ :pointer, :string, :int ], :int
+    attfunc :tctdbnew, [], :pointer
+    attfunc :tctdbsetmutex, [ :pointer ], :int
+    attfunc :tctdbtune, [ :pointer, :uint64, :uint8, :uint8, :uint8 ], :int
+    attfunc :tctdbsetcache, [ :pointer, :uint32, :uint32, :uint32 ], :int
+    attfunc :tctdbsetxmsiz, [ :pointer, :uint64 ], :int
 
-      attfunc :tab_close, :tctdbclose, [ :pointer ], :int
+    attfunc :tctdbopen, [ :pointer, :string, :int ], :int
 
-      attfunc :tab_genuid, :tctdbgenuid, [ :pointer ], :int64
+    attfunc :tab_close, :tctdbclose, [ :pointer ], :int
 
-      attfunc :tab_get, :tctdbget, [ :pointer, :string, :int ], :pointer
+    attfunc :tab_genuid, :tctdbgenuid, [ :pointer ], :int64
 
-      attfunc :tab_iterinit, :tctdbiterinit, [ :pointer ], :int
-      attfunc :tab_iternext2, :tctdbiternext2, [ :pointer ], :string
+    attfunc :tab_get, :tctdbget, [ :pointer, :string, :int ], :pointer
 
-      attfunc :tab_put, :tctdbput, [ :pointer, :string, :int, :pointer ], :int
+    attfunc :tab_iterinit, :tctdbiterinit, [ :pointer ], :int
+    attfunc :tab_iternext2, :tctdbiternext2, [ :pointer ], :string
 
-      #attfunc :tctdbput3, [ :pointer, :string, :string ], :int
-        # not using it anymore, Ruby can turn an array into a hash so easily
+    attfunc :tab_put, :tctdbput, [ :pointer, :string, :int, :pointer ], :int
 
-      attfunc :tab_out, :tctdbout, [ :pointer, :string, :int ], :int
+    #attfunc :tctdbput3, [ :pointer, :string, :string ], :int
+      # not using it anymore, Ruby can turn an array into a hash so easily
 
-      attfunc :tab_ecode, :tctdbecode, [ :pointer ], :int
-      attfunc :tab_errmsg, :tctdberrmsg, [ :int ], :string
+    attfunc :tab_out, :tctdbout, [ :pointer, :string, :int ], :int
 
-      attfunc :tab_del, :tctdbdel, [ :pointer ], :void
+    attfunc :tab_ecode, :tctdbecode, [ :pointer ], :int
+    attfunc :tab_errmsg, :tctdberrmsg, [ :int ], :string
 
-      attfunc :tab_rnum, :tctdbrnum, [ :pointer ], :uint64
+    attfunc :tab_del, :tctdbdel, [ :pointer ], :void
 
-      attfunc :tab_vanish, :tctdbvanish, [ :pointer ], :int
+    attfunc :tab_rnum, :tctdbrnum, [ :pointer ], :uint64
 
-      attfunc :tab_setindex, :tctdbsetindex, [ :pointer, :string, :int ], :int
+    attfunc :tab_vanish, :tctdbvanish, [ :pointer ], :int
 
-      attfunc :tctdbtranbegin, [ :pointer ], :int
-      attfunc :tctdbtrancommit, [ :pointer ], :int
-      attfunc :tctdbtranabort, [ :pointer ], :int
+    attfunc :tab_setindex, :tctdbsetindex, [ :pointer, :string, :int ], :int
 
-      attfunc :tab_fwmkeys2, :tctdbfwmkeys2, [ :pointer, :string, :int ], :pointer
+    attfunc :tctdbtranbegin, [ :pointer ], :int
+    attfunc :tctdbtrancommit, [ :pointer ], :int
+    attfunc :tctdbtranabort, [ :pointer ], :int
 
-      #
-      # tctdbqry functions
-      #
-      # http://tokyocabinet.sourceforge.net/spex-en.html#tctdbapi
+    attfunc :tab_fwmkeys2, :tctdbfwmkeys2, [ :pointer, :string, :int ], :pointer
 
-      attfunc :qry_new, :tctdbqrynew, [ :pointer ], :pointer
-      attfunc :qry_del, :tctdbqrydel, [ :pointer ], :void
+    #
+    # tctdbqry functions
+    #
+    # http://tokyocabinet.sourceforge.net/spex-en.html#tctdbapi
 
-      attfunc :qry_addcond, :tctdbqryaddcond, [ :pointer, :string, :int, :string ], :void
-      attfunc :qry_setorder, :tctdbqrysetorder, [ :pointer, :string, :int ], :void
-      attfunc :qry_setmax, :tctdbqrysetmax, [ :pointer, :int ], :void
+    attfunc :qry_new, :tctdbqrynew, [ :pointer ], :pointer
+    attfunc :qry_del, :tctdbqrydel, [ :pointer ], :void
 
-      attfunc :qry_search, :tctdbqrysearch, [ :pointer ], :pointer
+    attfunc :qry_addcond, :tctdbqryaddcond, [ :pointer, :string, :int, :string ], :void
+    attfunc :qry_setorder, :tctdbqrysetorder, [ :pointer, :string, :int ], :void
+    attfunc :qry_setmax, :tctdbqrysetmax, [ :pointer, :int ], :void
 
-      #
-      # tcmap functions
-      #
-      # http://tokyocabinet.sourceforge.net/spex-en.html#tcutilapi
+    attfunc :qry_search, :tctdbqrysearch, [ :pointer ], :pointer
 
-      attfunc :tcmapnew, [], :pointer
+    #
+    # tcmap functions
+    #
+    # http://tokyocabinet.sourceforge.net/spex-en.html#tcutilapi
 
-      attfunc :tcmapput2, [ :pointer, :string, :string ], :void
-      attfunc :tcmapout2, [ :pointer, :string ], :int
-      attfunc :tcmapclear, [ :pointer ], :void
+    attfunc :tcmapnew, [], :pointer
 
-      attfunc :tcmapdel, [ :pointer ], :void
+    attfunc :tcmapput2, [ :pointer, :string, :string ], :void
+    attfunc :tcmapout2, [ :pointer, :string ], :int
+    attfunc :tcmapclear, [ :pointer ], :void
 
-      attfunc :tcmapget2, [ :pointer, :string ], :string
+    attfunc :tcmapdel, [ :pointer ], :void
 
-      attfunc :tcmapiterinit, [ :pointer ], :void
-      attfunc :tcmapiternext2, [ :pointer ], :string
+    attfunc :tcmapget2, [ :pointer, :string ], :string
 
-      attfunc :tcmaprnum, [ :pointer ], :uint64
+    attfunc :tcmapiterinit, [ :pointer ], :void
+    attfunc :tcmapiternext2, [ :pointer ], :string
 
-      #
-      # tclist functions
-      #
-      # http://tokyocabinet.sourceforge.net/spex-en.html#tcutilapi
+    attfunc :tcmaprnum, [ :pointer ], :uint64
 
-      attfunc :tclistnew, [], :pointer
+    #
+    # tclist functions
+    #
+    # http://tokyocabinet.sourceforge.net/spex-en.html#tcutilapi
 
-      attfunc :tclistnum, [ :pointer ], :int
-      attfunc :tclistval2, [ :pointer, :int ], :string
+    attfunc :tclistnew, [], :pointer
 
-      attfunc :tclistpush2, [ :pointer, :string ], :void
-      attfunc :tclistpop2, [ :pointer ], :string
-      attfunc :tclistshift2, [ :pointer ], :string
-      attfunc :tclistunshift2, [ :pointer, :string ], :void
-      attfunc :tclistover2, [ :pointer, :int, :string ], :void
+    attfunc :tclistnum, [ :pointer ], :int
+    attfunc :tclistval2, [ :pointer, :int ], :string
 
-      attfunc :tclistremove2, [ :pointer, :int ], :string
-      # beware, seems like have to free the return string self
+    attfunc :tclistpush2, [ :pointer, :string ], :void
+    attfunc :tclistpop2, [ :pointer ], :string
+    attfunc :tclistshift2, [ :pointer ], :string
+    attfunc :tclistunshift2, [ :pointer, :string ], :void
+    attfunc :tclistover2, [ :pointer, :int, :string ], :void
 
-      attfunc :tclistdel, [ :pointer ], :void
-    end
+    attfunc :tclistremove2, [ :pointer, :int ], :string
+    # beware, seems like have to free the return string self
 
+    attfunc :tclistdel, [ :pointer ], :void
   end
+
 end
+

data/lib/rufus/tokyo/cabinet/table.rb

@@ -28,768 +28,604 @@
 # jmettraux@gmail.com
 #
 
-module Rufus
-  module Tokyo
+require 'rufus/tokyo/query'
+require 'rufus/tokyo/config'
+require 'rufus/tokyo/transactions'
+
+
+module Rufus::Tokyo
+
+  #
+  # A 'table' a table database.
+  #
+  #   http://alpha.mixi.co.jp/blog/?p=290
+  #   http://tokyocabinet.sourceforge.net/spex-en.html#tctdbapi
+  #
+  # A short example :
+  #
+  #   require 'rubygems'
+  #   require 'rufus/tokyo/cabinet/table'
+  #
+  #   t = Rufus::Tokyo::Table.new('table.tdb', :create, :write)
+  #     # '.tdb' suffix is a must
+  #
+  #   t['pk0'] = { 'name' => 'alfred', 'age' => '22' }
+  #   t['pk1'] = { 'name' => 'bob', 'age' => '18' }
+  #   t['pk2'] = { 'name' => 'charly', 'age' => '45' }
+  #   t['pk3'] = { 'name' => 'doug', 'age' => '77' }
+  #   t['pk4'] = { 'name' => 'ephrem', 'age' => '32' }
+  #
+  #   p t.query { |q|
+  #     q.add_condition 'age', :numge, '32'
+  #     q.order_by 'age'
+  #     q.limit 2
+  #   }
+  #     # => [ {"name"=>"ephrem", :pk=>"pk4", "age"=>"32"},
+  #     #      {"name"=>"charly", :pk=>"pk2", "age"=>"45"} ]
+  #
+  #   t.close
+  #
+  class Table
+
+    include HashMethods
+    include CabinetConfig
+
+    include Transactions
+      # this class has tranbegin/trancommit/tranabort so let's include the
+      # transaction mixin
 
     #
-    # Methods for setting up / tuning a Cabinet.
+    # Creates a Table instance (creates or opens it depending on the args)
     #
-    # Gets included into Table.
+    # For example,
     #
-    module CabinetConfig
-
-      protected
-
-      #
-      # Given a path, a hash of parameters and a suffix,
-      #
-      # a) makes sure that the path has the given suffix or raises an exception
-      # b) gathers params found in the path (#) or in params
-      # c) determines the config as set by the parameters
-      #
-      def determine_conf (path, params, suffix)
-
-        if path.index('#')
-
-          ss = path.split('#')
-          path = ss.shift
-
-          ss.each { |p| pp = p.split('='); params[pp[0]] = pp[1] }
-        end
-
-        raise "path '#{path}' must be suffixed with #{suffix}" \
-          unless path[-suffix.length..-1] == suffix
-
-        params = params.inject({}) { |h, (k, v)| h[k.to_sym] = v; h }
-
-        conf = {
-          :params => params,
-          :path => path,
-          :mode => determine_open_mode(params),
-          :mutex => (params[:mutex].to_s == 'true'),
-          #:indexes => params[:idx] || params[:indexes],
-          :xmsiz => (params[:xmsiz] || 67108864).to_i
-        }
-        conf.merge!(determine_tuning_values(params))
-        conf.merge(determine_cache_values(params))
-      end
-
-      def determine_open_mode (params) #:nodoc#
-
-        mode = params[:mode].to_s
-        mode = 'wc' if mode.size < 1
-
-        {
-          'r' => (1 << 0), # open as a reader
-          'w' => (1 << 1), # open as a writer
-          'c' => (1 << 2), # writer creating
-          't' => (1 << 3), # writer truncating
-          'e' => (1 << 4), # open without locking
-          'f' => (1 << 5), # lock without blocking
-          's' => (1 << 6), # synchronize every transaction (tctdb.h)
-
-        }.inject(0) { |r, (c, v)|
-
-          r = r | v if mode.index(c); r
-        }
-      end
-
-      def determine_tuning_values (params) #:nodoc#
-
-        bnum = (params[:bnum] || 131071).to_i
-        apow = (params[:apow] || 4).to_i
-        fpow = (params[:fpow] || 10).to_i
-
-        o = params[:opts] || ''
-        o = {
-          'l' => 1 << 0, # large
-          'd' => 1 << 1, # deflate
-          'b' => 1 << 2, # bzip2
-          't' => 1 << 3, # tcbs
-          'x' => 1 << 4
-        }.inject(0) { |i, (k, v)| i = i | v if o.index(k); i }
-
-        { :bnum => bnum, :apow => apow, :fpow => fpow, :opts => o }
-      end
-
-      def determine_cache_values (params) #:nodoc#
-
-        {
-          :rcnum => params[:rcnum].to_i,
-          :lcnum => (params[:lcnum] || 2048).to_i,
-          :ncnum => (params[:ncnum] || 512).to_i
-        }
-      end
-    end
-
+    #   t = Rufus::Tokyo::Table.new('table.tdb')
+    #     # '.tdb' suffix is a must
     #
-    # A 'table' a table database.
+    # will create the table.tdb (or simply open it if already present)
+    # and make sure we have write access to it.
     #
-    #   http://alpha.mixi.co.jp/blog/?p=290
-    #   http://tokyocabinet.sourceforge.net/spex-en.html#tctdbapi
+    # == parameters
     #
-    # A short example :
+    # Parameters can be set in the path or via the optional params hash (like
+    # in Rufus::Tokyo::Cabinet)
     #
-    #   require 'rubygems'
-    #   require 'rufus/tokyo/cabinet/table'
+    #   * :mode    a set of chars ('r'ead, 'w'rite, 'c'reate, 't'runcate,
+    #              'e' non locking, 'f' non blocking lock), default is 'wc'
+    #   * :opts    a set of chars ('l'arge, 'd'eflate, 'b'zip2, 't'cbs)
+    #              (usually empty or something like 'ld' or 'lb')
     #
-    #   t = Rufus::Tokyo::Table.new('table.tdb', :create, :write)
-    #     # '.tdb' suffix is a must
+    #   * :bnum    number of elements of the bucket array
+    #   * :apow    size of record alignment by power of 2 (defaults to 4)
+    #   * :fpow    maximum number of elements of the free block pool by
+    #              power of 2 (defaults to 10)
+    #   * :mutex   when set to true, makes sure only 1 thread at a time
+    #              accesses the table (well, Ruby, global thread lock, ...)
     #
-    #   t['pk0'] = { 'name' => 'alfred', 'age' => '22' }
-    #   t['pk1'] = { 'name' => 'bob', 'age' => '18' }
-    #   t['pk2'] = { 'name' => 'charly', 'age' => '45' }
-    #   t['pk3'] = { 'name' => 'doug', 'age' => '77' }
-    #   t['pk4'] = { 'name' => 'ephrem', 'age' => '32' }
+    #   * :rcnum   specifies the maximum number of records to be cached.
+    #              If it is not more than 0, the record cache is disabled.
+    #              It is disabled by default.
+    #   * :lcnum   specifies the maximum number of leaf nodes to be cached.
+    #              If it is not more than 0, the default value is specified.
+    #              The default value is 2048.
+    #   * :ncnum   specifies the maximum number of non-leaf nodes to be
+    #              cached. If it is not more than 0, the default value is
+    #              specified. The default value is 512.
     #
-    #   p t.query { |q|
-    #     q.add_condition 'age', :numge, '32'
-    #     q.order_by 'age'
-    #     q.limit 2
-    #   }
-    #     # => [ {"name"=>"ephrem", :pk=>"pk4", "age"=>"32"},
-    #     #      {"name"=>"charly", :pk=>"pk2", "age"=>"45"} ]
+    #   * :xmsiz   specifies the size of the extra mapped memory. If it is
+    #              not more than 0, the extra mapped memory is disabled.
+    #              The default size is 67108864.
     #
-    #   t.close
+    # Some examples :
     #
-    class Table
-
-      include HashMethods
-      include CabinetConfig
-
-      #
-      # Creates a Table instance (creates or opens it depending on the args)
-      #
-      # For example,
-      #
-      #   t = Rufus::Tokyo::Table.new('table.tdb')
-      #     # '.tdb' suffix is a must
-      #
-      # will create the table.tdb (or simply open it if already present)
-      # and make sure we have write access to it.
-      #
-      # == parameters
-      #
-      # Parameters can be set in the path or via the optional params hash (like
-      # in Rufus::Tokyo::Cabinet)
-      #
-      #   * :mode    a set of chars ('r'ead, 'w'rite, 'c'reate, 't'runcate,
-      #              'e' non locking, 'f' non blocking lock), default is 'wc'
-      #   * :opts    a set of chars ('l'arge, 'd'eflate, 'b'zip2, 't'cbs)
-      #              (usually empty or something like 'ld' or 'lb')
-      #
-      #   * :bnum    number of elements of the bucket array
-      #   * :apow    size of record alignment by power of 2 (defaults to 4)
-      #   * :fpow    maximum number of elements of the free block pool by
-      #              power of 2 (defaults to 10)
-      #   * :mutex   when set to true, makes sure only 1 thread at a time
-      #              accesses the table (well, Ruby, global thread lock, ...)
-      #
-      #   * :rcnum   specifies the maximum number of records to be cached.
-      #              If it is not more than 0, the record cache is disabled.
-      #              It is disabled by default.
-      #   * :lcnum   specifies the maximum number of leaf nodes to be cached.
-      #              If it is not more than 0, the default value is specified.
-      #              The default value is 2048.
-      #   * :ncnum   specifies the maximum number of non-leaf nodes to be
-      #              cached. If it is not more than 0, the default value is
-      #              specified. The default value is 512.
-      #
-      #   * :xmsiz   specifies the size of the extra mapped memory. If it is
-      #              not more than 0, the extra mapped memory is disabled.
-      #              The default size is 67108864.
-      #
-      # Some examples :
-      #
-      #   t = Rufus::Tokyo::Table.new('table.tdb')
-      #   t = Rufus::Tokyo::Table.new('table.tdb#mode=r')
-      #   t = Rufus::Tokyo::Table.new('table.tdb', :mode => 'r')
-      #   t = Rufus::Tokyo::Table.new('table.tdb#opts=ld#mode=r')
-      #   t = Rufus::Tokyo::Table.new('table.tdb', :opts => 'ld', :mode => 'r')
-      #
-      def initialize (path, params={})
-
-        conf = determine_conf(path, params, '.tdb')
-
-        @db = lib.tctdbnew
-
-        #
-        # tune table
-
-        libcall(:tctdbsetmutex) if conf[:mutex]
-
-        libcall(:tctdbtune, conf[:bnum], conf[:apow], conf[:fpow], conf[:opts])
-
-        # TODO : set indexes here... well, there is already #set_index
-        #conf[:indexes]...
-
-        libcall(:tctdbsetcache, conf[:rcnum], conf[:lcnum], conf[:ncnum])
-
-        libcall(:tctdbsetxmsiz, conf[:xmsiz])
+    #   t = Rufus::Tokyo::Table.new('table.tdb')
+    #   t = Rufus::Tokyo::Table.new('table.tdb#mode=r')
+    #   t = Rufus::Tokyo::Table.new('table.tdb', :mode => 'r')
+    #   t = Rufus::Tokyo::Table.new('table.tdb#opts=ld#mode=r')
+    #   t = Rufus::Tokyo::Table.new('table.tdb', :opts => 'ld', :mode => 'r')
+    #
+    def initialize (path, params={})
 
-        #
-        # open table
+      conf = determine_conf(path, params, :table)
 
-        libcall(:tctdbopen, conf[:path], conf[:mode])
-      end
+      @db = lib.tctdbnew
 
       #
-      # using the cabinet lib
-      #
-      def lib
-        CabinetLib
-      end
+      # tune table
 
-      #
-      # Closes the table (and frees the datastructure allocated for it),
-      # returns true in case of success.
-      #
-      def close
-        result = lib.tab_close(@db)
-        lib.tab_del(@db)
-        (result == 1)
-      end
+      libcall(:tctdbsetmutex) if conf[:mutex]
 
-      #
-      # Generates a unique id (in the context of this Table instance)
-      #
-      def generate_unique_id
-        lib.tab_genuid(@db)
-      end
-      alias :genuid :generate_unique_id
-
-      INDEX_TYPES = {
-        :lexical => 0,
-        :decimal => 1,
-        :void => 9999,
-        :remove => 9999,
-        :keep => 1 << 24
-      }
-
-      #
-      # Sets an index on a column of the table.
-      #
-      # Types maybe be :lexical or :decimal, use :keep to "add" and
-      # :remove (or :void) to "remove" an index.
-      #
-      # If column_name is :pk or "", the index will be set on the primary key.
-      #
-      # Returns true in case of success.
-      #
-      def set_index (column_name, *types)
+      libcall(:tctdbtune, conf[:bnum], conf[:apow], conf[:fpow], conf[:opts])
 
-        column_name = '' if column_name == :pk
+      # TODO : set indexes here... well, there is already #set_index
+      #conf[:indexes]...
 
-        i = types.inject(0) { |i, t| i = i & INDEX_TYPES[t]; i }
+      libcall(:tctdbsetcache, conf[:rcnum], conf[:lcnum], conf[:ncnum])
 
-        (lib.tab_setindex(@db, column_name, i) == 1)
-      end
+      libcall(:tctdbsetxmsiz, conf[:xmsiz])
 
       #
-      # Inserts a record in the table db
-      #
-      #   table['pk0'] = [ 'name', 'fred', 'age', '45' ]
-      #   table['pk1'] = { 'name' => 'jeff', 'age' => '46' }
-      #
-      # Accepts both a hash or an array (expects the array to be of the
-      # form [ key, value, key, value, ... ] else it will raise
-      # an ArgumentError)
-      #
-      def []= (pk, h_or_a)
-
-        m = Rufus::Tokyo::Map[h_or_a]
+      # open table
 
-        r = lib.tab_put(@db, pk, CabinetLib.strlen(pk), m.pointer)
-
-        m.free
+      libcall(:tctdbopen, conf[:path], conf[:mode])
+    end
 
-        (r == 1) || raise_error
+    #
+    # using the cabinet lib
+    #
+    def lib
+      CabinetLib
+    end
 
-        h_or_a
-      end
+    #
+    # Closes the table (and frees the datastructure allocated for it),
+    # returns true in case of success.
+    #
+    def close
+      result = lib.tab_close(@db)
+      lib.tab_del(@db)
+      (result == 1)
+    end
 
-      #
-      # Removes an entry in the table
-      #
-      # (might raise an error if the delete itself failed, but returns nil
-      # if there was no entry for the given key)
-      #
-      def delete (k)
-        v = self[k]
-        return nil unless v
-        libcall(:tab_out, k, CabinetLib.strlen(k))
-        v
-      end
+    #
+    # Generates a unique id (in the context of this Table instance)
+    #
+    def generate_unique_id
+      lib.tab_genuid(@db)
+    end
+    alias :genuid :generate_unique_id
 
-      #
-      # Removes all records in this table database
-      #
-      def clear
-        libcall(:tab_vanish)
-      end
+    INDEX_TYPES = {
+      :lexical => 0,
+      :decimal => 1,
+      :void => 9999,
+      :remove => 9999,
+      :keep => 1 << 24
+    }
 
-      #
-      # Returns an array of all the primary keys in the table
-      #
-      # With no options given, this method will return all the keys (strings)
-      # in a Ruby array.
-      #
-      #   :prefix --> returns only the keys who match a given string prefix
-      #
-      #   :limit --> returns a limited number of keys
-      #
-      #   :native --> returns an instance of Rufus::Tokyo::List instead of
-      #     a Ruby Hash, you have to call #free on that List when done with it !
-      #     Else you're exposing yourself to a memory leak.
-      #
-      def keys (options={})
+    #
+    # Sets an index on a column of the table.
+    #
+    # Types maybe be :lexical or :decimal, use :keep to "add" and
+    # :remove (or :void) to "remove" an index.
+    #
+    # If column_name is :pk or "", the index will be set on the primary key.
+    #
+    # Returns true in case of success.
+    #
+    def set_index (column_name, *types)
 
-        if pref = options[:prefix]
+      column_name = '' if column_name == :pk
 
-          l = lib.tab_fwmkeys2(@db, pref, options[:limit] || -1)
-          l = Rufus::Tokyo::List.new(l)
-          options[:native] ? l : l.release
+      i = types.inject(0) { |i, t| i = i | INDEX_TYPES[t]; i }
 
-        else
+      (lib.tab_setindex(@db, column_name, i) == 1)
+    end
 
-          limit = options[:limit] || -1
-          limit = nil if limit < 1
+    #
+    # Inserts a record in the table db
+    #
+    #   table['pk0'] = [ 'name', 'fred', 'age', '45' ]
+    #   table['pk1'] = { 'name' => 'jeff', 'age' => '46' }
+    #
+    # Accepts both a hash or an array (expects the array to be of the
+    # form [ key, value, key, value, ... ] else it will raise
+    # an ArgumentError)
+    #
+    # Raises an error in case of failure.
+    #
+    def []= (pk, h_or_a)
 
-          l = options[:native] ? Rufus::Tokyo::List.new : []
+      m = Rufus::Tokyo::Map[h_or_a]
 
-          lib.tab_iterinit(@db)
+      r = lib.tab_put(@db, pk, CabinetLib.strlen(pk), m.pointer)
 
-          while (k = (lib.tab_iternext2(@db) rescue nil))
-            break if limit and l.size >= limit
-            l << k
-          end
+      m.free
 
-          l
-        end
-      end
+      (r == 1) || raise_error # raising potential error after freeing map
 
-      #
-      # Returns the number of records in this table db
-      #
-      def size
-        lib.tab_rnum(@db)
-      end
+      h_or_a
+    end
 
-      #
-      # Prepares a query instance (block is optional)
-      #
-      def prepare_query (&block)
-        q = TableQuery.new(self)
-        block.call(q) if block
-        q
-      end
+    #
+    # Removes an entry in the table
+    #
+    # (might raise an error if the delete itself failed, but returns nil
+    # if there was no entry for the given key)
+    #
+    def delete (k)
+      v = self[k]
+      return nil unless v
+      libcall(:tab_out, k, CabinetLib.strlen(k))
+      v
+    end
 
-      #
-      # Prepares and runs a query, returns a ResultSet instance
-      # (takes care of freeing the query structure)
-      #
-      def do_query (&block)
-        q = prepare_query(&block)
-        rs = q.run
-        q.free
-        rs
-      end
+    #
+    # Removes all records in this table database
+    #
+    def clear
+      libcall(:tab_vanish)
+    end
 
-      #
-      # Prepares and runs a query, returns an array of hashes (all Ruby)
-      # (takes care of freeing the query and the result set structures)
-      #
-      def query (&block)
-        rs = do_query(&block)
-        a = rs.to_a
-        rs.free
-        a
-      end
+    #
+    # Returns an array of all the primary keys in the table
+    #
+    # With no options given, this method will return all the keys (strings)
+    # in a Ruby array.
+    #
+    #   :prefix --> returns only the keys who match a given string prefix
+    #
+    #   :limit --> returns a limited number of keys
+    #
+    #   :native --> returns an instance of Rufus::Tokyo::List instead of
+    #     a Ruby Hash, you have to call #free on that List when done with it !
+    #     Else you're exposing yourself to a memory leak.
+    #
+    def keys (options={})
 
-      #
-      # Transaction in a block.
-      #
-      #   table.transaction do
-      #     table['pk0'] => { 'name' => 'Fred', 'age' => '40' }
-      #     table['pk1'] => { 'name' => 'Brooke', 'age' => '76' }
-      #     table.abort if weather.bad?
-      #   end
-      #
-      # If an error or an abort is trigger withing the transaction, it's rolled
-      # back. If the block executes successfully, it gets commited.
-      #
-      def transaction
+      if pref = options[:prefix]
 
-        return unless block_given?
+        l = lib.tab_fwmkeys2(@db, pref, options[:limit] || -1)
+        l = Rufus::Tokyo::List.new(l)
+        options[:native] ? l : l.release
 
-        begin
-          tranbegin
-          yield
-          trancommit
-        rescue Exception => e
-          tranabort
-        end
-      end
+      else
 
-      #
-      # Aborts the enclosing transaction
-      #
-      # See #transaction
-      #
-      def abort
-        raise "abort transaction !"
-      end
+        limit = options[:limit] || -1
+        limit = nil if limit < 1
 
-      #
-      # Warning : this method is low-level, you probably only need
-      # to use #transaction and a block.
-      #
-      # Direct call for 'transaction begin'.
-      #
-      def tranbegin
-        libcall(:tctdbtranbegin)
-      end
+        l = options[:native] ? Rufus::Tokyo::List.new : []
 
-      #
-      # Warning : this method is low-level, you probably only need
-      # to use #transaction and a block.
-      #
-      # Direct call for 'transaction commit'.
-      #
-      def trancommit
-        libcall(:tctdbtrancommit)
-      end
+        lib.tab_iterinit(@db)
 
-      #
-      # Warning : this method is low-level, you probably only need
-      # to use #transaction and a block.
-      #
-      # Direct call for 'transaction abort'.
-      #
-      def tranabort
-        libcall(:tctdbtranabort)
-      end
+        while (k = (lib.tab_iternext2(@db) rescue nil))
+          break if limit and l.size >= limit
+          l << k
+        end
 
-      #
-      # Returns the actual pointer to the Tokyo Cabinet table
-      #
-      def pointer
-        @db
+        l
       end
+    end
 
-      protected
+    #
+    # Deletes all the entries whose key begin with the given prefix.
+    #
+    def delete_keys_with_prefix (prefix)
 
-      #
-      # Returns the value (as a Ruby Hash) else nil
-      #
-      # (the actual #[] method is provided by HashMethods)
-      #
-      def get (k)
-        m = lib.tab_get(@db, k, CabinetLib.strlen(k))
-        return nil if m.address == 0 # :( too bad, but it works
-        Map.to_h(m) # which frees the map
+      ks = lib.tab_fwmkeys2(@db, prefix, -1) # -1 for no limit
+      #Rufus::Tokyo::List.new(ks).release.each { |k| self.delete(k) }
+      begin
+        ks = Rufus::Tokyo::List.new(ks)
+        ks.each { |k| self.delete(k) }
+      ensure
+        ks.free
       end
+    end
 
-      def libcall (lib_method, *args)
-
-        #(lib.send(lib_method, @db, *args) == 1) or raise_error
-          # stack level too deep with JRuby 1.1.6 :(
+    #
+    # Returns the number of records in this table db
+    #
+    def size
+      lib.tab_rnum(@db)
+    end
 
-        (eval(%{ lib.#{lib_method}(@db, *args) }) == 1) or raise_error
-          # works with JRuby 1.1.6
-      end
+    #
+    # Prepares a query instance (block is optional)
+    #
+    def prepare_query (&block)
+      q = TableQuery.new(self)
+      block.call(q) if block
+      q
+    end
 
-      #
-      # Obviously something got wrong, let's ask the db about it and raise
-      # a TokyoError
-      #
-      def raise_error
+    #
+    # Prepares and runs a query, returns a ResultSet instance
+    # (takes care of freeing the query structure)
+    #
+    def do_query (&block)
+      q = prepare_query(&block)
+      rs = q.run
+      q.free
+      rs
+    end
 
-        err_code = lib.tab_ecode(@db)
-        err_msg = lib.tab_errmsg(err_code)
+    #
+    # Prepares and runs a query, returns an array of hashes (all Ruby)
+    # (takes care of freeing the query and the result set structures)
+    #
+    def query (&block)
+      rs = do_query(&block)
+      a = rs.to_a
+      rs.free
+      a
+    end
 
-        raise TokyoError, "(err #{err_code}) #{err_msg}"
-      end
+    #
+    # Warning : this method is low-level, you probably only need
+    # to use #transaction and a block.
+    #
+    # Direct call for 'transaction begin'.
+    #
+    def tranbegin
+      libcall(:tctdbtranbegin)
     end
 
     #
-    # A query on a Tokyo Cabinet table db
+    # Warning : this method is low-level, you probably only need
+    # to use #transaction and a block.
+    #
+    # Direct call for 'transaction commit'.
     #
-    class TableQuery
+    def trancommit
+      libcall(:tctdbtrancommit)
+    end
 
-      OPERATORS = {
+    #
+    # Warning : this method is low-level, you probably only need
+    # to use #transaction and a block.
+    #
+    # Direct call for 'transaction abort'.
+    #
+    def tranabort
+      libcall(:tctdbtranabort)
+    end
 
-        # strings...
+    #
+    # Returns the actual pointer to the Tokyo Cabinet table
+    #
+    def pointer
+      @db
+    end
 
-        :streq => 0, # string equality
-        :eq => 0,
-        :eql => 0,
-        :equals => 0,
+    protected
 
-        :strinc => 1, # string include
-        :inc => 1, # string include
-        :includes => 1, # string include
+    #
+    # Returns the value (as a Ruby Hash) else nil
+    #
+    # (the actual #[] method is provided by HashMethods)
+    #
+    def get (k)
+      m = lib.tab_get(@db, k, CabinetLib.strlen(k))
+      return nil if m.address == 0 # :( too bad, but it works
+      Map.to_h(m) # which frees the map
+    end
 
-        :strbw => 2, # string begins with
-        :bw => 2,
-        :starts_with => 2,
-        :strew => 3, # string ends with
-        :ew => 3,
-        :ends_with => 3,
+    def libcall (lib_method, *args)
 
-        :strand => 4, # string which include all the tokens in the given exp
-        :and => 4,
+      #(lib.send(lib_method, @db, *args) == 1) or raise_error
+        # stack level too deep with JRuby 1.1.6 :(
 
-        :stror => 5, # string which include at least one of the tokens
-        :or => 5,
+      (eval(%{ lib.#{lib_method}(@db, *args) }) == 1) or raise_error
+        # works with JRuby 1.1.6
+    end
 
-        :stroreq => 6, # string which is equal to at least one token
+    #
+    # Obviously something got wrong, let's ask the db about it and raise
+    # a TokyoError
+    #
+    def raise_error
 
-        :strorrx => 7, # string which matches the given regex
-        :regex => 7,
-        :matches => 7,
+      err_code = lib.tab_ecode(@db)
+      err_msg = lib.tab_errmsg(err_code)
 
-        # numbers...
+      raise TokyoError, "(err #{err_code}) #{err_msg}"
+    end
+  end
 
-        :numeq => 8, # equal
-        :numequals => 8,
-        :numgt => 9, # greater than
-        :gt => 9,
-        :numge => 10, # greater or equal
-        :ge => 10,
-        :gte => 10,
-        :numlt => 11, # greater or equal
-        :lt => 11,
-        :numle => 12, # greater or equal
-        :le => 12,
-        :lte => 12,
-        :numbt => 13, # a number between two tokens in the given exp
-        :bt => 13,
-        :between => 13,
+  #
+  # A query on a Tokyo Cabinet table db
+  #
+  class TableQuery
 
-        :numoreq => 14 # number which is equal to at least one token
-      }
+    include QueryConstants
 
-      TDBQCNEGATE = 1 << 24
-      TDBQCNOIDX = 1 << 25
+    #
+    # Creates a query for a given Rufus::Tokyo::Table
+    #
+    # Queries are usually created via the #query (#prepare_query #do_query)
+    # of the Table instance.
+    #
+    # Methods of interest here are :
+    #
+    #   * #add (or #add_condition)
+    #   * #order_by
+    #   * #limit
+    #
+    # also
+    #
+    #   * #pk_only
+    #   * #no_pk
+    #
+    def initialize (table)
+      @table = table
+      @query = @table.lib.qry_new(@table.pointer)
+      @opts = {}
+    end
 
-      DIRECTIONS = {
-        :strasc => 0,
-        :strdesc => 1,
-        :asc => 0,
-        :desc => 1,
-        :numasc => 2,
-        :numdesc => 3
-      }
+    def lib
+      @table.lib
+    end
 
-      #
-      # Creates a query for a given Rufus::Tokyo::Table
-      #
-      # Queries are usually created via the #query (#prepare_query #do_query)
-      # of the Table instance.
-      #
-      # Methods of interest here are :
-      #
-      #   * #add (or #add_condition)
-      #   * #order_by
-      #   * #limit
-      #
-      # also
-      #
-      #   * #pk_only
-      #   * #no_pk
-      #
-      def initialize (table)
-        @table = table
-        @query = @table.lib.qry_new(@table.pointer)
-        @opts = {}
-      end
+    #
+    # Adds a condition
+    #
+    #   table.query { |q|
+    #     q.add 'name', :equals, 'Oppenheimer'
+    #     q.add 'age', :numgt, 35
+    #   }
+    #
+    # Understood 'operators' :
+    #
+    #   :streq # string equality
+    #   :eq
+    #   :eql
+    #   :equals
+    #
+    #   :strinc # string include
+    #   :inc # string include
+    #   :includes # string include
+    #
+    #   :strbw # string begins with
+    #   :bw
+    #   :starts_with
+    #   :strew # string ends with
+    #   :ew
+    #   :ends_with
+    #
+    #   :strand # string which include all the tokens in the given exp
+    #   :and
+    #
+    #   :stror # string which include at least one of the tokens
+    #   :or
+    #
+    #   :stroreq # string which is equal to at least one token
+    #
+    #   :strorrx # string which matches the given regex
+    #   :regex
+    #   :matches
+    #
+    #   # numbers...
+    #
+    #   :numeq # equal
+    #   :numequals
+    #   :numgt # greater than
+    #   :gt
+    #   :numge # greater or equal
+    #   :ge
+    #   :gte
+    #   :numlt # greater or equal
+    #   :lt
+    #   :numle # greater or equal
+    #   :le
+    #   :lte
+    #   :numbt # a number between two tokens in the given exp
+    #   :bt
+    #   :between
+    #
+    #   :numoreq # number which is equal to at least one token
+    #
+    def add (colname, operator, val, affirmative=true, no_index=true)
+      op = operator.is_a?(Fixnum) ? operator : OPERATORS[operator]
+      op = op | TDBQCNEGATE unless affirmative
+      op = op | TDBQCNOIDX if no_index
+      lib.qry_addcond(@query, colname, op, val)
+    end
+    alias :add_condition :add
 
-      def lib
-        @table.lib
-      end
+    #
+    # Sets the max number of records to return for this query.
+    #
+    # (sorry no 'offset' as of now)
+    #
+    def limit (i)
+      lib.qry_setmax(@query, i)
+    end
 
-      #
-      # Adds a condition
-      #
-      #   table.query { |q|
-      #     q.add 'name', :equals, 'Oppenheimer'
-      #     q.add 'age', :numgt, 35
-      #   }
-      #
-      # Understood 'operators' :
-      #
-      #   :streq # string equality
-      #   :eq
-      #   :eql
-      #   :equals
-      #
-      #   :strinc # string include
-      #   :inc # string include
-      #   :includes # string include
-      #
-      #   :strbw # string begins with
-      #   :bw
-      #   :starts_with
-      #   :strew # string ends with
-      #   :ew
-      #   :ends_with
-      #
-      #   :strand # string which include all the tokens in the given exp
-      #   :and
-      #
-      #   :stror # string which include at least one of the tokens
-      #   :or
-      #
-      #   :stroreq # string which is equal to at least one token
-      #
-      #   :strorrx # string which matches the given regex
-      #   :regex
-      #   :matches
-      #
-      #   # numbers...
-      #
-      #   :numeq # equal
-      #   :numequals
-      #   :numgt # greater than
-      #   :gt
-      #   :numge # greater or equal
-      #   :ge
-      #   :gte
-      #   :numlt # greater or equal
-      #   :lt
-      #   :numle # greater or equal
-      #   :le
-      #   :lte
-      #   :numbt # a number between two tokens in the given exp
-      #   :bt
-      #   :between
-      #
-      #   :numoreq # number which is equal to at least one token
-      #
-      def add (colname, operator, val, affirmative=true, no_index=true)
-        op = operator.is_a?(Fixnum) ? operator : OPERATORS[operator]
-        op = op | TDBQCNEGATE unless affirmative
-        op = op | TDBQCNOIDX if no_index
-        lib.qry_addcond(@query, colname, op, val)
-      end
-      alias :add_condition :add
+    #
+    # Sets the sort order for the result of the query
+    #
+    # The 'direction' may be :
+    #
+    #   :strasc # string ascending
+    #   :strdesc
+    #   :asc # string ascending
+    #   :desc
+    #   :numasc # number ascending
+    #   :numdesc
+    #
+    def order_by (colname, direction=:strasc)
+      lib.qry_setorder(@query, colname, DIRECTIONS[direction])
+    end
 
-      #
-      # Sets the max number of records to return for this query.
-      #
-      # (sorry no 'offset' as of now)
-      #
-      def limit (i)
-        lib.qry_setmax(@query, i)
-      end
+    #
+    # When set to true, only the primary keys of the matching records will
+    # be returned.
+    #
+    def pk_only (on=true)
+      @opts[:pk_only] = on
+    end
 
-      #
-      # Sets the sort order for the result of the query
-      #
-      # The 'direction' may be :
-      #
-      #   :strasc # string ascending
-      #   :strdesc
-      #   :asc # string ascending
-      #   :desc
-      #   :numasc # number ascending
-      #   :numdesc
-      #
-      def order_by (colname, direction=:strasc)
-        lib.qry_setorder(@query, colname, DIRECTIONS[direction])
-      end
+    #
+    # When set to true, the :pk (primary key) is not inserted in the record
+    # (hashes) returned
+    #
+    def no_pk (on=true)
+      @opts[:no_pk] = on
+    end
 
-      #
-      # When set to true, only the primary keys of the matching records will
-      # be returned.
-      #
-      def pk_only (on=true)
-        @opts[:pk_only] = on
-      end
+    #
+    # Runs this query (returns a TableResultSet instance)
+    #
+    def run
+      TableResultSet.new(@table, lib.qry_search(@query), @opts)
+    end
 
-      #
-      # When set to true, the :pk (primary key) is not inserted in the record
-      # (hashes) returned
-      #
-      def no_pk (on=true)
-        @opts[:no_pk] = on
-      end
+    #
+    # Frees this data structure
+    #
+    def free
+      lib.qry_del(@query)
+      @query = nil
+    end
 
-      #
-      # Runs this query (returns a TableResultSet instance)
-      #
-      def run
-        TableResultSet.new(@table, lib.qry_search(@query), @opts)
-      end
+    alias :close :free
+    alias :destroy :free
+  end
 
-      #
-      # Frees this data structure
-      #
-      def free
-        lib.qry_del(@query)
-        @query = nil
-      end
+  #
+  # The thing queries return
+  #
+  class TableResultSet
+    include Enumerable
 
-      alias :close :free
-      alias :destroy :free
+    def initialize (table, list_pointer, query_opts)
+      @table = table
+      @list = list_pointer
+      @opts = query_opts
     end
 
     #
-    # The thing queries return
+    # Returns the count of element in this result set
     #
-    class TableResultSet
-      include Enumerable
-
-      def initialize (table, list_pointer, query_opts)
-        @table = table
-        @list = list_pointer
-        @opts = query_opts
-      end
-
-      #
-      # Returns the count of element in this result set
-      #
-      def size
-        CabinetLib.tclistnum(@list)
-      end
+    def size
+      CabinetLib.tclistnum(@list)
+    end
 
-      alias :length :size
+    alias :length :size
 
-      #
-      # The classical each
-      #
-      def each
-        (0..size-1).each do |i|
-          pk = CabinetLib.tclistval2(@list, i)
-          if @opts[:pk_only]
-            yield(pk)
-          else
-            val = @table[pk]
-            val[:pk] = pk unless @opts[:no_pk]
-            yield(val)
-          end
+    #
+    # The classical each
+    #
+    def each
+      (0..size-1).each do |i|
+        pk = CabinetLib.tclistval2(@list, i)
+        if @opts[:pk_only]
+          yield(pk)
+        else
+          val = @table[pk]
+          val[:pk] = pk unless @opts[:no_pk]
+          yield(val)
         end
       end
+    end
 
-      #
-      # Returns an array of hashes
-      #
-      def to_a
-        collect { |m| m }
-      end
-
-      #
-      # Frees this query (the underlying Tokyo Cabinet list structure)
-      #
-      def free
-        CabinetLib.tclistdel(@list)
-        @list = nil
-      end
+    #
+    # Returns an array of hashes
+    #
+    def to_a
+      collect { |m| m }
+    end
 
-      alias :close :free
-      alias :destroy :free
+    #
+    # Frees this query (the underlying Tokyo Cabinet list structure)
+    #
+    def free
+      CabinetLib.tclistdel(@list)
+      @list = nil
     end
 
+    alias :close :free
+    alias :destroy :free
   end
 end
+