rufus-tokyo 0.1.12 → 0.1.13

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

@@ -69,7 +69,6 @@ module Rufus::Tokyo
       # this class has tranbegin/trancommit/tranabort so let's include the
       # transaction mixin
 
-    #
     # Creates a Table instance (creates or opens it depending on the args)
     #
     # For example,
@@ -111,6 +110,9 @@ module Rufus::Tokyo
     #              not more than 0, the extra mapped memory is disabled.
     #              The default size is 67108864.
     #
+    #   * :dfunit  unit step number. If it is not more than 0,
+    #              the auto defragmentation is disabled. (Since TC 1.4.21)
+    #
     # Some examples :
     #
     #   t = Rufus::Tokyo::Table.new('table.tdb')
@@ -139,33 +141,46 @@ module Rufus::Tokyo
 
       libcall(:tctdbsetxmsiz, conf[:xmsiz])
 
+      libcall(:tctdbsetdfunit, conf[:dfunit]) \
+        if lib.respond_to?(:tctdbsetdfunit) # TC >= 1.4.21
+
       #
       # open table
 
-      libcall(:tctdbopen, conf[:path], conf[:mode])
+      @path = conf[:path]
+
+      libcall(:tctdbopen, @path, conf[:mode])
     end
 
-    #
-    # using the cabinet lib
+    # Using the cabinet lib
     #
     def lib
+
       CabinetLib
     end
 
+    # Returns the path to the table.
     #
+    def path
+
+      @path
+    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
 
-    #
     # 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
@@ -178,7 +193,6 @@ module Rufus::Tokyo
       :keep => 1 << 24
     }
 
-    #
     # Sets an index on a column of the table.
     #
     # Types maybe be :lexical or :decimal, use :keep to "add" and
@@ -197,7 +211,6 @@ module Rufus::Tokyo
       (lib.tab_setindex(@db, column_name, i) == 1)
     end
 
-    #
     # Inserts a record in the table db
     #
     #   table['pk0'] = [ 'name', 'fred', 'age', '45' ]
@@ -213,7 +226,7 @@ module Rufus::Tokyo
 
       m = Rufus::Tokyo::Map[h_or_a]
 
-      r = lib.tab_put(@db, pk, CabinetLib.strlen(pk), m.pointer)
+      r = lib.tab_put(@db, pk, Rufus::Tokyo.blen(pk), m.pointer)
 
       m.free
 
@@ -222,27 +235,27 @@ module Rufus::Tokyo
       h_or_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
-      libcall(:tab_out, k, CabinetLib.strlen(k))
+      libcall(:tab_out, k, Rufus::Tokyo.blen(k))
+
       v
     end
 
-    #
     # Removes all records in this table database
     #
     def clear
+
       libcall(:tab_vanish)
     end
 
-    #
     # Returns an array of all the primary keys in the table
     #
     # With no options given, this method will return all the keys (strings)
@@ -258,10 +271,15 @@ module Rufus::Tokyo
     #
     def keys (options={})
 
-      if pref = options[:prefix]
+      outlen = nil
+
+      if pre = options[:prefix]
+
+        l = lib.tab_fwmkeys(
+          @db, pre, Rufus::Tokyo.blen(pre), options[:limit] || -1)
 
-        l = lib.tab_fwmkeys2(@db, pref, options[:limit] || -1)
         l = Rufus::Tokyo::List.new(l)
+
         options[:native] ? l : l.release
 
       else
@@ -273,24 +291,32 @@ module Rufus::Tokyo
 
         lib.tab_iterinit(@db)
 
-        while (k = (lib.tab_iternext2(@db) rescue nil))
+        outlen = FFI::MemoryPointer.new(:int)
+
+        loop do
           break if limit and l.size >= limit
-          l << k
+          out = lib.tab_iternext(@db, outlen)
+          break if out.address == 0
+          l << out.get_bytes(0, outlen.get_int(0))
         end
 
         l
       end
+
+    ensure
+
+      outlen.free if outlen
     end
 
-    #
     # Deletes all the entries whose key begin with the given prefix.
     #
     def delete_keys_with_prefix (prefix)
 
       # TODO : use ...searchout
 
-      ks = lib.tab_fwmkeys2(@db, prefix, -1) # -1 for no limit
-      #Rufus::Tokyo::List.new(ks).release.each { |k| self.delete(k) }
+      ks = lib.tab_fwmkeys(@db, prefix, Rufus::Tokyo.blen(prefix), -1)
+        # -1 for no limit
+
       begin
         ks = Rufus::Tokyo::List.new(ks)
         ks.each { |k| self.delete(k) }
@@ -299,41 +325,55 @@ module Rufus::Tokyo
       end
     end
 
+    # No 'misc' methods for the table library, so this lget is equivalent
+    # to calling get for each key. Hoping later versions of TC will provide
+    # a mget method.
     #
+    def lget (keys)
+
+      # TODO : maybe investigate a query on the column 'primary_key' ?
+
+      keys.inject({}) { |h, k| v = self[k]; h[k] = v if v; h }
+    end
+
     # Returns the number of records in this table db
     #
     def size
+
       lib.tab_rnum(@db)
     end
 
-    #
     # Prepares a query instance (block is optional)
     #
     def prepare_query (&block)
+
       q = TableQuery.new(self)
       block.call(q) if block
+
       q
     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
 
-    #
     # 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
 
@@ -343,6 +383,7 @@ module Rufus::Tokyo
     # Direct call for 'transaction begin'.
     #
     def tranbegin
+
       libcall(:tctdbtranbegin)
     end
 
@@ -364,7 +405,6 @@ module Rufus::Tokyo
       libcall(:tctdbtranabort)
     end
 
-    #
     # Returns the actual pointer to the Tokyo Cabinet table
     #
     def pointer
@@ -373,14 +413,16 @@ module Rufus::Tokyo
 
     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
+
+      m = lib.tab_get(@db, k, Rufus::Tokyo.blen(k))
+
+      return nil if m.address == 0
+
       Map.to_h(m) # which frees the map
     end
 
@@ -393,7 +435,6 @@ module Rufus::Tokyo
         # works with JRuby 1.1.6
     end
 
-    #
     # Obviously something got wrong, let's ask the db about it and raise
     # a TokyoError
     #
@@ -413,7 +454,6 @@ module Rufus::Tokyo
 
     include QueryConstants
 
-    #
     # Creates a query for a given Rufus::Tokyo::Table
     #
     # Queries are usually created via the #query (#prepare_query #do_query)
@@ -440,7 +480,6 @@ module Rufus::Tokyo
       @table.lib
     end
 
-    #
     # Adds a condition
     #
     #   table.query { |q|
@@ -507,7 +546,6 @@ module Rufus::Tokyo
     end
     alias :add_condition :add
 
-    #
     # Sets the max number of records to return for this query.
     #
     # (If you're using TC >= 1.4.10 the optional 'offset' (skip) parameter
@@ -520,7 +558,6 @@ module Rufus::Tokyo
         lib.qry_setmax(@query, i)
     end
 
-    #
     # Sets the sort order for the result of the query
     #
     # The 'direction' may be :
@@ -536,7 +573,6 @@ module Rufus::Tokyo
       lib.qry_setorder(@query, colname, DIRECTIONS[direction])
     end
 
-    #
     # When set to true, only the primary keys of the matching records will
     # be returned.
     #
@@ -544,7 +580,6 @@ module Rufus::Tokyo
       @opts[:pk_only] = on
     end
 
-    #
     # When set to true, the :pk (primary key) is not inserted in the record
     # (hashes) returned
     #
@@ -552,7 +587,6 @@ module Rufus::Tokyo
       @opts[:no_pk] = on
     end
 
-    #
     # Runs this query (returns a TableResultSet instance)
     #
     def run
@@ -561,7 +595,6 @@ module Rufus::Tokyo
         TableResultSet.new(@table, lib.qry_search(@query), @opts)
     end
 
-    #
     # Gets the count of records returned by this query.
     #
     # Note : the 'real' impl is only available since TokyoCabinet 1.4.12.
@@ -575,7 +608,6 @@ module Rufus::Tokyo
       end
     end
 
-    #
     # Frees this data structure
     #
     def free
@@ -591,29 +623,30 @@ module Rufus::Tokyo
   # The thing queries return
   #
   class TableResultSet
+
     include Enumerable
 
     def initialize (table, list_pointer, query_opts)
+
       @table = table
-      @list = list_pointer
+      @list = Rufus::Tokyo::List.new(list_pointer)
       @opts = query_opts
     end
 
-    #
     # Returns the count of element in this result set
     #
     def size
-      CabinetLib.tclistnum(@list)
+
+      @list.size
     end
 
     alias :length :size
 
-    #
     # The classical each
     #
     def each
       (0..size-1).each do |i|
-        pk = CabinetLib.tclistval2(@list, i)
+        pk = @list[i]
         if @opts[:pk_only]
           yield(pk)
         else
@@ -624,18 +657,18 @@ module Rufus::Tokyo
       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.free
       @list = nil
     end
 

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

@@ -28,6 +28,49 @@ require 'rufus/tokyo/hmethods'
 
 module Rufus::Tokyo
 
+  #
+  # :nodoc:
+  #
+  module ListMapMixin
+
+    # A shortcut
+    #
+    def clib
+
+      CabinetLib
+    end
+
+    # Returns the underlying 'native' (FFI) memory pointer
+    #
+    def pointer
+
+      @pointer
+    end
+
+    def pointer_or_raise
+
+      @pointer || raise("#{self.class} got freed, cannot use anymore")
+    end
+
+    def outlen_op (method, *args)
+
+      args.unshift(pointer_or_raise)
+
+      outlen = FFI::MemoryPointer.new(:int)
+      args << outlen
+
+      out = clib.send(method, *args)
+
+      return nil if out.address == 0
+
+      return out.get_bytes(0, outlen.get_int(0))
+
+    ensure
+
+      outlen.free
+    end
+  end
+
   #
   # A Tokyo Cabinet in-memory (tcutil.h) map
   #
@@ -36,117 +79,118 @@ module Rufus::Tokyo
   class Map
 
     include HashMethods
+    include ListMapMixin
 
-    #
     # Creates an empty instance of a Tokyo Cabinet in-memory map
     #
     # (It's OK to pass the pointer of a C map directly, this is in fact
     # used in rufus/tokyo/table when retrieving entries)
     #
-    def initialize (pointer = nil)
-      @map = pointer || clib.tcmapnew
-    end
+    def initialize (pointer=nil)
 
-    #
-    # a shortcut
-    #
-    def clib
-      CabinetLib
+      @pointer = pointer || clib.tcmapnew
     end
 
-    #
     # Inserts key/value pair
     #
     def []= (k, v)
-      clib.tcmapput2(m, k, v)
+
+      clib.tcmapput(pointer, k, Rufus::Tokyo::blen(k), v, Rufus::Tokyo::blen(v))
+
       v
     end
 
-    #
     # Deletes an entry
     #
     def delete (k)
+
       v = self[k]
       return nil unless v
-      (clib.tcmapout2(m, k) == 1) || raise("failed to remove key '#{k}'")
+
+      (clib.tcmapout(pointer_or_raise, k, Rufus::Tokyo::blen(k)) == 1) ||
+        raise("failed to remove key '#{k}'")
+
       v
     end
 
-    #
     # Empties the map
     #
     def clear
-      clib.tcmapclear(m)
+
+      clib.tcmapclear(pointer_or_raise)
     end
 
-    #
     # (the actual #[] method is provided by HashMethods)
     #
     def get (k)
-      m; clib.tcmapget2(m, k) rescue nil
+
+      outlen_op(:tcmapget, k, Rufus::Tokyo.blen(k))
     end
     protected :get
 
-    #
     # Returns an array of all the keys in the map
     #
     def keys
+
+      clib.tcmapiterinit(pointer_or_raise)
       a = []
-      clib.tcmapiterinit(m)
-      while (k = (clib.tcmapiternext2(m) rescue nil)); a << k; end
-      a
+
+      klen = FFI::MemoryPointer.new(:int)
+
+      loop do
+        k = clib.tcmapiternext(@pointer, klen)
+        break if k.address == 0
+        a << k.get_bytes(0, klen.get_int(0))
+      end
+
+      return a
+
+    ensure
+
+      klen.free
     end
 
-    #
     # Returns the count of entries in the map
     #
     def size
-      clib.tcmaprnum(m)
+
+      clib.tcmaprnum(pointer_or_raise)
     end
 
     alias :length :size
 
-    #
     # Frees the map (nukes it from memory)
     #
     def free
-      clib.tcmapdel(@map)
-      @map = nil
+
+      clib.tcmapdel(pointer_or_raise)
+      @pointer = nil
     end
 
     alias :destroy :free
     alias :close :free
 
-    #
-    # Returns the pointer to the underlying Tokyo Cabinet map
-    #
-    def pointer
-      @map || raise('map got freed, cannot use anymore')
-    end
-
-    alias :m :pointer
-
-    #
     # Turns a given Tokyo map structure into a Ruby Hash. By default
     # (free = true) will dispose of the map before replying with the Ruby
     # Hash.
     #
     def self.to_h (map_pointer, free=true)
+
       m = self.new(map_pointer)
       h = m.to_h
       m.free if free
+
       h
     end
 
-    #
     # Turns a Ruby hash into a Tokyo Cabinet Map and returns it
     # (don't forget to free the map when you're done with it !)
     #
     def self.from_h (h)
+
       h.inject(Map.new) { |m, (k, v)| m[k] = v; m }
     end
 
-    #
     # Behaves much like Hash#[] but outputs a Rufus::Tokyo::Map
     # (don't forget to free the map when you're done with it !)
     #
@@ -166,9 +210,10 @@ module Rufus::Tokyo
   # http://tokyocabinet.sourceforge.net/spex-en.html#tcutilapi
   #
   class List
+
     include Enumerable
+    include ListMapMixin
 
-    #
     # Creates a new Tokyo Cabinet list.
     #
     # (by passing a list pointer, one can wrap an existing list pointer
@@ -177,71 +222,70 @@ module Rufus::Tokyo
     def initialize (list_pointer=nil)
 
       if list_pointer.is_a?(FFI::Pointer)
-        @list = list_pointer
+        @pointer = list_pointer
       else
-        @list = clib.tclistnew
+        @pointer = clib.tclistnew
         list_pointer.each { |e| self << e } if list_pointer
       end
     end
 
-    #
-    # a shortcut
-    #
-    def clib
-      CabinetLib
-    end
-
-    #
     # Inserts an element in the list (note that the lib will raise an
     # ArgumentError if s is not a String)
     #
     def << (s)
-      clib.tclistpush2(@list, s)
+
+      clib.tclistpush(@pointer, s, Rufus::Tokyo.blen(s))
+
       self
     end
 
-    #
     # Pushes an argument or a list of arguments to this list
     #
     def push (*args)
+
       args.each { |a| self << a }
+
       self
     end
 
-    #
     # Pops the last element in the list
     #
     def pop
-      clib.tclistpop2(@list) rescue nil
+
+      outlen_op(:tclistpop)
     end
 
-    #
     # Removes and returns the first element in a list
     #
     def shift
-      clib.tclistshift2(@list) rescue nil
+
+      #clib.tclistshift2(@pointer) rescue nil
+      outlen_op(:tclistshift)
     end
 
-    #
     # Inserts a string at the beginning of the list
     #
     def unshift (s)
-      clib.tclistunshift2(@list, s)
+
+      clib.tclistunshift(@pointer, s, Rufus::Tokyo.blen(s))
+
       self
     end
 
+    # The put operation.
+    #
     def []= (a, b, c=nil)
 
       i, s = c.nil? ? [ a, b ] : [ [a, b], c ]
 
       range = if i.is_a?(Range)
-                i
-              elsif i.is_a?(Array)
-                start, count = i
-                (start..start + count - 1)
-              else
-                [ i ]
-              end
+        i
+      elsif i.is_a?(Array)
+        start, count = i
+        (start..start + count - 1)
+      else
+        [ i ]
+      end
 
       range = norm(range)
 
@@ -251,21 +295,21 @@ module Rufus::Tokyo
       range.each_with_index do |offset, index|
         val = values[index]
         if val
-          clib.tclistover2(@list, offset, val)
+          clib.tclistover(@pointer, offset, val, Rufus::Tokyo.blen(val))
         else
-          clib.tclistremove2(@list, values.size)
+          outlen_op(:tclistremove, values.size)
         end
       end
 
       self
     end
 
-    #
     # Removes the value at a given index and returns the value
     # (returns nil if no value available)
     #
     def delete_at (i)
-      clib.tclistremove2(@list, i)
+
+      outlen_op(:tclistremove, i)
     end
 
     def delete_if
@@ -279,16 +323,15 @@ module Rufus::Tokyo
       # TODO
     end
 
-    #
     # Returns the size of this Tokyo Cabinet list
     #
     def size
-      clib.tclistnum(@list)
+
+      clib.tclistnum(@pointer)
     end
 
     alias :length :size
 
-    #
     # The equivalent of Ruby Array#[]
     #
     def [] (i, count=nil)
@@ -298,43 +341,48 @@ module Rufus::Tokyo
       len = self.size
 
       range = if count.nil?
-                i.is_a?(Range) ? i : [i]
-              else
-                (i..i + count - 1)
-              end
+        i.is_a?(Range) ? i : [i]
+      else
+        (i..i + count - 1)
+      end
 
-      r = norm(range).collect { |i| clib.tclistval2(@list, i) rescue nil }
+      r = norm(range).collect { |i| outlen_op(:tclistval, i) }
 
       range.first == range.last ? r.first : r
     end
 
+    # Empties the list.
+    #
     def clear
-      clib.tclistclear(@list)
+
+      clib.tclistclear(@pointer)
     end
 
+    # The classical each.
+    #
     def each
+
       (0..self.size - 1).each { |i| yield self[i] }
     end
 
-    #
     # Turns this Tokyo Cabinet list into a Ruby array
     #
     def to_a
+
       self.collect { |e| e }
     end
 
-    #
     # Closes (frees) this list
     #
     def free
-      self.class.free(@list)
-      @list = nil
+
+      self.class.free(@pointer)
+      @pointer = nil
     end
 
     alias :close :free
     alias :destroy :free
 
-    #
     # Frees (closes) the given 'native' (FFI) list (memory pointer)
     #
     def self.free (list_pointer)
@@ -342,7 +390,6 @@ module Rufus::Tokyo
       CabinetLib.tclistdel(list_pointer)
     end
 
-    #
     # Closes (frees memory from it) this list and returns the ruby version
     # of it
     #
@@ -353,15 +400,6 @@ module Rufus::Tokyo
       a
     end
 
-    #
-    # Returns the underlying 'native' (FFI) memory pointer
-    #
-    def pointer
-
-      @list
-    end
-
-    #
     # Turns a list pointer into a Ruby Array instance (and makes sure to
     # release the pointer
     #
@@ -372,7 +410,6 @@ module Rufus::Tokyo
 
     protected
 
-    #
     # Makes sure this offset/range fits the size of the list
     #
     def norm (i)