rufus-tokyo 0.1.4 → 0.1.5

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

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

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

@@ -28,515 +28,607 @@
 # jmettraux@gmail.com
 #
 
-require 'rufus/tokyo/cabinet/lib'
-require 'rufus/tokyo/cabinet/util'
-
-
-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 CabinetLibMixin
-    include TokyoContainerMixin
-    include HashMethods
+module Rufus
+  module Tokyo
 
-    #
-    # Creates a Table instance (creates or opens it depending on the args)
-    #
-    # For example,
-    #
-    #   t = Rufus::Tokyo::Table.new('table.tdb', :create, :write)
-    #     # '.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.
-    # Note that the suffix (.tdc) is relevant to Tokyo Cabinet, using another
-    # will result in a Tokyo Cabinet error.
-    #
-    def initialize (*args)
+    module OpenModes
 
-      path = args.first # car
-      params = args[1..-1] # cdr
+      #
+      # some Tokyo constants
 
-      mode = compute_open_mode(params)
+      OREADER = 1 << 0 # open as a reader
+      OWRITER = 1 << 1 # open as a writer
+      OCREAT = 1 << 2 # writer creating
+      OTRUNC = 1 << 3 # writer truncating
+      ONOLCK = 1 << 4 # open without locking
+      OLCKNB = 1 << 5 # lock without blocking
 
-      @db = self.lib.tctdbnew
+      OTSYNC = 1 << 6 # synchronize every transaction (tctdb.h)
 
-      (lib.tctdbopen(@db, path, compute_open_mode(params)) == 1 ) || raise_error
-    end
+      #
+      # Makes sure that a set of parameters is a hash (will transform an
+      # array into a hash if necessary)
+      #
+      def params_to_h (params)
 
-    #
-    # Closes the table (and frees the datastructure allocated for it),
-    # returns true in case of success.
-    #
-    def close
-      result = lib.tctdbclose(@db)
-      lib.tctdbdel(@db)
-      (result == 1)
+        params.is_a?(Hash) ?
+        params :
+          Array(params).inject({}) { |h, e| h[e] = true; h }
+      end
+
+      #
+      # Given params (array or hash), computes the open mode (an int)
+      # for the Tokyo Cabinet object.
+      #
+      def compute_open_mode (params)
+
+        params = params_to_h(params)
+
+        i = {
+          :read => OREADER,
+          :reader => OREADER,
+          :write => OWRITER,
+          :writer => OWRITER,
+          :create => OCREAT,
+          :truncate => OTRUNC,
+          :no_lock => ONOLCK,
+          :lock_no_block => OLCKNB,
+          :sync_every => OTSYNC
+
+        }.inject(0) { |r, (k, v)|
+
+          r = r | v if params[k]; r
+        }
+
+        unless params[:read_only] || params[:readonly]
+          i = i | OCREAT
+          i = i | OWRITER
+        end
+
+        i
+      end
     end
 
     #
-    # Generates a unique id (in the context of this Table instance)
+    # A 'table' a table database.
     #
-    def generate_unique_id
-      lib.tctdbgenuid(@db)
-    end
-    alias :genuid :generate_unique_id
-
+    #   http://alpha.mixi.co.jp/blog/?p=290
+    #   http://tokyocabinet.sourceforge.net/spex-en.html#tctdbapi
     #
-    # Accepts a variable number of arguments, at least two. First one
-    # is the primary key of the record, the others are the columns.
+    # A short example :
     #
-    # One can also directly write
+    #   require 'rubygems'
+    #   require 'rufus/tokyo/cabinet/table'
     #
-    #   table['one'] = [ 'name', 'toto', 'age', '33' ]
-    #   table['two'] = [ 'name', 'fred', 'age', '45' ]
+    #   t = Rufus::Tokyo::Table.new('table.tdb', :create, :write)
+    #     # '.tdb' suffix is a must
     #
-    # instead of
+    #   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' }
     #
-    #   table.tabbed_put('one', 'name', 'toto', 'age', '33')
-    #   table.tabbed_put('two', 'name', 'fred', 'age', '45')
+    #   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"} ]
     #
-    # beware : inserting an array uses a tab separator...
+    #   t.close
     #
-    def tabbed_put (pk, *args)
+    class Table
 
-      cols = args.collect { |e| e.to_s }.join("\t")
+      include HashMethods
+      include OpenModes
 
-      (lib.tctdbput3(@db, pk, cols) == 1) || raise_error
+      #
+      # Creates a Table instance (creates or opens it depending on the args)
+      #
+      # For example,
+      #
+      #   t = Rufus::Tokyo::Table.new('table.tdb', :create, :write)
+      #     # '.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.
+      # Note that the suffix (.tdc) is relevant to Tokyo Cabinet, using another
+      # will result in a Tokyo Cabinet error.
+      #
+      def initialize (*args)
 
-      args
-    end
+        path = args.first # car
+        params = args[1..-1] # cdr
 
-    #
-    # Inserts a record in the table db
-    #
-    #   table['pk0'] = [ 'name', 'fred', 'age', '45' ]
-    #   table['pk1'] = { 'name' => 'jeff', 'age' => '46' }
-    #
-    def []= (pk, h_or_a)
+        mode = compute_open_mode(params)
 
-      return tabbed_put(pk, *h_or_a) if h_or_a.is_a?(Array)
+        @db = lib.tctdbnew
 
-      pklen = lib.strlen(pk)
+        (lib.tctdbopen(@db, path, mode) == 1 ) || raise_error
+      end
 
-      m = Rufus::Tokyo::Map.from_h(h_or_a)
+      #
+      # using the cabinet lib
+      #
+      def lib
+        CabinetLib
+      end
 
-      r = lib.tctdbput(@db, pk, pklen, m.pointer)
+      #
+      # 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
 
-      m.free
+      #
+      # 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)
+
+        column_name = '' if column_name == :pk
+
+        i = types.inject(0) { |i, t| i = i & INDEX_TYPES[t]; i }
+
+        (lib.tab_setindex(@db, column_name, i) == 1)
+      end
 
-      (r == 1) || raise_error
+      #
+      # Accepts a variable number of arguments, at least two. First one
+      # is the primary key of the record, the others are the columns.
+      #
+      # One can also directly write
+      #
+      #   table['one'] = [ 'name', 'toto', 'age', '33' ]
+      #   table['two'] = [ 'name', 'fred', 'age', '45' ]
+      #
+      # instead of
+      #
+      #   table.tabbed_put('one', 'name', 'toto', 'age', '33')
+      #   table.tabbed_put('two', 'name', 'fred', 'age', '45')
+      #
+      # beware : inserting an array uses a tab separator...
+      #
+      def tabbed_put (pk, *args)
+
+        cols = args.collect { |e| e.to_s }.join("\t")
+
+        (CabinetLib.tctdbput3(@db, pk, cols) == 1) || raise_error
+
+        args
+      end
 
-      h_or_a
-    end
+      #
+      # Inserts a record in the table db
+      #
+      #   table['pk0'] = [ 'name', 'fred', 'age', '45' ]
+      #   table['pk1'] = { 'name' => 'jeff', 'age' => '46' }
+      #
+      def []= (pk, h_or_a)
 
-    #
-    # 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
-      (lib.tctdbout2(@db, k) == 1) || raise_error
-      v
-    end
+        return tabbed_put(pk, *h_or_a) if h_or_a.is_a?(Array)
 
-    #
-    # Removes all records in this table database
-    #
-    def clear
-      (lib.tctdbvanish(@db) == 1) || raise_error
-    end
+        pklen = CabinetLib.strlen(pk)
 
-    #
-    # Returns the value (as a Ruby Hash) else nil
-    #
-    # (the actual #[] method is provided by HashMethods)
-    #
-    def get (k)
-      m = lib.tctdbget(@db, k, lib.strlen(k))
-      return nil if m.address == 0 # :( too bad, but it works
-      Rufus::Tokyo::Map.to_h(m) # which frees the map
-    end
-    protected :get
+        m = Map.from_h(h_or_a)
 
-    #
-    # Returns an array of all the primary keys in the table
-    #
-    def keys
-      a = []
-      lib.tctdbiterinit(@db)
-      while (k = (lib.tctdbiternext2(@db) rescue nil)); a << k; end
-      a
-    end
+        r = lib.tab_put(@db, pk, pklen, m.pointer)
 
-    #
-    # Returns the number of records in this table db
-    #
-    def size
-      lib.tctdbrnum(@db)
-    end
+        m.free
 
-    #
-    # Prepares a query instance (block is optional)
-    #
-    def prepare_query (&block)
-      q = TableQuery.new(self)
-      block.call(q) if block
-      q
-    end
+        (r == 1) || 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
+        h_or_a
+      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
+      #
+      # 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
+        (lib.tab_out(@db, k, CabinetLib.strlen(k)) == 1) || raise_error
+        v
+      end
 
-    #
-    # Returns the actual pointer to the Tokyo Cabinet table
-    #
-    def pointer
-      @db
-    end
+      #
+      # Removes all records in this table database
+      #
+      def clear
+        (lib.tab_vanish(@db) == 1) || raise_error
+      end
 
-    protected
+      #
+      # 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
+      protected :get
+
+      #
+      # Returns an array of all the primary keys in the table
+      #
+      def keys
+        a = []
+        lib.tab_iterinit(@db)
+        while (k = (lib.tab_iternext2(@db) rescue nil)); a << k; end
+        a
+      end
 
-    #
-    # Obviously something got wrong, let's ask the db about it and raise
-    # a TokyoError
-    #
-    def raise_error
+      #
+      # Returns the number of records in this table db
+      #
+      def size
+        lib.tab_rnum(@db)
+      end
 
-      err_code = lib.tctdbecode(@db)
-      err_msg = lib.tctdberrmsg(err_code)
+      #
+      # Prepares a query instance (block is optional)
+      #
+      def prepare_query (&block)
+        q = TableQuery.new(self)
+        block.call(q) if block
+        q
+      end
 
-      raise TokyoError, "(err #{err_code}) #{err_msg}"
-    end
-  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
 
-  #
-  # A query on a Tokyo Cabinet table db
-  #
-  class TableQuery
-    include CabinetLibMixin
-
-    OPERATORS = {
-
-      # strings...
-
-      :streq => 0, # string equality
-      :eq => 0,
-      :eql => 0,
-      :equals => 0,
-
-      :strinc => 1, # string include
-      :inc => 1, # string include
-      :includes => 1, # string include
-
-      :strbw => 2, # string begins with
-      :bw => 2,
-      :starts_with => 2,
-      :strew => 3, # string ends with
-      :ew => 3,
-      :ends_with => 3,
-
-      :strand => 4, # string which include all the tokens in the given exp
-      :and => 4,
-
-      :stror => 5, # string which include at least one of the tokens
-      :or => 5,
-
-      :stroreq => 6, # string which is equal to at least one token
-
-      :strorrx => 7, # string which matches the given regex
-      :regex => 7,
-      :matches => 7,
-
-      # numbers...
-
-      :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,
-
-      :numoreq => 14 # number which is equal to at least one token
-    }
-
-    TDBQCNEGATE = 1 << 24
-    TDBQCNOIDX = 1 << 25
-
-    DIRECTIONS = {
-      :strasc => 0,
-      :strdesc => 1,
-      :asc => 0,
-      :desc => 1,
-      :numasc => 2,
-      :numdesc => 3
-    }
+      #
+      # 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
 
-    #
-    # 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 = lib.tctdbqrynew(@table.pointer)
-      @opts = {}
-    end
+      #
+      # Returns the actual pointer to the Tokyo Cabinet table
+      #
+      def pointer
+        @db
+      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.tctdbqryaddcond(@query, colname, op, val)
-    end
-    alias :add_condition :add
+      protected
 
-    #
-    # Sets the max number of records to return for this query.
-    #
-    # (sorry no 'offset' as of now)
-    #
-    def limit (i)
-      lib.tctdbqrysetmax(@query, i)
-    end
+      #
+      # Obviously something got wrong, let's ask the db about it and raise
+      # a TokyoError
+      #
+      def raise_error
 
-    #
-    # 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.tctdbqrysetorder(@query, colname, DIRECTIONS[direction])
-    end
+        err_code = lib.tab_ecode(@db)
+        err_msg = lib.tab_errmsg(err_code)
 
-    #
-    # When set to true, only the primary keys of the matching records will
-    # be returned.
-    #
-    def pk_only (on=true)
-      @opts[:pk_only] = on
+        raise TokyoError, "(err #{err_code}) #{err_msg}"
+      end
     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
+    # A query on a Tokyo Cabinet table db
+    #
+    class TableQuery
+
+      OPERATORS = {
+
+        # strings...
+
+        :streq => 0, # string equality
+        :eq => 0,
+        :eql => 0,
+        :equals => 0,
+
+        :strinc => 1, # string include
+        :inc => 1, # string include
+        :includes => 1, # string include
+
+        :strbw => 2, # string begins with
+        :bw => 2,
+        :starts_with => 2,
+        :strew => 3, # string ends with
+        :ew => 3,
+        :ends_with => 3,
+
+        :strand => 4, # string which include all the tokens in the given exp
+        :and => 4,
+
+        :stror => 5, # string which include at least one of the tokens
+        :or => 5,
+
+        :stroreq => 6, # string which is equal to at least one token
+
+        :strorrx => 7, # string which matches the given regex
+        :regex => 7,
+        :matches => 7,
+
+        # numbers...
+
+        :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,
+
+        :numoreq => 14 # number which is equal to at least one token
+      }
+
+      TDBQCNEGATE = 1 << 24
+      TDBQCNOIDX = 1 << 25
+
+      DIRECTIONS = {
+        :strasc => 0,
+        :strdesc => 1,
+        :asc => 0,
+        :desc => 1,
+        :numasc => 2,
+        :numdesc => 3
+      }
+
+      #
+      # 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
 
-    #
-    # Runs this query (returns a TableResultSet instance)
-    #
-    def run
-      TableResultSet.new(@table, lib.tctdbqrysearch(@query), @opts)
-    end
+      def lib
+        @table.lib
+      end
 
-    #
-    # Frees this data structure
-    #
-    def free
-      lib.tctdbqrydel(@query)
-      @query = nil
-    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 max number of records to return for this query.
+      #
+      # (sorry no 'offset' as of now)
+      #
+      def limit (i)
+        lib.qry_setmax(@query, i)
+      end
 
-    alias :close :free
-    alias :destroy :free
-  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, only the primary keys of the matching records will
+      # be returned.
+      #
+      def pk_only (on=true)
+        @opts[:pk_only] = on
+      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
+
+      #
+      # Runs this query (returns a TableResultSet instance)
+      #
+      def run
+        TableResultSet.new(@table, lib.qry_search(@query), @opts)
+      end
 
-  #
-  # The thing queries return
-  #
-  class TableResultSet
-    include CabinetLibMixin
-    include Enumerable
-
-    def initialize (table, list_pointer, query_opts)
-      @table = table
-      @list = list_pointer
-      @opts = query_opts
+      #
+      # Frees this data structure
+      #
+      def free
+        lib.qry_del(@query)
+        @query = nil
+      end
+
+      alias :close :free
+      alias :destroy :free
     end
 
     #
-    # Returns the count of element in this result set
+    # The thing queries return
     #
-    def size
-      lib.tclistnum(@list)
-    end
+    class TableResultSet
+      include Enumerable
 
-    alias :length :size
+      def initialize (table, list_pointer, query_opts)
+        @table = table
+        @list = list_pointer
+        @opts = query_opts
+      end
 
-    #
-    # The classical each
-    #
-    def each
-      (0..size-1).each do |i|
-        pk = lib.tclistval2(@list, i)
-        if @opts[:pk_only]
-          yield(pk)
-        else
-          val = @table[pk]
-          val[:pk] = pk unless @opts[:no_pk]
-          yield(val)
+      #
+      # Returns the count of element in this result set
+      #
+      def size
+        CabinetLib.tclistnum(@list)
+      end
+
+      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
         end
       end
-    end
 
-    #
-    # Returns an array of hashes
-    #
-    def to_a
-      collect { |m| m }
-    end
+      #
+      # Returns an array of hashes
+      #
+      def to_a
+        collect { |m| m }
+      end
 
-    #
-    # Frees this query (the underlying Tokyo Cabinet list structure)
-    #
-    def free
-      lib.tclistdel(@list)
-      @list = nil
+      #
+      # Frees this query (the underlying Tokyo Cabinet list structure)
+      #
+      def free
+        CabinetLib.tclistdel(@list)
+        @list = nil
+      end
+
+      alias :close :free
+      alias :destroy :free
     end
 
-    alias :close :free
-    alias :destroy :free
   end
 end
-