diff options
author | Jeremy Kemper <jeremy@bitsweat.net> | 2006-06-20 01:58:36 +0000 |
---|---|---|
committer | Jeremy Kemper <jeremy@bitsweat.net> | 2006-06-20 01:58:36 +0000 |
commit | 722e0b6a8bb62226437e466b5a98356d026b05f5 (patch) | |
tree | 63aebf36e9d2dcc63f35210b764b1af061178073 /activerecord/lib/active_record/locking | |
parent | e4254939aa8abb7a18f65e95cafaa2f37cbfa754 (diff) | |
download | rails-722e0b6a8bb62226437e466b5a98356d026b05f5.tar.gz rails-722e0b6a8bb62226437e466b5a98356d026b05f5.tar.bz2 rails-722e0b6a8bb62226437e466b5a98356d026b05f5.zip |
r4664@asus: jeremy | 2006-06-19 18:55:36 -0700
Use the #lock method to obtain a row lock on a single record. Simply reloads the record with :lock => true.
git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@4462 5ecf4fe2-1ee6-0310-87b1-e25e094e27de
Diffstat (limited to 'activerecord/lib/active_record/locking')
-rw-r--r-- | activerecord/lib/active_record/locking/optimistic.rb | 89 | ||||
-rw-r--r-- | activerecord/lib/active_record/locking/pessimistic.rb | 77 |
2 files changed, 166 insertions, 0 deletions
diff --git a/activerecord/lib/active_record/locking/optimistic.rb b/activerecord/lib/active_record/locking/optimistic.rb new file mode 100644 index 0000000000..7bae573924 --- /dev/null +++ b/activerecord/lib/active_record/locking/optimistic.rb @@ -0,0 +1,89 @@ +module ActiveRecord + module Locking + # 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: + # + # 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 <tt>ActiveRecord::Base.lock_optimistically = false</tt>. + # 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: + 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 + + 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) + + 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 #{self.class.quoted_locking_column} = #{quote(previous_value)} + end_sql + + unless affected_rows == 1 + raise ActiveRecord::StaleObjectError, "Attempted to update a stale object" + end + + return true + end + + module ClassMethods + DEFAULT_LOCKING_COLUMN = 'lock_version' + + # 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 + + # The version column used for optimistic locking. Defaults to lock_version. + def locking_column + reset_locking_column + end + + # Quote the column name used for optimistic locking. + def quoted_locking_column + connection.quote_column_name(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 diff --git a/activerecord/lib/active_record/locking/pessimistic.rb b/activerecord/lib/active_record/locking/pessimistic.rb new file mode 100644 index 0000000000..caad760742 --- /dev/null +++ b/activerecord/lib/active_record/locking/pessimistic.rb @@ -0,0 +1,77 @@ +# Copyright (c) 2006 Shugo Maeda <shugo@ruby-lang.org> +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject +# to the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR +# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +module ActiveRecord + module Locking + # Locking::Pessimistic provides support for row-level locking using + # SELECT ... FOR UPDATE and other lock types. + # + # Pass :lock => true to ActiveRecord::Base.find to obtain an exclusive + # lock on the selected rows: + # # select * from accounts where id=1 for update + # Account.find(1, :lock => true) + # + # Pass :lock => 'some locking clause' to give a database-specific locking clause + # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'. + # + # 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.balance -= 100 + # shugo.save! + # yuko.balance += 100 + # yuko.save! + # end + # + # You can also use ActiveRecord::Base#lock! 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 => ...) + # account1 = accounts.detect { |account| ... } + # account2 = accounts.detect { |account| ... } + # # select * from accounts where id=? for update + # account1.lock! + # account2.lock! + # account1.balance -= 100 + # account1.save! + # account2.balance += 100 + # account2.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 + 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 + # the locked record. + def lock!(lock = true) + reload(:lock => lock) unless new_record? + self + end + end + end +end |