activerecord-turntable 2.5.0 → 3.0.0.alpha1

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

@@ -1,24 +1,24 @@
-require 'active_record/tasks/database_tasks'
+require "active_record/tasks/database_tasks"
 
 module ActiveRecord
   module Tasks
     module DatabaseTasks
       def create_all_turntable_cluster
-        each_local_turntable_cluster_configuration { |name, configuration|
+        each_local_turntable_cluster_configuration { |_name, configuration|
           puts "[turntable] *** executing to database: #{configuration['database']}"
           create configuration
         }
       end
 
       def drop_all_turntable_cluster
-        each_local_turntable_cluster_configuration { |name, configuration|
+        each_local_turntable_cluster_configuration { |_name, configuration|
           puts "[turntable] *** executing to database: #{configuration['database']}"
           drop configuration
         }
       end
 
       def create_current_turntable_cluster(environment = env)
-        each_current_turntable_cluster_configuration(true, environment) { |name, configuration|
+        each_current_turntable_cluster_configuration(true, environment) { |_name, configuration|
           puts "[turntable] *** executing to database: #{configuration['database']}"
           create configuration
         }
@@ -26,7 +26,7 @@ module ActiveRecord
       end
 
       def drop_current_turntable_cluster(environment = env)
-        each_current_turntable_cluster_configuration(true, environment) { |name, configuration|
+        each_current_turntable_cluster_configuration(true, environment) { |_name, configuration|
           puts "[turntable] *** executing to database: #{configuration['database']}"
           drop configuration
         }
@@ -45,20 +45,20 @@ module ActiveRecord
 
       def each_current_turntable_cluster_configuration(with_test = false, environment = env)
         environments = [environment]
-        environments << 'test' if with_test and environment == 'development'
+        environments << "test" if with_test && environment == "development"
 
         current_turntable_cluster_configurations(*environments).each do |name, configuration|
-          yield(name, configuration) unless configuration['database'].blank?
+          yield(name, configuration) unless configuration["database"].blank?
         end
       end
 
       def each_local_turntable_cluster_configuration
         ActiveRecord::Base.configurations.keys.each do |k|
           current_turntable_cluster_configurations(k).each do |name, configuration|
-            next if configuration['database'].blank?
+            next if configuration["database"].blank?
 
             if local_database?(configuration)
-              yield(name,configuration)
+              yield(name, configuration)
             else
               $stderr.puts "This task only modifies local databases. #{configuration['database']} is on a remote host."
             end

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

@@ -1,7 +1,7 @@
 #
 # force TestFixtures to begin transaction with all shards.
 #
-require 'active_record/fixtures'
+require "active_record/fixtures"
 
 module ActiveRecord
   class FixtureSet
@@ -9,11 +9,7 @@ module ActiveRecord
 
     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 = if ar41_or_later?
-                      ClassCache.new class_names, config
-                    else
-                      class_names = class_names.stringify_keys
-                    end
+      class_names = ClassCache.new class_names, config
 
       # FIXME: Apparently JK uses this.
       connection = block_given? ? yield : ActiveRecord::Base.connection
@@ -27,11 +23,7 @@ module ActiveRecord
           fixtures_map = {}
 
           fixture_sets = files_to_read.map do |fs_name|
-            klass = if ar41_or_later?
-                      class_names[fs_name]
-                    else
-                      class_names[fs_name] || default_fixture_model_name(fs_name)
-                    end
+            klass = class_names[fs_name]
             conn = klass.is_a?(String) ? connection : klass.connection
             fixtures_map[fs_name] = new( # ActiveRecord::FixtureSet.new
               conn,
@@ -40,19 +32,15 @@ module ActiveRecord
               ::File.join(fixtures_directory, fs_name))
           end
 
-          if ar42_or_later?
-            update_all_loaded_fixtures fixtures_map
-          else
-            all_loaded_fixtures.update(fixtures_map)
-          end
+          update_all_loaded_fixtures fixtures_map
 
-          ActiveRecord::Base.force_transaction_all_shards!(:requires_new => true) do
+          ActiveRecord::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.each_key do |table|
-                conn.delete "DELETE FROM #{conn.quote_table_name(table)}", 'Fixture Delete'
+                conn.delete "DELETE FROM #{conn.quote_table_name(table)}", "Fixture Delete"
               end
 
               table_rows.each do |fixture_set_name, rows|
@@ -81,10 +69,10 @@ module ActiveRecord
     include ActiveRecord::Turntable::Util
 
     def setup_fixtures(config = ActiveRecord::Base)
-      return unless !ActiveRecord::Base.configurations.blank?
+      return if ActiveRecord::Base.configurations.blank?
 
       if pre_loaded_fixtures && !use_transactional_fixtures
-        raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_fixtures'
+        raise "pre_loaded_fixtures requires use_transactional_fixtures"
       end
 
       @fixture_cache = {}
@@ -96,7 +84,7 @@ module ActiveRecord
         if @@already_loaded_fixtures[self.class]
           @loaded_fixtures = @@already_loaded_fixtures[self.class]
         else
-          @loaded_fixtures = turntable_load_fixtures(config)
+          @loaded_fixtures = load_fixtures(config)
           @@already_loaded_fixtures[self.class] = @loaded_fixtures
         end
         ActiveRecord::Base.force_connect_all_shards!
@@ -108,34 +96,16 @@ module ActiveRecord
       else
         ActiveRecord::Fixtures.reset_cache
         @@already_loaded_fixtures[self.class] = nil
-        @loaded_fixtures = turntable_load_fixtures(config)
+        @loaded_fixtures = load_fixtures(config)
       end
 
       # Instantiate fixtures for every test if requested.
-      turntable_instantiate_fixtures(config) if use_instantiated_fixtures
+      instantiate_fixtures(config) if use_instantiated_fixtures
     end
 
     def enlist_fixture_connections
       ActiveRecord::Base.connection_handler.connection_pool_list.map(&:connection) +
         ActiveRecord::Base.turntable_connections.values.map(&:connection)
     end
-
-    private
-
-    def turntable_load_fixtures(config)
-      if ar41_or_later?
-        load_fixtures(config)
-      else
-        load_fixtures
-      end
-    end
-
-    def turntable_instantiate_fixtures(config)
-      if ar41_or_later?
-        instantiate_fixtures(config)
-      else
-        instantiate_fixtures
-      end
-    end
   end
 end

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

@@ -1,160 +1,53 @@
 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)))
-                  )
-                )
-                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
-
-                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)
-                raise
-              end
+      ::ActiveRecord::Locking::Optimistic.class_eval <<-EOD
+        private
+        # @note Override to add sharding condition on optimistic locking
+        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(
+              self.class.primary_key => id,
+              lock_col => previous_lock_value,
+            )
+            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(klass.turntable_shard_key)
+              )
             end
-          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
+            affected_rows = condition_scope.update_all(
+              attributes_for_update(attribute_names).map do |name|
+                [name, _read_attribute(name)]
+              end.to_h
+            )
 
-                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)
-                raise
-              end
+            unless affected_rows == 1
+              raise ActiveRecord::StaleObjectError.new(self, "update")
             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
+            affected_rows
 
-                condition_scope = relation.where(
-                  self.class.primary_key => id,
-                  lock_col => previous_lock_value,
-                )
-
-                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
-
-                affected_rows = condition_scope.update_all(
-                  Hash[attributes_for_update(attribute_names).map do |name|
-                    [name, _read_attribute(name)]
-                  end]
-                )
-
-                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)
-                raise
-              end
-            end
-          EOD
+            # If something went wrong, revert the version.
+          rescue Exception
+            send(lock_col + '=', previous_lock_value)
+            raise
+          end
         end
-      end
+      EOD
     end
   end
 end

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

@@ -1,46 +1,15 @@
-require 'active_record/log_subscriber'
+require "active_record/log_subscriber"
 
 module ActiveRecord::Turntable
   module ActiveRecordExt
     module LogSubscriber
-      extend ActiveSupport::Concern
-
-      included do
-        alias_method_chain :sql, :turntable
-      end
-
-      protected
-
-      # @note Override to add shard name logging
-      def sql_with_turntable(event)
-        self.class.runtime += event.duration
-        return unless logger.debug?
-
+      # @note prepend to add shard name logging
+      def sql(event)
         payload = event.payload
-
-        return if ActiveRecord::LogSubscriber::IGNORE_PAYLOAD_NAMES.include?(payload[:name])
-
-        name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
-        shard = '[Shard: %s]' % (event.payload[:turntable_shard_name] ? event.payload[:turntable_shard_name] : nil)
-        sql   = payload[:sql].squeeze(' ')
-        binds = nil
-
-        unless (payload[:binds] || []).empty?
-          binds = "  " + payload[:binds].map { |col,v|
-            render_bind(col, v)
-          }.inspect
+        if payload[:turntable_shard_name]
+          payload[:name] = "#{payload[:name]} [Shard: #{payload[:turntable_shard_name]}]"
         end
-
-        if odd?
-          name = color(name, ActiveRecord::LogSubscriber::CYAN, true)
-          shard = color(shard, ActiveRecord::LogSubscriber::CYAN, true)
-          sql  = color(sql, nil, true)
-        else
-          name = color(name, ActiveRecord::LogSubscriber::MAGENTA, true)
-          shard = color(shard, ActiveRecord::LogSubscriber::MAGENTA, true)
-        end
-
-        debug "  #{name} #{shard} #{sql}#{binds}"
+        super
       end
     end
   end

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

@@ -1,4 +1,4 @@
-require 'active_record/migration'
+require "active_record/migration"
 
 module ActiveRecord
   class MigrationProxy