X-Git-Url: https://git.njae.me.uk/?a=blobdiff_plain;f=vendor%2Frails%2Factiverecord%2Flib%2Factive_record%2Flocking%2Foptimistic.rb;fp=vendor%2Frails%2Factiverecord%2Flib%2Factive_record%2Flocking%2Foptimistic.rb;h=ff9899d03261246d88b772952cabda0ec7672d4a;hb=d115f2e23823271635bad69229a42cd8ac68debe;hp=0000000000000000000000000000000000000000;hpb=37cb670bf3ddde90b214e591f100ed4446469484;p=depot.git
diff --git a/vendor/rails/activerecord/lib/active_record/locking/optimistic.rb b/vendor/rails/activerecord/lib/active_record/locking/optimistic.rb
new file mode 100644
index 0000000..ff9899d
--- /dev/null
+++ b/vendor/rails/activerecord/lib/active_record/locking/optimistic.rb
@@ -0,0 +1,148 @@
+module ActiveRecord
+ module Locking
+ # == 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.
+ #
+ # Check out ActiveRecord::Locking::Pessimistic for an alternative.
+ #
+ # == Usage
+ #
+ # 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:
+ 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 :attributes_from_column_definition, :lock
+
+ class << base
+ alias_method :locking_column=, :set_locking_column
+ end
+ end
+
+ def locking_enabled? #:nodoc:
+ self.class.locking_enabled?
+ 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
+ end
+
+ def update_with_lock(attribute_names = @attributes.keys) #:nodoc:
+ return update_without_lock(attribute_names) 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)
+
+ 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
+
+ unless affected_rows == 1
+ raise ActiveRecord::StaleObjectError, "Attempted to update a stale object"
+ end
+
+ affected_rows
+
+ # If something went wrong, revert the version.
+ rescue Exception
+ send(lock_col + '=', previous_value)
+ raise
+ end
+ end
+
+ module ClassMethods
+ DEFAULT_LOCKING_COLUMN = 'lock_version'
+
+ def self.extended(base)
+ class < 1) if locking_enabled?
+ update_counters_without_lock(id, counters)
+ end
+ end
+ end
+ end
+end