activetokyocabinet 0.1.0 → 0.1.1

data/README

@@ -4,11 +4,11 @@ Copyright (c) 2010 SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
 
 == Description
 
-ActiveTokyoCabinet is a library for using TokyoCabinet under ActiveRecord.
+ActiveTokyoCabinet is a library for using Tokyo(Cabinet|Tyrant) under ActiveRecord.
 
-ActiveTokyoCabinet depend on TokyoCabinet.
+ActiveTokyoCabinet depend on Tokyo(Cabinet|Tyrant).
 
-see http://1978th.net/tokyocabinet/ .
+see http://1978th.net/tokyocabinet/ , http://1978th.net/tokyotyrant/
 
 == Project Page
 
@@ -16,15 +16,23 @@ http://rubyforge.org/projects/activetokyocabi
 
 == Install
 
-gem install zipruby
+gem install activetokyocabinet
+
+see http://gemcutter.org/gems/activetokyocabinet
 
 == Example
 === database.yml
-
+    # TokyoCabinet
     development:
       adapter: tokyocabinet
       database: path_of_database_directory
                                # ~~~~~~~~~
+    # TokyoCabinet
+    development:
+      adapter: tokyotyrant
+      database:
+        hellos: { host: localhost, port: 1978 }
+        tests: { host: localhost, port: 1979 }
 
 === Model
 
@@ -41,32 +49,37 @@ gem install zipruby
 
     class HelloController < ApplicationController
       def index
+        hello_id = nil
+    
         (20..35).each do |i|
           hello = Hello.new
           hello.name = 'yamada'
-          hello.age  = 20
+          hello.age  = i
           hello.save!
+          hello_id = hello.id
         end
     
         p Hello.find(:all, 
                      :conditions => ["name = ? and age > ?", "yamada", 25],
                      :order => 'age desc', :limit => 5, :offset => 3)
     
-        hello = Hello.find(1)
-        hello.name = 'sato'
+        hello = Hello.find(hello_id)
+        hello.name = 'yamashita'
         hello.save!
     
-        p Hello.find(:first, :conditions => ["name = ?", "tanaka"])
+        p Hello.find(:first, :conditions => ["name = ?", "yamashita"])
     
-        hello = Hello.find(2)
+        hello = Hello.find(hello_id)
         hello.destroy
     
+        p Hello.find(:first, :conditions => ["name = ?", "yamashita"])
+    
         p Hello.find(:all)
     
         Hello.delete_all(["name = ? and age <= ?", "yamada", 30])
     
         p Hello.find(:all)
-    
+
         render :text => 'hello'
       end
     end

data/lib/active_record/connection_adapters/abstract_tokyocabinet_adapter.rb

@@ -0,0 +1,157 @@
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_tokyocabinet/tdb'
+require 'active_tokyocabinet/sqlparser.tab'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractTokyoCabinetAdapter < AbstractAdapter
+      def initialize(connection, logger, query_klass)
+        super(connection, logger)
+        @query_klass = query_klass
+      end
+
+      def supports_count_distinct?
+        false
+      end
+
+      def select(sql, name = nil)
+        rows = []
+
+        log(sql, name) do
+          parsed_sql = ActiveTokyoCabinet::SQLParser.new(sql).parse
+
+          tdbopen(parsed_sql) do |tdb|
+            select_list = parsed_sql[:select_list]
+
+            rkeys(tdb, parsed_sql).each do |rkey|
+              rcols = tdb.get(rkey)
+              next if rcols.nil?
+
+              unless select_list.nil? or select_list.empty?
+                rcols = select_list.each {|k| r[k] = rcols[k] }
+              end
+
+              rcols['id'] = rkey
+              rows << rcols
+            end
+          end
+
+          if (count = parsed_sql[:count])
+            rows = [{count => rows.length}]
+          end
+        end
+
+        return rows
+      end
+
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        pkey = nil
+
+        log(sql, name) do
+          parsed_sql = ActiveTokyoCabinet::SQLParser.new(sql).parse
+
+          tdbopen(parsed_sql) do |tdb|
+            pkey = tdb.genuid
+            keys = parsed_sql[:column_list]
+            vals = parsed_sql[:value_list]
+            cols = {}
+
+            keys.zip(vals).each do |k, v|
+              cols[k] = v.to_s
+            end
+
+            unless tdb.put(pkey, cols)
+              ecode = tdb.ecode
+              raise '%s: %s' % [tdb.errmsg(ecode), sql]
+            end
+          end
+        end
+        return pkey
+      end
+
+      def update_sql(sql, name = nil)
+        rownum = 0
+
+        log(sql, name) do
+          parsed_sql = ActiveTokyoCabinet::SQLParser.new(sql).parse
+
+          tdbopen(parsed_sql) do |tdb|
+            set_clause_list = parsed_sql[:set_clause_list]
+
+            rkeys(tdb, parsed_sql).each do |rkey|
+              rcols = tdb.get(rkey)
+
+              set_clause_list.each do |k, v|
+                rcols[k] = v.to_s
+              end
+
+              rownum += 1
+
+              unless tdb.put(rkey, rcols)
+                ecode = tdb.ecode
+                raise '%s: %s' % [tdb.errmsg(ecode), sql]
+              end
+            end
+          end
+        end
+
+        return rownum
+      end
+
+      def delete_sql(sql, name = nil)
+        rownum = 0
+
+        log(sql, name) do
+          parsed_sql = ActiveTokyoCabinet::SQLParser.new(sql).parse
+
+          tdbopen(parsed_sql) do |tdb|
+            rkeys(tdb, parsed_sql)
+            set_clause_list = parsed_sql[:set_clause_list]
+
+            rkeys(tdb, parsed_sql).each do |rkey|
+              rownum += 1
+
+              unless tdb.out(rkey)
+                ecode = tdb.ecode
+                raise '%s: %s' % [tdb.errmsg(ecode), sql]
+              end
+            end
+          end
+        end
+
+        return rownum
+      end
+
+      def rkeys(tdb, parsed_sql)
+        condition, order, limit, offset = parsed_sql.values_at(:condition, :order, :limit, :offset)
+        condition ||= []
+
+        unless condition.kind_of?(Array) and condition.all? {|i| i.kind_of?(Hash) }
+          return [parsed_sql[:condition]].flatten
+        end
+
+        qry = @query_klass::new(tdb)
+
+        condition.each do |cond|
+          name, op, expr = cond.values_at(:name, :op, :expr)
+          op = @query_klass.const_get(op)
+          expr = expr.kind_of?(Array) ? expr.join(' ') : expr.to_s
+          qry.addcond(name, op, expr)
+        end
+
+        if order
+          name, type = order.values_at(:name, :type)
+          type = @query_klass.const_get(type)
+          qry.setorder(name, type)
+        end
+
+        if limit or offset
+          qry.setlimit(limit || 0, offset || 0)
+        end
+
+        return qry.search
+      end
+      private :rkeys
+    end
+  end
+end

data/lib/active_record/connection_adapters/tokyocabinet_adapter.rb

@@ -1,235 +1,65 @@
-require 'active_record/connection_adapters/abstract_adapter'
-require 'tokyocabinet'
-require 'active_tokyocabinet/tdb'
-require 'active_tokyocabinet/sqlparser.tab'
-
-module ActiveRecord
-  class Base
-    def self.tokyocabinet_connection(config)
-      unless config[:database]
-        raise ArgumentError, "No database file specified. Missing argument: database"
-      end
-
-      if Object.const_defined?(:RAILS_ROOT)
-        config[:database] = File.expand_path(config[:database], RAILS_ROOT)
-      end
-
-      ConnectionAdapters::TokyoCabinetAdapter.new(nil, logger, config)
-    end
-  end
-
-  module ConnectionAdapters
-    class TokyoCabinetAdapter < AbstractAdapter
-      def initialize(connection, logger, config)
-        super(connection, logger)
-        @config = config
-      end
-
-      def table_exists?(table_name)
-        path = tdbpath(table_name)
-        File.exist?(path)
-      end
-
-      def select(sql, name = nil)
-        rows = []
-
-        log(sql, name) do
-          parsed_sql = ActiveTokyoCabinet::SQLParser.new(sql).parse
-
-          tdbopen(parsed_sql[:table], TokyoCabinet::TDB::OREADER) do |tdb|
-            if (qry = tdbqry(tdb, parsed_sql))
-              rkeys = qry.search
-            else
-              rkeys = [parsed_sql[:condition]].flatten
-            end
-
-            select_list = parsed_sql[:select_list]
-
-            rkeys.each do |rkey|
-              rcols = tdb.get(rkey)
-              next if rcols.nil?
-
-              unless select_list.nil? or select_list.empty?
-                rcols = select_list.each {|k| r[k] = rcols[k] }
-              end
-
-              rcols['id'] = rkey
-              rows << rcols
-            end
-          end
-
-          if (count = parsed_sql[:count])
-            rows = [{count => rows.length}]
-          end
-        end
-
-        return rows
-      end
-
-      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        pkey = nil
-
-        log(sql, name) do
-          parsed_sql = ActiveTokyoCabinet::SQLParser.new(sql).parse
-
-          tdbopen(parsed_sql[:table], TokyoCabinet::TDB::OWRITER) do |tdb|
-            pkey = tdb.genuid
-            keys = parsed_sql[:column_list]
-            vals = parsed_sql[:value_list]
-            cols = {}
-
-            keys.zip(vals).each do |k, v|
-              cols[k] = v.to_s
-            end
-
-            unless tdb.put(pkey, cols)
-              ecode = tdb.ecode
-              raise '%s: %s' % [tdb.errmsg(ecode), sql]
-            end
-          end
-        end
-        return pkey
-      end
-
-      def update_sql(sql, name = nil)
-        rownum = 0
-
-        log(sql, name) do
-          parsed_sql = ActiveTokyoCabinet::SQLParser.new(sql).parse
-
-          tdbopen(parsed_sql[:table], TokyoCabinet::TDB::OWRITER) do |tdb|
-            set_clause_list = parsed_sql[:set_clause_list]
-
-            if (qry = tdbqry(tdb, parsed_sql))
-              r = qry.proc do |pkey, cols|
-                set_clause_list.each do |k, v|
-                  cols[k] = v.to_s
-                end
-
-                rownum += 1
-                TokyoCabinet::TDBQRY::QPPUT
-              end
-
-              unless r
-                ecode = tdb.ecode
-                raise '%s: %s' % [tdb.errmsg(ecode), sql]
-              end
-            else
-              [parsed_sql[:condition]].flatten.each do |rkey|
-                rcols = tdb.get(rkey)
-
-                set_clause_list.each do |k, v|
-                  rcols[k] = v.to_s
-                end
-
-                rownum += 1
-
-                unless tdb.put(rkey, rcols)
-                  ecode = tdb.ecode
-                  raise '%s: %s' % [tdb.errmsg(ecode), sql]
-                end
-              end
-            end
-          end
-        end
-
-        return rownum
-      end
-
-      def delete_sql(sql, name = nil) #:nodoc:
-        rownum = 0
-
-        log(sql, name) do
-          parsed_sql = ActiveTokyoCabinet::SQLParser.new(sql).parse
-
-          tdbopen(parsed_sql[:table], TokyoCabinet::TDB::OWRITER) do |tdb|
-            set_clause_list = parsed_sql[:set_clause_list]
-
-            if (qry = tdbqry(tdb, parsed_sql))
-              r = qry.proc do |pkey, cols|
-                rownum += 1
-                TokyoCabinet::TDBQRY::QPOUT
-              end
-
-              unless r
-                ecode = tdb.ecode
-                raise '%s: %s' % [tdb.errmsg(ecode), sql]
-              end
-            else
-              [parsed_sql[:condition]].flatten.each do |rkey|
-                rownum += 1
-
-                unless tdb.out(rkey)
-                  ecode = tdb.ecode
-                  raise '%s: %s' % [tdb.errmsg(ecode), sql]
-                end
-              end
-            end
-          end
-        end
-
-        return rownum
-      end
-
-      def tdbopen(table_name, omode)
-        tdb = TokyoCabinet::TDB::new
-        path = tdbpath(table_name)
-
-        unless File.exist?(path)
-          omode = TokyoCabinet::TDB::OWRITER | TokyoCabinet::TDB::OCREAT
-        end
-
-        unless tdb.open(path, omode)
-          ecode = tdb.ecode
-          raise "%s: %s" % [tdb.errmsg(ecode), path]
-        end
-
-        begin
-          yield(tdb)
-        ensure
-          unless tdb.close
-            ecode = tdb.ecode
-            raise tdb.errmsg(ecode)
-          end
-        end
-      end
-      private :tdbopen
-
-      def tdbqry(tdb, parsed_sql)
-        condition, order, limit, offset = parsed_sql.values_at(:condition, :order, :limit, :offset)
-        condition ||= []
-
-        unless condition.kind_of?(Array) and condition.all? {|i| i.kind_of?(Hash) }
-          return nil
-        end
-
-        qry = TokyoCabinet::TDBQRY::new(tdb)
-
-        condition.each do |cond|
-          name, op, expr = cond.values_at(:name, :op, :expr)
-          op = TokyoCabinet::TDBQRY.const_get(op)
-          expr = expr.kind_of?(Array) ? expr.join(' ') : expr.to_s
-          qry.addcond(name, op, expr)
-        end
-
-        if order
-          name, type = order.values_at(:name, :type)
-          type = TokyoCabinet::TDBQRY.const_get(type)
-          qry.setorder(name, type)
-        end
-
-        if limit or offset
-          qry.setlimit(limit || 0, offset || 0)
-        end
-
-        return qry
-      end
-      private :tdbqry
-
-      def tdbpath(table_name)
-        File.join(@config[:database], table_name + ".tct")
-      end
-      private :tdbpath
-    end
-  end
-end
+require 'active_record/connection_adapters/abstract_tokyocabinet_adapter'
+require 'tokyocabinet'
+
+module ActiveRecord
+  class Base
+    def self.tokyocabinet_connection(config)
+      unless config[:database]
+        raise ArgumentError, "No database file specified. Missing argument: database"
+      end
+
+      if Object.const_defined?(:RAILS_ROOT)
+        config[:database] = File.expand_path(config[:database], RAILS_ROOT)
+      end
+
+      ConnectionAdapters::TokyoCabinetAdapter.new(nil, logger, config)
+    end
+  end
+
+  module ConnectionAdapters
+    class TokyoCabinetAdapter < AbstractTokyoCabinetAdapter
+      def initialize(connection, logger, config)
+        super(connection, logger, TokyoCabinet::TDBQRY)
+        @config = config
+      end
+
+      def table_exists?(table_name)
+        path = tdbpath(table_name)
+        File.exist?(path)
+      end
+
+      def tdbopen(parsed_sql)
+        table_name = parsed_sql[:table]
+        path = tdbpath(table_name)
+
+        if File.exist?(path) and parsed_sql[:command] == :select
+          omode = TokyoCabinet::TDB::OREADER
+        else
+          omode = TokyoCabinet::TDB::OWRITER | TokyoCabinet::TDB::OCREAT
+        end
+
+        tdb = TokyoCabinet::TDB::new
+
+        unless tdb.open(path, omode)
+          ecode = tdb.ecode
+          raise "%s: %s" % [tdb.errmsg(ecode), path]
+        end
+
+        begin
+          yield(tdb)
+        ensure
+          unless tdb.close
+            ecode = tdb.ecode
+            raise tdb.errmsg(ecode)
+          end
+        end
+      end
+      private :tdbopen
+
+      def tdbpath(table_name)
+        File.join(@config[:database], table_name + ".tct")
+      end
+      private :tdbpath
+    end
+  end
+end

data/lib/active_record/connection_adapters/tokyotyrant_adapter.rb

@@ -0,0 +1,63 @@
+require 'active_record/connection_adapters/abstract_tokyocabinet_adapter'
+require 'tokyotyrant'
+
+module ActiveRecord
+  class Base
+    def self.tokyotyrant_connection(config)
+      unless config[:database]
+        raise ArgumentError, "No database file specified. Missing argument: database"
+      end
+
+      ConnectionAdapters::TokyoTyrantAdapter.new({}, logger, config)
+    end
+  end
+
+  module ConnectionAdapters
+    class TokyoTyrantAdapter < AbstractTokyoCabinetAdapter
+      def initialize(connection, logger, config)
+        super(connection, logger, TokyoTyrant::RDBQRY)
+        @database = {}
+
+        config.fetch(:database).map do |table_name, attribute|
+          @database[table_name] = {
+            :host => attribute.fetch('host').to_s,
+            :port => attribute.fetch('port', 0).to_i,
+            :timeout => attribute.fetch('timeout', 0).to_i,
+          }
+        end
+      end
+
+      def table_exists?(table_name)
+        @database.has_key?(table_name)
+      end
+
+      def disconnect!
+        super
+
+        @connection.keys.each do |table_name|
+          conn = @connection[table_name]
+          conn.close
+          @connection.delete(table_name)
+        end
+      end
+
+      def tdbopen(parsed_sql)
+        table_name = parsed_sql[:table]
+
+        unless (tdb = @connection[table_name])
+          host, port, timeout = @database.fetch(table_name).values_at(:host, :port, :timeout)
+          tdb = TokyoTyrant::RDBTBL::new
+
+          unless tdb.open(host, port, timeout)
+            ecode = tdb.ecode
+            raise "%s: %s" % [tdb.errmsg(ecode), path]
+          end
+        end
+
+        yield(tdb)
+        @connection[table_name] = tdb
+      end
+      private :tdbopen
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: activetokyocabinet
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - winebarrel
@@ -13,17 +13,7 @@ date: 2010-01-06 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rails
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: tokyocabinet
+  name: activerecord
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
@@ -42,6 +32,8 @@ extra_rdoc_files:
 - README
 files: 
 - lib/active_record/connection_adapters/tokyocabinet_adapter.rb
+- lib/active_record/connection_adapters/abstract_tokyocabinet_adapter.rb
+- lib/active_record/connection_adapters/tokyotyrant_adapter.rb
 - lib/active_tokyocabinet/tdb.rb
 - lib/active_tokyocabinet/sqlparser.y
 - lib/active_tokyocabinet/sqlparser.tab.rb
@@ -53,7 +45,7 @@ licenses: []
 post_install_message: 
 rdoc_options: 
 - --title
-- ActiveTokyoCabinet - a library for using TokyoCabinet under ActiveRecord.
+- ActiveTokyoCabinet - a library for using Tokyo(Cabinet|Tyrant) under ActiveRecord.
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -74,6 +66,6 @@ rubyforge_project: activetokyocabinet
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: ActiveTokyoCabinet is a library for using TokyoCabinet under ActiveRecord.
+summary: ActiveTokyoCabinet is a library for using Tokyo(Cabinet|Tyrant) under ActiveRecord.
 test_files: []