activerecord-turntable 2.0.6 → 2.1.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d82829564262382156d47ab48a5331ee39507e2b
-  data.tar.gz: 2046ebf2f59a336a20d91df727c98da717a1b4f5
+  metadata.gz: bd8da73b8e0ac2f22797a0eb070c3624038b2ea3
+  data.tar.gz: 57b762fbd0ef0d06c5f7562c4cf68d5cc3c8f8bb
 SHA512:
-  metadata.gz: a29ef422e6cbe7494c67c9480e541469ebbfc2773f48a0ef606c130ca7b6c791a6a8502cb23ce46f8fb739899b4ea4c438a46d348e3ca4d4e42b6cd93e9117ce
-  data.tar.gz: befc1adb93081acf2d9ba91c5cad860039b37530e484198334cec82935dc608719e8845dd83fe326d8da0c9add919222edfb5493033a2f8c69a256e712292a34
+  metadata.gz: 74cb71bdcd32cca8731ce965b5fd7d0e8b8dd9d7bde6484abb6aa83021d530c3a54ac22d33c73bc2bb8d7c491a0401562b827e78eef3e56eb3bb5e6a56121f8e
+  data.tar.gz: 8ffc60cb0b0dd8e4428f4b3d76690a6135eeb2c60bf5bb0a7ffb0c8655e0be7a835c72bfa8580841c46b0a44bb60d57f88b04d7a48ae7b54ea620cc44f5bc909

data/.travis.yml

@@ -2,7 +2,7 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.2
+  - 2.1
   - 2.2
   - ruby-head
 gemfile:
@@ -14,6 +14,4 @@ before_script:
 script: bundle exec rake spec
 matrix:
   allow_failures:
-    - rvm: 2.2
     - rvm: ruby-head
-    - gemfile: gemfiles/rails4_2.gemfile

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## activerecord-turntable 2.1.0 (unreleased) ##
+
+Support activerecord 4.2.0
+
+### Bugfixes
+
+* Fix cluster helper methods(i.e xxxx_cluster_transaction helper) on lazy load environments(development, test)
+
 ## activerecord-turntable 2.0.6 ##
 
 ### Bugfixes

data/Rakefile

@@ -85,6 +85,7 @@ namespace :turntable do
         ActiveRecord::Base.connection.create_table :cards_users do |t|
           t.belongs_to :card,    :null => false
           t.belongs_to :user,    :null => false
+          t.integer    :num,     :default => 1, :null => false
           t.timestamps
         end
         ActiveRecord::Base.connection.create_sequence_for :cards_users

data/activerecord-turntable.gemspec

@@ -43,6 +43,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "faker"
   spec.add_development_dependency "webmock"
   spec.add_development_dependency "pry"
+  if RUBY_VERSION > "2.0"
+    spec.add_development_dependency "pry-byebug"
+  end
   spec.add_development_dependency "guard-rspec"
   spec.add_development_dependency "coveralls"
 

data/gemfiles/rails4_2.gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 
-gem 'activerecord', "= 4.2.0.rc1"
-gem 'activesupport', "= 4.2.0.rc1"
+gem 'activerecord', "~> 4.2.0"
+gem 'activesupport', "~> 4.2.0"
 
 gemspec :path => '../'

data/lib/active_record/turntable/active_record_ext/association.rb

@@ -11,33 +11,58 @@ module ActiveRecord::Turntable
         ActiveRecord::Associations::Builder::Association.valid_options += [:foreign_shard_key]
       end
 
+      private
+
+      def turntable_scope(scope, bind = nil)
+        if should_use_shard_key?
+          scope = scope.where(klass.turntable_shard_key => owner.send(foreign_shard_key))
+        end
+        scope
+      end
+
       module SingularAssociationExt
         extend ActiveSupport::Concern
 
         included do
-          alias_method_chain :find_target, :turntable
+          if ActiveRecord::Turntable.rails42_later?
+            alias_method_chain :get_records, :turntable
+          else
+            alias_method_chain :find_target, :turntable
+          end
         end
 
-        private
-
         # @note Override to add sharding condition for singular association
-        if ActiveRecord::Turntable.rails41_later?
-          def find_target_with_turntable
-            current_scope = scope
-            if should_use_shard_key?
-              current_scope = current_scope.where(klass.turntable_shard_key => owner.send(foreign_shard_key))
+        if ActiveRecord::Turntable.rails42_later?
+          def get_records_with_turntable
+            if reflection.scope_chain.any?(&:any?) ||
+                scope.eager_loading? ||
+                klass.current_scope ||
+                klass.default_scopes.any? ||
+                should_use_shard_key? # OPTIMIZE: Use bind values if cachable scope
+
+              return turntable_scope(scope).limit(1).to_a
             end
-            if record = current_scope.take
+
+            conn = klass.connection
+            sc = reflection.association_scope_cache(conn, owner) do
+              ActiveRecord::StatementCache.create(conn) { |params|
+                as = ActiveRecord::Associations::AssociationScope.create { params.bind }
+                target_scope.merge(as.scope(self, conn)).limit(1)
+              }
+            end
+
+            binds = ActiveRecord::Associations::AssociationScope.get_bind_values(owner, reflection.chain)
+            sc.execute binds, klass, klass.connection
+          end
+        elsif ActiveRecord::Turntable.rails41_later?
+          def find_target_with_turntable
+            if record = turntable_scope(scope).take
               set_inverse_instance record
             end
           end
         else
           def find_target_with_turntable
-            current_scope = scope
-            if should_use_shard_key?
-              current_scope = current_scope.where(klass.turntable_shard_key => owner.send(foreign_shard_key))
-            end
-            current_scope.take.tap { |record| set_inverse_instance(record) }
+            turntable_scope(scope).take.tap { |record| set_inverse_instance(record) }
           end
         end
       end
@@ -46,27 +71,54 @@ module ActiveRecord::Turntable
         extend ActiveSupport::Concern
 
         included do
-          alias_method_chain :find_target, :turntable
+          if ActiveRecord::Turntable.rails42_later?
+            alias_method_chain :get_records, :turntable
+          else
+            alias_method_chain :find_target, :turntable
+          end
         end
 
         private
 
-        # @note Override to add sharding condition for collection association
-        def find_target_with_turntable
-          records =
-            if options[:finder_sql]
-              reflection.klass.find_by_sql(custom_finder_sql)
-            else
-              current_scope = scope
-              if should_use_shard_key?
-                current_scope = current_scope.where(klass.turntable_shard_key => owner.send(foreign_shard_key))
-              end
-              current_scope.to_a
+        if ActiveRecord::Turntable.rails42_later?
+          def get_records_with_turntable
+            if reflection.scope_chain.any?(&:any?) ||
+                scope.eager_loading? ||
+                klass.current_scope ||
+                klass.default_scopes.any? ||
+                should_use_shard_key? # OPTIMIZE: Use bind values if cachable scope
+
+              return turntable_scope(scope).to_a
+            end
+
+            conn = klass.connection
+            sc = reflection.association_scope_cache(conn, owner) do
+              ActiveRecord::StatementCache.create(conn) { |params|
+                as = ActiveRecord::Associations::AssociationScope.create { params.bind }
+                target_scope.merge as.scope(self, conn)
+              }
             end
-          records.each { |record| set_inverse_instance(record) }
-          records
-        end
 
+            binds = ActiveRecord::Associations::AssociationScope.get_bind_values(owner, reflection.chain)
+            sc.execute binds, klass, klass.connection
+          end
+        else
+          # @note Override to add sharding condition for collection association
+          def find_target_with_turntable
+            records =
+              if options[:finder_sql]
+                reflection.klass.find_by_sql(custom_finder_sql)
+              else
+                current_scope = scope
+                if should_use_shard_key?
+                  current_scope = current_scope.where(klass.turntable_shard_key => owner.send(foreign_shard_key))
+                end
+                current_scope.to_a
+              end
+            records.each { |record| set_inverse_instance(record) }
+            records
+          end
+        end
       end
 
       private

data/lib/active_record/turntable/active_record_ext/clever_load.rb

@@ -12,7 +12,8 @@ module ActiveRecord::Turntable::ActiveRecordExt
       # load records
       records = self.to_a
       klass = records.first.class
-      reflection = klass.reflections[association_name]
+      association_key = ActiveRecord::Turntable.rails42_later? ? association_name.to_s : association_name
+      reflection = klass.reflections[association_key]
 
       if reflection
         foreign_class = reflection.klass

data/lib/active_record/turntable/active_record_ext/locking_optimistic.rb

@@ -29,7 +29,11 @@ module ActiveRecord::Turntable::ActiveRecordExt
                 )
               )
               if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
-                condition_scope = condition_scope.where(klass.turntable_shard_key => self.send(turntable_shard_key))
+                condition_scope = condition_scope.where(
+                  relation.table[klass.turntable_shard_key].eq(
+                     self.class.quote_value(self.send(turntable_shard_key), column_for_attribute(klass.turntable_shard_key))
+                  )
+                )
               end
               stmt = condition_scope.arel.compile_update(arel_attributes_with_values_for_update(attribute_names))
 
@@ -48,7 +52,7 @@ module ActiveRecord::Turntable::ActiveRecordExt
             end
           end
         EOD
-      else
+      elsif ar_version < "4.2"
         method_name = ar_version =~ /\A4\.1\.[01]\z/ ? "update_record" : "_update_record"
 
         class_eval <<-EOD
@@ -73,7 +77,11 @@ module ActiveRecord::Turntable::ActiveRecordExt
                 )
               )
               if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
-                condition_scope = condition_scope.where(klass.turntable_shard_key => self.send(turntable_shard_key))
+                condition_scope = condition_scope.where(
+                  relation.table[klass.turntable_shard_key].eq(
+                     self.class.quote_value(self.send(turntable_shard_key), column_for_attribute(klass.turntable_shard_key))
+                  )
+                )
               end
               stmt = condition_scope.arel.compile_update(
                        arel_attributes_with_values_for_update(attribute_names),
@@ -88,6 +96,56 @@ module ActiveRecord::Turntable::ActiveRecordExt
 
               affected_rows
 
+            # If something went wrong, revert the version.
+            rescue Exception
+              send(lock_col + '=', previous_lock_value)
+              raise
+            end
+          end
+        EOD
+      else
+        class_eval <<-EOD
+          def _update_record(attribute_names = self.attribute_names) #:nodoc:
+            return super unless locking_enabled?
+            return 0 if attribute_names.empty?
+
+            klass = self.class
+            lock_col = self.class.locking_column
+            previous_lock_value = send(lock_col).to_i
+            increment_lock
+
+            attribute_names += [lock_col]
+            attribute_names.uniq!
+
+            begin
+              relation = self.class.unscoped
+
+              condition_scope = relation.where(
+                relation.table[self.class.primary_key].eq(id).and(
+                  relation.table[lock_col].eq(self.class.quote_value(previous_lock_value, column_for_attribute(lock_col)))
+                )
+              )
+              if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
+                condition_scope = condition_scope.where(
+                  relation.table[klass.turntable_shard_key].eq(
+                     self.class.quote_value(self.send(turntable_shard_key), column_for_attribute(klass.turntable_shard_key))
+                  )
+                )
+              end
+
+              stmt = condition_scope.arel.compile_update(
+                arel_attributes_with_values_for_update(attribute_names),
+                self.class.primary_key
+              )
+
+              affected_rows = self.class.connection.update stmt
+
+              unless affected_rows == 1
+                raise ActiveRecord::StaleObjectError.new(self, "update")
+              end
+
+              affected_rows
+
             # If something went wrong, revert the version.
             rescue Exception
               send(lock_col + '=', previous_lock_value)

data/lib/active_record/turntable/active_record_ext/persistence.rb

@@ -21,11 +21,16 @@ module ActiveRecord::Turntable::ActiveRecordExt
             finder_scope.find(id)
           end
 
-        @attributes.update(fresh_object.instance_variable_get('@attributes'))
-
-        @column_types           = self.class.column_types
-        @column_types_override  = fresh_object.instance_variable_get('@column_types_override')
-        @attributes_cache       = {}
+        if ActiveRecord::Turntable.rails42_later?
+          @attributes = fresh_object.instance_variable_get('@attributes')
+        else
+          @attributes.update(fresh_object.instance_variable_get('@attributes'))
+
+          @column_types           = self.class.column_types
+          @column_types_override  = fresh_object.instance_variable_get('@column_types_override')
+          @attributes_cache       = {}
+        end
+        @new_record = false
         self
       end
 
@@ -57,6 +62,8 @@ module ActiveRecord::Turntable::ActiveRecordExt
                          end
 
           finder_scope.where(primary_key => self[primary_key]).update_all(changes) == 1
+        else
+          true
         end
       end
 
@@ -85,26 +92,47 @@ module ActiveRecord::Turntable::ActiveRecordExt
 
       private
 
+      ar_version = ActiveRecord::VERSION::STRING
+
       # @note Override to add sharding scope on destroying
-      def relation_for_destroy
-        pk         = self.class.primary_key
-        column     = self.class.columns_hash[pk]
-        substitute = self.class.connection.substitute_at(column, 0)
-        klass      = self.class
-
-        relation = self.class.unscoped.where(
-          self.class.arel_table[pk].eq(substitute))
-        if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
-          relation = relation.where(klass.turntable_shard_key => self.send(turntable_shard_key))
+      if ActiveRecord::Turntable.rails42_later?
+        def relation_for_destroy
+          pk         = self.class.primary_key
+          column     = self.class.columns_hash[pk]
+          substitute = self.class.connection.substitute_at(column, 0)
+          klass      = self.class
+
+          relation = self.class.unscoped.where(
+                       self.class.arel_table[pk].eq(substitute))
+          relation.bind_values = [[column, id]]
+
+          if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
+            shard_key_column = klass.columns_hash[klass.turntable_shard_key]
+            shard_key_substitute = klass.connection.substitute_at(shard_key_column)
+
+            relation = relation.where(self.class.arel_table[klass.turntable_shard_key].eq(shard_key_substitute))
+            relation.bind_values << [shard_key_column, self[klass.turntable_shard_key]]
+          end
+          relation
+        end
+      else
+        def relation_for_destroy
+          pk         = self.class.primary_key
+          column     = self.class.columns_hash[pk]
+          substitute = self.class.connection.substitute_at(column, 0)
+          klass      = self.class
+
+          relation = self.class.unscoped.where(
+                       self.class.arel_table[pk].eq(substitute))
+          if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
+            relation = relation.where(klass.turntable_shard_key => self.send(turntable_shard_key))
+          end
+          relation.bind_values = [[column, id]]
+          relation
         end
-
-        relation.bind_values = [[column, id]]
-        relation
       end
 
-
       # @note Override to add sharding scope on updating
-      ar_version = ActiveRecord::VERSION::STRING
       if ar_version < "4.1"
         method_name = ar_version =~ /\A4\.0\.[0-5]\z/ ? "update_record" : "_update_record"
         class_eval <<-EOD

data/lib/active_record/turntable/active_record_ext/relation.rb

@@ -16,16 +16,42 @@ module ActiveRecord::Turntable
       end
 
       # @note Override to add sharding scope on updating
-      def _update_record_with_turntable(values, id, id_was, turntable_scope = nil) # :nodoc:
-        substitutes, binds = substitute_values values
-        condition_scope = @klass.unscoped.where(@klass.arel_table[@klass.primary_key].eq(id_was || id))
-        condition_scope = condition_scope.merge(turntable_scope) if turntable_scope
-        um = condition_scope.arel.compile_update(substitutes, @klass.primary_key)
-
-        @klass.connection.update(
-          um,
-          'SQL',
-          binds)
+      if ActiveRecord::Turntable.rails42_later?
+        def _update_record_with_turntable(values, id, id_was, turntable_scope = nil) # :nodoc:
+          substitutes, binds = substitute_values values
+
+          scope = @klass.unscoped
+
+          if @klass.finder_needs_type_condition?
+            scope.unscope!(where: @klass.inheritance_column)
+          end
+
+          relation = scope.where(@klass.primary_key => (id_was || id))
+          relation = relation.merge(turntable_scope) if turntable_scope
+
+          bvs = binds + relation.bind_values
+          um = relation
+            .arel
+            .compile_update(substitutes, @klass.primary_key)
+
+          @klass.connection.update(
+            um,
+            'SQL',
+            bvs,
+          )
+        end
+      else
+        def _update_record_with_turntable(values, id, id_was, turntable_scope = nil) # :nodoc:
+          substitutes, binds = substitute_values values
+          condition_scope = @klass.unscoped.where(@klass.arel_table[@klass.primary_key].eq(id_was || id))
+          condition_scope = condition_scope.merge(turntable_scope) if turntable_scope
+          um = condition_scope.arel.compile_update(substitutes, @klass.primary_key)
+
+          @klass.connection.update(
+            um,
+            'SQL',
+            binds)
+        end
       end
     end
   end

data/lib/active_record/turntable/base.rb

@@ -1,3 +1,5 @@
+require 'active_support/lazy_load_hooks'
+
 module ActiveRecord::Turntable
   module Base
     extend ActiveSupport::Concern
@@ -7,12 +9,17 @@ module ActiveRecord::Turntable
                         :turntable_enabled, :turntable_sequencer_enabled
 
       self.turntable_connections = {}
-      self.turntable_clusters = Hash.new {|h,k| h[k]={}}
+      self.turntable_clusters = {}.with_indifferent_access
       self.turntable_enabled = false
       self.turntable_sequencer_enabled = false
       class << self
         delegate :shards_transaction, :with_all, :to => :connection
       end
+
+      ActiveSupport.on_load(:turntable_config_loaded) do
+        self.initialize_clusters!
+      end
+      include ClusterHelperMethods
     end
 
     module ClassMethods
@@ -26,55 +33,29 @@ module ActiveRecord::Turntable
         self.turntable_enabled = true
         self.turntable_cluster_name = cluster_name
         self.turntable_shard_key = shard_key_name
-        self.turntable_cluster = Cluster.new(
-                                   self,
-                                   turntable_config[:clusters][cluster_name],
-                                   options
-                                 )
-        self.turntable_clusters[cluster_name][self] = turntable_cluster
-
+        self.turntable_cluster =
+          self.turntable_clusters[cluster_name] ||= Cluster.new(
+                                                      turntable_config[:clusters][cluster_name],
+                                                      options
+                                                    )
         turntable_replace_connection_pool
-        turntable_define_cluster_methods(cluster_name)
-      end
-
-      #
-      def force_transaction_all_shards!(options={}, &block)
-        force_connect_all_shards!
-        shards = turntable_connections.values
-        shards += [ActiveRecord::Base.connection_pool]
-        recursive_transaction(shards, options, &block)
       end
 
-      def recursive_transaction(pools, options, &block)
-        pool = pools.shift
-        if pools.present?
-          pool.connection.transaction(options) do
-            recursive_transaction(pools, options, &block)
-          end
-        else
-          pool.connection.transaction(options, &block)
-        end
-      end
-
-      def force_connect_all_shards!
-        conf = configurations[Rails.env]
-        shards = {}
-        shards = shards.merge(conf["shards"]) if conf["shards"]
-        shards = shards.merge(conf["seq"]) if conf["seq"]
-        shards.each do |name, config|
-          turntable_connections[name] ||=
-            ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec_for(config))
-        end
-      end
 
       def turntable_replace_connection_pool
         ch = connection_handler
-        cp = turntable_cluster.connection_proxy
+        cp = ConnectionProxy.new(self, turntable_cluster)
         pp = PoolProxy.new(cp)
         ch.class_to_pool.clear if defined?(ch.class_to_pool)
         ch.send(:class_to_pool)[name] = ch.send(:owner_to_pool)[name] = pp
       end
 
+      def initialize_clusters!
+        turntable_config[:clusters].each do |name, spec|
+          self.turntable_clusters[name] ||= Cluster.new(spec, {})
+        end
+      end
+
       def spec_for(config)
         begin
           require "active_record/connection_adapters/#{config['adapter']}_adapter"
@@ -114,16 +95,6 @@ module ActiveRecord::Turntable
         turntable_cluster.select_shard(current_sequence) if sequencer_enabled?
       end
 
-      def weighted_random_shard_with(*klasses, &block)
-        shards_weight = self.turntable_cluster.weighted_shards
-        sum = shards_weight.values.inject(&:+)
-        idx = rand(sum)
-        shard, weight = shards_weight.find {|k,v|
-          (idx -= v) < 0
-        }
-        self.connection.with_recursive_shards(shard.name, *klasses, &block)
-      end
-
       def with_shard(any_shard)
         shard = case any_shard
                 when Numeric
@@ -135,41 +106,6 @@ module ActiveRecord::Turntable
                 end
         connection.with_shard(shard) { yield }
       end
-
-      private
-
-      def turntable_define_cluster_methods(cluster_name)
-        turntable_define_cluster_class_methods(cluster_name)
-      end
-
-      def turntable_define_cluster_class_methods(cluster_name)
-        (class << ActiveRecord::Base; self; end).class_eval <<-EOD
-          unless respond_to?(:#{cluster_name}_transaction)
-            def #{cluster_name}_transaction(shards = [], options = {})
-              cluster = turntable_clusters[#{cluster_name.inspect}].values.first
-              cluster.shards_transaction(shards, options) { yield }
-            end
-          end
-
-          unless respond_to?(:all_cluster_transaction)
-            def all_cluster_transaction(options = {})
-              clusters = turntable_clusters.values.map { |v| v.values.first }
-              recursive_cluster_transaction(clusters) { yield }
-            end
-
-            def recursive_cluster_transaction(clusters, options = {}, &block)
-              current_cluster = clusters.shift
-              current_cluster.shards_transaction do
-                if clusters.present?
-                  recursive_cluster_transaction(clusters, options, &block)
-                else
-                  yield
-                end
-              end
-            end
-          end
-        EOD
-      end
     end
 
     def shards_transaction(options = {}, &block)

data/lib/active_record/turntable/cluster.rb

@@ -8,15 +8,11 @@ module ActiveRecord::Turntable
       "algorithm" => "range",
     }.with_indifferent_access
 
-    def initialize(klass, cluster_spec, options = {})
-      @klass = klass
+    def initialize(cluster_spec, options = {})
       @config = DEFAULT_CONFIG.merge(cluster_spec)
       @options = options.with_indifferent_access
       @shards = {}.with_indifferent_access
 
-      # setup master shard
-      @master_shard = MasterShard.new(klass)
-
       # setup sequencer
       if (seq = (@options[:seq] || @config[:seq])) && seq[:type] == :mysql
         @seq_shard = SeqShard.new(seq)
@@ -30,36 +26,21 @@ module ActiveRecord::Turntable
       # setup algorithm
       alg_name = "ActiveRecord::Turntable::Algorithm::#{@config["algorithm"].camelize}Algorithm"
       @algorithm = alg_name.constantize.new(@config)
-
-      # setup proxy
-      @connection_proxy = ConnectionProxy.new(self, cluster_spec)
-    end
-
-    def klass
-      @klass
-    end
-
-    def master
-      @master_shard
     end
 
     def seq
-      @seq_shard || @master_shard
+      @seq_shard
     end
 
     def shards
       @shards
     end
 
-    def connection_proxy
-      @connection_proxy
-    end
-
     def shard_for(key)
       @shards[@algorithm.calculate(key)]
     rescue
       raise ActiveRecord::Turntable::CannotSpecifyShardError,
-      "[#{klass}] cannot select_shard for key:#{key}"
+        "cannot select_shard for key:#{key}"
     end
 
     def select_shard(key)
@@ -74,8 +55,7 @@ module ActiveRecord::Turntable
           shards = @shards.values.dup
         end
       end
-      shard_or_object = shards.shift
-      shard = to_shard(shard_or_object)
+      shard = to_shard(shards.shift)
       if shards.present?
         shard.connection.transaction(options) do
           shards_transaction(shards, options, true, &block)
@@ -98,14 +78,12 @@ module ActiveRecord::Turntable
       when Symbol
         shards[shard_or_object]
       else
-        binding.pry
         raise ActiveRecord::Turntable::TurntableError,
                 "transaction cannot call to object: #{shard_or_object}"
       end
     end
 
     def weighted_shards(key = nil)
-      key ||= @klass.current_sequence
       Hash[@algorithm.calculate_used_shards_with_weight(key).map do |k,v|
         [@shards[k], v]
       end]

data/lib/active_record/turntable/cluster_helper_methods.rb

@@ -0,0 +1,85 @@
+module ActiveRecord::Turntable
+  module ClusterHelperMethods
+    extend ActiveSupport::Concern
+
+    included do
+      ActiveSupport.on_load(:turntable_config_loaded) do
+        turntable_clusters.each do |name, cluster|
+          turntable_define_cluster_methods(name)
+        end
+      end
+    end
+
+    module ClassMethods
+      def force_transaction_all_shards!(options={}, &block)
+        force_connect_all_shards!
+        shards = turntable_connections.values
+        shards += [ActiveRecord::Base.connection_pool]
+        recursive_transaction(shards, options, &block)
+      end
+
+      def recursive_transaction(pools, options, &block)
+        pool = pools.shift
+        if pools.present?
+          pool.connection.transaction(options) do
+            recursive_transaction(pools, options, &block)
+          end
+        else
+          pool.connection.transaction(options, &block)
+        end
+      end
+
+      def force_connect_all_shards!
+        conf = configurations[Rails.env]
+        shards = {}
+        shards = shards.merge(conf["shards"]) if conf["shards"]
+        shards = shards.merge(conf["seq"]) if conf["seq"]
+        shards.each do |name, config|
+          turntable_connections[name] ||=
+            ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec_for(config))
+        end
+      end
+
+      def weighted_random_shard_with(*klasses, &block)
+        shards_weight = self.turntable_cluster.weighted_shards(self.current_sequence)
+        sum = shards_weight.values.inject(&:+)
+        idx = rand(sum)
+        shard, weight = shards_weight.find {|k,v|
+          (idx -= v) < 0
+        }
+        self.connection.with_recursive_shards(shard.name, *klasses, &block)
+      end
+
+      def all_cluster_transaction(options = {})
+        clusters = turntable_clusters.values
+        recursive_cluster_transaction(clusters) { yield }
+      end
+
+      def recursive_cluster_transaction(clusters, options = {}, &block)
+        current_cluster = clusters.shift
+        current_cluster.shards_transaction do
+          if clusters.present?
+            recursive_cluster_transaction(clusters, options, &block)
+          else
+            yield
+          end
+        end
+      end
+
+      def turntable_define_cluster_methods(cluster_name)
+        turntable_define_cluster_class_methods(cluster_name)
+      end
+
+      def turntable_define_cluster_class_methods(cluster_name)
+        (class << ActiveRecord::Base; self; end).class_eval <<-EOD
+          unless respond_to?(:#{cluster_name}_transaction)
+            def #{cluster_name}_transaction(shards = [], options = {})
+              cluster = turntable_clusters[#{cluster_name.inspect}]
+              cluster.shards_transaction(shards, options) { yield }
+            end
+          end
+        EOD
+      end
+    end
+  end
+end

data/lib/active_record/turntable/config.rb

@@ -1,3 +1,4 @@
+require 'active_support/lazy_load_hooks'
 require 'active_support/core_ext/hash/indifferent_access'
 
 module ActiveRecord::Turntable
@@ -13,12 +14,13 @@ module ActiveRecord::Turntable
       @config[key]
     end
 
-    def self.load!(config_file, env = (defined?(Rails) ? Rails.env : 'development'))
+    def self.load!(config_file = ActiveRecord::Base.turntable_config_file, env = (defined?(Rails) ? Rails.env : 'development'))
       instance.load!(config_file, env)
     end
 
     def load!(config_file, env)
       @config = YAML.load(ERB.new(IO.read(config_file)).result).with_indifferent_access[env]
+      ActiveSupport.run_load_hooks(:turntable_config_loaded, ActiveRecord::Base)
     end
   end
 end

data/lib/active_record/turntable/connection_proxy.rb

@@ -6,12 +6,14 @@ module ActiveRecord::Turntable
     # for expiring query cache
     CLEAR_CACHE_METHODS = [:update, :insert, :delete, :exec_insert, :exec_update, :exec_delete, :insert_many]
 
+    attr_reader :klass
     attr_writer :spec
 
-    def initialize(cluster, options = {})
-      @cluster      =  cluster
-      @model_class  =  cluster.klass
-      @default_current_shard =  (cluster.master || cluster.shards.first[1])
+    def initialize(klass, cluster, options = {})
+      @klass   = klass
+      @cluster = cluster
+      @master_shard = MasterShard.new(klass)
+      @default_current_shard = @master_shard
       @mixer = ActiveRecord::Turntable::Mixer.new(self)
     end
 
@@ -36,7 +38,7 @@ module ActiveRecord::Turntable
     end
 
     def enable_query_cache!
-      @model_class.turntable_connections.each do |k,v|
+      klass.turntable_connections.each do |k,v|
         v.connection.enable_query_cache!
       end
     end
@@ -46,7 +48,7 @@ module ActiveRecord::Turntable
     end
 
     def clear_query_cache
-      @model_class.turntable_connections.each do |k,v|
+      klass.turntable_connections.each do |k,v|
         v.connection.clear_query_cache
       end
     end
@@ -91,7 +93,7 @@ module ActiveRecord::Turntable
     end
 
     def master
-      @cluster.master
+      @master_shard
     end
 
     def master_connection
@@ -99,7 +101,7 @@ module ActiveRecord::Turntable
     end
 
     def seq
-      @cluster.seq
+      @cluster.seq || master
     end
 
     def current_shard
@@ -107,7 +109,7 @@ module ActiveRecord::Turntable
     end
 
     def current_shard=(shard)
-      logger.debug { "Changing #{@model_class}'s shard to #{shard.name}"}
+      logger.debug { "Changing #{klass}'s shard to #{shard.name}"}
       current_shard_entry[object_id] = shard
     end
 
@@ -170,7 +172,7 @@ module ActiveRecord::Turntable
     # Send queries to master connection and all shards in this cluster
     # @param [Boolean] continue_on_error when a shard raises error, ignore exception and continue
     def with_master_and_all(continue_on_error = false)
-      ([@cluster.master] + @cluster.shards.values).map do |shard|
+      ([master] + @cluster.shards.values).map do |shard|
         begin
           with_shard(shard) {
             yield
@@ -185,7 +187,7 @@ module ActiveRecord::Turntable
     end
 
     def with_master(&block)
-      with_shard(@cluster.master) do
+      with_shard(master) do
         yield
       end
     end

data/lib/active_record/turntable/mixer.rb

@@ -126,12 +126,12 @@ module ActiveRecord::Turntable
     def build_select_fader(tree, method, query, *args, &block)
       shard_keys = if !tree.where and tree.from.size == 1 and SQLTree::Node::SubQuery === tree.from.first.table_reference.table
                      find_shard_keys(tree.from.first.table_reference.table.where,
-                                     @proxy.cluster.klass.table_name,
-                                     @proxy.cluster.klass.turntable_shard_key.to_s)
+                                     @proxy.klass.table_name,
+                                     @proxy.klass.turntable_shard_key.to_s)
                    else
                      find_shard_keys(tree.where,
-                                     @proxy.cluster.klass.table_name,
-                                     @proxy.cluster.klass.turntable_shard_key.to_s)
+                                     @proxy.klass.table_name,
+                                     @proxy.klass.turntable_shard_key.to_s)
                    end
 
       if shard_keys.size == 1 # shard
@@ -186,7 +186,7 @@ module ActiveRecord::Turntable
     end
 
     def build_update_fader(tree, method, query, *args, &block)
-      shard_keys = find_shard_keys(tree.where, @proxy.cluster.klass.table_name, @proxy.cluster.klass.turntable_shard_key.to_s)
+      shard_keys = find_shard_keys(tree.where, @proxy.klass.table_name, @proxy.klass.turntable_shard_key.to_s)
       shards_with_query = if shard_keys.present?
                             build_shards_with_same_query(shard_keys.map {|k| @proxy.cluster.shard_for(k) }, query)
                           else
@@ -208,7 +208,7 @@ module ActiveRecord::Turntable
     end
 
     def build_insert_fader(tree, method, query, *args, &block)
-      values_hash = divide_insert_values(tree, @proxy.cluster.klass.turntable_shard_key)
+      values_hash = divide_insert_values(tree, @proxy.klass.turntable_shard_key)
       shards_with_query = {}
       values_hash.each do |k,vs|
         tree.values = [[SQLTree::Node::Expression::Variable.new("\\0")]]

data/lib/active_record/turntable/railtie.rb

@@ -12,6 +12,13 @@ module ActiveRecord::Turntable
       end
     end
 
+    # initialize
+    initializer "turntable.initialize_clusters" do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Turntable::Config.load!
+      end
+    end
+
     # QueryCache Middleware for turntable shards
     initializer "turntable.insert_query_cache_middleware" do |app|
       app.middleware.insert_after ActiveRecord::QueryCache, ActiveRecord::Turntable::Rack::QueryCache

data/lib/active_record/turntable/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Turntable
-    VERSION = "2.0.6"
+    VERSION = "2.1.0.beta1"
   end
 end

data/lib/active_record/turntable.rb

@@ -20,6 +20,7 @@ module ActiveRecord::Turntable
     autoload :Algorithm
     autoload :Base
     autoload :Cluster
+    autoload :ClusterHelperMethods
     autoload :Config
     autoload :ConnectionProxy
     autoload :MasterShard
@@ -64,5 +65,9 @@ module ActiveRecord::Turntable
     rails4? && ActiveRecord::VERSION::MINOR >= 1
   end
 
+  def self.rails42_later?
+    rails4? && ActiveRecord::VERSION::MINOR >= 2
+  end
+
   require "active_record/turntable/railtie" if defined?(Rails)
 end

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

@@ -49,14 +49,14 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Association do
     let(:cards_user) { CardsUser.where(user: user).first }
 
     context "associated objects has same turntable_key" do
-      subject { cards_user.cards_users_histories }
+      subject { cards_user.cards_users_histories.to_a }
       it { expect { subject }.to_not raise_error }
       it { is_expected.to include(*cards_users_histories.select { |history| history.cards_user_id == cards_user.id }) }
     end
 
     context "associated objects has different turntable_key" do
       context "when foreign_shard_key option passed" do
-        subject { cards_user.events_users_histories_with_foreign_shard_key }
+        subject { cards_user.events_users_histories_with_foreign_shard_key.to_a }
 
         it { expect { subject }.to_not raise_error }
         it { is_expected.to include(*events_users_histories.select { |history| history.cards_user_id == cards_user.id }) }

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

@@ -34,7 +34,9 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Persistence do
   let(:card){
     Card.create!(:name => 'foobar')
   }
-
+  let(:cards_user){
+    user.cards_users.create(card: card)
+  }
   context "When creating record" do
     context "with blob column" do
       let(:blob_value) { "\123\123\123" }
@@ -108,31 +110,31 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Persistence do
 
   context "When the model is sharded by other key" do
     it "should send shard_key condition when updating" do
-      user_status.hp = 20
+      cards_user.num = 10
 
       strio = StringIO.new
       ActiveRecord::Base.logger = Logger.new(strio)
       expect {
-        user_status.save!
+        cards_user.save!
       }.to_not raise_error
-      expect(strio.string).to match(/`user_statuses`\.`user_id` = #{user_status.user_id}[^\s]*($|\s)/)
+      expect(strio.string).to match(/`cards_users`\.`user_id` = #{cards_user.user_id}[^\s]*($|\s)/)
     end
 
     it "should change updated_at when updating" do
-      user_status.hp = 20
+      cards_user.num = 2
 
       expect {
-        user_status.save!
-      }.to change(user_status, :updated_at)
+        cards_user.save!
+      }.to change(cards_user, :updated_at)
     end
 
     it "should send shard_key condition when destroying" do
       strio = StringIO.new
       ActiveRecord::Base.logger = Logger.new(strio)
       expect {
-        user_status.destroy
+        cards_user.destroy
       }.to_not raise_error
-      expect(strio.string).to match(/`user_statuses`\.`user_id` = #{user_status.user_id}[^\s]*($|\s)/)
+      expect(strio.string).to match(/`cards_users`\.`user_id` = #{cards_user.user_id}[^\s]*($|\s)/)
     end
 
     it "should warn when creating without shard_key" do
@@ -140,39 +142,39 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Persistence do
     end
 
     it "should execute one query when reloading" do
-      user; user_status
+      user; cards_user
       strio = StringIO.new
       ActiveRecord::Base.logger = Logger.new(strio)
 
-      expect { user_status.reload }.to_not raise_error
+      expect { cards_user.reload }.to_not raise_error
 
       expect(strio.string.split("\n").select {|stmt| stmt =~ /SELECT/ and stmt !~ /Turntable/ }).to have(1).items
     end
 
     it "should execute one query when touching" do
-      user; user_status
+      user; cards_user
       strio = StringIO.new
       ActiveRecord::Base.logger = Logger.new(strio)
 
-      expect { user_status.touch }.to_not raise_error
+      expect { cards_user.touch }.to_not raise_error
       expect(strio.string.split("\n").select {|stmt| stmt =~ /UPDATE/ and stmt !~ /Turntable/ }).to have(1).items
     end
 
     it "should execute one query when locking" do
-      user; user_status
+      user; cards_user
       strio = StringIO.new
       ActiveRecord::Base.logger = Logger.new(strio)
 
-      expect { user_status.lock! }.to_not raise_error
+      expect { cards_user.lock! }.to_not raise_error
       expect(strio.string.split("\n").select {|stmt| stmt =~ /SELECT/ and stmt !~ /Turntable/ }).to have(1).items
     end
 
     it "should execute one query when update_columns" do
-      user; user_status
+      user; cards_user
       strio = StringIO.new
       ActiveRecord::Base.logger = Logger.new(strio)
 
-      expect { user_status.update_columns(hp: 10) }.to_not raise_error
+      expect { cards_user.update_columns(num: 10) }.to_not raise_error
       expect(strio.string.split("\n").select {|stmt| stmt =~ /UPDATE/ and stmt !~ /Turntable/ }).to have(1).items
     end
   end
@@ -199,9 +201,9 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Persistence do
   end
 
   context "When call reload" do
-    subject { user_status.reload }
-    it { is_expected.to be_instance_of(UserStatus)}
-    it { is_expected.to eq(user_status) }
+    subject { cards_user.reload }
+    it { is_expected.to be_instance_of(CardsUser) }
+    it { is_expected.to eq(cards_user) }
   end
 
 end

data/spec/active_record/turntable/cluster_spec.rb

@@ -10,14 +10,13 @@ describe ActiveRecord::Turntable::Cluster do
     truncate_shard
   end
   let(:cluster_config) { ActiveRecord::Base.turntable_config[:clusters][:user_cluster] }
-  let(:cluster) { ActiveRecord::Turntable::Cluster.new(User, cluster_config) }
+  let(:cluster) { ActiveRecord::Turntable::Cluster.new(cluster_config) }
   let(:in_range_shard_key_value) { cluster_config[:shards].last[:less_than] - 1 }
   let(:out_of_range_shard_key_value) { cluster_config[:shards].last[:less_than] }
 
   context "When initialized" do
     subject { cluster }
 
-    its(:klass) { should == User }
     its(:shards) { should have(3).items }
   end
 

data/spec/active_record/turntable/connection_proxy_spec.rb

@@ -11,8 +11,8 @@ describe ActiveRecord::Turntable::ConnectionProxy do
       truncate_shard
     end
 
-    let(:cluster) { ActiveRecord::Turntable::Cluster.new(User, ActiveRecord::Base.turntable_config[:clusters][:user_cluster]) }
-    subject { ActiveRecord::Turntable::ConnectionProxy.new(cluster) }
+    let(:cluster) { ActiveRecord::Turntable::Cluster.new(ActiveRecord::Base.turntable_config[:clusters][:user_cluster]) }
+    subject { ActiveRecord::Turntable::ConnectionProxy.new(User, cluster) }
 
     its(:master_connection) { is_expected.to eql(ActiveRecord::Base.connection) }
   end

data/spec/active_record/turntable/mixer_spec.rb

@@ -8,8 +8,8 @@ describe ActiveRecord::Turntable::Mixer do
   before do
     establish_connection_to(:test)
     truncate_shard
-    @cluster = ActiveRecord::Turntable::Cluster.new(User, ActiveRecord::Base.turntable_config[:clusters][:user_cluster])
-    @connection_proxy = ActiveRecord::Turntable::ConnectionProxy.new(@cluster)
+    @cluster = ActiveRecord::Turntable::Cluster.new(ActiveRecord::Base.turntable_config[:clusters][:user_cluster])
+    @connection_proxy = ActiveRecord::Turntable::ConnectionProxy.new(User, @cluster)
   end
 
   context "When initialized" do

data/spec/active_record/turntable/transaction_spec.rb

@@ -12,7 +12,7 @@ describe "transaction" do
   let(:clusters) { ActiveRecord::Base.turntable_clusters }
 
   describe "all_cluster_transaction" do
-    let(:all_clusters) { clusters.values.map { |v| v.values.first } }
+    let(:all_clusters) { clusters.values }
     let(:shards) { all_clusters.map { |c| c.shards.values }.flatten(1) }
 
     it "all shards should begin transaction" do
@@ -23,7 +23,7 @@ describe "transaction" do
   end
 
   describe "cluster_transaction" do
-    let(:cluster) { clusters[:user_cluster].values.first }
+    let(:cluster) { clusters[:user_cluster] }
     let(:shards) { cluster.shards.values }
 
     it "all shards in the cluster should begin transaction" do

data/spec/spec_helper.rb

@@ -5,6 +5,11 @@ require 'bundler/setup'
 require 'rspec/its'
 require 'rspec/collection_matchers'
 require 'webmock/rspec'
+require 'pry'
+begin
+  require 'pry-byebug'
+rescue LoadError
+end
 
 require 'activerecord-turntable'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-turntable
 version: !ruby/object:Gem::Version
-  version: 2.0.6
+  version: 2.1.0.beta1
 platform: ruby
 authors:
 - gussan
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-08 00:00:00.000000000 Z
+date: 2015-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -261,6 +261,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -354,6 +368,7 @@ files:
 - lib/active_record/turntable/algorithm/range_bsearch_algorithm.rb
 - lib/active_record/turntable/base.rb
 - lib/active_record/turntable/cluster.rb
+- lib/active_record/turntable/cluster_helper_methods.rb
 - lib/active_record/turntable/config.rb
 - lib/active_record/turntable/connection_proxy.rb
 - lib/active_record/turntable/connection_proxy/mixable.rb
@@ -445,9 +460,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: activerecord-turntable
 rubygems_version: 2.4.4