From e4254939aa8abb7a18f65e95cafaa2f37cbfa754 Mon Sep 17 00:00:00 2001 From: Jeremy Kemper Date: Tue, 20 Jun 2006 01:58:27 +0000 Subject: [PATCH] r4663@asus: jeremy | 2006-06-19 17:23:57 -0700 ActiveRecord::Locking is now ActiveRecord::Locking::Optimistic (to make way for Pessimistic.) git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@4461 5ecf4fe2-1ee6-0310-87b1-e25e094e27de --- activerecord/lib/active_record.rb | 2 +- activerecord/lib/active_record/locking.rb | 131 ++++++++++++---------- 2 files changed, 70 insertions(+), 63 deletions(-) diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb index fc70b0de687af..ddd1f9ff4cba4 100755 --- a/activerecord/lib/active_record.rb +++ b/activerecord/lib/active_record.rb @@ -54,7 +54,7 @@ ActiveRecord::Base.class_eval do include ActiveRecord::Validations - include ActiveRecord::Locking + include ActiveRecord::Locking::Optimistic include ActiveRecord::Callbacks include ActiveRecord::Observing include ActiveRecord::Timestamp diff --git a/activerecord/lib/active_record/locking.rb b/activerecord/lib/active_record/locking.rb index ee4224c004844..9e7564ed25d76 100644 --- a/activerecord/lib/active_record/locking.rb +++ b/activerecord/lib/active_record/locking.rb @@ -1,77 +1,84 @@ module ActiveRecord - # 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) - # - # p1.first_name = "Michael" - # p1.save - # - # p2.first_name = "should fail" - # p2.save # Raises a ActiveRecord::StaleObjectError - # - # 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 behavior can be turned off by setting ActiveRecord::Base.lock_optimistically = false. - # To override the name of the lock_version column, invoke the set_locking_column method. - # This method uses the same syntax as set_table_name module Locking - def self.included(base) #:nodoc: - base.class_eval do - alias_method_chain :update, :lock + # 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) + # + # p1.first_name = "Michael" + # p1.save + # + # p2.first_name = "should fail" + # p2.save # Raises a ActiveRecord::StaleObjectError + # + # 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 behavior can be turned off by setting ActiveRecord::Base.lock_optimistically = false. + # To override the name of the lock_version column, invoke the set_locking_column method. + # This method uses the same syntax as set_table_name + module Optimistic + def self.included(base) #:nodoc: + super + base.extend ClassMethods + + base.cattr_accessor :lock_optimistically + base.lock_optimistically = true + + base.alias_method_chain :update, :lock + class << base + alias_method :locking_column=, :set_locking_column + end end - end - def update_with_lock #:nodoc: - return update_without_lock unless locking_enabled? + def locking_enabled? #:nodoc: + lock_optimistically && respond_to?(self.class.locking_column) + end + + def update_with_lock #:nodoc: + return update_without_lock unless locking_enabled? + + lock_col = self.class.locking_column + previous_value = send(lock_col) + send(lock_col + '=', previous_value + 1) - lock_col = self.class.locking_column - previous_value = send(lock_col) - send(lock_col + '=', previous_value + 1) + affected_rows = connection.update(<<-end_sql, "#{self.class.name} Update with optimistic locking") + UPDATE #{self.class.table_name} + SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} + WHERE #{self.class.primary_key} = #{quote(id)} + AND #{lock_col} = #{quote(previous_value)} + end_sql - affected_rows = connection.update(<<-end_sql, "#{self.class.name} Update with optimistic locking") - UPDATE #{self.class.table_name} - SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} - WHERE #{self.class.primary_key} = #{quote(id)} - AND #{lock_col} = #{quote(previous_value)} - end_sql + unless affected_rows == 1 + raise ActiveRecord::StaleObjectError, "Attempted to update a stale object" + end - unless affected_rows == 1 - raise ActiveRecord::StaleObjectError, "Attempted to update a stale object" + return true end - return true - end - end + module ClassMethods + DEFAULT_LOCKING_COLUMN = 'lock_version' - class Base - @@lock_optimistically = true - cattr_accessor :lock_optimistically + # 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 + end - def locking_enabled? #:nodoc: - lock_optimistically && respond_to?(self.class.locking_column) - end - - class << self - def set_locking_column(value = nil, &block) - define_attr_method :locking_column, value, &block - end - - def locking_column #:nodoc: - reset_locking_column - end - - def reset_locking_column #:nodoc: - default = 'lock_version' - set_locking_column(default) - default + # The version column used for optimistic locking. Defaults to lock_version. + def locking_column + reset_locking_column + end + + # Reset the column used for optimistic locking back to the lock_version default. + def reset_locking_column + set_locking_column DEFAULT_LOCKING_COLUMN + end end end - end end