activerecord-turntable 2.5.0 → 3.0.0.alpha1

data/lib/active_record/turntable/sequencer/api.rb

@@ -2,19 +2,19 @@
 #
 # Sequencer via HTTP API
 #
-require 'httpclient'
+require "httpclient"
 
 module ActiveRecord::Turntable
   class Sequencer
     class Api < Sequencer
-      API_ENDPOINT = '/sequences/'
-      NEXT_VALUE_ENDPOINT = '/new'
+      API_ENDPOINT = "/sequences/".freeze
+      NEXT_VALUE_ENDPOINT = "/new".freeze
 
       def initialize(klass, options = {})
         @klass = klass
         @options = options
-        @host = @options["api_host"]
-        @port = @options["api_port"]
+        @host = @options[:api_host]
+        @port = @options[:api_port]
         @client = HTTPClient.new
       end
 
@@ -22,14 +22,14 @@ module ActiveRecord::Turntable
         res = @client.get_content("http://#{@host}:#{@port}#{API_ENDPOINT}#{sequence_name}#{NEXT_VALUE_ENDPOINT}")
         new_id = res.to_i
         raise SequenceNotFoundError if new_id.zero?
-        return new_id
+        new_id
       end
 
       def current_sequence_value(sequence_name)
         res = @client.get_content("http://#{@host}:#{@port}#{API_ENDPOINT}#{sequence_name}")
         current_id = res.to_i
         raise SequenceNotFoundError if current_id.zero?
-        return current_id
+        current_id
       end
     end
   end

data/lib/active_record/turntable/sequencer/barrage.rb

@@ -4,25 +4,24 @@ module ActiveRecord::Turntable
       @@unique_barrage_instance = {}
 
       def initialize(klass, options = {})
-        require 'barrage'
+        require "barrage"
         @klass = klass
         @options = options["options"]
-        @barrage = get_barrage_instance
       end
 
       def next_sequence_value(sequence_name)
-        @barrage.next
+        barrage.next
       end
 
       def current_sequence_value(sequence_name)
-        @barrage.current
+        barrage.current
       end
 
       private
 
-      def get_barrage_instance
-        @@unique_barrage_instance[@options] ||= ::Barrage.new(@options)
-      end
+        def barrage
+          @@unique_barrage_instance[@options] ||= ::Barrage.new(@options)
+        end
     end
   end
 end

data/lib/active_record/turntable/sequencer/mysql.rb

@@ -17,7 +17,7 @@ module ActiveRecord::Turntable
         res = conn.execute("SELECT LAST_INSERT_ID()")
         new_id = res.first.first.to_i
         raise SequenceNotFoundError if new_id.zero?
-        return new_id
+        new_id
       end
 
       def current_sequence_value(sequence_name)
@@ -25,7 +25,7 @@ module ActiveRecord::Turntable
         conn.execute "UPDATE #{@klass.connection.quote_table_name(sequence_name)} SET id=LAST_INSERT_ID(id)"
         res = conn.execute("SELECT LAST_INSERT_ID()")
         current_id = res.first.first.to_i
-        return current_id
+        current_id
       end
     end
   end

data/lib/active_record/turntable/sequencer.rb

@@ -14,9 +14,9 @@ module ActiveRecord::Turntable
     end
 
     @@sequence_types = {
-      :api => Api,
-      :mysql => Mysql,
-      :barrage => Barrage
+      api: Api,
+      mysql: Mysql,
+      barrage: Barrage,
     }
 
     @@sequences = {}
@@ -24,9 +24,9 @@ module ActiveRecord::Turntable
     cattr_reader :sequences, :tables
 
     def self.build(klass, sequence_name = nil, cluster_name = nil)
-      sequence_name ||= current_cluster_config_for(cluster_name || klass)["seq"].keys.first
-      seq_config = current_cluster_config_for(cluster_name || klass)["seq"][sequence_name]
-      seq_type = (seq_config["seq_type"] ? seq_config["seq_type"].to_sym : :mysql)
+      sequence_name ||= current_cluster_config_for(cluster_name || klass)[:seq].keys.first
+      seq_config = current_cluster_config_for(cluster_name || klass)[:seq][sequence_name]
+      seq_type = (seq_config[:seq_type] ? seq_config[:seq_type].to_sym : :mysql)
       @@tables[klass.table_name] ||= (@@sequences[sequence_name(klass.table_name, klass.primary_key)] ||= @@sequence_types[seq_type].new(klass, seq_config))
     end
 
@@ -39,7 +39,7 @@ module ActiveRecord::Turntable
     end
 
     def self.table_name(seq_name)
-      seq_name.split('_').first
+      seq_name.split("_").first
     end
 
     def next_sequence_value
@@ -52,13 +52,13 @@ module ActiveRecord::Turntable
 
     private
 
-    def self.current_cluster_config_for(klass_or_name)
-      cluster_name = if klass_or_name.is_a?(Symbol)
-                       klass_or_name
-                     else
-                       klass_or_name.turntable_cluster_name.to_s
-                     end
-      ActiveRecord::Base.turntable_config["clusters"][cluster_name]
-    end
+      def self.current_cluster_config_for(klass_or_name)
+        cluster_name = if klass_or_name.is_a?(Symbol)
+                         klass_or_name
+                       else
+                         klass_or_name.turntable_cluster_name.to_s
+                       end
+        ActiveRecord::Base.turntable_config[:clusters][cluster_name]
+      end
   end
 end

data/lib/active_record/turntable/shard.rb

@@ -1,16 +1,19 @@
 module ActiveRecord::Turntable
   class Shard
     module Connections; end
+    def self.connection_classes
+      Connections.constants.map { |name| Connections.const_get(name) }
+    end
 
     DEFAULT_CONFIG = {
-      "connection" => (defined?(Rails) ? Rails.env : "development")
+      "connection" => (defined?(Rails) ? Rails.env : "development"),
     }.with_indifferent_access
 
     attr_reader :name
 
     def initialize(shard_spec)
       @config = DEFAULT_CONFIG.merge(shard_spec)
-      @name = @config["connection"]
+      @name = @config[:connection]
       ActiveRecord::Base.turntable_connections[name] = connection_pool
     end
 
@@ -26,26 +29,26 @@ module ActiveRecord::Turntable
 
     private
 
-    def connection_klass
-      @connection_klass ||= create_connection_class
-    end
+      def connection_klass
+        @connection_klass ||= create_connection_class
+      end
 
-    def get_or_set_connection_class
-      if Connections.const_defined?(name.classify)
-        klass = Connections.const_get(name.classify)
-      else
-        klass = Class.new(ActiveRecord::Base)
-        Connections.const_set(name.classify, klass)
-        klass.abstract_class = true
+      def get_or_set_connection_class
+        if Connections.const_defined?(name.classify)
+          klass = Connections.const_get(name.classify)
+        else
+          klass = Class.new(ActiveRecord::Base)
+          Connections.const_set(name.classify, klass)
+          klass.abstract_class = true
+        end
+        klass
       end
-      klass
-    end
 
-    def create_connection_class
-      klass = get_or_set_connection_class
-      klass.remove_connection
-      klass.establish_connection ActiveRecord::Base.connection_pool.spec.config[:shards][name].with_indifferent_access
-      klass
-    end
+      def create_connection_class
+        klass = get_or_set_connection_class
+        klass.remove_connection
+        klass.establish_connection ActiveRecord::Base.connection_pool.spec.config[:shards][name].with_indifferent_access
+        klass
+      end
   end
 end

data/lib/active_record/turntable/sql_tree_patch.rb

@@ -1,22 +1,22 @@
-require 'sql_tree'
-require 'active_support/core_ext/kernel/reporting'
+require "sql_tree"
+require "active_support/core_ext/kernel/reporting"
 
 module SQLTree
   class << self
     attr_accessor :identifier_quote_field_char
   end
-  self.identifier_quote_field_char = '`'
+  self.identifier_quote_field_char = "`"
 end
 
 class SQLTree::Token
-  extended_keywords = ['BINARY', 'LIMIT', 'OFFSET', 'INDEX', 'KEY', 'USE', 'FORCE', 'IGNORE']
+  extended_keywords = %w(BINARY LIMIT OFFSET INDEX KEY USE FORCE IGNORE)
   KEYWORDS.concat(extended_keywords)
 
   extended_keywords.each do |kwd|
     const_set(kwd, Class.new(SQLTree::Token::Keyword))
   end
 
-  BINARY_ESCAPE = Class.new(SQLTree::Token).new('x')
+  BINARY_ESCAPE = Class.new(SQLTree::Token).new("x")
 
   def possible_index_hint?
     [SQLTree::Token::USE, SQLTree::Token::FORCE, SQLTree::Token::IGNORE].include?(self.class)
@@ -29,7 +29,7 @@ end
 
 class SQLTree::Tokenizer
   def tokenize_quoted_string(&block) # :yields: SQLTree::Token::String
-    string = ''
+    string = ""
     until next_char.nil? || current_char == "'"
       string << (current_char == "\\" ? instance_eval("%@\\#{next_char.gsub('@', '\@')}@") : current_char)
     end
@@ -38,34 +38,33 @@ class SQLTree::Tokenizer
 
   # @note Override to handle x'..' binary string
   def each_token(&block) # :yields: SQLTree::Token
-
     while next_char
       case current_char
-      when /^\s?$/;        # whitespace, go to next character
-      when '(';            handle_token(SQLTree::Token::LPAREN, &block)
-      when ')';            handle_token(SQLTree::Token::RPAREN, &block)
-      when '.';            handle_token(SQLTree::Token::DOT, &block)
-      when ',';            handle_token(SQLTree::Token::COMMA, &block)
-      when /\d/;           tokenize_number(&block)
-      when "'";            tokenize_quoted_string(&block)
-      when 'E', 'x', 'X';  tokenize_possible_escaped_string(&block)
-      when /\w/;           tokenize_keyword(&block)
-      when OPERATOR_CHARS; tokenize_operator(&block)
-      when SQLTree.identifier_quote_char; tokenize_quoted_identifier(&block)
+      when /^\s?$/ then # whitespace, go to next character
+      when "(" then            handle_token(SQLTree::Token::LPAREN, &block)
+      when ")" then            handle_token(SQLTree::Token::RPAREN, &block)
+      when "." then            handle_token(SQLTree::Token::DOT, &block)
+      when "," then            handle_token(SQLTree::Token::COMMA, &block)
+      when /\d/ then           tokenize_number(&block)
+      when "'" then            tokenize_quoted_string(&block)
+      when "E", "x", 'X' then  tokenize_possible_escaped_string(&block)
+      when /\w/ then           tokenize_keyword(&block)
+      when OPERATOR_CHARS then tokenize_operator(&block)
+      when SQLTree.identifier_quote_char then tokenize_quoted_identifier(&block)
       end
     end
 
     # Make sure to yield any tokens that are still stashed on the queue.
     empty_keyword_queue!(&block)
   end
-  alias :each :each_token
+  alias_method :each, :each_token
 
   def tokenize_possible_escaped_string(&block)
     if peek_char == "'"
       token = case current_char
-              when 'E'
+              when "E"
                 SQLTree::Token::STRING_ESCAPE
-              when 'x', 'X'
+              when "x", "X"
                 SQLTree::Token::BINARY_ESCAPE
               end
       handle_token(token, &block)
@@ -87,16 +86,16 @@ module SQLTree::Node
 
     def to_sql(options = {})
       raise "At least one SELECT expression is required" if self.select.empty?
-      sql = (self.distinct) ? "SELECT DISTINCT " : "SELECT "
-      sql << select.map { |s| s.to_sql(options) }.join(', ')
-      sql << " FROM "     << from.map { |f| f.to_sql(options) }.join(', ') if from
+      sql = self.distinct ? "SELECT DISTINCT " : "SELECT "
+      sql << select.map { |s| s.to_sql(options) }.join(", ")
+      sql << " FROM "     << from.map { |f| f.to_sql(options) }.join(", ") if from
       sql << " WHERE "    << where.to_sql(options) if where
-      sql << " GROUP BY " << group_by.map { |g| g.to_sql(options) }.join(', ') if group_by
-      sql << " ORDER BY " << order_by.map { |o| o.to_sql(options) }.join(', ') if order_by
+      sql << " GROUP BY " << group_by.map { |g| g.to_sql(options) }.join(", ") if group_by
+      sql << " ORDER BY " << order_by.map { |o| o.to_sql(options) }.join(", ") if order_by
       sql << " HAVING "   << having.to_sql(options) if having
-      sql << " LIMIT "    << Array(limit).map {|f| f.to_sql(options) }.join(', ') if limit
+      sql << " LIMIT "    << Array(limit).map { |f| f.to_sql(options) }.join(", ") if limit
       sql << " OFFSET "   << offset.to_sql(options) if offset
-      return sql
+      sql
     end
 
     def self.parse(tokens)
@@ -116,12 +115,12 @@ module SQLTree::Node
         select_node.having   = self.parse_having_clause(tokens) if SQLTree::Token::HAVING === tokens.peek
       end
       select_node.order_by = self.parse_order_clause(tokens) if SQLTree::Token::ORDER === tokens.peek
-      if SQLTree::Token::LIMIT === tokens.peek and list = self.parse_limit_clause(tokens)
+      if SQLTree::Token::LIMIT === tokens.peek && (list = self.parse_limit_clause(tokens))
         select_node.offset = list.shift if list.size > 1
         select_node.limit  = list.shift
       end
       select_node.offset = self.parse_offset_clause(tokens) if SQLTree::Token::OFFSET === tokens.peek
-      return select_node
+      select_node
     end
 
     def self.parse_limit_clause(tokens)
@@ -137,14 +136,14 @@ module SQLTree::Node
 
   class SubQuery < SelectQuery
     def to_sql(options = {})
-      "("+super(options)+")"
+      "(" + super(options) + ")"
     end
 
     def self.parse(tokens)
       tokens.consume(SQLTree::Token::LPAREN)
       select_node = super(tokens)
       tokens.consume(SQLTree::Token::RPAREN)
-      return select_node
+      select_node
     end
   end
 
@@ -152,14 +151,16 @@ module SQLTree::Node
     leaf :index_hint
 
     def initialize(table, table_alias = nil, index_hint = nil)
-      @table, @table_alias, @index_hint = table, table_alias, index_hint
+      @table = table
+      @table_alias = table_alias
+      @index_hint = index_hint
     end
 
-    def to_sql(options={})
+    def to_sql(options = {})
       sql = (SQLTree::Node::SubQuery === table) ? table.to_sql : quote_field_name(table)
       sql << " AS " << quote_field_name(table_alias) if table_alias
       sql << " " << index_hint.to_sql if index_hint
-      return sql
+      sql
     end
 
     def self.parse(tokens)
@@ -167,7 +168,7 @@ module SQLTree::Node
         tokens.next
         table_reference = self.new(tokens.current.literal)
         if tokens.peek && !tokens.peek.possible_index_hint? &&
-            (SQLTree::Token::AS === tokens.peek || SQLTree::Token::Identifier === tokens.peek)
+           (SQLTree::Token::AS === tokens.peek || SQLTree::Token::Identifier === tokens.peek)
           tokens.consume(SQLTree::Token::AS) if SQLTree::Token::AS === tokens.peek
           table_reference.table_alias = tokens.next.literal
         end
@@ -194,12 +195,14 @@ module SQLTree::Node
     leaf :index_list
 
     def initialize(hint_method, hint_key, index_list)
-      @hint_method, @hint_key, @index_list = hint_method, hint_key, index_list
+      @hint_method = hint_method
+      @hint_key = hint_key
+      @index_list = index_list
     end
 
-    def to_sql(options={})
+    def to_sql(options = {})
       sql = "#{hint_method} #{hint_key} "
-      sql << "(#{index_list.map {|idx| idx.to_sql }.join(' ')})"
+      sql << "(#{index_list.map(&:to_sql).join(' ')})"
       sql
     end
 
@@ -225,20 +228,20 @@ module SQLTree::Node
       end
 
       def self.parse_rhs(tokens, precedence, operator = nil)
-        if ['IN', 'NOT IN'].include?(operator)
+        if ["IN", "NOT IN"].include?(operator)
           if SQLTree::Token::SELECT === tokens.peek(2)
             return SQLTree::Node::SubQuery.parse(tokens)
           else
             return List.parse(tokens)
           end
-        elsif ['IS', 'IS NOT'].include?(operator)
+        elsif ["IS", "IS NOT"].include?(operator)
           tokens.consume(SQLTree::Token::NULL)
           return SQLTree::Node::Expression::Value.new(nil)
-        elsif ['BETWEEN'].include?(operator)
+        elsif ["BETWEEN"].include?(operator)
           expr = parse_atomic(tokens)
           operator = parse_operator(tokens)
           rhs      = parse_rhs(tokens, precedence, operator)
-          expr     = self.new(:operator => operator, :lhs => expr, :rhs => rhs)
+          expr     = self.new(operator: operator, lhs: expr, rhs: rhs)
           return expr
         else
           return parse(tokens, precedence + 1)
@@ -252,7 +255,7 @@ module SQLTree::Node
 
     class Field < Variable
       def to_sql(options = {})
-        @table.nil? ? quote_field_name(@name) : quote_field_name(@table) + '.' + quote_field_name(@name)
+        @table.nil? ? quote_field_name(@name) : quote_field_name(@table) + "." + quote_field_name(@name)
       end
     end
 
@@ -268,11 +271,11 @@ module SQLTree::Node
 
       def to_sql(options = {})
         case value
-        when nil;            'NULL'
-        when String;         "#{escape_string}#{quote_str(@value)}"
-        when Numeric;        @value.to_s
-        when Date;           @value.strftime("'%Y-%m-%d'")
-        when DateTime, Time; @value.strftime("'%Y-%m-%d %H:%M:%S'")
+        when nil then            "NULL"
+        when String then         "#{escape_string}#{quote_str(@value)}"
+        when Numeric then        @value.to_s
+        when Date then           @value.strftime("'%Y-%m-%d'")
+        when DateTime, Time then @value.strftime("'%Y-%m-%d %H:%M:%S'")
         else raise "Don't know how te represent this value in SQL!"
         end
       end
@@ -321,14 +324,13 @@ module SQLTree::Node
   end
 
   class InsertQuery < Base
-
-    def to_sql(options = { })
-      sql = "INSERT INTO #{ table.to_sql(options)} "
-      sql << '(' + fields.map { |f| f.to_sql(options) }.join(', ') + ') ' if fields
-      sql << 'VALUES'
+    def to_sql(options = {})
+      sql = "INSERT INTO #{table.to_sql(options)} "
+      sql << "(" + fields.map { |f| f.to_sql(options) }.join(", ") + ") " if fields
+      sql << "VALUES"
       sql << values.map do |value|
-               ' (' + value.map { |v| v.to_sql(options) }.join(', ') + ')'
-             end.join(',')
+        " (" + value.map { |v| v.to_sql(options) }.join(", ") + ")"
+      end.join(",")
       sql
     end
 
@@ -344,7 +346,7 @@ module SQLTree::Node
         values << parse_list(tokens)
         tokens.consume(SQLTree::Token::RPAREN)
       end
-      return values
+      values
     end
   end
 end

data/lib/active_record/turntable/util.rb

@@ -10,28 +10,8 @@ module ActiveRecord::Turntable
       ar_version < Gem::Version.new(version)
     end
 
-    def ar4?
-      ActiveRecord::VERSION::MAJOR == 4
-    end
-
-    def ar41_or_later?
-      ar_version_equals_or_later?("4.1")
-    end
-
-    def earlier_than_ar41?
-      ar_version_earlier_than?("4.1")
-    end
-
-    def ar42_or_later?
-      ar_version_equals_or_later?("4.2")
-    end
-
-    def earlier_than_ar42?
-      ar_version_earlier_than?("4.2")
-    end
-
     def ar_version
-      ActiveRecord::gem_version
+      ActiveRecord.gem_version
     end
   end
 end

data/lib/active_record/turntable/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Turntable
-    VERSION = "2.5.0"
+    VERSION = "3.0.0.alpha1".freeze
   end
 end

data/lib/active_record/turntable.rb

@@ -3,23 +3,14 @@
 #
 # ActiveRecord Sharding Plugin
 #
-require 'active_record/turntable/version'
-require 'active_record'
-require 'active_record/fixtures'
-require 'active_support/concern'
-require 'active_record/turntable/error'
-require 'active_record/turntable/util'
-require 'logger'
-require 'singleton'
-
-# for 4.0.x series
-module ActiveRecord
-  unless respond_to?(:gem_version)
-    class << self
-      alias_method :gem_version, :version
-    end
-  end
-end
+require "active_record/turntable/version"
+require "active_record"
+require "active_record/fixtures"
+require "active_support/concern"
+require "active_record/turntable/error"
+require "active_record/turntable/util"
+require "logger"
+require "singleton"
 
 module ActiveRecord::Turntable
   extend ActiveSupport::Concern
@@ -37,12 +28,12 @@ module ActiveRecord::Turntable
     autoload :Migration
     autoload :Mixer
     autoload :PoolProxy
+    autoload :QueryCache
     autoload :Shard
     autoload :ShardingCondition
     autoload :SeqShard
     autoload :Sequencer
   end
-  autoload :Rack
   autoload :Helpers
 
   included do
@@ -56,7 +47,7 @@ module ActiveRecord::Turntable
     def turntable_config_file
       @@turntable_config_file ||=
         File.join(defined?(::Rails) ?
-                   ::Rails.root.to_s : DEFAULT_PATH, 'config/turntable.yml')
+                   ::Rails.root.to_s : DEFAULT_PATH, "config/turntable.yml")
     end
 
     def turntable_config_file=(filename)
@@ -66,6 +57,10 @@ module ActiveRecord::Turntable
     def turntable_config
       ActiveRecord::Turntable::Config.instance
     end
+
+    def turntable_connection_classes
+      ActiveRecord::Turntable::Shard.connection_classes
+    end
   end
 
   require "active_record/turntable/railtie" if defined?(Rails)

data/lib/activerecord-turntable.rb

@@ -1,2 +1,2 @@
-require 'active_record'
-require 'active_record/turntable'
+require "active_record"
+require "active_record/turntable"

data/script/performance/algorithm

@@ -1,14 +1,14 @@
 #!/usr/bin/env ruby
-require 'rspec'
-require File.join(File.dirname(__FILE__), '../../../spec/spec_helper')
-require 'benchmark'
+require "rspec"
+require File.join(File.dirname(__FILE__), "../../spec/spec_helper")
+require "benchmark"
 
 def setup_algorithm(n, alg = "Range")
   config = {
     "shards" => n.times.map do |i|
-      {"connection" => "connection_#{i}", "less_than" => (i+1) * 100}
-    end
-  }
+      { connection: "connection_#{i}", less_than: (i + 1) * 100 }
+    end,
+  }.with_indifferent_access
   "ActiveRecord::Turntable::Algorithm::#{alg}Algorithm".constantize.new(config)
 end
 
@@ -18,15 +18,14 @@ Benchmark.bm(40) do |x|
       algorithm = setup_algorithm(n, alg)
       x.report("#{alg}: selrand(#{n}) * 1000") {
         1000.times do
-          algorithm.calculate(rand(n*100))
+          algorithm.calculate(rand(n * 100))
         end
       }
       x.report("#{alg}: sellast(#{n}) * 1000") {
         1000.times do
-          algorithm.calculate(n*100-1)
+          algorithm.calculate(n * 100 - 1)
         end
       }
     end
   end
 end
-

data/spec/active_record/turntable/active_record_ext/association_preloader_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ActiveRecord::Turntable::ActiveRecordExt::Association do
   before(:all) do
@@ -11,7 +11,7 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Association do
   end
 
   let!(:user) do
-    user = User.new({:nickname => 'user1'})
+    user = User.new({ nickname: "user1" })
     user.id = 1
     user.save
     user
@@ -49,7 +49,7 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Association do
       end
 
       it "its has_many targets should be assigned all related object" do
-        expect(subject.cards_users_histories).to include(*cards_users_histories.select { |history| history.cards_user_id == subject.id} )
+        expect(subject.cards_users_histories).to include(*cards_users_histories.select { |history| history.cards_user_id == subject.id })
       end
     end
 
@@ -64,7 +64,7 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Association do
         end
 
         it "its has_many targets should be assigned all related object" do
-          expect(subject.events_users_histories_with_foreign_shard_key).to include(*events_users_histories.select { |history| history.cards_user_id == subject.id} )
+          expect(subject.events_users_histories_with_foreign_shard_key).to include(*events_users_histories.select { |history| history.cards_user_id == subject.id })
         end
       end