rufus-tokyo 0.1.5 → 0.1.6

data/CHANGELOG.txt

@@ -2,6 +2,18 @@
 = rufus-tokyo CHANGELOG.txt
 
 
+== rufus-tokyo - 0.1.6    released 2009/02/16
+
+- todo : Tyrant and TyrantTable now complain when used in lieu of each other
+- todo : implemented Tyrant and TyrantTable #stat
+- todo : made tran begin/abort/commit directly available (framework builders)
+- todo : implemented Rufus::Tokyo::Table#transaction
+- bug  : JRuby support back in
+- todo : implemented Rufus::Tokyo::Map#[] (class method)
+- todo : simplified Table and TyrantTable #[]=
+- bug  : preventing table#[]= from segfaulting on bad input (Justin)
+
+
 == rufus-tokyo - 0.1.5    released 2009/02/13
 
 - todo : implemented set_index (cabinet / tyrant tables)

data/README.txt

@@ -47,32 +47,54 @@ http://tokyocabinet.sourceforge.net/spex-en.html#tctdbapi
 
   require 'rubygems'
   require 'rufus/tokyo'
-  
-  t = Rufus::Tokyo::Table.new('table.tdb', :create, :write)
-  
+
+  t = Rufus::Tokyo::Table.new('table.tdb')
+
   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'
   }
     # => [ {"name"=>"ephrem", :pk=>"pk4", "age"=>"32"},
     #      {"name"=>"charly", :pk=>"pk2", "age"=>"45"} ]
-  
+
   t.close
 
+Note that the Tokyo Cabinet Table API does support transactions :
+
+  p t.size
+    # => 0
+
+  t.transaction do
+    t['pk0'] = { 'name' => 'alfred', 'age' => '22' }
+    t['pk1'] = { 'name' => 'bob', 'age' => '18' }
+    t.abort
+  end
+
+  p t.size
+    # => 0
+
+
 === TT remote db
 
 http://tokyocabinet.sourceforge.net/tyrantdoc/
 
+to start a ttserver (backed by a hash), on the command line
+
+  ttserver -port 45001 data.tch
+
+
+then, in Ruby :
+
   require 'rubygems'
-  require 'rufus/tokyo'
+  require 'rufus/tokyo/tyrant'
 
-  db = Rufus::Tokyo::Tyrant.new('tyrant.example.com', 45001)
+  db = Rufus::Tokyo::Tyrant.new('localhost', 45001)
 
   db['nada'] = 'surf'
 
@@ -82,31 +104,76 @@ http://tokyocabinet.sourceforge.net/tyrantdoc/
   db.close
 
 
+Rufus::Tokyo::Tyrant instances have a #stat method :
+
+  puts db.stat.inject('') { |s, (k, v)| s << "#{k} => #{v}\n" }
+    # =>
+    #   pid => 7566
+    #   loadavg => 0.398438
+    #   size => 528736
+    #   rnum => 0
+    #   time => 1234764065.305923
+    #   sid => 898521513
+    #   type => hash
+    #   bigend => 0
+    #   ru_sys => 3.398698
+    #   version => 1.1.15
+    #   ru_user => 2.155215
+    #   ru_real => 3218.451152
+    #   fd => 7
+
+
 === TT remote table
 
-like a local table :
+to start a ttserver (backed by a table), on the command line :
+
+  ttserver -port 45002 data.tct
+
+
+then, in Ruby, much like a local table :
 
   require 'rubygems'
-  require 'rufus/tokyo'
-  
-  t = Rufus::Tokyo::TyrantTable.new('localhost', 45006)
-  
+  require 'rufus/tokyo/tyrant'
+
+  t = Rufus::Tokyo::TyrantTable.new('localhost', 45002)
+
   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'
   }
     # => [ {"name"=>"ephrem", :pk=>"pk4", "age"=>"32"},
     #      {"name"=>"charly", :pk=>"pk2", "age"=>"45"} ]
-  
+
   t.close
 
 
+Rufus::Tokyo::TyrantTable instances have a #stat method :
+
+  puts t.stat.inject('') { |s, (k, v)| s << "#{k} => #{v}\n" }
+    # =>
+    #   pid => 7569
+    #   loadavg => 0.295410
+    #   size => 935792
+    #   rnum => 0
+    #   time => 1234764228.942014
+    #   sid => 1027604232
+    #   type => table
+    #   bigend => 0
+    #   ru_sys => 5.966750
+    #   version => 1.1.15
+    #   ru_user => 2.601947
+    #   ru_real => 3382.084479
+    #   fd => 10
+
+
+== rdoc
+
 more in the rdoc
 
   http://rufus.rubyforge.org/rufus-tokyo/
@@ -115,6 +182,8 @@ more in the rdoc
   http://rufus.rubyforge.org/rufus-tokyo/classes/Rufus/Tokyo/Tyrant.html
   http://rufus.rubyforge.org/rufus-tokyo/classes/Rufus/Tokyo/TyrantTable.html
 
+don't hesitate to "man ttserver" on the command line.
+
 or directly in the source
 
   http://github.com/jmettraux/rufus-tokyo/blob/master/lib/rufus/tokyo/cabinet/abstract.rb
@@ -123,62 +192,28 @@ or directly in the source
   http://github.com/jmettraux/rufus-tokyo/blob/master/lib/rufus/tokyo/tyrant/table.rb
 
 
-== Tokyo Cabinet install
-
-On a Mac, you would do 
-
-  sudo port install tokyocabinet
-
-
-If you don't have Tokyo Cabinet on your system, you can get it and compile it :
-
-  git clone git://github.com/etrepum/tokyo-cabinet.git
-  cd tokyo-cabinet
-  #git checkout 1.4.4
-  ./configure
-  make
-  sudo make install
-
-or get the souce at
-
-  http://sourceforge.net/project/showfiles.php?group_id=200242&package_id=237686
-
-(note : I tend to run rufus-tokyo against the latest version of Tokyo Cabinet)
-
-
-== Tokyo Tyrant install
-
-(Tokyo Tyrant requires Tokyo Cabinet)
-
-If you don't have Tokyo Tyrant on your system, you can get it and compile it :
-
-  git clone git://github.com/etrepum/tokyo-tyrant.git
-  cd tokyo-cabinet
-  #git checkout 1.1.14
-  ./configure
-  make
-  sudo make install
+== Tokyo Cabinet / Tyrant install
 
-or get the souce at
+a compilation of notes is available at :
 
-  http://sourceforge.net/project/showfiles.php?group_id=200242&package_id=237686
+  http://openwferu.rubyforge.org/tokyo.html
 
 
 == dependencies
 
-  the ruby gem ffi
+the ruby gem 'ffi'
 
 
 == mailing list
 
-On the rufus-ruby list[http://groups.google.com/group/rufus-ruby] :
+On the rufus-ruby list :
 
   http://groups.google.com/group/rufus-ruby
 
 
 == issue tracker
 
-http://rubyforge.org/tracker/?atid=18584&group_id=4812&func=browse
+  http://rubyforge.org/tracker/?atid=18584&group_id=4812&func=browse
 
 
 == irc

data/lib/rufus/tokyo.rb

@@ -28,7 +28,7 @@ require 'ffi' # sudo gem install ffi
 module Rufus
   module Tokyo
 
-    VERSION = '0.1.5'
+    VERSION = '0.1.6'
 
     #
     # A common error class
@@ -38,8 +38,9 @@ module Rufus
   end
 end
 
-require File.dirname(__FILE__) + '/tokyo/hmethods'
-require File.dirname(__FILE__) + '/tokyo/cabinet'
-require File.dirname(__FILE__) + '/tokyo/tyrant'
-require File.dirname(__FILE__) + '/tokyo/dystopia'
+require 'rufus/tokyo/cabinet'
+
+# TODO : do not include me
+#require 'rufus/tokyo/tyrant'
+#require 'rufus/tokyo/dystopia'
 

data/lib/rufus/tokyo/cabinet.rb

@@ -1,6 +1,6 @@
 
-require File.dirname(__FILE__) + '/cabinet/lib'
-require File.dirname(__FILE__) + '/cabinet/util'
-require File.dirname(__FILE__) + '/cabinet/table'
-require File.dirname(__FILE__) + '/cabinet/abstract'
+require 'rufus/tokyo/cabinet/lib'
+require 'rufus/tokyo/cabinet/util'
+require 'rufus/tokyo/cabinet/table'
+require 'rufus/tokyo/cabinet/abstract'
 

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

@@ -35,23 +35,23 @@ module Rufus
     # The libtokyocabinet.so methods get bound to this module
     #
     module CabinetLib #:nodoc#
-      extend ::FFI::Library
+      extend FFI::Library
 
       #
       # 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
-    })
+        /opt/local/lib/libtokyocabinet.dylib
+        /usr/local/lib/libtokyocabinet.dylib
+        /usr/local/lib/libtokyocabinet.so
+      })
 
       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
+        "didn't find Tokyo Cabinet libs on your system. " +
+        "Please install Tokyo Cabinet (http://tokyocabinet.sf.net)"
+      ) unless path
 
       ffi_lib(path)
 
@@ -116,7 +116,9 @@ module Rufus
       attfunc :tab_iternext2, :tctdbiternext2, [ :pointer ], :string
 
       attfunc :tab_put, :tctdbput, [ :pointer, :string, :int, :pointer ], :int
-      attfunc :tctdbput3, [ :pointer, :string, :string ], :int
+
+      #attfunc :tctdbput3, [ :pointer, :string, :string ], :int
+        # not using it anymore, Ruby can turn an array into a hash so easily
 
       attfunc :tab_out, :tctdbout, [ :pointer, :string, :int ], :int
 
@@ -131,6 +133,10 @@ module Rufus
 
       attfunc :tab_setindex, :tctdbsetindex, [ :pointer, :string, :int ], :int
 
+      attfunc :tctdbtranbegin, [ :pointer ], :int
+      attfunc :tctdbtrancommit, [ :pointer ], :int
+      attfunc :tctdbtranabort, [ :pointer ], :int
+
       #
       # tctdbqry functions
       #

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

@@ -52,7 +52,7 @@ module Rufus
       def params_to_h (params)
 
         params.is_a?(Hash) ?
-        params :
+          params :
           Array(params).inject({}) { |h, e| h[e] = true; h }
       end
 
@@ -146,7 +146,7 @@ module Rufus
 
         @db = lib.tctdbnew
 
-        (lib.tctdbopen(@db, path, mode) == 1 ) || raise_error
+        libcall(:tctdbopen, path, mode)
       end
 
       #
@@ -201,46 +201,21 @@ module Rufus
         (lib.tab_setindex(@db, column_name, i) == 1)
       end
 
-      #
-      # 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
-
       #
       # 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)
 
-        return tabbed_put(pk, *h_or_a) if h_or_a.is_a?(Array)
-
-        pklen = CabinetLib.strlen(pk)
-
-        m = Map.from_h(h_or_a)
+        m = Rufus::Tokyo::Map[h_or_a]
 
-        r = lib.tab_put(@db, pk, pklen, m.pointer)
+        r = lib.tab_put(@db, pk, CabinetLib.strlen(pk), m.pointer)
 
         m.free
 
@@ -258,7 +233,7 @@ module Rufus
       def delete (k)
         v = self[k]
         return nil unless v
-        (lib.tab_out(@db, k, CabinetLib.strlen(k)) == 1) || raise_error
+        libcall(:tab_out, k, CabinetLib.strlen(k))
         v
       end
 
@@ -266,7 +241,7 @@ module Rufus
       # Removes all records in this table database
       #
       def clear
-        (lib.tab_vanish(@db) == 1) || raise_error
+        libcall(:tab_vanish)
       end
 
       #
@@ -329,6 +304,70 @@ module Rufus
         a
       end
 
+      #
+      # 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
+
+        return unless block_given?
+
+        begin
+          tranbegin
+          yield
+          trancommit
+        rescue Exception => e
+          tranabort
+        end
+      end
+
+      #
+      # Aborts the enclosing transaction
+      #
+      # See #transaction
+      #
+      def abort
+        raise "abort transaction !"
+      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
+
+      #
+      # 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
+
+      #
+      # 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
+
       #
       # Returns the actual pointer to the Tokyo Cabinet table
       #
@@ -338,6 +377,15 @@ module Rufus
 
       protected
 
+      def libcall (lib_method, *args)
+
+        #(lib.send(lib_method, @db, *args) == 1) or raise_error
+          # stack level too deep with JRuby 1.1.6 :(
+
+        (eval(%{ lib.#{lib_method}(@db, *args) }) == 1) or raise_error
+          # works with JRuby 1.1.6
+      end
+
       #
       # Obviously something got wrong, let's ask the db about it and raise
       # a TokyoError

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

@@ -28,6 +28,9 @@
 # jmettraux@gmail.com
 #
 
+require 'rufus/tokyo/hmethods'
+
+
 module Rufus
   module Tokyo
 
@@ -142,10 +145,24 @@ module Rufus
 
       #
       # 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 !)
+      #
+      def self.[] (*h_or_a)
+
+        if h_or_a.is_a?(Array) && h_or_a.size == 1 && h_or_a.first.is_a?(Array)
+          h_or_a = h_or_a.first
+        end
+
+        from_h(::Hash[*h_or_a])
+      end
     end
 
     #
@@ -173,8 +190,11 @@ module Rufus
         CabinetLib
       end
 
+      #
+      # Inserts an element in the list (note that the lib will raise an
+      # ArgumentError if s is not a String)
+      #
       def << (s)
-        #raise 'cannot insert nils into Tokyo Cabinet lists' unless s
         clib.tclistpush2(@list, s)
         self
       end
@@ -184,6 +204,7 @@ module Rufus
       #
       def push (*args)
         args.each { |a| self << a }
+        self
       end
 
       #

data/lib/rufus/tokyo/dystopia.rb

@@ -37,6 +37,6 @@ module Rufus
   end
 end
 
-require File.dirname(__FILE__) + '/dystopia/lib'
-require File.dirname(__FILE__) + '/dystopia/words'
+require 'rufus/tokyo/dystopia/lib'
+require 'rufus/tokyo/dystopia/words'
 

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

@@ -36,41 +36,36 @@ module Rufus
     #
     module DystopiaLib #:nodoc#
 
+      extend FFI::Library
+
       #
       # find Tokyo Dystopia lib
 
       paths = Array(ENV['TOKYO_DYSTOPIA_LIB'] || %w{
-      /opt/local/lib/libtokyodystopia.dylib
-      /usr/local/lib/libtokyodystopia.dylib
-      /usr/local/lib/libtokyodystopia.so
-    })
+        /opt/local/lib/libtokyodystopia.dylib
+        /usr/local/lib/libtokyodystopia.dylib
+        /usr/local/lib/libtokyodystopia.so
+      })
 
       if path = paths.find { |path| File.exist?(path) }
 
-        extend ::FFI::Library
-
-        ffi_lib(path)
+      raise "did not find Tokyo Dystopia libs on your system" unless path
 
-        #
-        # tcwdb functions
-        #
-        # http://tokyocabinet.sourceforge.net/dystopiadoc/#tcwdbapi
+      ffi_lib(path)
 
-        attach_function :tcwdbnew, [], :pointer
+      #
+      # tcwdb functions
+      #
+      # http://tokyocabinet.sourceforge.net/dystopiadoc/#tcwdbapi
 
-        attach_function :tcwdbopen, [ :pointer, :string, :int ], :int
-        attach_function :tcwdbclose, [ :pointer ], :int
+      attach_function :tcwdbnew, [], :pointer
 
-        attach_function :tcwdbecode, [ :pointer ], :int
+      attach_function :tcwdbopen, [ :pointer, :string, :int ], :int
+      attach_function :tcwdbclose, [ :pointer ], :int
 
-        attach_function :tcwdbput2, [ :pointer, :int64, :string, :string ], :pointer
-      else
+      attach_function :tcwdbecode, [ :pointer ], :int
 
-        def method_missing (m, *args)
-          raise "no libtokyodystopia.dylib found on your system"
-        end
-      end
+      attach_function :tcwdbput2, [ :pointer, :int64, :string, :string ], :pointer
     end
-
   end
 end

data/lib/rufus/tokyo/tyrant.rb

@@ -1,5 +1,58 @@
+#
+#--
+# Copyright (c) 2009, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#++
+#
 
-require File.dirname(__FILE__) + '/tyrant/lib'
-require File.dirname(__FILE__) + '/tyrant/abstract'
-require File.dirname(__FILE__) + '/tyrant/table'
+#
+# "made in Japan"
+#
+# jmettraux@gmail.com
+#
+
+require 'rufus/tokyo'
+
+module Rufus::Tokyo
+
+  #
+  # Gathering some methods common to the Tokyo Tyrant abstract and table APIs.
+  #
+  module TyrantMethods
+
+    #
+    # Returns a hash of information about the Tokyo Tyrant database (or table)
+    # at the other end of the connection.
+    #
+    def stat
+
+      lib.tcrdbstat(@db).split("\n").inject({}) { |r, l|
+        kv = l.split("\t")
+        r[kv.first] = kv.last
+        r
+      }
+    end
+  end
+end
+
+require 'rufus/tokyo/tyrant/lib'
+require 'rufus/tokyo/tyrant/abstract'
+require 'rufus/tokyo/tyrant/table'
 

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

@@ -40,6 +40,7 @@ module Rufus
     #   t['toto'] # => 'blah blah'
     #
     class Tyrant < Cabinet
+      include TyrantMethods
 
       attr_reader :host, :port
 
@@ -55,6 +56,15 @@ module Rufus
 
         (lib.tcrdbopen(@db, host, port) == 1) ||
           raise("couldn't connect to tyrant at #{host}:#{port}")
+
+        if self.stat['type'] == 'table'
+
+          self.close
+
+          raise ArgumentError.new(
+            "tyrant at #{host}:#{port} is a table, " +
+            "use Rufus::Tokyo::TyrantTable instead to access it.")
+        end
       end
 
       #
@@ -64,6 +74,5 @@ module Rufus
         TyrantLib
       end
     end
-    
   end
 end

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

@@ -36,97 +36,92 @@ module Rufus
     #
     module TyrantLib #:nodoc#
 
+      extend FFI::Library
+
       #
       # find Tokyo Tyrant lib
 
       paths = Array(ENV['TOKYO_TYRANT_LIB'] || %w{
-      /opt/local/lib/libtokyotyrant.dylib
-      /usr/local/lib/libtokyotyrant.dylib
-      /usr/local/lib/libtokyotyrant.so
-    })
-
-      if path = paths.find { |path| File.exist?(path) }
-
-        extend ::FFI::Library
+        /opt/local/lib/libtokyotyrant.dylib
+        /usr/local/lib/libtokyotyrant.dylib
+        /usr/local/lib/libtokyotyrant.so
+      })
 
-        ffi_lib(path)
+      path = paths.find { |path| File.exist?(path) }
 
-        class << self
-          alias :attfunc :attach_function
-        end
+      raise "Did not find Tokyo Tyrant libraries on your system" unless path
 
-        #
-        # tcrdb functions
+      ffi_lib(path)
 
-        attfunc :tcrdbnew, [], :pointer
+      class << self
+        alias :attfunc :attach_function
+      end
 
-        attfunc :tcrdbopen, [ :pointer, :string, :int ], :int
-        attfunc :abs_close, :tcrdbclose, [ :pointer ], :int
+      #
+      # tcrdb functions
 
-        attfunc :abs_del, :tcrdbdel, [ :pointer ], :void
+      attfunc :tcrdbnew, [], :pointer
 
-        attfunc :abs_rnum, :tcrdbrnum, [ :pointer ], :uint64
-        attfunc :abs_size, :tcrdbsize, [ :pointer ], :uint64
+      attfunc :tcrdbstat, [ :pointer ], :string
 
-        attfunc :abs_put2, :tcrdbput2, [ :pointer, :string, :string ], :int
-        attfunc :abs_get2, :tcrdbget2, [ :pointer, :string ], :string
-        attfunc :abs_out2, :tcrdbout2, [ :pointer, :string ], :int
+      attfunc :tcrdbopen, [ :pointer, :string, :int ], :int
+      attfunc :abs_close, :tcrdbclose, [ :pointer ], :int
 
-        attfunc :abs_iterinit, :tcrdbiterinit, [ :pointer ], :int
-        attfunc :abs_iternext2, :tcrdbiternext2, [ :pointer ], :string
+      attfunc :abs_del, :tcrdbdel, [ :pointer ], :void
 
-        attfunc :abs_vanish, :tcrdbvanish, [ :pointer ], :int
+      attfunc :abs_rnum, :tcrdbrnum, [ :pointer ], :uint64
+      attfunc :abs_size, :tcrdbsize, [ :pointer ], :uint64
 
-        attfunc :abs_sync, :tcrdbsync, [ :pointer ], :int
-        attfunc :abs_copy, :tcrdbcopy, [ :pointer, :string ], :int
+      attfunc :abs_put2, :tcrdbput2, [ :pointer, :string, :string ], :int
+      attfunc :abs_get2, :tcrdbget2, [ :pointer, :string ], :string
+      attfunc :abs_out2, :tcrdbout2, [ :pointer, :string ], :int
 
-        #
-        # table functions
+      attfunc :abs_iterinit, :tcrdbiterinit, [ :pointer ], :int
+      attfunc :abs_iternext2, :tcrdbiternext2, [ :pointer ], :string
 
-        attfunc :tab_close, :tcrdbclose, [ :pointer ], :int
+      attfunc :abs_vanish, :tcrdbvanish, [ :pointer ], :int
 
-        attfunc :tab_genuid, :tcrdbtblgenuid, [ :pointer ], :int64
+      attfunc :abs_sync, :tcrdbsync, [ :pointer ], :int
+      attfunc :abs_copy, :tcrdbcopy, [ :pointer, :string ], :int
 
-        attfunc :tab_get, :tcrdbtblget, [ :pointer, :string, :int ], :pointer
+      #
+      # table functions
 
-        attfunc :tab_iterinit, :tcrdbiterinit, [ :pointer ], :int
-        attfunc :tab_iternext2, :tcrdbiternext2, [ :pointer ], :string
+      attfunc :tab_close, :tcrdbclose, [ :pointer ], :int
 
-        attfunc :tab_put, :tcrdbtblput, [ :pointer, :string, :int, :pointer ], :int
+      attfunc :tab_genuid, :tcrdbtblgenuid, [ :pointer ], :int64
 
-        attfunc :tab_out, :tcrdbtblout, [ :pointer, :string, :int ], :int
+      attfunc :tab_get, :tcrdbtblget, [ :pointer, :string, :int ], :pointer
 
-        attfunc :tab_ecode, :tcrdbecode, [ :pointer ], :int
-        attfunc :tab_errmsg, :tcrdberrmsg, [ :int ], :string
+      attfunc :tab_iterinit, :tcrdbiterinit, [ :pointer ], :int
+      attfunc :tab_iternext2, :tcrdbiternext2, [ :pointer ], :string
 
-        attfunc :tab_del, :tcrdbdel, [ :pointer ], :void
+      attfunc :tab_put, :tcrdbtblput, [ :pointer, :string, :int, :pointer ], :int
 
-        attfunc :tab_rnum, :tcrdbrnum, [ :pointer ], :uint64
+      attfunc :tab_out, :tcrdbtblout, [ :pointer, :string, :int ], :int
 
-        attfunc :tab_vanish, :tcrdbvanish, [ :pointer ], :int
+      attfunc :tab_ecode, :tcrdbecode, [ :pointer ], :int
+      attfunc :tab_errmsg, :tcrdberrmsg, [ :int ], :string
 
-        attfunc :tab_setindex, :tcrdbtblsetindex, [ :pointer, :string, :int ], :int
+      attfunc :tab_del, :tcrdbdel, [ :pointer ], :void
 
-        #
-        # qry functions
+      attfunc :tab_rnum, :tcrdbrnum, [ :pointer ], :uint64
 
-        attfunc :qry_new, :tcrdbqrynew, [ :pointer ], :pointer
-        attfunc :qry_del, :tcrdbqrydel, [ :pointer ], :void
+      attfunc :tab_vanish, :tcrdbvanish, [ :pointer ], :int
 
-        attfunc :qry_addcond, :tcrdbqryaddcond, [ :pointer, :string, :int, :string ], :void
-        attfunc :qry_setorder, :tcrdbqrysetorder, [ :pointer, :string, :int ], :void
-        attfunc :qry_setmax, :tcrdbqrysetmax, [ :pointer, :int ], :void
+      attfunc :tab_setindex, :tcrdbtblsetindex, [ :pointer, :string, :int ], :int
 
-        attfunc :qry_search, :tcrdbqrysearch, [ :pointer ], :pointer
+      #
+      # qry functions
 
-      else
+      attfunc :qry_new, :tcrdbqrynew, [ :pointer ], :pointer
+      attfunc :qry_del, :tcrdbqrydel, [ :pointer ], :void
 
-        def method_missing (m, *args)
-          raise "no libtokyotyrant.dylib found on your system"
-        end
-      end
+      attfunc :qry_addcond, :tcrdbqryaddcond, [ :pointer, :string, :int, :string ], :void
+      attfunc :qry_setorder, :tcrdbqrysetorder, [ :pointer, :string, :int ], :void
+      attfunc :qry_setmax, :tcrdbqrysetmax, [ :pointer, :int ], :void
 
+      attfunc :qry_search, :tcrdbqrysearch, [ :pointer ], :pointer
     end
-
   end
 end

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

@@ -41,6 +41,7 @@ module Rufus
     #     # => { 'name' => 'toto the first', 'age' => '34' }
     #
     class TyrantTable < Table
+      include TyrantMethods
 
       attr_reader :host, :port
 
@@ -53,6 +54,15 @@ module Rufus
 
         (lib.tcrdbopen(@db, host, port) == 1) ||
           raise("couldn't connect to tyrant at #{host}:#{port}")
+
+        if self.stat['type'] != 'table'
+
+          self.close
+
+          raise ArgumentError.new(
+            "tyrant at #{host}:#{port} is a not table, " +
+            "use Rufus::Tokyo::Tyrant instead to access it.")
+        end
       end
 
       #
@@ -62,24 +72,27 @@ module Rufus
         TyrantLib
       end
 
-      #
-      # Inserts a record in the table db
-      #
-      #   table['pk1'] = { 'name' => 'jeff', 'age' => '46' }
-      #
-      def []= (pk, h)
-
-        pklen = CabinetLib.strlen(pk)
-
-        m = Map.from_h(h)
-
-        r = lib.tab_put(@db, pk, pklen, m.pointer)
-
-        m.free
+      def transaction #:nodoc#
+        raise_transaction_nme('transaction')
+      end
+      def abort #:nodoc#
+        raise_transaction_nme('abort')
+      end
+      def tranbegin #:nodoc#
+        raise_transaction_nme('tranbegin')
+      end
+      def trancommit #:nodoc#
+        raise_transaction_nme('trancommit')
+      end
+      def tranabort #:nodoc#
+        raise_transaction_nme('tranabort')
+      end
 
-        (r == 1) || raise_error
+      protected
 
-        h
+      def raise_transaction_nme (method_name)
+        raise NoMethodError.new(
+          "Tyrant tables don't support transactions", method_name)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rufus-tokyo
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors: 
 - John Mettraux
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-13 00:00:00 +09:00
+date: 2009-02-16 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency