activerecord-turntable 1.1.2 → 2.0.0.rc1

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

@@ -0,0 +1,81 @@
+require 'active_record/tasks/database_tasks'
+
+module ActiveRecord
+  module Tasks
+    module DatabaseTasks
+      def create_all_turntable_cluster
+        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|
+          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|
+          puts "[turntable] *** executing to database: #{configuration['database']}"
+          create configuration
+        }
+        ActiveRecord::Base.establish_connection environment.to_sym
+      end
+
+      def drop_current_turntable_cluster(environment = env)
+        each_current_turntable_cluster_configuration(true, environment) { |name, configuration|
+          puts "[turntable] *** executing to database: #{configuration['database']}"
+          drop configuration
+        }
+      end
+
+      def each_current_turntable_cluster_connected(with_test = false, environment = env)
+        each_current_turntable_cluster_configuration(with_test, environment) do |name, configuration|
+          ActiveRecord::Base.clear_active_connections!
+          ActiveRecord::Base.establish_connection(configuration)
+          ActiveRecord::Migration.current_shard = name
+          yield(name, configuration)
+        end
+        ActiveRecord::Base.clear_active_connections!
+        ActiveRecord::Base.establish_connection environment.to_sym
+      end
+
+      def each_current_turntable_cluster_configuration(with_test = false, environment = env)
+        environments = [environment]
+        environments << 'test' if with_test and environment == 'development'
+
+        current_turntable_cluster_configurations(*environments).each do |name, configuration|
+          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?
+
+            if local_database?(configuration)
+              yield(name,configuration)
+            else
+              $stderr.puts "This task only modifies local databases. #{configuration['database']} is on a remote host."
+            end
+          end
+        end
+      end
+
+      def current_turntable_cluster_configurations(*environments)
+        configurations = []
+        environments.each do |environ|
+          config = ActiveRecord::Base.configurations[environ]
+          %w(shards seq).each do |name|
+            configurations += config[name].to_a
+          end
+        end
+        configurations
+      end
+    end
+  end
+end

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

@@ -3,56 +3,52 @@
 #
 require 'active_record/fixtures'
 module ActiveRecord
-  class Fixtures
-    def self.create_fixtures(fixtures_directory, table_names, class_names = {})
-      table_names = [table_names].flatten.map { |n| n.to_s }
-      table_names.each { |n|
-        class_names[n.tr('/', '_').to_sym] = n.classify if n.include?('/')
-      }
+  class FixtureSet
+    def self.create_fixtures(fixtures_directory, table_names, class_names = {}, config = ActiveRecord::Base)
+      fixture_set_names = Array(fixture_set_names).map(&:to_s)
+      class_names = class_names.stringify_keys
 
       # FIXME: Apparently JK uses this.
       connection = block_given? ? yield : ActiveRecord::Base.connection
 
-      files_to_read = table_names.reject { |table_name|
-        fixture_is_cached?(connection, table_name)
+      files_to_read = fixture_set_names.reject { |fs_name|
+        fixture_is_cached?(connection, fs_name)
       }
 
       unless files_to_read.empty?
         connection.disable_referential_integrity do
           fixtures_map = {}
 
-          fixture_files = files_to_read.map do |path|
-            table_name = path.tr '/', '_'
-
-            fixtures_map[path] = ActiveRecord::Fixtures.new(
+          fixture_sets = files_to_read.map do |fs_name|
+            fixtures_map[fs_name] = new( # ActiveRecord::FixtureSet.new
               connection,
-              table_name,
-              class_names[table_name.to_sym] || table_name.classify,
-              ::File.join(fixtures_directory, path))
+              fs_name,
+              class_names[fs_name] || default_fixture_model_name(fs_name),
+              ::File.join(fixtures_directory, fs_name))
           end
 
           all_loaded_fixtures.update(fixtures_map)
 
           ActiveRecord::Turntable::Base.force_transaction_all_shards!(:requires_new => true) do
-            fixture_files.each do |ff|
-              conn = ff.model_class.respond_to?(:connection) ? ff.model_class.connection : connection
-              table_rows = ff.table_rows
+            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|
                 conn.delete "DELETE FROM #{conn.quote_table_name(table)}", 'Fixture Delete'
               end
 
-              table_rows.each do |table_name,rows|
+              table_rows.each do |fixture_set_name, rows|
                 rows.each do |row|
-                  conn.insert_fixture(row, table_name)
+                  conn.insert_fixture(row, fixture_set_name)
                 end
               end
             end
 
             # Cap primary key sequences to max(pk).
             if connection.respond_to?(:reset_pk_sequence!)
-              table_names.each do |table_name|
-                connection.reset_pk_sequence!(table_name.tr('/', '_'))
+              fixture_sets.each do |fs|
+                connection.reset_pk_sequence!(fs.table_name)
               end
             end
           end
@@ -60,13 +56,12 @@ module ActiveRecord
           cache_fixtures(connection, fixtures_map)
         end
       end
-      cached_fixtures(connection, table_names)
+      cached_fixtures(connection, fixture_set_names)
     end
-
   end
 
   module TestFixtures
-    def setup_fixtures
+    def setup_fixtures(config = ActiveRecord::Base)
       return unless !ActiveRecord::Base.configurations.blank?
 
       if pre_loaded_fixtures && !use_transactional_fixtures
@@ -82,50 +77,67 @@ module ActiveRecord
         if @@already_loaded_fixtures[self.class]
           @loaded_fixtures = @@already_loaded_fixtures[self.class]
         else
-          @loaded_fixtures = load_fixtures
+          @loaded_fixtures = turntable_load_fixtures(config)
           @@already_loaded_fixtures[self.class] = @loaded_fixtures
         end
         ActiveRecord::Base.force_connect_all_shards!
         @fixture_connections = enlist_fixture_connections
         @fixture_connections.each do |connection|
-          connection.increment_open_transactions
-          connection.transaction_joinable = false
-          connection.begin_db_transaction
+          connection.begin_transaction joinable: false
         end
-        # Load fixtures for every test.
+      # Load fixtures for every test.
       else
         ActiveRecord::Fixtures.reset_cache
         @@already_loaded_fixtures[self.class] = nil
-        @loaded_fixtures = load_fixtures
+        @loaded_fixtures = turntable_load_fixtures(config)
       end
 
       # Instantiate fixtures for every test if requested.
-      instantiate_fixtures if use_instantiated_fixtures
+      turntable_instantiate_fixtures(config) if use_instantiated_fixtures
     end
 
     def enlist_fixture_connections
-      ActiveRecord::Base.connection_handler.connection_pools.values.map(&:connection) +
+      ActiveRecord::Base.connection_handler.connection_pool_list.map(&:connection) +
         ActiveRecord::Base.turntable_connections.values.map(&:connection)
     end
 
     def teardown_fixtures
-      return unless defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
-
-      unless run_in_transaction?
-        ActiveRecord::Fixtures.reset_cache
-      end
+      return if ActiveRecord::Base.configurations.blank?
 
       # Rollback changes if a transaction is active.
       if run_in_transaction?
         @fixture_connections.each do |connection|
-          if connection.open_transactions != 0
-            connection.rollback_db_transaction
-            connection.decrement_open_transactions
-          end
+          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?
+        load_fixtures(config)
+      elsif ActiveRecord::Turntable.rails4?
+        load_fixtures
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def turntable_instantiate_fixtures(config)
+      if ActiveRecord::Turntable.rails41_later?
+        instantiate_fixtures(config)
+      elsif ActiveRecord::Turntable.rails4?
+        instantiate_fixtures
+      else
+        raise NotImplementedError
+      end
+    end
+
   end
 end

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

@@ -0,0 +1,101 @@
+module ActiveRecord::Turntable::ActiveRecordExt
+  module LockingOptimistic
+
+    ::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(klass.turntable_shard_key => self.send(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
+          end
+        EOD
+      else
+        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(klass.turntable_shard_key => self.send(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
+          end
+        EOD
+      end
+    end
+  end
+end

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

@@ -1,64 +1,46 @@
+require 'active_record/log_subscriber'
+
 module ActiveRecord::Turntable
   module ActiveRecordExt
     module LogSubscriber
       extend ActiveSupport::Concern
 
       included do
-        if ActiveRecord::VERSION::STRING < '3.1'
-          def sql(event)
-            self.class.runtime += event.duration
-            return unless logger.debug?
-
-            name = '%s (%.1fms)' % [event.payload[:name], event.duration]
-            shard = '[Shard: %s]' % (event.payload[:turntable_shard_name] ? event.payload[:turntable_shard_name] : nil)
-            sql  = event.payload[:sql].squeeze(' ')
-
-            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}"
-          end
+        alias_method_chain :sql, :turntable
+      end
 
-        else
-          def sql(event)
-            self.class.runtime += event.duration
-            return unless logger.debug?
+      protected
 
-            payload = event.payload
+      def sql_with_turntable(event)
+        self.class.runtime += event.duration
+        return unless logger.debug?
 
-            return if 'SCHEMA' == payload[:name]
+        payload = event.payload
 
-            name    = '%s (%.1fms)' % [payload[:name], event.duration]
-            shard = '[Shard: %s]' % (event.payload[:turntable_shard_name] ? event.payload[:turntable_shard_name] : nil)
-            sql     = payload[:sql].squeeze(' ')
-            binds   = nil
+        return if ActiveRecord::LogSubscriber::IGNORE_PAYLOAD_NAMES.include?(payload[:name])
 
-            unless (payload[:binds] || []).empty?
-              binds = "  " + payload[:binds].map { |col,v|
-                [col.name, v]
-              }.inspect
-            end
+        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
 
-            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
+        unless (payload[:binds] || []).empty?
+          binds = "  " + payload[:binds].map { |col,v|
+            render_bind(col, v)
+          }.inspect
+        end
 
-            debug "  #{name} #{shard} #{sql}#{binds}"
-          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}"
       end
     end
   end
 end
-

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

@@ -0,0 +1,7 @@
+require 'active_record/migration'
+
+module ActiveRecord
+  class MigrationProxy
+    delegate :target_shard?, to: :migration
+  end
+end

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

@@ -5,118 +5,120 @@ module ActiveRecord::Turntable::ActiveRecordExt
         clear_aggregation_cache
         clear_association_cache
 
-        block = lambda {
-          fresh_object = self.class.unscoped {
-            finder_scope = if turntable_enabled? and self.class.primary_key != self.class.turntable_shard_key.to_s
-                             self.class.where(self.class.turntable_shard_key => self.send(turntable_shard_key))
-                           else
-                             self.class
-                           end
-            finder_scope.find(self.id, options)
-          }
-          @attributes.update(fresh_object.instance_variable_get('@attributes'))
-        }
-
-        if defined?(::ActiveRecord::IdentityMap)
-          ::ActiveRecord::IdentityMap.without(&block)
-        else
-          block.call
-        end
+        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
+
+        @attributes.update(fresh_object.instance_variable_get('@attributes'))
 
-        @attributes_cache = {}
+        @column_types           = self.class.column_types
+        @column_types_override  = fresh_object.instance_variable_get('@column_types_override')
+        @attributes_cache       = {}
         self
       end
-    end
 
-    if ActiveRecord::VERSION::STRING < '3.1'
-      ::ActiveRecord::Persistence.class_eval do
-        def destroy
-          klass = self.class
-          if persisted?
-            condition_scope = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(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
-            condition_scope.delete_all
-          end
+      def touch(name = nil)
+        raise ActiveRecordError, "can not touch on a new record object" unless persisted?
 
-          @destroyed = true
-          freeze
-        end
+        attributes = timestamp_attributes_for_update_in_model
+        attributes << name if name
 
-        private
+        unless attributes.empty?
+          current_time = current_time_from_proper_timezone
+          changes = {}
 
-        # overrides ActiveRecord::Persistence's original method so that
-        def update(attribute_names = @attributes.keys)
-          klass = self.class
-          attributes_with_values = arel_attributes_values(false, false, attribute_names)
-          return 0 if attributes_with_values.empty?
-          condition_scope = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(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))
+          attributes.each do |column|
+            column = column.to_s
+            changes[column] = write_attribute(column, current_time)
           end
-          condition_scope.arel.update(attributes_with_values)
+
+          changes[self.class.locking_column] = increment_lock if locking_enabled?
+
+          @changed_attributes.except!(*changes.keys)
+          primary_key = self.class.primary_key
+
+          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
+
+          finder_scope.where(primary_key => self[primary_key]).update_all(changes) == 1
         end
       end
 
-    else
-      ::ActiveRecord::Persistence.class_eval do
-        def destroy
-          klass = self.class
-          destroy_associations
-
-          if persisted?
-            ActiveRecord::IdentityMap.remove(self) if defined?(ActiveRecord::IdentityMap) and ActiveRecord::IdentityMap.enabled?
-            pk         = klass.primary_key
-            column     = klass.columns_hash[pk]
-            substitute = connection.substitute_at(column, 0)
-
-            relation = klass.unscoped.where(klass.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.delete_all
-          end
+      private
 
-          @destroyed = true
-          freeze
-        end
+      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
 
-        def destroy_without_callbacks
-          klass = self.class
-          destroy_associations
+        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
 
-          if persisted?
-            ActiveRecord::IdentityMap.remove(self) if defined?(ActiveRecord::IdentityMap) and ActiveRecord::IdentityMap.enabled?
-            pk         = klass.primary_key
-            column     = klass.columns_hash[pk]
-            substitute = connection.substitute_at(column, 0)
+        relation.bind_values = [[column, id]]
+        relation
+      end
 
-            relation = klass.unscoped.where(klass.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))
+      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)
+            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
-            relation.bind_values = [[column, id]]
-            relation.delete_all
           end
-
-          @destroyed = true
-          freeze
-        end
-
-        private
-        def update(attribute_names = @attributes.keys)
-          attributes_with_values = arel_attributes_values(false, false, attribute_names)
-          return 0 if attributes_with_values.empty?
-          klass = self.class
-          condition_scope = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(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))
+        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))
+              end
+              klass.unscoped.#{method_name} attributes_values, id, id_was, scope
+            end
           end
-          stmt = condition_scope.arel.compile_update(attributes_with_values)
-          klass.connection.update stmt.to_sql
-        end
+        EOD
       end
     end
   end