rufus-tokyo 1.0.1 → 1.0.2

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

@@ -27,6 +27,7 @@ require 'rufus/tokyo/utils'
 require 'rufus/tokyo/query'
 require 'rufus/tokyo/config'
 require 'rufus/tokyo/transactions'
+require 'rufus/tokyo/openable'
 
 
 module Rufus::Tokyo
@@ -65,6 +66,7 @@ module Rufus::Tokyo
 
     include HashMethods
     include CabinetConfig
+    extend  Openable
 
     include Transactions
       # this class has tranbegin/trancommit/tranabort so let's include the
@@ -151,6 +153,11 @@ module Rufus::Tokyo
       @path = conf[:path]
 
       libcall(:tctdbopen, @path, conf[:mode])
+
+      #
+      # no default
+
+      @default_proc = nil
     end
 
     # Using the cabinet lib
@@ -221,9 +228,9 @@ module Rufus::Tokyo
 
       column_name = column_name == :pk ? '' : column_name.to_s
 
-      i = types.inject(0) { |i, t| i = i | INDEX_TYPES[t]; i }
+      ii = types.inject(0) { |i, t| i = i | INDEX_TYPES[t]; i }
 
-      (lib.tab_setindex(@db, column_name, i) == 1)
+      (lib.tab_setindex(@db, column_name, ii) == 1)
     end
 
     # Inserts a record in the table db
@@ -291,67 +298,35 @@ module Rufus::Tokyo
     #
     def keys (options={})
 
-      outlen = nil
-
-      if pre = options[:prefix]
-
-        l = lib.tab_fwmkeys(
-          @db, pre, Rufus::Tokyo.blen(pre), options[:limit] || -1)
-
-        l = Rufus::Tokyo::List.new(l)
-
-        options[:native] ? l : l.release
-
-      else
+      pre = options.fetch(:prefix, "")
 
-        limit = options[:limit] || -1
-        limit = nil if limit < 1
+      l = lib.tab_fwmkeys(
+        @db, pre, Rufus::Tokyo.blen(pre), options[:limit] || -1)
 
-        l = options[:native] ? Rufus::Tokyo::List.new : []
-
-        lib.tab_iterinit(@db)
-
-        outlen = FFI::MemoryPointer.new(:int)
-
-        loop do
-          break if limit and l.size >= limit
-          out = lib.tab_iternext(@db, outlen)
-          break if out.address == 0
-          l << out.get_bytes(0, outlen.get_int(0))
-        end
-
-        l
-      end
-
-    ensure
+      l = Rufus::Tokyo::List.new(l)
 
-      outlen && outlen.free
+      options[:native] ? l : l.release
     end
 
     # Deletes all the entries whose key begin with the given prefix.
     #
     def delete_keys_with_prefix (prefix)
 
-      # TODO : use ...searchout
-
-      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) }
-      ensure
-        ks && ks.free
-      end
+      query_delete { |q| q.add('', :strbw, prefix) }
     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)
+    def lget (*keys)
 
-      keys.inject({}) { |h, k| k = k.to_s; v = self[k]; h[k] = v if v; h }
+      keys.flatten.inject({}) { |h, k|
+        k = k.to_s
+        v = self[k]
+        h[k] = v if v
+        h
+      }
     end
 
     alias :mget :lget
@@ -414,12 +389,25 @@ module Rufus::Tokyo
       q && q.free
     end
 
+    # Prepares a query and then runs it and deletes all the results.
+    #
+    def query_count (&block)
+
+      q = prepare_query { |q|
+        q.pk_only  # improve efficiency, since we have to do the query
+      }
+      q.count
+    ensure
+      q.free if q
+    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
 
@@ -429,6 +417,7 @@ module Rufus::Tokyo
     # Direct call for 'transaction commit'.
     #
     def trancommit
+
       libcall(:tctdbtrancommit)
     end
 
@@ -438,6 +427,7 @@ module Rufus::Tokyo
     # Direct call for 'transaction abort'.
     #
     def tranabort
+
       libcall(:tctdbtranabort)
     end
 
@@ -575,7 +565,7 @@ module Rufus::Tokyo
     # (the actual #[] method is provided by HashMethods)
     #
     def get (k)
-
+      k = k.to_s
       m = lib.tab_get(@db, k, Rufus::Tokyo.blen(k))
 
       return nil if m.address == 0
@@ -628,9 +618,11 @@ module Rufus::Tokyo
     #   * #no_pk
     #
     def initialize (table)
-      @table = table
-      @query = @table.lib.qry_new(@table.pointer)
-      @opts = {}
+
+      @table   = table
+      @query   = @table.lib.qry_new(@table.pointer)
+      @opts    = {}
+      @has_run = false
     end
 
     # Returns the FFI lib the table uses.
@@ -822,6 +814,7 @@ module Rufus::Tokyo
     #
     def run
 
+      @has_run = true
       #@last_resultset =
       TableResultSet.new(@table, lib.qry_search(@query), @opts)
     end
@@ -840,6 +833,7 @@ module Rufus::Tokyo
     def count
 
       #if lib.respond_to?(:qry_count)
+      run.free unless @has_run
       lib.qry_count(@query)
       #else
       #  @last_resultset ? @last_resultset.size : 0

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

@@ -89,6 +89,8 @@ module Rufus::Tokyo
     def initialize (pointer=nil)
 
       @pointer = pointer || clib.tcmapnew
+
+      @default_proc = nil
     end
 
     # Inserts key/value pair
@@ -346,7 +348,7 @@ module Rufus::Tokyo
         (i..i + count - 1)
       end
 
-      r = norm(range).collect { |i| outlen_op(:tclistval, i) }
+      r = norm(range).collect { |ii| outlen_op(:tclistval, ii) }
 
       range.first == range.last ? r.first : r
     end

data/lib/rufus/tokyo/config.rb

@@ -55,11 +55,12 @@ module Tokyo
 
       [
         {
-          :params => params,
-          :mode => determine_open_mode(params),
-          :mutex => (params[:mutex].to_s == 'true'),
+          :params   => params,
+          :mode     => determine_open_mode(params),
+          :mutex    => (params[:mutex].to_s == 'true'),
           #:indexes => params[:idx] || params[:indexes],
-          :xmsiz => (params[:xmsiz] || 67108864).to_i,
+          :xmsiz    => (params[:xmsiz] || 67108864).to_i,
+          :cmpfunc  => params[:cmpfunc]
         },
         determine_type_and_path(path, params, required_type),
         determine_tuning_values(params),

data/lib/rufus/tokyo/dystopia/core.rb

@@ -23,6 +23,7 @@
 # creators of Open Syslog.
 #
 #++
+require 'rufus/tokyo/openable'
 
 module Rufus::Tokyo::Dystopia
   #
@@ -31,6 +32,8 @@ module Rufus::Tokyo::Dystopia
   # http://tokyocabinet.sourceforge.net/dystopiadoc/#dystopiaapi
   #
   class Core
+    extend Rufus::Tokyo::Openable
+
     class Error < Rufus::Tokyo::Dystopia::Error; end
 
     def self.lib

data/lib/rufus/tokyo/dystopia/lib.rb

@@ -37,11 +37,11 @@ module Rufus::Tokyo
 
     paths = Array(ENV['TOKYO_DYSTOPIA_LIB'] || Dir['/{opt,usr}/{,local/}lib{,64}/libtokyodystopia.{dylib,so*}'])
 
-    path = paths.find { |path| File.exist?(path) }
-
-    raise "did not find Tokyo Dystopia libs on your system" unless path
-
-    ffi_lib(path)
+    begin
+      ffi_lib(*paths)
+    rescue LoadError => le
+      raise "did not find Tokyo Dystopia libs on your system"
+    end
 
     #
     # tcidb functions - The Core API

data/lib/rufus/tokyo/hmethods.rb

@@ -33,6 +33,8 @@ module Tokyo
 
     include Enumerable
 
+    attr_accessor :default_proc
+
     # The [] methods
     #
     # (assumes there's an underlying get(k) method)
@@ -57,8 +59,39 @@ module Tokyo
     # Our classical 'each'
     #
     def each
-
-      keys.each { |k| yield(k, self[k]) }
+      # 
+      # drop to Edo's C API calls to avoid two-step iteration
+      # (keys() then each())
+      # 
+      if defined?(@db) and %w[iterinit iternext].all? { |m| @db.respond_to?(m) }
+        @db.iterinit
+        while k = @db.iternext
+          yield(k, self[k])
+        end
+      # 
+      # drop to Tokyo's FFI calls to avoid two-step iteration
+      # (keys() then each())
+      # 
+      elsif self.class.name != "Rufus::Tokyo::Table" and # use String for Edo
+            defined?(@db)                            and
+            respond_to?(:lib)                        and
+            %w[abs_iterinit abs_iternext].all? { |m| lib.respond_to?(m) }
+        begin
+          lib.abs_iterinit(@db)
+          int = FFI::MemoryPointer.new(:int)
+          loop do
+            key_pointer = lib.abs_iternext(@db, int)
+            break if key_pointer.address.zero?
+            k = key_pointer.get_bytes(0, int.get_int(0))
+            yield(k, self[k])
+          end
+        ensure
+          int.free if int
+        end
+      # we couldn't do it fast, so go ahead with slow-but-accurate
+      else
+        keys.each { |k| yield(k, self[k]) }
+      end
     end
 
     # Turns this instance into a Ruby hash
@@ -72,7 +105,10 @@ module Tokyo
     #
     def to_a
 
-      self.collect { |e| e }
+      #self.collect { |e| e }
+        # not OK with ruby 1.9.1
+
+      self.inject([]) { |a, (k, v)| a << [ k, v ]; a }
     end
 
     # Returns a new Ruby hash which is a merge of this Map and the given hash
@@ -91,19 +127,25 @@ module Tokyo
       self
     end
 
+    # Returns the default value, the value that would be returned by h[k] if
+    # k did not exist among h keys.
+    #
     def default (key=nil)
 
-      val = self[key]
+      return nil unless @default_proc
 
-      val.nil? ? @default_proc.call(self, key) : val
+      @default_proc.call(self, key) rescue nil
     end
 
+    # Sets the default value for the Hash.
+    #
+    # Warning : use #default_proc= if you want to change the default_proc
+    # directly.
+    #
     def default= (val)
 
-      @default_proc = lambda { |h, k| val }
+      @default_proc = val.nil? ? nil : lambda { |h, k| val }
     end
-
-    attr_reader :default_proc
   end
 
 end

data/lib/rufus/tokyo/openable.rb

@@ -0,0 +1,23 @@
+module Rufus::Tokyo
+  #
+  # A mixin for classes with new() that need a matching IO-like open().
+  #
+  module Openable
+    #
+    # Same args as new(), but can take a block form that will
+    # close the db when done. Similar to File.open(). (via Zev and JEG2)
+    #
+    def open(*args)
+      db = new(*args)
+      if block_given?
+        begin
+          yield db
+        ensure
+          db.close
+        end
+      else
+        db
+      end
+    end
+  end
+end

data/lib/rufus/tokyo/transactions.rb

@@ -77,6 +77,50 @@ module Tokyo
     class Abort < RuntimeError; end
   end
 
+  # When included will make sure calls on transaction methods do
+  # throw NoMethodError.
+  #
+  module NoTransactions
+
+    # Tyrant dbs do not support transactions.
+    #
+    def transaction
+      raise_transaction_nme('transaction')
+    end
+
+    # Tyrant dbs do not support transactions.
+    #
+    def abort
+      raise_transaction_nme('abort')
+    end
+
+    # Tyrant dbs do not support transactions.
+    #
+    def tranbegin
+      raise_transaction_nme('tranbegin')
+    end
+
+    # Tyrant dbs do not support transactions.
+    #
+    def trancommit
+      raise_transaction_nme('trancommit')
+    end
+
+    # Tyrant dbs do not support transactions.
+    #
+    def tranabort
+      raise_transaction_nme('tranabort')
+    end
+
+    protected
+
+    def raise_transaction_nme (method_name)
+
+      raise(NoMethodError.new(
+        "Tyrant dbs don't support transactions", method_name))
+    end
+  end
+
 end
 end
 

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

@@ -35,10 +35,18 @@ module Rufus::Tokyo
   #   t['toto'] = 'blah blah'
   #   t['toto'] # => 'blah blah'
   #
+  # == Cabinet methods not available to Tyrant
+  #
+  # The #defrag method is not available for Tyrant.
+  #
+  # More importantly transaction related methods are not available either.
+  # No transactions for Tokyo Tyrant.
+  #
   class Tyrant < Cabinet
 
     include TyrantCommons
     include Ext
+    include NoTransactions
 
     attr_reader :host, :port
 
@@ -63,14 +71,33 @@ module Rufus::Tokyo
     #
     #   t = Rufus::Tokyo::Tyrant.new('127.0.0.1', 44001)
     #
-    def initialize (host, port=0)
+    #
+    # == :default and :default_proc
+    #
+    # Much like a Ruby Hash, a Tyrant accepts a default value or a default_proc
+    #
+    #   db = Rufus::Tokyo::Tyrant.new('127.0.0.1', 1978, :default => 'xxx')
+    #   db['fred'] = 'Astaire'
+    #   p db['fred'] # => 'Astaire'
+    #   p db['ginger'] # => 'xxx'
+    #
+    #   db = Rufus::Tokyo::Tyrant.new(
+    #     '127.0.0.1',
+    #     1978,
+    #     :default_proc => lambda { |cab, key| "not found : '#{k}'" }
+    #   p db['ginger'] # => "not found : 'ginger'"
+    #
+    # The first arg passed to the default_proc is the tyrant itself, so this
+    # opens up interesting possibilities.
+    #
+    def initialize (host, port=0, params={})
 
       @db = lib.tcrdbnew
 
       @host = host
       @port = port
 
-      (lib.tcrdbopen(@db, host, port) == 1) || raise(
+      (lib.tcrdbopen(@db, host, port) != 0) || raise(
         TokyoError.new("couldn't connect to tyrant at #{host}:#{port}"))
 
       if self.stat['type'] == 'table'
@@ -81,6 +108,12 @@ module Rufus::Tokyo
           "tyrant at #{host}:#{port} is a table, " +
           "use Rufus::Tokyo::TyrantTable instead to access it.")
       end
+
+      #
+      # default value|proc
+
+      self.default = params[:default]
+      @default_proc ||= params[:default_proc]
     end
 
     # Using the tyrant lib
@@ -90,20 +123,27 @@ module Rufus::Tokyo
       TyrantLib
     end
 
-    # isn't that a bit dangerous ? it creates a file on the server...
+    # Tells the Tyrant server to create a copy of itself at the given (remote)
+    # target_path.
     #
-    # DISABLED.
+    # Returns true when successful.
+    #
+    # Note : if you started your ttserver with a path like "tyrants/data.tch"
+    # you have to provide a target path in the same subdir, like
+    # "tyrants/data_prime.tch".
     #
     def copy (target_path)
 
-      #@db.copy(target_path)
-      raise 'not allowed to create files on the server'
+      (lib.abs_copy(@db, target_path) == 1) || raise_error
     end
 
     # Tyrant databases DO NOT support the 'defrag' call. Calling this method
     # will raise an exception.
     #
-    undef_method(:defrag)
+    def defrag
+
+      raise(NoMethodError.new("Tyrant dbs don't support #defrag"))
+    end
 
     protected
 
@@ -119,6 +159,13 @@ module Rufus::Tokyo
 
       lib.tcrdbstat(@db)
     end
+
+    def raise_error
+
+      code = lib.abs_ecode(@db)
+      message = lib.abs_errmsg(@db, code)
+      raise TokyoError.new("(err #{code}) #{message}")
+    end
   end
 end