activerecord-turntable 2.1.0.beta1 → 2.1.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd8da73b8e0ac2f22797a0eb070c3624038b2ea3
-  data.tar.gz: 57b762fbd0ef0d06c5f7562c4cf68d5cc3c8f8bb
+  metadata.gz: c2673c7fcde5190f1b2da9ac7d398ebf0e3faf1a
+  data.tar.gz: 40fa47723f339d79d3846aaa90aabccdc0232337
 SHA512:
-  metadata.gz: 74cb71bdcd32cca8731ce965b5fd7d0e8b8dd9d7bde6484abb6aa83021d530c3a54ac22d33c73bc2bb8d7c491a0401562b827e78eef3e56eb3bb5e6a56121f8e
-  data.tar.gz: 8ffc60cb0b0dd8e4428f4b3d76690a6135eeb2c60bf5bb0a7ffb0c8655e0be7a835c72bfa8580841c46b0a44bb60d57f88b04d7a48ae7b54ea620cc44f5bc909
+  metadata.gz: b79b1ecdbea938ab801be102982441244841af16ff2c83fd4bc1a003f10ec000adc95480a40ac2e743ddd10a9d8ad9d7a84ae12aecb70abe1d4be68ee3783f6c
+  data.tar.gz: 1b35bfd21a4a4bfa04506375785f3e1496eb03f1ab209776d03295deab494ea9983e6bc523341d83df8577da82272190e11c8de0d8511aa3b998142ae98800bc

data/lib/active_record/turntable.rb

@@ -8,9 +8,19 @@ 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
+
 module ActiveRecord::Turntable
   extend ActiveSupport::Concern
   extend ActiveSupport::Autoload
@@ -57,17 +67,5 @@ module ActiveRecord::Turntable
     end
   end
 
-  def self.rails4?
-    ActiveRecord::VERSION::MAJOR == 4
-  end
-
-  def self.rails41_later?
-    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/lib/active_record/turntable/active_record_ext/abstract_adapter.rb

@@ -17,7 +17,7 @@ module ActiveRecord::Turntable
                                    :turntable_shard_name => turntable_shard_name) { yield }
         rescue Exception => e
           message = "#{e.class.name}: #{e.message}: #{sql} : #{turntable_shard_name}"
-          @logger.debug message if @logger
+          @logger.error message if @logger
           exception = translate_exception(e, message)
           exception.set_backtrace e.backtrace
           raise exception

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

@@ -24,7 +24,7 @@ module ActiveRecord::Turntable
         extend ActiveSupport::Concern
 
         included do
-          if ActiveRecord::Turntable.rails42_later?
+          if Util.ar42_or_later?
             alias_method_chain :get_records, :turntable
           else
             alias_method_chain :find_target, :turntable
@@ -32,7 +32,7 @@ module ActiveRecord::Turntable
         end
 
         # @note Override to add sharding condition for singular association
-        if ActiveRecord::Turntable.rails42_later?
+        if Util.ar42_or_later?
           def get_records_with_turntable
             if reflection.scope_chain.any?(&:any?) ||
                 scope.eager_loading? ||
@@ -54,7 +54,7 @@ module ActiveRecord::Turntable
             binds = ActiveRecord::Associations::AssociationScope.get_bind_values(owner, reflection.chain)
             sc.execute binds, klass, klass.connection
           end
-        elsif ActiveRecord::Turntable.rails41_later?
+        elsif Util.ar41_or_later?
           def find_target_with_turntable
             if record = turntable_scope(scope).take
               set_inverse_instance record
@@ -71,7 +71,7 @@ module ActiveRecord::Turntable
         extend ActiveSupport::Concern
 
         included do
-          if ActiveRecord::Turntable.rails42_later?
+          if Util.ar42_or_later?
             alias_method_chain :get_records, :turntable
           else
             alias_method_chain :find_target, :turntable
@@ -80,7 +80,7 @@ module ActiveRecord::Turntable
 
         private
 
-        if ActiveRecord::Turntable.rails42_later?
+        if Util.ar42_or_later?
           def get_records_with_turntable
             if reflection.scope_chain.any?(&:any?) ||
                 scope.eager_loading? ||

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

@@ -1,48 +1,50 @@
-module ActiveRecord::Turntable::ActiveRecordExt
-  module CleverLoad
-    extend ActiveSupport::Concern
+module ActiveRecord::Turntable
+  module ActiveRecordExt
+    module CleverLoad
+      extend ActiveSupport::Concern
 
-    included do
-      class << ActiveRecord::Base
-        delegate :clever_load!, :to => :all
+      included do
+        class << ActiveRecord::Base
+          delegate :clever_load!, :to => :all
+        end
       end
-    end
 
-    def clever_load!(association_name)
-      # load records
-      records = self.to_a
-      klass = records.first.class
-      association_key = ActiveRecord::Turntable.rails42_later? ? association_name.to_s : association_name
-      reflection = klass.reflections[association_key]
+      def clever_load!(association_name)
+        # load records
+        records = self.to_a
+        klass = records.first.class
+        association_key = Util.ar42_or_later? ? association_name.to_s : association_name
+        reflection = klass.reflections[association_key]
 
-      if reflection
-        foreign_class = reflection.klass
-        foreign_objects = case reflection.macro
-                          when :has_one
-                            foreign_class.where(reflection.foreign_key => records.map(&reflection.association_primary_key.to_sym).uniq)
-                          when :belongs_to
-                            foreign_class.where(reflection.association_primary_key => records.map(&reflection.foreign_key.to_sym).uniq)
-                          else
-                            []
-                          end
+        if reflection
+          foreign_class = reflection.klass
+          foreign_objects = case reflection.macro
+                            when :has_one
+                              foreign_class.where(reflection.foreign_key => records.map(&reflection.association_primary_key.to_sym).uniq)
+                            when :belongs_to
+                              foreign_class.where(reflection.association_primary_key => records.map(&reflection.foreign_key.to_sym).uniq)
+                            else
+                              []
+                            end
 
-        self.each do |obj|
-          matched_object = case reflection.macro
-                           when :has_one
-                             foreign_objects.find {|fo|
-                               obj.send(reflection.association_primary_key) == fo.send(reflection.foreign_key)
-                             }
-                           when :belongs_to
-                             foreign_objects.find {|fo|
-                               obj.send(reflection.foreign_key) == fo.send(reflection.association_primary_key)
-                             }
-                           end
-          obj.association(association_name).target = matched_object
-          obj.association(association_name).set_inverse_instance(matched_object) if matched_object
-          obj.association(association_name).loaded!
+          self.each do |obj|
+            matched_object = case reflection.macro
+                             when :has_one
+                               foreign_objects.find {|fo|
+                                 obj.send(reflection.association_primary_key) == fo.send(reflection.foreign_key)
+                               }
+                             when :belongs_to
+                               foreign_objects.find {|fo|
+                                 obj.send(reflection.foreign_key) == fo.send(reflection.association_primary_key)
+                               }
+                             end
+            obj.association(association_name).target = matched_object
+            obj.association(association_name).set_inverse_instance(matched_object) if matched_object
+            obj.association(association_name).loaded!
+          end
         end
+        records
       end
-      records
     end
   end
 end

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

@@ -4,9 +4,9 @@
 require 'active_record/fixtures'
 module ActiveRecord
   class FixtureSet
-    def self.create_fixtures(fixtures_directory, table_names, class_names = {}, config = ActiveRecord::Base)
+    def self.create_fixtures(fixtures_directory, fixture_set_names, class_names = {}, config = ActiveRecord::Base)
       fixture_set_names = Array(fixture_set_names).map(&:to_s)
-      class_names = class_names.stringify_keys
+      class_names = ClassCache.new class_names, config
 
       # FIXME: Apparently JK uses this.
       connection = block_given? ? yield : ActiveRecord::Base.connection
@@ -20,21 +20,23 @@ module ActiveRecord
           fixtures_map = {}
 
           fixture_sets = files_to_read.map do |fs_name|
+            klass = class_names[fs_name]
+            conn = klass ? klass.connection : connection
             fixtures_map[fs_name] = new( # ActiveRecord::FixtureSet.new
-              connection,
+              conn,
               fs_name,
-              class_names[fs_name] || default_fixture_model_name(fs_name),
+              klass,
               ::File.join(fixtures_directory, fs_name))
           end
 
-          all_loaded_fixtures.update(fixtures_map)
+          update_all_loaded_fixtures fixtures_map
 
           ActiveRecord::Turntable::Base.force_transaction_all_shards!(:requires_new => true) do
             fixture_sets.each do |fs|
               conn = fs.model_class.respond_to?(:connection) ? fs.model_class.connection : connection
               table_rows = fs.table_rows
 
-              table_rows.keys.each do |table|
+              table_rows.each_key do |table|
                 conn.delete "DELETE FROM #{conn.quote_table_name(table)}", 'Fixture Delete'
               end
 
@@ -61,6 +63,8 @@ module ActiveRecord
   end
 
   module TestFixtures
+    extend ActiveRecord::Turntable::Util
+
     def setup_fixtures(config = ActiveRecord::Base)
       return unless !ActiveRecord::Base.configurations.blank?
 
@@ -101,43 +105,22 @@ module ActiveRecord
         ActiveRecord::Base.turntable_connections.values.map(&:connection)
     end
 
-    def teardown_fixtures
-      return if ActiveRecord::Base.configurations.blank?
-
-      # Rollback changes if a transaction is active.
-      if run_in_transaction?
-        @fixture_connections.each do |connection|
-          connection.rollback_transaction if connection.transaction_open?
-        end
-        @fixture_connections.clear
-      else
-        ActiveRecord::FixtureSet.reset_cache
-      end
-
-      ActiveRecord::Base.clear_active_connections!
-    end
-
     private
 
     def turntable_load_fixtures(config)
-      if ActiveRecord::Turntable.rails41_later?
+      if ar41_or_later?
         load_fixtures(config)
-      elsif ActiveRecord::Turntable.rails4?
-        load_fixtures
       else
-        raise NotImplementedError
+        load_fixtures
       end
     end
 
     def turntable_instantiate_fixtures(config)
-      if ActiveRecord::Turntable.rails41_later?
+      if ar41_or_later?
         instantiate_fixtures(config)
-      elsif ActiveRecord::Turntable.rails4?
-        instantiate_fixtures
       else
-        raise NotImplementedError
+        instantiate_fixtures
       end
     end
-
   end
 end

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

@@ -1,158 +1,160 @@
-module ActiveRecord::Turntable::ActiveRecordExt
-  module LockingOptimistic
-    # @note Override to add sharding condition on optimistic locking
-    ::ActiveRecord::Locking::Optimistic.class_eval do
-
-      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
-          def #{method_name}(attribute_names = @attributes.keys) #: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))
+module ActiveRecord::Turntable
+  module ActiveRecordExt
+    module LockingOptimistic
+      # @note Override to add sharding condition on optimistic locking
+      ::ActiveRecord::Locking::Optimistic.class_eval do
+
+        ar_version = ActiveRecord::VERSION::STRING
+        if Util.earlier_than_ar41?
+          method_name = Util.ar_version_earlier_than?("4.0.6") ? "update_record" : "_update_record"
+
+          class_eval <<-EOD
+            def #{method_name}(attribute_names = @attributes.keys) #: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)))
                   )
                 )
-              end
-              stmt = condition_scope.arel.compile_update(arel_attributes_with_values_for_update(attribute_names))
+                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))
 
-              affected_rows = self.class.connection.update stmt
+                affected_rows = self.class.connection.update stmt
 
-              unless affected_rows == 1
-                raise ActiveRecord::StaleObjectError.new(self, "update")
-              end
+                unless affected_rows == 1
+                  raise ActiveRecord::StaleObjectError.new(self, "update")
+                end
 
-              affected_rows
+                affected_rows
 
-            # If something went wrong, revert the version.
-            rescue Exception
-              send(lock_col + '=', previous_lock_value)
-              raise
+              # If something went wrong, revert the version.
+              rescue Exception
+                send(lock_col + '=', previous_lock_value)
+                raise
+              end
             end
-          end
-        EOD
-      elsif ar_version < "4.2"
-        method_name = ar_version =~ /\A4\.1\.[01]\z/ ? "update_record" : "_update_record"
-
-        class_eval <<-EOD
-          def _update_record(attribute_names = @attributes.keys) #: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))
+          EOD
+        elsif Util.earlier_than_ar42?
+          method_name = Util.ar_version_earlier_than?("4.1.2") ? "update_record" : "_update_record"
+
+          class_eval <<-EOD
+            def _update_record(attribute_names = @attributes.keys) #: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)))
                   )
                 )
-              end
-              stmt = condition_scope.arel.compile_update(
-                       arel_attributes_with_values_for_update(attribute_names),
-                       self.class.primary_key
-                     )
+                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
+                affected_rows = self.class.connection.update stmt
 
-              unless affected_rows == 1
-                raise ActiveRecord::StaleObjectError.new(self, "update")
-              end
+                unless affected_rows == 1
+                  raise ActiveRecord::StaleObjectError.new(self, "update")
+                end
 
-              affected_rows
+                affected_rows
 
-            # If something went wrong, revert the version.
-            rescue Exception
-              send(lock_col + '=', previous_lock_value)
-              raise
+              # If something went wrong, revert the version.
+              rescue Exception
+                send(lock_col + '=', previous_lock_value)
+                raise
+              end
             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))
+          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)))
                   )
                 )
-              end
+                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
-              )
+                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
+                affected_rows = self.class.connection.update stmt
 
-              unless affected_rows == 1
-                raise ActiveRecord::StaleObjectError.new(self, "update")
-              end
+                unless affected_rows == 1
+                  raise ActiveRecord::StaleObjectError.new(self, "update")
+                end
 
-              affected_rows
+                affected_rows
 
-            # If something went wrong, revert the version.
-            rescue Exception
-              send(lock_col + '=', previous_lock_value)
-              raise
+              # If something went wrong, revert the version.
+              rescue Exception
+                send(lock_col + '=', previous_lock_value)
+                raise
+              end
             end
-          end
-        EOD
+          EOD
+        end
       end
     end
   end

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

@@ -1,182 +1,218 @@
-module ActiveRecord::Turntable::ActiveRecordExt
-  module Persistence
-    extend ActiveSupport::Concern
-
-    ::ActiveRecord::Persistence.class_eval do
-      # @note Override to add sharding scope on reloading
-      def reload(options = nil)
-        clear_aggregation_cache
-        clear_association_cache
-
-        finder_scope = if turntable_enabled? and self.class.primary_key != self.class.turntable_shard_key.to_s
-                         self.class.unscoped.where(self.class.turntable_shard_key => self.send(turntable_shard_key))
-                       else
-                         self.class.unscoped
-                       end
-
-        fresh_object =
-          if options && options[:lock]
-            finder_scope.lock.find(id)
+module ActiveRecord::Turntable
+  module ActiveRecordExt
+    module Persistence
+      extend ActiveSupport::Concern
+
+      ::ActiveRecord::Persistence.class_eval do
+        # @note Override to add sharding scope on reloading
+        def reload(options = nil)
+          clear_aggregation_cache
+          clear_association_cache
+
+          finder_scope = if turntable_enabled? and self.class.primary_key != self.class.turntable_shard_key.to_s
+                           self.class.unscoped.where(self.class.turntable_shard_key => self.send(turntable_shard_key))
+                         else
+                           self.class.unscoped
+                         end
+
+          fresh_object =
+            if options && options[:lock]
+              finder_scope.lock.find(id)
+            else
+              finder_scope.find(id)
+            end
+
+          if Util.ar42_or_later?
+            @attributes = fresh_object.instance_variable_get('@attributes')
           else
-            finder_scope.find(id)
+            @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
 
-        if ActiveRecord::Turntable.rails42_later?
-          @attributes = fresh_object.instance_variable_get('@attributes')
-        else
-          @attributes.update(fresh_object.instance_variable_get('@attributes'))
+        # @note Override to add sharding scope on `touch`
+        if Util.ar42_or_later?
+          def touch(*names)
+            raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
 
-          @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
+            attributes = timestamp_attributes_for_update_in_model
+            attributes.concat(names)
+
+            unless attributes.empty?
+              current_time = current_time_from_proper_timezone
+              changes = {}
 
-      # @note Override to add sharding scope on `touch`
-      def touch(name = nil)
-        raise ActiveRecordError, "can not touch on a new record object" unless persisted?
+              attributes.each do |column|
+                column = column.to_s
+                changes[column] = write_attribute(column, current_time)
+              end
+
+              changes[self.class.locking_column] = increment_lock if locking_enabled?
 
-        attributes = timestamp_attributes_for_update_in_model
-        attributes << name if name
+              clear_attribute_changes(changes.keys)
+              primary_key = self.class.primary_key
 
-        unless attributes.empty?
-          current_time = current_time_from_proper_timezone
-          changes = {}
+              finder_scope = if turntable_enabled? and primary_key != self.class.turntable_shard_key.to_s
+                               self.class.unscoped.where(self.class.turntable_shard_key => self.send(turntable_shard_key))
+                             else
+                               self.class.unscoped
+                             end
 
-          attributes.each do |column|
-            column = column.to_s
-            changes[column] = write_attribute(column, current_time)
+              finder_scope.where(primary_key => self[primary_key]).update_all(changes) == 1
+            else
+              true
+            end
           end
+        else
+          def touch(name = nil)
+            raise ActiveRecordError, "can not touch on a new record object" unless persisted?
 
-          changes[self.class.locking_column] = increment_lock if locking_enabled?
+            attributes = timestamp_attributes_for_update_in_model
+            attributes << name if name
 
-          @changed_attributes.except!(*changes.keys)
-          primary_key = self.class.primary_key
+            unless attributes.empty?
+              current_time = current_time_from_proper_timezone
+              changes = {}
 
-          finder_scope = if turntable_enabled? and primary_key != self.class.turntable_shard_key.to_s
-                           self.class.unscoped.where(self.class.turntable_shard_key => self.send(turntable_shard_key))
-                         else
-                           self.class.unscoped
-                         end
+              attributes.each do |column|
+                column = column.to_s
+                changes[column] = write_attribute(column, current_time)
+              end
 
-          finder_scope.where(primary_key => self[primary_key]).update_all(changes) == 1
-        else
-          true
-        end
-      end
+              changes[self.class.locking_column] = increment_lock if locking_enabled?
+
+              @changed_attributes.except!(*changes.keys)
+              primary_key = self.class.primary_key
 
-      # @note Override to add sharding scope on `update_columns`
-      def update_columns(attributes)
-        raise ActiveRecordError, "cannot update on a new record object" unless persisted?
+              finder_scope = if turntable_enabled? and primary_key != self.class.turntable_shard_key.to_s
+                               self.class.unscoped.where(self.class.turntable_shard_key => self.send(turntable_shard_key))
+                             else
+                               self.class.unscoped
+                             end
 
-        attributes.each_key do |key|
-          verify_readonly_attribute(key.to_s)
+              finder_scope.where(primary_key => self[primary_key]).update_all(changes) == 1
+            else
+              true
+            end
+          end
         end
 
-        update_scope = if turntable_enabled? and self.class.primary_key != self.class.turntable_shard_key.to_s
-                         self.class.unscoped.where(self.class.turntable_shard_key => self.send(turntable_shard_key))
-                       else
-                         self.class.unscoped
-                       end
+        # @note Override to add sharding scope on `update_columns`
+        def update_columns(attributes)
+          raise ActiveRecordError, "cannot update a new record" if new_record?
+          raise ActiveRecordError, "cannot update a destroyed record" if destroyed?
 
-        updated_count = update_scope.where(self.class.primary_key => id).update_all(attributes)
+          attributes.each_key do |key|
+            verify_readonly_attribute(key.to_s)
+          end
 
-        attributes.each do |k, v|
-          raw_write_attribute(k, v)
-        end
+          update_scope = if turntable_enabled? and self.class.primary_key != self.class.turntable_shard_key.to_s
+                           self.class.unscoped.where(self.class.turntable_shard_key => self.send(turntable_shard_key))
+                         else
+                           self.class.unscoped
+                         end
 
-        updated_count == 1
-      end
+          updated_count = update_scope.where(self.class.primary_key => id).update_all(attributes)
 
-      private
+          attributes.each do |k, v|
+            raw_write_attribute(k, v)
+          end
 
-      ar_version = ActiveRecord::VERSION::STRING
+          updated_count == 1
+        end
+
+        private
 
-      # @note Override to add sharding scope on destroying
-      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
+        # @note Override to add sharding scope on destroying
+        if Util.ar42_or_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]]
+            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)
+            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]]
+              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
-          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))
+        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
-      end
 
-      # @note Override to add sharding scope on updating
-      if ar_version < "4.1"
-        method_name = ar_version =~ /\A4\.0\.[0-5]\z/ ? "update_record" : "_update_record"
-        class_eval <<-EOD
-          def #{method_name}(attribute_names = @attributes.keys)
-            attributes_with_values = arel_attributes_with_values_for_update(attribute_names)
-            if attributes_with_values.empty?
-              0
-            else
-              klass = self.class
-              column_hash = klass.connection.schema_cache.columns_hash klass.table_name
-              db_columns_with_values = attributes_with_values.map { |attr,value|
-                real_column = column_hash[attr.name]
-                [real_column, value]
-              }
-              bind_attrs = attributes_with_values.dup
-              bind_attrs.keys.each_with_index do |column, i|
-                real_column = db_columns_with_values[i].first
-                bind_attrs[column] = klass.connection.substitute_at(real_column, i)
-              end
-              condition_scope = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(id_was || id))
-              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))
+        # @note Override to add sharding scope on updating
+        if Util.earlier_than_ar41?
+          method_name = Util.ar_version_earlier_than?("4.0.6") ? "update_record" : "_update_record"
+          class_eval <<-EOD
+            def #{method_name}(attribute_names = @attributes.keys)
+              attributes_with_values = arel_attributes_with_values_for_update(attribute_names)
+              if attributes_with_values.empty?
+                0
+              else
+                klass = self.class
+                column_hash = klass.connection.schema_cache.columns_hash klass.table_name
+                db_columns_with_values = attributes_with_values.map { |attr,value|
+                  real_column = column_hash[attr.name]
+                  [real_column, value]
+                }
+                bind_attrs = attributes_with_values.dup
+                bind_attrs.keys.each_with_index do |column, i|
+                  real_column = db_columns_with_values[i].first
+                  bind_attrs[column] = klass.connection.substitute_at(real_column, i)
+                end
+                condition_scope = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(id_was || id))
+                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))
+                end
+                stmt = condition_scope.arel.compile_update(bind_attrs)
+                klass.connection.update stmt, 'SQL', db_columns_with_values
               end
-              stmt = condition_scope.arel.compile_update(bind_attrs)
-              klass.connection.update stmt, 'SQL', db_columns_with_values
             end
-          end
-        EOD
-      else
-        method_name = ar_version =~ /\A4\.1\.[01]\z/ ? "update_record" : "_update_record"
-        class_eval <<-EOD
-          def #{method_name}(attribute_names = @attributes.keys)
-            klass = self.class
-            attributes_values = arel_attributes_with_values_for_update(attribute_names)
-            if attributes_values.empty?
-              0
-            else
-              scope = if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
-                klass.unscoped.where(klass.turntable_shard_key => self.send(turntable_shard_key))
+          EOD
+        else
+          method_name = Util.ar_version_earlier_than?("4.1.2") ? "update_record" : "_update_record"
+          attributes_method_name = Util.ar42_or_later? ? "self.attribute_names" : "@attributes.keys"
+          class_eval <<-EOD
+            def #{method_name}(attribute_names = #{attributes_method_name})
+              klass = self.class
+              attributes_values = arel_attributes_with_values_for_update(attribute_names)
+              if attributes_values.empty?
+                0
+              else
+                scope = if klass.turntable_enabled? and klass.primary_key != klass.turntable_shard_key.to_s
+                  klass.unscoped.where(klass.turntable_shard_key => self.send(turntable_shard_key))
+                end
+                klass.unscoped.#{method_name} attributes_values, id, id_was, scope
               end
-              klass.unscoped.#{method_name} attributes_values, id, id_was, scope
             end
-          end
-        EOD
+          EOD
+        end
       end
     end
   end

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

@@ -4,9 +4,8 @@ module ActiveRecord::Turntable
       extend ActiveSupport::Concern
 
       included do
-        version = ActiveRecord::VERSION::STRING
-        if version >= '4.1'
-          if version < '4.1.2'
+        if Util.ar41_or_later?
+          if Util.ar_version_earlier_than?('4.1.2')
             alias_method :_update_record_without_turntable, :update_record
             alias_method :update_record, :_update_record_with_turntable
           else
@@ -16,7 +15,7 @@ module ActiveRecord::Turntable
       end
 
       # @note Override to add sharding scope on updating
-      if ActiveRecord::Turntable.rails42_later?
+      if Util.ar42_or_later?
         def _update_record_with_turntable(values, id, id_was, turntable_scope = nil) # :nodoc:
           substitutes, binds = substitute_values values
 

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

@@ -14,7 +14,11 @@ module ActiveRecord::Turntable
             begin
               status = yield
             rescue ActiveRecord::Rollback
-              @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+              if Util.ar42_or_later?
+                clear_transaction_record_state
+              else
+                @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+              end
               status = nil
             end
 

data/lib/active_record/turntable/util.rb

@@ -0,0 +1,37 @@
+module ActiveRecord::Turntable
+  module Util
+    extend self
+
+    def ar_version_equals_or_later?(version)
+      ar_version >= Gem::Version.new(version)
+    end
+
+    def ar_version_earlier_than?(version)
+      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
+    end
+  end
+end

data/lib/active_record/turntable/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-turntable
 version: !ruby/object:Gem::Version
-  version: 2.1.0.beta1
+  version: 2.1.0.beta2
 platform: ruby
 authors:
 - gussan
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-07 00:00:00.000000000 Z
+date: 2015-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -398,6 +398,7 @@ files:
 - lib/active_record/turntable/sequencer/mysql.rb
 - lib/active_record/turntable/shard.rb
 - lib/active_record/turntable/sql_tree_patch.rb
+- lib/active_record/turntable/util.rb
 - lib/active_record/turntable/version.rb
 - lib/activerecord-turntable.rb
 - lib/generators/active_record/turntable/install_generator.rb
@@ -465,7 +466,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: activerecord-turntable
-rubygems_version: 2.4.4
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: ActiveRecord sharding extension