activerecord 2.3.18 → 3.2.22

data/lib/active_record/transactions.rb

@@ -3,19 +3,17 @@ require 'thread'
 module ActiveRecord
   # See ActiveRecord::Transactions::ClassMethods for documentation.
   module Transactions
+    extend ActiveSupport::Concern
+
     class TransactionError < ActiveRecordError # :nodoc:
     end
 
-    def self.included(base)
-      base.extend(ClassMethods)
-
-      base.class_eval do
-        [:destroy, :save, :save!].each do |method|
-          alias_method_chain method, :transactions
-        end
-      end
+    included do
+      define_callbacks :commit, :rollback, :terminator => "result == false", :scope => [:kind, :name]
     end
 
+    # = Active Record Transactions
+    #
     # Transactions are protective blocks where SQL statements are only permanent
     # if they can all succeed as one atomic action. The classic example is a
     # transfer between two accounts where you can only have a deposit if the
@@ -23,17 +21,18 @@ module ActiveRecord
     # the database and guard the data against program errors or database
     # break-downs. So basically you should use transaction blocks whenever you
     # have a number of statements that must be executed together or not at all.
-    # Example:
+    #
+    # For example:
     #
     #   ActiveRecord::Base.transaction do
     #     david.withdrawal(100)
     #     mary.deposit(100)
     #   end
     #
-    # This example will only take money from David and give to Mary if neither
-    # +withdrawal+ nor +deposit+ raises an exception. Exceptions will force a
-    # ROLLBACK that returns the database to the state before the transaction was
-    # begun. Be aware, though, that the objects will _not_ have their instance
+    # This example will only take money from David and give it to Mary if neither
+    # +withdrawal+ nor +deposit+ raise an exception. Exceptions will force a
+    # ROLLBACK that returns the database to the state before the transaction
+    # began. Be aware, though, that the objects will _not_ have their instance
     # data returned to their pre-transactional state.
     #
     # == Different Active Record classes in a single transaction
@@ -43,16 +42,16 @@ module ActiveRecord
     # that class. This is because transactions are per-database connection, not
     # per-model.
     #
-    # In this example a <tt>Balance</tt> record is transactionally saved even
-    # though <tt>transaction</tt> is called on the <tt>Account</tt> class:
+    # In this example a +balance+ record is transactionally saved even
+    # though +transaction+ is called on the +Account+ class:
     #
     #   Account.transaction do
     #     balance.save!
     #     account.save!
     #   end
     #
-    # Note that the +transaction+ method is also available as a model instance
-    # method. For example, you can also do this:
+    # The +transaction+ method is also available as a model instance method.
+    # For example, you can also do this:
     #
     #   balance.transaction do
     #     balance.save!
@@ -61,9 +60,9 @@ module ActiveRecord
     #
     # == Transactions are not distributed across database connections
     #
-    # A transaction acts on a single database connection.  If you have
+    # A transaction acts on a single database connection. If you have
     # multiple class-specific databases, the transaction will not protect
-    # interaction among them.  One workaround is to begin a transaction
+    # interaction among them. One workaround is to begin a transaction
     # on each class whose models you alter:
     #
     #   Student.transaction do
@@ -73,16 +72,22 @@ module ActiveRecord
     #     end
     #   end
     #
-    # This is a poor solution, but full distributed transactions are beyond
+    # This is a poor solution, but fully distributed transactions are beyond
     # the scope of Active Record.
     #
-    # == Save and destroy are automatically wrapped in a transaction
+    # == +save+ and +destroy+ are automatically wrapped in a transaction
     #
-    # Both Base#save and Base#destroy come wrapped in a transaction that ensures
-    # that whatever you do in validations or callbacks will happen under the
-    # protected cover of a transaction. So you can use validations to check for
-    # values that the transaction depends on or you can raise exceptions in the
-    # callbacks to rollback, including <tt>after_*</tt> callbacks.
+    # Both +save+ and +destroy+ come wrapped in a transaction that ensures
+    # that whatever you do in validations or callbacks will happen under its
+    # protected cover. So you can use validations to check for values that
+    # the transaction depends on or you can raise exceptions in the callbacks
+    # to rollback, including <tt>after_*</tt> callbacks.
+    #
+    # As a consequence changes to the database are not seen outside your connection
+    # until the operation is complete. For example, if you try to update the index
+    # of a search engine in +after_save+ the indexer won't see the updated record.
+    # The +after_commit+ callback is the only one that is triggered once the update
+    # is committed. See below.
     #
     # == Exception handling and rolling back
     #
@@ -90,14 +95,14 @@ module ActiveRecord
     # be propagated (after triggering the ROLLBACK), so you should be ready to
     # catch those in your application code.
     #
-    # One exception is the ActiveRecord::Rollback exception, which will trigger
+    # One exception is the <tt>ActiveRecord::Rollback</tt> exception, which will trigger
     # a ROLLBACK when raised, but not be re-raised by the transaction block.
     #
-    # *Warning*: one should not catch ActiveRecord::StatementInvalid exceptions
-    # inside a transaction block. StatementInvalid exceptions indicate that an
+    # *Warning*: one should not catch <tt>ActiveRecord::StatementInvalid</tt> exceptions
+    # inside a transaction block. <tt>ActiveRecord::StatementInvalid</tt> exceptions indicate that an
     # error occurred at the database level, for example when a unique constraint
     # is violated. On some database systems, such as PostgreSQL, database errors
-    # inside a transaction causes the entire transaction to become unusable
+    # inside a transaction cause the entire transaction to become unusable
     # until it's restarted from the beginning. Here is an example which
     # demonstrates the problem:
     #
@@ -110,7 +115,7 @@ module ActiveRecord
     #     rescue ActiveRecord::StatementInvalid
     #       # ...which we ignore.
     #     end
-    #     
+    #
     #     # On PostgreSQL, the transaction is now unusable. The following
     #     # statement will cause a PostgreSQL error, even though the unique
     #     # constraint is no longer violated:
@@ -119,13 +124,14 @@ module ActiveRecord
     #     #     ignored until end of transaction block"
     #   end
     #
-    # One should restart the entire transaction if a StatementError occurred.
+    # One should restart the entire transaction if an
+    # <tt>ActiveRecord::StatementInvalid</tt> occurred.
     #
     # == Nested transactions
     #
-    # #transaction calls can be nested. By default, this makes all database
+    # +transaction+ calls can be nested. By default, this makes all database
     # statements in the nested transaction block become part of the parent
-    # transaction. For example:
+    # transaction. For example, the following behavior may be surprising:
     #
     #   User.transaction do
     #     User.create(:username => 'Kotori')
@@ -134,13 +140,16 @@ module ActiveRecord
     #       raise ActiveRecord::Rollback
     #     end
     #   end
-    #   
-    #   User.find(:all)  # => empty
     #
-    # It is also possible to requires a sub-transaction by passing
-    # <tt>:requires_new => true</tt>.  If anything goes wrong, the
-    # database rolls back to the beginning of the sub-transaction
-    # without rolling back the parent transaction. For example:
+    # creates both "Kotori" and "Nemu". Reason is the <tt>ActiveRecord::Rollback</tt>
+    # exception in the nested block does not issue a ROLLBACK. Since these exceptions
+    # are captured in transaction blocks, the parent block does not see it and the
+    # real transaction is committed.
+    #
+    # In order to get a ROLLBACK for the nested transaction you may ask for a real
+    # sub-transaction by passing <tt>:requires_new => true</tt>. If anything goes wrong,
+    # the database rolls back to the beginning of the sub-transaction without rolling
+    # back the parent transaction. If we add it to the previous example:
     #
     #   User.transaction do
     #     User.create(:username => 'Kotori')
@@ -149,72 +158,146 @@ module ActiveRecord
     #       raise ActiveRecord::Rollback
     #     end
     #   end
-    #   
-    #   User.find(:all)  # => Returns only Kotori
+    #
+    # only "Kotori" is created. (This works on MySQL and PostgreSQL, but not on SQLite3.)
     #
     # Most databases don't support true nested transactions. At the time of
     # writing, the only database that we're aware of that supports true nested
     # transactions, is MS-SQL. Because of this, Active Record emulates nested
-    # transactions by using savepoints. See
-    # http://dev.mysql.com/doc/refman/5.0/en/savepoints.html
+    # transactions by using savepoints on MySQL and PostgreSQL. See
+    # http://dev.mysql.com/doc/refman/5.0/en/savepoint.html
     # for more information about savepoints.
     #
+    # === Callbacks
+    #
+    # There are two types of callbacks associated with committing and rolling back transactions:
+    # +after_commit+ and +after_rollback+.
+    #
+    # +after_commit+ callbacks are called on every record saved or destroyed within a
+    # transaction immediately after the transaction is committed. +after_rollback+ callbacks
+    # are called on every record saved or destroyed within a transaction immediately after the
+    # transaction or savepoint is rolled back.
+    #
+    # These callbacks are useful for interacting with other systems since you will be guaranteed
+    # that the callback is only executed when the database is in a permanent state. For example,
+    # +after_commit+ is a good spot to put in a hook to clearing a cache since clearing it from
+    # within a transaction could trigger the cache to be regenerated before the database is updated.
+    #
     # === Caveats
     #
     # If you're on MySQL, then do not use DDL operations in nested transactions
     # blocks that are emulated with savepoints. That is, do not execute statements
     # like 'CREATE TABLE' inside such blocks. This is because MySQL automatically
-    # releases all savepoints upon executing a DDL operation. When #transaction
+    # releases all savepoints upon executing a DDL operation. When +transaction+
     # is finished and tries to release the savepoint it created earlier, a
     # database error will occur because the savepoint has already been
     # automatically released. The following example demonstrates the problem:
-    # 
+    #
     #   Model.connection.transaction do                           # BEGIN
     #     Model.connection.transaction(:requires_new => true) do  # CREATE SAVEPOINT active_record_1
     #       Model.connection.create_table(...)                    # active_record_1 now automatically released
     #     end                                                     # RELEASE savepoint active_record_1
     #                                                             # ^^^^ BOOM! database error!
     #   end
+    #
+    # Note that "TRUNCATE" is also a MySQL DDL statement!
     module ClassMethods
       # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
       def transaction(options = {}, &block)
         # See the ConnectionAdapters::DatabaseStatements#transaction API docs.
         connection.transaction(options, &block)
       end
+
+      # This callback is called after a record has been created, updated, or destroyed.
+      #
+      # You can specify that the callback should only be fired by a certain action with
+      # the +:on+ option:
+      #
+      #   after_commit :do_foo, :on => :create
+      #   after_commit :do_bar, :on => :update
+      #   after_commit :do_baz, :on => :destroy
+      #
+      # Also, to have the callback fired on create and update, but not on destroy:
+      #
+      #   after_commit :do_zoo, :if => :persisted?
+      #
+      # Note that transactional fixtures do not play well with this feature. Please
+      # use the +test_after_commit+ gem to have these hooks fired in tests.
+      def after_commit(*args, &block)
+        options = args.last
+        if options.is_a?(Hash) && options[:on]
+          options[:if] = Array.wrap(options[:if])
+          options[:if] << "transaction_include_action?(:#{options[:on]})"
+        end
+        set_callback(:commit, :after, *args, &block)
+      end
+
+      # This callback is called after a create, update, or destroy are rolled back.
+      #
+      # Please check the documentation of +after_commit+ for options.
+      def after_rollback(*args, &block)
+        options = args.last
+        if options.is_a?(Hash) && options[:on]
+          options[:if] = Array.wrap(options[:if])
+          options[:if] << "transaction_include_action?(:#{options[:on]})"
+        end
+        set_callback(:rollback, :after, *args, &block)
+      end
     end
 
     # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
-    def transaction(&block)
-      self.class.transaction(&block)
+    def transaction(options = {}, &block)
+      self.class.transaction(options, &block)
     end
 
-    def destroy_with_transactions #:nodoc:
-      with_transaction_returning_status(:destroy_without_transactions)
+    def destroy #:nodoc:
+      with_transaction_returning_status { super }
     end
 
-    def save_with_transactions(perform_validation = true) #:nodoc:
-      rollback_active_record_state! { with_transaction_returning_status(:save_without_transactions, perform_validation) }
+    def save(*) #:nodoc:
+      rollback_active_record_state! do
+        with_transaction_returning_status { super }
+      end
     end
 
-    def save_with_transactions! #:nodoc:
-      rollback_active_record_state! { self.class.transaction { save_without_transactions! } }
+    def save!(*) #:nodoc:
+      with_transaction_returning_status { super }
     end
 
     # Reset id and @new_record if the transaction rolls back.
     def rollback_active_record_state!
-      id_present = has_attribute?(self.class.primary_key)
-      previous_id = id
-      previous_new_record = new_record?
+      remember_transaction_record_state
       yield
     rescue Exception
-      @new_record = previous_new_record
-      if id_present
-        self.id = previous_id
-      else
-        @attributes.delete(self.class.primary_key)
-        @attributes_cache.delete(self.class.primary_key)
-      end
+      IdentityMap.remove(self) if IdentityMap.enabled?
+      restore_transaction_record_state
       raise
+    ensure
+      clear_transaction_record_state
+    end
+
+    # Call the after_commit callbacks
+    def committed! #:nodoc:
+      run_callbacks :commit
+    ensure
+      clear_transaction_record_state
+    end
+
+    # Call the after rollback callbacks. The restore_state argument indicates if the record
+    # state should be rolled back to the beginning or just to the last savepoint.
+    def rolledback!(force_restore_state = false) #:nodoc:
+      run_callbacks :rollback
+    ensure
+      IdentityMap.remove(self) if IdentityMap.enabled?
+      restore_transaction_record_state(force_restore_state)
+    end
+
+    # Add the record to the current transaction so that the :after_rollback and :after_commit callbacks
+    # can be called.
+    def add_to_transaction
+      if self.class.connection.add_transaction_record(self)
+        remember_transaction_record_state
+      end
     end
 
     # Executes +method+ within a transaction and captures its return value as a
@@ -223,13 +306,76 @@ module ActiveRecord
     #
     # This method is available within the context of an ActiveRecord::Base
     # instance.
-    def with_transaction_returning_status(method, *args)
+    def with_transaction_returning_status
       status = nil
       self.class.transaction do
-        status = send(method, *args)
+        add_to_transaction
+        status = yield
         raise ActiveRecord::Rollback unless status
       end
       status
     end
+
+    protected
+
+    # Save the new record state and id of a record so it can be restored later if a transaction fails.
+    def remember_transaction_record_state #:nodoc:
+      @_start_transaction_state ||= {}
+      @_start_transaction_state[:id] = id if has_attribute?(self.class.primary_key)
+      unless @_start_transaction_state.include?(:new_record)
+        @_start_transaction_state[:new_record] = @new_record
+      end
+      unless @_start_transaction_state.include?(:destroyed)
+        @_start_transaction_state[:destroyed] = @destroyed
+      end
+      @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) + 1
+      @_start_transaction_state[:frozen?] = @attributes.frozen?
+    end
+
+    # Clear the new record state and id of a record.
+    def clear_transaction_record_state #:nodoc:
+      if defined?(@_start_transaction_state)
+        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+        remove_instance_variable(:@_start_transaction_state) if @_start_transaction_state[:level] < 1
+      end
+    end
+
+    # Restore the new record state and id of a record that was previously saved by a call to save_record_state.
+    def restore_transaction_record_state(force = false) #:nodoc:
+      if defined?(@_start_transaction_state)
+        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+        if @_start_transaction_state[:level] < 1 || force
+          restore_state = remove_instance_variable(:@_start_transaction_state)
+          was_frozen = restore_state[:frozen?]
+          @attributes = @attributes.dup if @attributes.frozen?
+          @new_record = restore_state[:new_record]
+          @destroyed  = restore_state[:destroyed]
+          if restore_state.has_key?(:id)
+            self.id = restore_state[:id]
+          else
+            @attributes.delete(self.class.primary_key)
+            @attributes_cache.delete(self.class.primary_key)
+          end
+          @attributes.freeze if was_frozen
+        end
+      end
+    end
+
+    # Determine if a record was created or destroyed in a transaction. State should be one of :new_record or :destroyed.
+    def transaction_record_state(state) #:nodoc:
+      @_start_transaction_state[state] if defined?(@_start_transaction_state)
+    end
+
+    # Determine if a transaction included an action for :create, :update, or :destroy. Used in filtering callbacks.
+    def transaction_include_action?(action) #:nodoc:
+      case action
+      when :create
+        transaction_record_state(:new_record)
+      when :destroy
+        destroyed?
+      when :update
+        !(transaction_record_state(:new_record) || destroyed?)
+      end
+    end
   end
 end

data/lib/active_record/translation.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module Translation
+    include ActiveModel::Translation
+
+    # Set the lookup ancestors for ActiveModel.
+    def lookup_ancestors #:nodoc:
+      klass = self
+      classes = [klass]
+      return classes if klass == ActiveRecord::Base
+
+      while klass != klass.base_class
+        classes << klass = klass.superclass
+      end
+      classes
+    end
+
+    # Set the i18n scope to overwrite ActiveModel.
+    def i18n_scope #:nodoc:
+      :activerecord
+    end
+  end
+end

data/lib/active_record/validations/associated.rb

@@ -0,0 +1,43 @@
+module ActiveRecord
+  module Validations
+    class AssociatedValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if Array.wrap(value).reject {|r| r.marked_for_destruction? || r.valid?}.any?
+          record.errors.add(attribute, :invalid, options.merge(:value => value))
+        end
+      end
+    end
+
+    module ClassMethods
+      # Validates whether the associated object or objects are all valid themselves. Works with any kind of association.
+      #
+      #   class Book < ActiveRecord::Base
+      #     has_many :pages
+      #     belongs_to :library
+      #
+      #     validates_associated :pages, :library
+      #   end
+      #
+      # WARNING: This validation must not be used on both ends of an association. Doing so will lead to a circular dependency and cause infinite recursion.
+      #
+      # NOTE: This validation will not fail if the association hasn't been assigned. If you want to
+      # ensure that the association is both present and guaranteed to be valid, you also need to
+      # use +validates_presence_of+.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "is invalid")
+      # * <tt>:on</tt> - Specifies when this validation is active. Runs in all
+      #   validation contexts by default (+nil+), other options are <tt>:create</tt>
+      #   and <tt>:update</tt>.
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
+      #   method, proc or string should return or evaluate to a true or false value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
+      #   method, proc or string should return or evaluate to a true or false value.
+      def validates_associated(*attr_names)
+        validates_with AssociatedValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_record/validations/uniqueness.rb

@@ -0,0 +1,180 @@
+require 'active_support/core_ext/array/wrap'
+
+module ActiveRecord
+  module Validations
+    class UniquenessValidator < ActiveModel::EachValidator
+      def initialize(options)
+        super(options.reverse_merge(:case_sensitive => true))
+      end
+
+      # Unfortunately, we have to tie Uniqueness validators to a class.
+      def setup(klass)
+        @klass = klass
+      end
+
+      def validate_each(record, attribute, value)
+        finder_class = find_finder_class_for(record)
+        table = finder_class.arel_table
+
+        coder = record.class.serialized_attributes[attribute.to_s]
+
+        if value && coder
+          value = coder.dump value
+        end
+
+        relation = build_relation(finder_class, table, attribute, value)
+        relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.send(:id))) if record.persisted?
+
+        Array.wrap(options[:scope]).each do |scope_item|
+          scope_value = record.read_attribute(scope_item)
+          relation = relation.and(table[scope_item].eq(scope_value))
+        end
+
+        if finder_class.unscoped.where(relation).exists?
+          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+        end
+      end
+
+    protected
+
+      # The check for an existing value should be run from a class that
+      # isn't abstract. This means working down from the current class
+      # (self), to the first non-abstract class. Since classes don't know
+      # their subclasses, we have to build the hierarchy between self and
+      # the record's class.
+      def find_finder_class_for(record) #:nodoc:
+        class_hierarchy = [record.class]
+
+        while class_hierarchy.first != @klass
+          class_hierarchy.insert(0, class_hierarchy.first.superclass)
+        end
+
+        class_hierarchy.detect { |klass| !klass.abstract_class? }
+      end
+
+      def build_relation(klass, table, attribute, value) #:nodoc:
+        column = klass.columns_hash[attribute.to_s]
+        value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s if value && column.text?
+
+        if !options[:case_sensitive] && value && column.text?
+          # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
+          relation = klass.connection.case_insensitive_comparison(table, attribute, column, value)
+        else
+          value    = klass.connection.case_sensitive_modifier(value) if value
+          relation = table[attribute].eq(value)
+        end
+
+        relation
+      end
+    end
+
+    module ClassMethods
+      # Validates whether the value of the specified attributes are unique across the system.
+      # Useful for making sure that only one user
+      # can be named "davidhh".
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_uniqueness_of :user_name
+      #   end
+      #
+      # It can also validate whether the value of the specified attributes are unique based on a scope parameter:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_uniqueness_of :user_name, :scope => :account_id
+      #   end
+      #
+      # Or even multiple scope parameters. For example, making sure that a teacher can only be on the schedule once
+      # per semester for a particular class.
+      #
+      #   class TeacherSchedule < ActiveRecord::Base
+      #     validates_uniqueness_of :teacher_id, :scope => [:semester_id, :class_id]
+      #   end
+      #
+      # When the record is created, a check is performed to make sure that no record exists in the database
+      # with the given value for the specified attribute (that maps to a column). When the record is updated,
+      # the same check is made but disregarding the record itself.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - Specifies a custom error message (default is: "has already been taken").
+      # * <tt>:scope</tt> - One or more columns by which to limit the scope of the uniqueness constraint.
+      # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by non-text columns (+true+ by default).
+      # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to true, skips this validation if the attribute is blank (default is +false+).
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).
+      #   The method, proc or string should return or evaluate to a true or false value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or
+      #   <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The method, proc or string should
+      #   return or evaluate to a true or false value.
+      #
+      # === Concurrency and integrity
+      #
+      # Using this validation method in conjunction with ActiveRecord::Base#save
+      # does not guarantee the absence of duplicate record insertions, because
+      # uniqueness checks on the application level are inherently prone to race
+      # conditions. For example, suppose that two users try to post a Comment at
+      # the same time, and a Comment's title must be unique. At the database-level,
+      # the actions performed by these users could be interleaved in the following manner:
+      #
+      #               User 1                 |               User 2
+      #  ------------------------------------+--------------------------------------
+      #  # User 1 checks whether there's     |
+      #  # already a comment with the title  |
+      #  # 'My Post'. This is not the case.  |
+      #  SELECT * FROM comments              |
+      #  WHERE title = 'My Post'             |
+      #                                      |
+      #                                      | # User 2 does the same thing and also
+      #                                      | # infers that his title is unique.
+      #                                      | SELECT * FROM comments
+      #                                      | WHERE title = 'My Post'
+      #                                      |
+      #  # User 1 inserts his comment.       |
+      #  INSERT INTO comments                |
+      #  (title, content) VALUES             |
+      #  ('My Post', 'hi!')                  |
+      #                                      |
+      #                                      | # User 2 does the same thing.
+      #                                      | INSERT INTO comments
+      #                                      | (title, content) VALUES
+      #                                      | ('My Post', 'hello!')
+      #                                      |
+      #                                      | # ^^^^^^
+      #                                      | # Boom! We now have a duplicate
+      #                                      | # title!
+      #
+      # This could even happen if you use transactions with the 'serializable'
+      # isolation level. The best way to work around this problem is to add a unique
+      # index to the database table using
+      # ActiveRecord::ConnectionAdapters::SchemaStatements#add_index. In the
+      # rare case that a race condition occurs, the database will guarantee
+      # the field's uniqueness.
+      #
+      # When the database catches such a duplicate insertion,
+      # ActiveRecord::Base#save will raise an ActiveRecord::StatementInvalid
+      # exception. You can either choose to let this error propagate (which
+      # will result in the default Rails exception page being shown), or you
+      # can catch it and restart the transaction (e.g. by telling the user
+      # that the title already exists, and asking him to re-enter the title).
+      # This technique is also known as optimistic concurrency control:
+      # http://en.wikipedia.org/wiki/Optimistic_concurrency_control
+      #
+      # The bundled ActiveRecord::ConnectionAdapters distinguish unique index
+      # constraint errors from other types of database errors by throwing an
+      # ActiveRecord::RecordNotUnique exception.
+      # For other adapters you will have to parse the (database-specific) exception
+      # message to detect such a case.
+      # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception:
+      # * ActiveRecord::ConnectionAdapters::MysqlAdapter
+      # * ActiveRecord::ConnectionAdapters::Mysql2Adapter
+      # * ActiveRecord::ConnectionAdapters::SQLiteAdapter
+      # * ActiveRecord::ConnectionAdapters::SQLite3Adapter
+      # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+      #
+      def validates_uniqueness_of(*attr_names)
+        validates_with UniquenessValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end