rufus-tokyo 0.1.12 → 0.1.13

data/lib/rufus/tokyo.rb

@@ -29,13 +29,25 @@ require 'ffi' # sudo gem install ffi
 module Rufus
 module Tokyo
 
-  VERSION = '0.1.12'
+  VERSION = '0.1.13'
 
   #
   # A common error class
   #
   class TokyoError < RuntimeError; end
 
+  #
+  # Grumpf, this is not elegant...
+  #
+  INT_MIN = -2147483648
+
+  # Returns 'bytesize' of the string (Ruby 1.9.1 for everyone).
+  #
+  def self.blen (s)
+
+    s.respond_to?(:bytesize) ? s.bytesize : s.size
+  end
+
 end
 end
 

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

@@ -53,7 +53,6 @@ module Rufus::Tokyo
     include HashMethods
     include Transactions
 
-    #
     # Creates/opens the cabinet, raises an exception in case of
     # creation/opening failure.
     #
@@ -165,6 +164,9 @@ module Rufus::Tokyo
     #   * :capnum  specifies the capacity number of records.
     #   * :capsiz  specifies the capacity size of using memory.
     #
+    #   * :dfunit  unit step number. If it is not more than 0,
+    #              the auto defragmentation is disabled. (Since TC 1.4.21)
+    #
     #
     # = NOTE :
     #
@@ -183,6 +185,8 @@ module Rufus::Tokyo
         name += { :hash => '.tch', :btree => '.tcb', :fixed => '.tcf' }[type]
       end
 
+      @path = name
+
       name = name + params.collect { |k, v| "##{k}=#{v}" }.join('')
 
       (lib.tcadbopen(@db, name) == 1) ||
@@ -193,130 +197,153 @@ module Rufus::Tokyo
     end
 
     # Same args as initialize, but can take a block form that will
-    # close the db when done.  Similar to File.open
+    # close the db when done. Similar to File.open
+    #
     def self.open (name, params={})
+
       db = self.new(name, params)
+
       if block_given?
         yield db
         nil
       else
         db
       end
+
     ensure
+
       db.close if block_given? && db
     end
 
-    #
     # Returns a new in-memory hash. Accepts the same optional params hash
     # as new().
     #
     def self.new_hash (params={})
+
       self.new(:hash, params)
     end
 
-    #
     # Returns a new in-memory B+ tree. Accepts the same optional params hash
     # as new().
     #
     def self.new_tree (params={})
+
       self.new(:tree, params)
     end
 
-    #
-    # using the cabinet lib
+    # Using the cabinet lib
     #
     def lib
+
       CabinetLib
     end
 
+    # Returns the path to this database.
     #
+    def path
+
+      @path
+    end
+
     # No comment
     #
     def []= (k, v)
-      lib.abs_put2(@db, k, v)
+
+      lib.abs_put(@db, k, Rufus::Tokyo.blen(k), v, Rufus::Tokyo.blen(v))
     end
 
+    # Like #put but doesn't overwrite the value if already set. Returns true
+    # only if there no previous entry for k.
     #
+    def putkeep (k, v)
+
+      (lib.abs_putkeep(
+        @db, k, Rufus::Tokyo.blen(k), v, Rufus::Tokyo.blen(v)) == 1)
+    end
+
     # (The actual #[] method is provided by HashMethods
     #
     def get (k)
-      lib.abs_get2(@db, k) rescue nil
+
+      outlen_op(:abs_get, k, Rufus::Tokyo.blen(k))
     end
     protected :get
 
-    #
     # Removes a record from the cabinet, returns the value if successful
     # else nil.
     #
     def delete (k)
+
       v = self[k]
-      (lib.abs_out2(@db, k) == 1) ? v : nil
+
+      (lib.abs_out(@db, k, Rufus::Tokyo.blen(k)) == 1) ? v : nil
     end
 
-    #
     # Returns the number of records in the 'cabinet'
     #
     def size
+
       lib.abs_rnum(@db)
     end
 
-    #
     # Removes all the records in the cabinet (use with care)
     #
     # Returns self (like Ruby's Hash does).
     #
     def clear
+
       lib.abs_vanish(@db)
+
       self
     end
 
-    #
     # Returns the 'weight' of the db (in bytes)
     #
     def weight
+
       lib.abs_size(@db)
     end
 
-    #
     # Closes the cabinet (and frees the datastructure allocated for it),
     # returns true in case of success.
     #
     def close
+
       result = lib.abs_close(@db)
       lib.abs_del(@db)
+
       (result == 1)
     end
 
-    #
     # Copies the current cabinet to a new file.
     #
     # Returns true if it was successful.
     #
     def copy (target_path)
+
       (lib.abs_copy(@db, target_path) == 1)
     end
 
-    #
     # Copies the current cabinet to a new file.
     #
     # Does it by copying each entry afresh to the target file. Spares some
     # space, hence the 'compact' label...
     #
     def compact_copy (target_path)
+
       @other_db = Cabinet.new(target_path)
       self.each { |k, v| @other_db[k] = v }
       @other_db.close
     end
 
-    #
     # "synchronize updated contents of an abstract database object with
     # the file and the device"
     #
     def sync
+
       (lib.abs_sync(@db) == 1)
     end
 
-    #
     # Returns an array with all the keys in the databse
     #
     # With no options given, this method will return all the keys (strings)
@@ -332,10 +359,15 @@ module Rufus::Tokyo
     #
     def keys (options={})
 
-      if pref = options[:prefix]
+      outlen = nil
+
+      if pre = options[:prefix]
+
+        l = lib.abs_fwmkeys(
+          @db, pre, Rufus::Tokyo.blen(pre), options[:limit] || -1)
 
-        l = lib.abs_fwmkeys2(@db, pref, options[:limit] || -1)
         l = Rufus::Tokyo::List.new(l)
+
         options[:native] ? l : l.release
 
       else
@@ -347,26 +379,34 @@ module Rufus::Tokyo
 
         lib.abs_iterinit(@db)
 
-        while (k = (lib.abs_iternext2(@db) rescue nil))
+        outlen = FFI::MemoryPointer.new(:int)
+
+        loop do
           break if limit and l.size >= limit
-          l << k
+          out = lib.abs_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 keys begin with the given prefix
     #
     def delete_keys_with_prefix (prefix)
 
-      call_misc('outlist', lib.abs_fwmkeys2(@db, prefix, -1))
-        # -1 for no limits
+      call_misc(
+        'outlist', lib.abs_fwmkeys(@db, prefix, Rufus::Tokyo.blen(prefix), -1))
+          # -1 for no limits
+
       nil
     end
 
-    #
     # Given a list of keys, returns a Hash { key => value } of the
     # matching entries (in one sweep).
     #
@@ -375,7 +415,6 @@ module Rufus::Tokyo
       Hash[*call_misc('getlist', Rufus::Tokyo::List.new(keys))]
     end
 
-    #
     # Merges the given hash into this Cabinet (or Tyrant) and returns self.
     #
     def merge! (hash)
@@ -387,7 +426,6 @@ module Rufus::Tokyo
     end
     alias :lput :merge!
 
-    #
     # Given a list of keys, deletes all the matching entries (in one sweep).
     #
     def ldelete (keys)
@@ -395,6 +433,29 @@ module Rufus::Tokyo
       call_misc('outlist', Rufus::Tokyo::List.new(keys))
     end
 
+    # Increments the value stored under the given key with the given increment
+    # (defaults to 1 (integer)).
+    #
+    # Accepts an integer or a double value.
+    #
+    def incr (key, inc=1)
+
+      v = inc.is_a?(Fixnum) ?
+        lib.addint(@db, key, Rufus::Tokyo.blen(key), inc) :
+        lib.adddouble(@db, key, Rufus::Tokyo.blen(key), inc)
+
+      raise(TokyoError.new(
+        "incr failed, there is probably already a string value set " +
+        "for the key '#{key}'"
+      )) if v == Rufus::Tokyo::INT_MIN || (v.respond_to?(:nan?) && v.nan?)
+
+      v
+    end
+    alias :addint :incr
+    alias :adddouble :incr
+    alias :add_int :incr
+    alias :add_double :incr
+
     # Warning : this method is low-level, you probably only need
     # to use #transaction and a block.
     #
@@ -407,6 +468,18 @@ module Rufus::Tokyo
       libcall(:tcadbtranbegin)
     end
 
+    # Triggers a defrag run (TC >= 1.4.21 only)
+    #
+    def defrag
+
+      raise(NotImplementedError.new(
+        "method defrag is supported since Tokyo Cabinet 1.4.21. " +
+        "your TC version doesn't support it"
+      )) unless lib.respond_to?(:tctdbsetdfunit)
+
+      call_misc('defrag', Rufus::Tokyo::List.new)
+    end
+
     # Warning : this method is low-level, you probably only need
     # to use #transaction and a block.
     #
@@ -441,8 +514,7 @@ module Rufus::Tokyo
       ) unless lib.respond_to?(:tcadbtranbegin)
     end
 
-    #
-    # wrapping tcadbmisc or tcrdbmisc
+    # Wrapping tcadbmisc or tcrdbmisc
     # (and taking care of freeing the list_pointer)
     #
     def call_misc (function, list_pointer)
@@ -459,7 +531,7 @@ module Rufus::Tokyo
       end
     end
 
-    # calls the tcadbmisc function
+    # Calls the tcadbmisc function
     #
     def do_call_misc (function, list_pointer)
 
@@ -471,6 +543,26 @@ module Rufus::Tokyo
       (eval(%{ lib.#{lib_method}(@db, *args) }) == 1) or \
         raise TokyoError.new("call to #{lib_method} failed")
     end
+
+    # A wrapper for library returning a string (binary data potentially)
+    #
+    def outlen_op (method, *args)
+
+      args.unshift(@db)
+
+      outlen = FFI::MemoryPointer.new(:int)
+      args << outlen
+
+      out = lib.send(method, *args)
+
+      return nil if out.address == 0
+
+      return out.get_bytes(0, outlen.get_int(0))
+
+    ensure
+
+      outlen.free
+    end
   end
 end
 

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

@@ -84,22 +84,29 @@ module Rufus::Tokyo
     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_put, :tcadbput, [ :pointer, :pointer, :int, :pointer, :int ], :int
+
+    attfunc :abs_get, :tcadbget, [ :pointer, :pointer, :int, :pointer ], :pointer
+
+    attfunc :abs_out, :tcadbout, [ :pointer, :pointer, :int ], :int
+
+    attfunc :abs_putkeep, :tcadbputkeep, [ :pointer, :pointer, :int, :pointer, :int ], :int
 
     attfunc :abs_iterinit, :tcadbiterinit, [ :pointer ], :int
-    attfunc :abs_iternext2, :tcadbiternext2, [ :pointer ], :string
+    attfunc :abs_iternext, :tcadbiternext, [ :pointer, :pointer ], :pointer
 
     attfunc :abs_vanish, :tcadbvanish, [ :pointer ], :int
 
     attfunc :abs_sync, :tcadbsync, [ :pointer ], :int
     attfunc :abs_copy, :tcadbcopy, [ :pointer, :string ], :int
 
-    attfunc :abs_fwmkeys2, :tcadbfwmkeys2, [ :pointer, :string, :int ], :pointer
+    attfunc :abs_fwmkeys, :tcadbfwmkeys, [ :pointer, :pointer, :int, :int ], :pointer
 
     attfunc :tcadbmisc, [ :pointer, :string, :pointer ], :pointer
 
+    attfunc :addint, :tcadbaddint, [ :pointer, :string, :int, :int ], :int
+    attfunc :adddouble, :tcadbadddouble, [ :pointer, :string, :int, :double ], :double
+
     begin # since TC 1.4.13
       attfunc :tcadbtranbegin, [ :pointer ], :int
       attfunc :tcadbtrancommit, [ :pointer ], :int
@@ -118,18 +125,23 @@ module Rufus::Tokyo
     attfunc :tctdbsetcache, [ :pointer, :uint32, :uint32, :uint32 ], :int
     attfunc :tctdbsetxmsiz, [ :pointer, :uint64 ], :int
 
+    begin # since TC 1.4.21
+      attfunc :tctdbsetdfunit, [ :pointer, :uint32 ], :int
+    rescue FFI::NotFoundError => nfe
+    end
+
     attfunc :tctdbopen, [ :pointer, :string, :int ], :int
 
     attfunc :tab_close, :tctdbclose, [ :pointer ], :int
 
     attfunc :tab_genuid, :tctdbgenuid, [ :pointer ], :int64
 
-    attfunc :tab_get, :tctdbget, [ :pointer, :string, :int ], :pointer
+    attfunc :tab_get, :tctdbget, [ :pointer, :pointer, :int ], :pointer
 
     attfunc :tab_iterinit, :tctdbiterinit, [ :pointer ], :int
-    attfunc :tab_iternext2, :tctdbiternext2, [ :pointer ], :string
+    attfunc :tab_iternext, :tctdbiternext, [ :pointer, :pointer ], :pointer
 
-    attfunc :tab_put, :tctdbput, [ :pointer, :string, :int, :pointer ], :int
+    attfunc :tab_put, :tctdbput, [ :pointer, :pointer, :int, :pointer ], :int
 
     #attfunc :tctdbput3, [ :pointer, :string, :string ], :int
       # not using it anymore, Ruby can turn an array into a hash so easily
@@ -151,7 +163,7 @@ module Rufus::Tokyo
     attfunc :tctdbtrancommit, [ :pointer ], :int
     attfunc :tctdbtranabort, [ :pointer ], :int
 
-    attfunc :tab_fwmkeys2, :tctdbfwmkeys2, [ :pointer, :string, :int ], :pointer
+    attfunc :tab_fwmkeys, :tctdbfwmkeys, [ :pointer, :pointer, :int, :int ], :pointer
 
     #
     # tctdbqry functions
@@ -183,18 +195,13 @@ module Rufus::Tokyo
     # http://tokyocabinet.sourceforge.net/spex-en.html#tcutilapi
 
     attfunc :tcmapnew, [], :pointer
-
-    attfunc :tcmapput2, [ :pointer, :string, :string ], :void
-    attfunc :tcmapout2, [ :pointer, :string ], :int
+    attfunc :tcmapput, [ :pointer, :pointer, :int, :pointer, :int ], :void
+    attfunc :tcmapout, [ :pointer, :pointer, :int ], :int
     attfunc :tcmapclear, [ :pointer ], :void
-
     attfunc :tcmapdel, [ :pointer ], :void
-
-    attfunc :tcmapget2, [ :pointer, :string ], :string
-
+    attfunc :tcmapget, [ :pointer, :pointer, :int, :pointer ], :pointer
     attfunc :tcmapiterinit, [ :pointer ], :void
-    attfunc :tcmapiternext2, [ :pointer ], :string
-
+    attfunc :tcmapiternext, [ :pointer, :pointer ], :pointer
     attfunc :tcmaprnum, [ :pointer ], :uint64
 
     #
@@ -203,19 +210,14 @@ module Rufus::Tokyo
     # 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
-
+    attfunc :tclistval, [ :pointer, :int, :pointer ], :pointer
+    attfunc :tclistpush, [ :pointer, :pointer, :int ], :void
+    attfunc :tclistpop, [ :pointer, :pointer ], :pointer
+    attfunc :tclistshift, [ :pointer, :pointer ], :pointer
+    attfunc :tclistunshift, [ :pointer, :pointer, :int ], :void
+    attfunc :tclistover, [ :pointer, :int, :pointer, :int ], :void
+    attfunc :tclistremove, [ :pointer, :int, :pointer ], :pointer
     attfunc :tclistdel, [ :pointer ], :void
   end