activerecord 2.3.18 → 3.2.22

data/lib/active_record/locking/optimistic.rb

@@ -3,16 +3,17 @@ module ActiveRecord
     # == What is Optimistic Locking
     #
     # Optimistic locking allows multiple users to access the same record for edits, and assumes a minimum of
-    # conflicts with the data.  It does this by checking whether another process has made changes to a record since
-    # it was opened, an ActiveRecord::StaleObjectError is thrown if that has occurred and the update is ignored.
+    # conflicts with the data. It does this by checking whether another process has made changes to a record since
+    # it was opened, an <tt>ActiveRecord::StaleObjectError</tt> exception is thrown if that has occurred
+    # and the update is ignored.
     #
-    # Check out ActiveRecord::Locking::Pessimistic for an alternative.
+    # Check out <tt>ActiveRecord::Locking::Pessimistic</tt> for an alternative.
     #
     # == Usage
     #
-    # Active Records support optimistic locking if the field <tt>lock_version</tt> is present.  Each update to the
-    # record increments the lock_version column and the locking facilities ensure that records instantiated twice
-    # will let the last one saved raise a StaleObjectError if the first was also updated. Example:
+    # Active Records support optimistic locking if the field +lock_version+ is present. Each update to the
+    # record increments the +lock_version+ column and the locking facilities ensure that records instantiated twice
+    # will let the last one saved raise a +StaleObjectError+ if the first was also updated. Example:
     #
     #   p1 = Person.find(1)
     #   p2 = Person.find(1)
@@ -23,7 +24,7 @@ module ActiveRecord
     #   p2.first_name = "should fail"
     #   p2.save # Raises a ActiveRecord::StaleObjectError
     #
-    # Optimistic locking will also check for stale data when objects are destroyed.  Example:
+    # Optimistic locking will also check for stale data when objects are destroyed. Example:
     #
     #   p1 = Person.find(1)
     #   p2 = Person.find(1)
@@ -36,25 +37,20 @@ module ActiveRecord
     # You're then responsible for dealing with the conflict by rescuing the exception and either rolling back, merging,
     # or otherwise apply the business logic needed to resolve the conflict.
     #
-    # You must ensure that your database schema defaults the lock_version column to 0.
+    # This locking mechanism will function inside a single Ruby process. To make it work across all
+    # web requests, the recommended approach is to add +lock_version+ as a hidden field to your form.
+    #
+    # You must ensure that your database schema defaults the +lock_version+ column to 0.
     #
     # This behavior can be turned off by setting <tt>ActiveRecord::Base.lock_optimistically = false</tt>.
-    # To override the name of the lock_version column, invoke the <tt>set_locking_column</tt> method.
+    # To override the name of the +lock_version+ column, invoke the <tt>set_locking_column</tt> method.
     # This method uses the same syntax as <tt>set_table_name</tt>
     module Optimistic
-      def self.included(base) #:nodoc:
-        base.extend ClassMethods
-
-        base.cattr_accessor :lock_optimistically, :instance_writer => false
-        base.lock_optimistically = true
-
-        base.alias_method_chain :update, :lock
-        base.alias_method_chain :destroy, :lock
-        base.alias_method_chain :attributes_from_column_definition, :lock
+      extend ActiveSupport::Concern
 
-        class << base
-          alias_method :locking_column=, :set_locking_column
-        end
+      included do
+        cattr_accessor :lock_optimistically, :instance_writer => false
+        self.lock_optimistically = true
       end
 
       def locking_enabled? #:nodoc:
@@ -62,69 +58,62 @@ module ActiveRecord
       end
 
       private
-        def attributes_from_column_definition_with_lock
-          result = attributes_from_column_definition_without_lock
-
-          # If the locking column has no default value set,
-          # start the lock version at zero.  Note we can't use
-          # locking_enabled? at this point as @attributes may
-          # not have been initialized yet
-
-          if lock_optimistically && result.include?(self.class.locking_column)
-            result[self.class.locking_column] ||= 0
-          end
-
-          return result
+        def increment_lock
+          lock_col = self.class.locking_column
+          previous_lock_value = send(lock_col).to_i
+          send(lock_col + '=', previous_lock_value + 1)
         end
 
-        def update_with_lock(attribute_names = @attributes.keys) #:nodoc:
-          return update_without_lock(attribute_names) unless locking_enabled?
+        def update(attribute_names = @attributes.keys) #:nodoc:
+          return super unless locking_enabled?
           return 0 if attribute_names.empty?
 
           lock_col = self.class.locking_column
-          previous_value = send(lock_col).to_i
-          send(lock_col + '=', previous_value + 1)
+          previous_lock_value = send(lock_col).to_i
+          increment_lock
 
           attribute_names += [lock_col]
           attribute_names.uniq!
 
           begin
-            affected_rows = connection.update(<<-end_sql, "#{self.class.name} Update with optimistic locking")
-              UPDATE #{self.class.quoted_table_name}
-              SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false, false, attribute_names))}
-              WHERE #{self.class.primary_key} = #{quote_value(id)}
-              AND #{self.class.quoted_locking_column} = #{quote_value(previous_value)}
-            end_sql
+            relation = self.class.unscoped
+
+            stmt = relation.where(
+              relation.table[self.class.primary_key].eq(id).and(
+                relation.table[lock_col].eq(quote_value(previous_lock_value, self.class.columns_hash[lock_col]))
+              )
+            ).arel.compile_update(arel_attributes_values(false, false, attribute_names))
+
+            affected_rows = connection.update stmt
 
             unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError, "Attempted to update a stale object: #{self.class.name}"
+              raise ActiveRecord::StaleObjectError.new(self, "update")
             end
 
             affected_rows
 
           # If something went wrong, revert the version.
           rescue Exception
-            send(lock_col + '=', previous_value)
+            send(lock_col + '=', previous_lock_value)
             raise
           end
         end
 
-        def destroy_with_lock #:nodoc:
-          return destroy_without_lock unless locking_enabled?
+        def destroy #:nodoc:
+          return super unless locking_enabled?
+
+          destroy_associations
 
-          unless new_record?
+          if persisted?
+            table = self.class.arel_table
             lock_col = self.class.locking_column
-            previous_value = send(lock_col).to_i
+            predicate = table[self.class.primary_key].eq(id).
+              and(table[lock_col].eq(send(lock_col).to_i))
 
-            affected_rows = connection.delete(
-              "DELETE FROM #{self.class.quoted_table_name} " +
-              "WHERE #{connection.quote_column_name(self.class.primary_key)} = #{quoted_id} " +
-                    "AND #{self.class.quoted_locking_column} = #{quote_value(previous_value)}",
-              "#{self.class.name} Destroy"
-            )
+            affected_rows = self.class.unscoped.where(predicate).delete_all
 
             unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError, "Attempted to delete a stale object: #{self.class.name}"
+              raise ActiveRecord::StaleObjectError.new(self, "destroy")
             end
           end
 
@@ -135,29 +124,31 @@ module ActiveRecord
       module ClassMethods
         DEFAULT_LOCKING_COLUMN = 'lock_version'
 
-        def self.extended(base)
-          class <<base
-            alias_method_chain :update_counters, :lock
-          end
-        end
-
-        # Is optimistic locking enabled for this table? Returns true if the
-        # +lock_optimistically+ flag is set to true (which it is, by default)
-        # and the table includes the +locking_column+ column (defaults to
-        # +lock_version+).
+        # Returns true if the +lock_optimistically+ flag is set to true
+        # (which it is, by default) and the table includes the
+        # +locking_column+ column (defaults to +lock_version+).
         def locking_enabled?
           lock_optimistically && columns_hash[locking_column]
         end
 
+        def locking_column=(value)
+          @original_locking_column = @locking_column if defined?(@locking_column)
+          @locking_column          = value.to_s
+        end
+
         # Set the column to use for optimistic locking. Defaults to +lock_version+.
         def set_locking_column(value = nil, &block)
-          define_attr_method :locking_column, value, &block
-          value
+          deprecated_property_setter :locking_column, value, block
         end
 
         # The version column used for optimistic locking. Defaults to +lock_version+.
         def locking_column
-          reset_locking_column
+          reset_locking_column unless defined?(@locking_column)
+          @locking_column
+        end
+
+        def original_locking_column #:nodoc:
+          deprecated_original_property_getter :locking_column
         end
 
         # Quote the column name used for optimistic locking.
@@ -167,14 +158,26 @@ module ActiveRecord
 
         # Reset the column used for optimistic locking back to the +lock_version+ default.
         def reset_locking_column
-          set_locking_column DEFAULT_LOCKING_COLUMN
+          self.locking_column = DEFAULT_LOCKING_COLUMN
         end
 
         # Make sure the lock version column gets updated when counters are
         # updated.
-        def update_counters_with_lock(id, counters)
+        def update_counters(id, counters)
           counters = counters.merge(locking_column => 1) if locking_enabled?
-          update_counters_without_lock(id, counters)
+          super
+        end
+
+        # If the locking column has no default value set,
+        # start the lock version at zero. Note we can't use
+        # <tt>locking_enabled?</tt> at this point as
+        # <tt>@attributes</tt> may not have been initialized yet.
+        def initialize_attributes(attributes, options = {}) #:nodoc:
+          if attributes.key?(locking_column) && lock_optimistically
+            attributes[locking_column] ||= 0
+          end
+
+          attributes
         end
       end
     end

data/lib/active_record/locking/pessimistic.rb

@@ -3,30 +3,30 @@ module ActiveRecord
     # Locking::Pessimistic provides support for row-level locking using
     # SELECT ... FOR UPDATE and other lock types.
     #
-    # Pass <tt>:lock => true</tt> to ActiveRecord::Base.find to obtain an exclusive
+    # Pass <tt>:lock => true</tt> to <tt>ActiveRecord::Base.find</tt> to obtain an exclusive
     # lock on the selected rows:
     #   # select * from accounts where id=1 for update
     #   Account.find(1, :lock => true)
     #
     # Pass <tt>:lock => 'some locking clause'</tt> to give a database-specific locking clause
-    # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'.
+    # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'. Example:
     #
-    # Example:
     #   Account.transaction do
     #     # select * from accounts where name = 'shugo' limit 1 for update
-    #     shugo = Account.find(:first, :conditions => "name = 'shugo'", :lock => true)
-    #     yuko = Account.find(:first, :conditions => "name = 'yuko'", :lock => true)
+    #     shugo = Account.where("name = 'shugo'").lock(true).first
+    #     yuko = Account.where("name = 'yuko'").lock(true).first
     #     shugo.balance -= 100
     #     shugo.save!
     #     yuko.balance += 100
     #     yuko.save!
     #   end
     #
-    # You can also use ActiveRecord::Base#lock! method to lock one record by id.
+    # You can also use <tt>ActiveRecord::Base#lock!</tt> method to lock one record by id.
     # This may be better if you don't need to lock every row. Example:
+    #
     #   Account.transaction do
     #     # select * from accounts where ...
-    #     accounts = Account.find(:all, :conditions => ...)
+    #     accounts = Account.where(...).all
     #     account1 = accounts.detect { |account| ... }
     #     account2 = accounts.detect { |account| ... }
     #     # select * from accounts where id=? for update
@@ -38,18 +38,40 @@ module ActiveRecord
     #     account2.save!
     #   end
     #
+    # You can start a transaction and acquire the lock in one go by calling
+    # <tt>with_lock</tt> with a block. The block is called from within
+    # a transaction, the object is already locked. Example:
+    #
+    #   account = Account.first
+    #   account.with_lock do
+    #     # This block is called within a transaction,
+    #     # account is already locked.
+    #     account.balance -= 100
+    #     account.save!
+    #   end
+    #
     # Database-specific information on row locking:
     #   MySQL: http://dev.mysql.com/doc/refman/5.1/en/innodb-locking-reads.html
-    #   PostgreSQL: http://www.postgresql.org/docs/8.1/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
+    #   PostgreSQL: http://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
     module Pessimistic
       # Obtain a row lock on this record. Reloads the record to obtain the requested
       # lock. Pass an SQL locking clause to append the end of the SELECT statement
-      # or pass true for "FOR UPDATE" (the default, an exclusive row lock).  Returns
+      # or pass true for "FOR UPDATE" (the default, an exclusive row lock). Returns
       # the locked record.
       def lock!(lock = true)
-        reload(:lock => lock) unless new_record?
+        reload(:lock => lock) if persisted?
         self
       end
+
+      # Wraps the passed block in a transaction, locking the object
+      # before yielding. You pass can the SQL locking clause
+      # as argument (see <tt>lock!</tt>).
+      def with_lock(lock = true)
+        transaction do
+          lock!(lock)
+          yield
+        end
+      end
     end
   end
 end

data/lib/active_record/log_subscriber.rb

@@ -0,0 +1,72 @@
+module ActiveRecord
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def self.runtime=(value)
+      Thread.current["active_record_sql_runtime"] = value
+    end
+
+    def self.runtime
+      Thread.current["active_record_sql_runtime"] ||= 0
+    end
+
+    def self.reset_runtime
+      rt, self.runtime = runtime, 0
+      rt
+    end
+
+    def initialize
+      super
+      @odd_or_even = false
+    end
+
+    def sql(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      payload = event.payload
+
+      return if 'SCHEMA' == payload[:name]
+
+      name  = '%s (%.1fms)' % [payload[:name], event.duration]
+      sql   = payload[:sql].squeeze(' ')
+      binds = nil
+
+      unless (payload[:binds] || []).empty?
+        binds = "  " + payload[:binds].map { |col,v|
+          if col
+            [col.name, v]
+          else
+            [nil, v]
+          end
+        }.inspect
+      end
+
+      if odd?
+        name = color(name, CYAN, true)
+        sql  = color(sql, nil, true)
+      else
+        name = color(name, MAGENTA, true)
+      end
+
+      debug "  #{name}  #{sql}#{binds}"
+    end
+
+    def identity(event)
+      return unless logger.debug?
+
+      name = color(event.payload[:name], odd? ? CYAN : MAGENTA, true)
+      line = odd? ? color(event.payload[:line], nil, true) : event.payload[:line]
+
+      debug "  #{name}  #{line}"
+    end
+
+    def odd?
+      @odd_or_even = !@odd_or_even
+    end
+
+    def logger
+      ActiveRecord::Base.logger
+    end
+  end
+end
+
+ActiveRecord::LogSubscriber.attach_to :active_record

data/lib/active_record/migration/command_recorder.rb

@@ -0,0 +1,105 @@
+module ActiveRecord
+  class Migration
+    # <tt>ActiveRecord::Migration::CommandRecorder</tt> records commands done during
+    # a migration and knows how to reverse those commands. The CommandRecorder
+    # knows how to invert the following commands:
+    #
+    # * add_column
+    # * add_index
+    # * add_timestamps
+    # * create_table
+    # * remove_timestamps
+    # * rename_column
+    # * rename_index
+    # * rename_table
+    class CommandRecorder
+      attr_accessor :commands, :delegate
+
+      def initialize(delegate = nil)
+        @commands = []
+        @delegate = delegate
+      end
+
+      # record +command+. +command+ should be a method name and arguments.
+      # For example:
+      #
+      #   recorder.record(:method_name, [:arg1, :arg2])
+      def record(*command)
+        @commands << command
+      end
+
+      # Returns a list that represents commands that are the inverse of the
+      # commands stored in +commands+. For example:
+      #
+      #   recorder.record(:rename_table, [:old, :new])
+      #   recorder.inverse # => [:rename_table, [:new, :old]]
+      #
+      # This method will raise an +IrreversibleMigration+ exception if it cannot
+      # invert the +commands+.
+      def inverse
+        @commands.reverse.map { |name, args|
+          method = :"invert_#{name}"
+          raise IrreversibleMigration unless respond_to?(method, true)
+          send(method, args)
+        }
+      end
+
+      def respond_to?(*args) # :nodoc:
+        super || delegate.respond_to?(*args)
+      end
+
+      [:create_table, :change_table, :rename_table, :add_column, :remove_column, :rename_index, :rename_column, :add_index, :remove_index, :add_timestamps, :remove_timestamps, :change_column, :change_column_default].each do |method|
+        class_eval <<-EOV, __FILE__, __LINE__ + 1
+          def #{method}(*args)          # def create_table(*args)
+            record(:"#{method}", args)  #   record(:create_table, args)
+          end                           # end
+        EOV
+      end
+
+      private
+
+      def invert_create_table(args)
+        [:drop_table, [args.first]]
+      end
+
+      def invert_rename_table(args)
+        [:rename_table, args.reverse]
+      end
+
+      def invert_add_column(args)
+        [:remove_column, args.first(2)]
+      end
+
+      def invert_rename_index(args)
+        [:rename_index, [args.first] + args.last(2).reverse]
+      end
+
+      def invert_rename_column(args)
+        [:rename_column, [args.first] + args.last(2).reverse]
+      end
+
+      def invert_add_index(args)
+        table, columns, options = *args
+        index_name = options.try(:[], :name)
+        options_hash =  index_name ? {:name => index_name} : {:column => columns}
+        [:remove_index, [table, options_hash]]
+      end
+
+      def invert_remove_timestamps(args)
+        [:add_timestamps, args]
+      end
+
+      def invert_add_timestamps(args)
+        [:remove_timestamps, args]
+      end
+
+      # Forwards any missing method call to the \target.
+      def method_missing(method, *args, &block)
+        @delegate.send(method, *args, &block)
+      rescue NoMethodError => e
+        raise e, e.message.sub(/ for #<.*$/, " via proxy for #{@delegate}")
+      end
+
+    end
+  end
+end