activerecord 3.2.22.5 → 4.0.0.beta1

data/lib/active_record/railties/jdbcmysql_error.rb

@@ -1,6 +1,6 @@
 #FIXME Remove if ArJdbcMysql will give.
 module ArJdbcMySQL #:nodoc:
-  class Error < StandardError
+  class Error < StandardError #:nodoc:
     attr_accessor :error_number, :sql_state
 
     def initialize msg

data/lib/active_record/readonly_attributes.rb

@@ -1,12 +1,10 @@
-require 'active_support/concern'
-require 'active_support/core_ext/class/attribute'
 
 module ActiveRecord
   module ReadonlyAttributes
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_attr_readonly, :instance_writer => false
+      class_attribute :_attr_readonly, instance_accessor: false
       self._attr_readonly = []
     end
 
@@ -22,5 +20,11 @@ module ActiveRecord
         self._attr_readonly
       end
     end
+
+    def _attr_readonly
+      message = "Instance level _attr_readonly method is deprecated, please use class level method."
+      ActiveSupport::Deprecation.warn message
+      defined?(@_attr_readonly) ? @_attr_readonly : self.class._attr_readonly
+    end
   end
 end

data/lib/active_record/reflection.rb

@@ -1,6 +1,3 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/object/inclusion'
-
 module ActiveRecord
   # = Active Record Reflection
   module Reflection # :nodoc:
@@ -20,13 +17,13 @@ module ActiveRecord
     # MacroReflection class has info for AggregateReflection and AssociationReflection
     # classes.
     module ClassMethods
-      def create_reflection(macro, name, options, active_record)
+      def create_reflection(macro, name, scope, options, active_record)
         case macro
-          when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
-            klass = options[:through] ? ThroughReflection : AssociationReflection
-            reflection = klass.new(macro, name, options, active_record)
-          when :composed_of
-            reflection = AggregateReflection.new(macro, name, options, active_record)
+        when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
+          klass = options[:through] ? ThroughReflection : AssociationReflection
+          reflection = klass.new(macro, name, scope, options, active_record)
+        when :composed_of
+          reflection = AggregateReflection.new(macro, name, scope, options, active_record)
         end
 
         self.reflections = self.reflections.merge(name => reflection)
@@ -43,7 +40,8 @@ module ActiveRecord
       #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
       #
       def reflect_on_aggregation(aggregation)
-        reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
+        reflection = reflections[aggregation]
+        reflection if reflection.is_a?(AggregateReflection)
       end
 
       # Returns an array of AssociationReflection objects for all the
@@ -67,7 +65,8 @@ module ActiveRecord
       #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
       #
       def reflect_on_association(association)
-        reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+        reflection = reflections[association]
+        reflection if reflection.is_a?(AssociationReflection)
       end
 
       # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
@@ -76,25 +75,26 @@ module ActiveRecord
       end
     end
 
-
     # Abstract base class for AggregateReflection and AssociationReflection. Objects of
     # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
     class MacroReflection
       # Returns the name of the macro.
       #
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:balance</tt>
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>:balance</tt>
       # <tt>has_many :clients</tt> returns <tt>:clients</tt>
       attr_reader :name
 
       # Returns the macro type.
       #
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:composed_of</tt>
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>:composed_of</tt>
       # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
       attr_reader :macro
 
+      attr_reader :scope
+
       # Returns the hash of options used for the macro.
       #
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>{ :class_name => "Money" }</tt>
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>{ class_name: "Money" }</tt>
       # <tt>has_many :clients</tt> returns +{}+
       attr_reader :options
 
@@ -102,9 +102,10 @@ module ActiveRecord
 
       attr_reader :plural_name # :nodoc:
 
-      def initialize(macro, name, options, active_record)
+      def initialize(macro, name, scope, options, active_record)
         @macro         = macro
         @name          = name
+        @scope         = scope
         @options       = options
         @active_record = active_record
         @plural_name   = active_record.pluralize_table_names ?
@@ -113,7 +114,7 @@ module ActiveRecord
 
       # Returns the class for the macro.
       #
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns the Money class
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns the Money class
       # <tt>has_many :clients</tt> returns the Client class
       def klass
         @klass ||= class_name.constantize
@@ -121,7 +122,7 @@ module ActiveRecord
 
       # Returns the class name for the macro.
       #
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>'Money'</tt>
       # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
       def class_name
         @class_name ||= (options[:class_name] || derive_class_name).to_s
@@ -137,10 +138,6 @@ module ActiveRecord
           active_record == other_aggregation.active_record
       end
 
-      def sanitized_conditions #:nodoc:
-        @sanitized_conditions ||= klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
-      end
-
       private
         def derive_class_name
           name.to_s.camelize
@@ -151,6 +148,10 @@ module ActiveRecord
     # Holds all the meta-data about an aggregation as it was specified in the
     # Active Record class.
     class AggregateReflection < MacroReflection #:nodoc:
+      def mapping
+        mapping = options[:mapping] || [name, name]
+        mapping.first.is_a?(Array) ? mapping : [mapping]
+      end
     end
 
     # Holds all the meta-data about an association as it was specified in the
@@ -172,15 +173,15 @@ module ActiveRecord
         @klass ||= active_record.send(:compute_type, class_name)
       end
 
-      def initialize(macro, name, options, active_record)
+      def initialize(*args)
         super
-        @collection = macro.in?([:has_many, :has_and_belongs_to_many])
+        @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
       end
 
-      # Returns a new, unsaved instance of the associated class. +options+ will
+      # Returns a new, unsaved instance of the associated class. +attributes+ will
       # be passed to the class's constructor.
-      def build_association(*options, &block)
-        klass.new(*options, &block)
+      def build_association(attributes, &block)
+        klass.new(attributes, &block)
       end
 
       def table_name
@@ -191,6 +192,10 @@ module ActiveRecord
         @quoted_table_name ||= klass.quoted_table_name
       end
 
+      def join_table
+        @join_table ||= options[:join_table] || derive_join_table
+      end
+
       def foreign_key
         @foreign_key ||= options[:foreign_key] || derive_foreign_key
       end
@@ -228,8 +233,8 @@ module ActiveRecord
         end
       end
 
-      def columns(tbl_name, log_msg)
-        @columns ||= klass.connection.columns(tbl_name, log_msg)
+      def columns(tbl_name)
+        @columns ||= klass.connection.columns(tbl_name)
       end
 
       def reset_column_information
@@ -238,6 +243,10 @@ module ActiveRecord
 
       def check_validity!
         check_validity_of_inverse!
+
+        if has_and_belongs_to_many? && association_foreign_key == foreign_key
+          raise HasAndBelongsToManyAssociationForeignKeyNeeded.new(self)
+        end
       end
 
       def check_validity_of_inverse!
@@ -266,11 +275,10 @@ module ActiveRecord
         false
       end
 
-      # An array of arrays of conditions. Each item in the outside array corresponds to a reflection
-      # in the #chain. The inside arrays are simply conditions (and each condition may itself be
-      # a hash, array, arel predicate, etc...)
-      def conditions
-        [[options[:conditions]].compact]
+      # An array of arrays of scopes. Each item in the outside array corresponds to a reflection
+      # in the #chain.
+      def scope_chain
+        scope ? [[scope]] : [[]]
       end
 
       alias :source_macro :macro
@@ -306,10 +314,10 @@ module ActiveRecord
       # the parent's validation.
       #
       # Unless you explicitly disable validation with
-      # <tt>:validate => false</tt>, validation will take place when:
+      # <tt>validate: false</tt>, validation will take place when:
       #
-      # * you explicitly enable validation; <tt>:validate => true</tt>
-      # * you use autosave; <tt>:autosave => true</tt>
+      # * you explicitly enable validation; <tt>validate: true</tt>
+      # * you use autosave; <tt>autosave: true</tt>
       # * the association is a +has_many+ association
       def validate?
         !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
@@ -320,6 +328,10 @@ module ActiveRecord
         macro == :belongs_to
       end
 
+      def has_and_belongs_to_many?
+        macro == :has_and_belongs_to_many
+      end
+
       def association_class
         case macro
         when :belongs_to
@@ -345,6 +357,10 @@ module ActiveRecord
         end
       end
 
+      def polymorphic?
+        options.key? :polymorphic
+      end
+
       private
         def derive_class_name
           class_name = name.to_s.camelize
@@ -362,6 +378,10 @@ module ActiveRecord
           end
         end
 
+        def derive_join_table
+          [active_record.table_name, klass.table_name].sort.join("\0").gsub(/^(.*_)(.+)\0\1(.+)/, '\1\2_\3').gsub("\0", "_")
+        end
+
         def primary_key(klass)
           klass.primary_key || raise(UnknownPrimaryKey.new(klass))
         end
@@ -378,7 +398,7 @@ module ActiveRecord
       #
       #   class Post < ActiveRecord::Base
       #     has_many :taggings
-      #     has_many :tags, :through => :taggings
+      #     has_many :tags, through: :taggings
       #   end
       #
       def source_reflection
@@ -390,7 +410,7 @@ module ActiveRecord
       #
       #   class Post < ActiveRecord::Base
       #     has_many :taggings
-      #     has_many :tags, :through => :taggings
+      #     has_many :tags, through: :taggings
       #   end
       #
       #   tags_reflection = Post.reflect_on_association(:tags)
@@ -418,41 +438,37 @@ module ActiveRecord
       #
       #   class Person
       #     has_many :articles
-      #     has_many :comment_tags, :through => :articles
+      #     has_many :comment_tags, through: :articles
       #   end
       #
       #   class Article
       #     has_many :comments
-      #     has_many :comment_tags, :through => :comments, :source => :tags
+      #     has_many :comment_tags, through: :comments, source: :tags
       #   end
       #
       #   class Comment
       #     has_many :tags
       #   end
       #
-      # There may be conditions on Person.comment_tags, Article.comment_tags and/or Comment.tags,
+      # There may be scopes on Person.comment_tags, Article.comment_tags and/or Comment.tags,
       # but only Comment.tags will be represented in the #chain. So this method creates an array
-      # of conditions corresponding to the chain. Each item in the #conditions array corresponds
-      # to an item in the #chain, and is itself an array of conditions from an arbitrary number
-      # of relevant reflections, plus any :source_type or polymorphic :as constraints.
-      def conditions
-        @conditions ||= begin
-          conditions = source_reflection.conditions.map { |c| c.dup }
+      # of scopes corresponding to the chain.
+      def scope_chain
+        @scope_chain ||= begin
+          scope_chain = source_reflection.scope_chain.map(&:dup)
 
-          # Add to it the conditions from this reflection if necessary.
-          conditions.first << options[:conditions] if options[:conditions]
+          # Add to it the scope from this reflection (if any)
+          scope_chain.first << scope if scope
 
-          through_conditions = through_reflection.conditions
+          through_scope_chain = through_reflection.scope_chain
 
           if options[:source_type]
-            through_conditions.first << { foreign_type => options[:source_type] }
+            through_scope_chain.first <<
+              through_reflection.klass.where(foreign_type => options[:source_type])
           end
 
           # Recursively fill out the rest of the array from the through reflection
-          conditions += through_conditions
-
-          # And return
-          conditions
+          scope_chain + through_scope_chain
         end
       end
 

data/lib/active_record/relation.rb

@@ -1,32 +1,42 @@
 # -*- coding: utf-8 -*-
-require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
   # = Active Record Relation
   class Relation
     JoinOperation = Struct.new(:relation, :join_class, :on)
-    ASSOCIATION_METHODS = [:includes, :eager_load, :preload]
-    MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :where, :having, :bind]
-    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :from, :reordering, :reverse_order, :uniq]
+
+    MULTI_VALUE_METHODS  = [:includes, :eager_load, :preload, :select, :group,
+                            :order, :joins, :where, :having, :bind, :references,
+                            :extending]
+
+    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :from, :reordering,
+                            :reverse_order, :uniq, :create_with]
+
+    VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
 
     include FinderMethods, Calculations, SpawnMethods, QueryMethods, Batches, Explain, Delegation
 
     attr_reader :table, :klass, :loaded
-    attr_accessor :extensions, :default_scoped
+    attr_accessor :default_scoped
+    alias :model :klass
     alias :loaded? :loaded
     alias :default_scoped? :default_scoped
 
-    def initialize(klass, table)
-      @klass, @table = klass, table
-
+    def initialize(klass, table, values = {})
+      @klass             = klass
+      @table             = table
+      @values            = values
       @implicit_readonly = nil
       @loaded            = false
       @default_scoped    = false
+    end
 
-      SINGLE_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_value", nil)}
-      (ASSOCIATION_METHODS + MULTI_VALUE_METHODS).each {|v| instance_variable_set(:"@#{v}_values", [])}
-      @extensions = []
-      @create_with_value = {}
+    def initialize_copy(other)
+      # This method is a hot spot, so for now, use Hash[] to dup the hash.
+      #   https://bugs.ruby-lang.org/issues/7166
+      @values        = Hash[@values]
+      @values[:bind] = @values[:bind].dup if @values.key? :bind
+      reset
     end
 
     def insert(values)
@@ -72,65 +82,100 @@ module ActiveRecord
         binds)
     end
 
+    # Initializes new record from relation while maintaining the current
+    # scope.
+    #
+    # Expects arguments in the same format as +Base.new+.
+    #
+    #   users = User.where(name: 'DHH')
+    #   user = users.new # => #<User id: nil, name: "DHH", created_at: nil, updated_at: nil>
+    #
+    # You can also pass a block to new with the new record as argument:
+    #
+    #   user = users.new { |user| user.name = 'Oscar' }
+    #   user.name # => Oscar
     def new(*args, &block)
       scoping { @klass.new(*args, &block) }
     end
 
-    def initialize_copy(other)
-      @bind_values = @bind_values.dup
-      reset
-    end
-
     alias build new
 
+    # Tries to create a new record with the same scoped attributes
+    # defined in the relation. Returns the initialized object if validation fails.
+    #
+    # Expects arguments in the same format as +Base.create+.
+    #
+    # ==== Examples
+    #   users = User.where(name: 'Oscar')
+    #   users.create # #<User id: 3, name: "oscar", ...>
+    #
+    #   users.create(name: 'fxn')
+    #   users.create # #<User id: 4, name: "fxn", ...>
+    #
+    #   users.create { |user| user.name = 'tenderlove' }
+    #   # #<User id: 5, name: "tenderlove", ...>
+    #
+    #   users.create(name: nil) # validation on name
+    #   # #<User id: nil, name: nil, ...>
     def create(*args, &block)
       scoping { @klass.create(*args, &block) }
     end
 
+    # Similar to #create, but calls +create!+ on the base class. Raises
+    # an exception if a validation error occurs.
+    #
+    # Expects arguments in the same format as <tt>Base.create!</tt>.
     def create!(*args, &block)
       scoping { @klass.create!(*args, &block) }
     end
 
-    # Tries to load the first record; if it fails, then <tt>create</tt> is called with the same arguments as this method.
-    #
-    # Expects arguments in the same format as <tt>Base.create</tt>.
+    def first_or_create(attributes = nil, &block) # :nodoc:
+      first || create(attributes, &block)
+    end
+
+    def first_or_create!(attributes = nil, &block) # :nodoc:
+      first || create!(attributes, &block)
+    end
+
+    def first_or_initialize(attributes = nil, &block) # :nodoc:
+      first || new(attributes, &block)
+    end
+
+    # Finds the first record with the given attributes, or creates a record with the attributes
+    # if one is not found.
     #
     # ==== Examples
     #   # Find the first user named Penélope or create a new one.
-    #   User.where(:first_name => 'Penélope').first_or_create
+    #   User.find_or_create_by(first_name: 'Penélope')
     #   # => <User id: 1, first_name: 'Penélope', last_name: nil>
     #
     #   # Find the first user named Penélope or create a new one.
     #   # We already have one so the existing record will be returned.
-    #   User.where(:first_name => 'Penélope').first_or_create
+    #   User.find_or_create_by(first_name: 'Penélope')
     #   # => <User id: 1, first_name: 'Penélope', last_name: nil>
     #
     #   # Find the first user named Scarlett or create a new one with a particular last name.
-    #   User.where(:first_name => 'Scarlett').first_or_create(:last_name => 'Johansson')
+    #   User.create_with(last_name: 'Johansson').find_or_create_by(first_name: 'Scarlett')
     #   # => <User id: 2, first_name: 'Scarlett', last_name: 'Johansson'>
     #
     #   # Find the first user named Scarlett or create a new one with a different last name.
     #   # We already have one so the existing record will be returned.
-    #   User.where(:first_name => 'Scarlett').first_or_create do |user|
+    #   User.find_or_create_by(first_name: 'Scarlett') do |user|
     #     user.last_name = "O'Hara"
     #   end
     #   # => <User id: 2, first_name: 'Scarlett', last_name: 'Johansson'>
-    def first_or_create(attributes = nil, options = {}, &block)
-      first || create(attributes, options, &block)
+    def find_or_create_by(attributes, &block)
+      find_by(attributes) || create(attributes, &block)
     end
 
-    # Like <tt>first_or_create</tt> but calls <tt>create!</tt> so an exception is raised if the created record is invalid.
-    #
-    # Expects arguments in the same format as <tt>Base.create!</tt>.
-    def first_or_create!(attributes = nil, options = {}, &block)
-      first || create!(attributes, options, &block)
+    # Like <tt>find_or_create_by</tt>, but calls <tt>create!</tt> so an exception is raised if the created record is invalid.
+    def find_or_create_by!(attributes, &block)
+      find_by(attributes) || create!(attributes, &block)
     end
 
-    # Like <tt>first_or_create</tt> but calls <tt>new</tt> instead of <tt>create</tt>.
-    #
-    # Expects arguments in the same format as <tt>Base.new</tt>.
-    def first_or_initialize(attributes = nil, options = {}, &block)
-      first || new(attributes, options, &block)
+    # Like <tt>find_or_create_by</tt>, but calls <tt>new</tt> instead of <tt>create</tt>.
+    def find_or_initialize_by(attributes, &block)
+      find_by(attributes) || new(attributes, &block)
     end
 
     # Runs EXPLAIN on the query or queries triggered by this relation and
@@ -141,58 +186,17 @@ module ActiveRecord
     # are needed by the next ones when eager loading is going on.
     #
     # Please see further details in the
-    # {Active Record Query Interface guide}[http://edgeguides.rubyonrails.org/active_record_querying.html#running-explain].
+    # {Active Record Query Interface guide}[http://guides.rubyonrails.org/active_record_querying.html#running-explain].
     def explain
       _, queries = collecting_queries_for_explain { exec_queries }
       exec_explain(queries)
     end
 
+    # Converts relation objects to Array.
     def to_a
-      # We monitor here the entire execution rather than individual SELECTs
-      # because from the point of view of the user fetching the records of a
-      # relation is a single unit of work. You want to know if this call takes
-      # too long, not if the individual queries take too long.
-      #
-      # It could be the case that none of the queries involved surpass the
-      # threshold, and at the same time the sum of them all does. The user
-      # should get a query plan logged in that case.
-      logging_query_plan do
-        exec_queries
-      end
-    end
-
-    def exec_queries
-      return @records if loaded?
-
-      default_scoped = with_default_scope
-
-      if default_scoped.equal?(self)
-        @records = if @readonly_value.nil? && !@klass.locking_enabled?
-          eager_loading? ? find_with_associations : @klass.find_by_sql(arel, @bind_values)
-        else
-          IdentityMap.without do
-            eager_loading? ? find_with_associations : @klass.find_by_sql(arel, @bind_values)
-          end
-        end
-
-        preload = @preload_values
-        preload +=  @includes_values unless eager_loading?
-        preload.each do |associations|
-          ActiveRecord::Associations::Preloader.new(@records, associations).run
-        end
-
-        # @readonly_value is true only if set explicitly. @implicit_readonly is true if there
-        # are JOINS and no explicit SELECT.
-        readonly = @readonly_value.nil? ? @implicit_readonly : @readonly_value
-        @records.each { |record| record.readonly! } if readonly
-      else
-        @records = default_scoped.to_a
-      end
-
-      @loaded = true
+      load
       @records
     end
-    private :exec_queries
 
     def as_json(options = nil) #:nodoc:
       to_a.as_json(options)
@@ -211,6 +215,7 @@ module ActiveRecord
       c.respond_to?(:zero?) ? c.zero? : c.empty?
     end
 
+    # Returns true if there are any records.
     def any?
       if block_given?
         to_a.any? { |*block_args| yield(*block_args) }
@@ -219,26 +224,28 @@ module ActiveRecord
       end
     end
 
+    # Returns true if there is more than one record.
     def many?
       if block_given?
         to_a.many? { |*block_args| yield(*block_args) }
       else
-        @limit_value ? to_a.many? : size > 1
+        limit_value ? to_a.many? : size > 1
       end
     end
 
     # Scope all queries to the current scope.
     #
-    # ==== Example
-    #
-    #   Comment.where(:post_id => 1).scoping do
+    #   Comment.where(post_id: 1).scoping do
     #     Comment.first # SELECT * FROM comments WHERE post_id = 1
     #   end
     #
     # Please check unscoped if you want to remove all previous scopes (including
     # the default_scope) during the execution of a block.
     def scoping
-      @klass.with_scope(self, :overwrite) { yield }
+      previous, klass.current_scope = klass.current_scope, self
+      yield
+    ensure
+      klass.current_scope = previous
     end
 
     # Updates all records with details given if they match a set of conditions supplied, limits and order can
@@ -249,50 +256,35 @@ module ActiveRecord
     # ==== Parameters
     #
     # * +updates+ - A string, array, or hash representing the SET part of an SQL statement.
-    # * +conditions+ - A string, array, or hash representing the WHERE part of an SQL statement.
-    #   See conditions in the intro.
-    # * +options+ - Additional options are <tt>:limit</tt> and <tt>:order</tt>, see the examples for usage.
     #
     # ==== Examples
     #
     #   # Update all customers with the given attributes
-    #   Customer.update_all :wants_email => true
+    #   Customer.update_all wants_email: true
     #
     #   # Update all books with 'Rails' in their title
-    #   Book.update_all "author = 'David'", "title LIKE '%Rails%'"
-    #
-    #   # Update all avatars migrated more than a week ago
-    #   Avatar.update_all ['migrated_at = ?', Time.now.utc], ['migrated_at > ?', 1.week.ago]
+    #   Book.where('title LIKE ?', '%Rails%').update_all(author: 'David')
     #
     #   # Update all books that match conditions, but limit it to 5 ordered by date
-    #   Book.update_all "author = 'David'", "title LIKE '%Rails%'", :order => 'created_at', :limit => 5
-    #
-    #   # Conditions from the current relation also works
-    #   Book.where('title LIKE ?', '%Rails%').update_all(:author => 'David')
-    #
-    #   # The same idea applies to limit and order
-    #   Book.where('title LIKE ?', '%Rails%').order(:created_at).limit(5).update_all(:author => 'David')
-    def update_all(updates, conditions = nil, options = {})
-      IdentityMap.repository[symbolized_base_class].clear if IdentityMap.enabled?
-      if conditions || options.present?
-        where(conditions).apply_finder_options(options.slice(:limit, :order)).update_all(updates)
-      else
-        stmt = Arel::UpdateManager.new(arel.engine)
+    #   Book.where('title LIKE ?', '%Rails%').order(:created_at).limit(5).update_all(author: 'David')
+    def update_all(updates)
+      raise ArgumentError, "Empty list of attributes to change" if updates.blank?
 
-        stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates))
-        stmt.table(table)
-        stmt.key = table[primary_key]
+      stmt = Arel::UpdateManager.new(arel.engine)
 
-        if joins_values.any?
-          @klass.connection.join_to_update(stmt, arel)
-        else
-          stmt.take(arel.limit)
-          stmt.order(*arel.orders)
-          stmt.wheres = arel.constraints
-        end
+      stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates))
+      stmt.table(table)
+      stmt.key = table[primary_key]
 
-        @klass.connection.update stmt, 'SQL', bind_values
+      if with_default_scope.joins_values.any?
+        @klass.connection.join_to_update(stmt, arel)
+      else
+        stmt.take(arel.limit)
+        stmt.order(*arel.orders)
+        stmt.wheres = arel.constraints
       end
+
+      @klass.connection.update stmt, 'SQL', bind_values
     end
 
     # Updates an object (or multiple objects) and saves it to the database, if validations pass.
@@ -306,28 +298,26 @@ module ActiveRecord
     # ==== Examples
     #
     #   # Updates one record
-    #   Person.update(15, :user_name => 'Samuel', :group => 'expert')
+    #   Person.update(15, user_name: 'Samuel', group: 'expert')
     #
     #   # Updates multiple records
     #   people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } }
     #   Person.update(people.keys, people.values)
     def update(id, attributes)
       if id.is_a?(Array)
-        id.each.with_index.map {|one_id, idx| update(one_id, attributes[idx])}
+        id.map.with_index { |one_id, idx| update(one_id, attributes[idx]) }
       else
         object = find(id)
-        object.update_attributes(attributes)
+        object.update(attributes)
         object
       end
     end
 
     # Destroys the records matching +conditions+ by instantiating each
     # record and calling its +destroy+ method. Each object's callbacks are
-    # executed (including <tt>:dependent</tt> association options and
-    # +before_destroy+/+after_destroy+ Observer methods). Returns the
+    # executed (including <tt>:dependent</tt> association options). Returns the
     # collection of objects that were destroyed; each will be frozen, to
-    # reflect that no changes should be made (since they can't be
-    # persisted).
+    # reflect that no changes should be made (since they can't be persisted).
     #
     # Note: Instantiation, callback execution, and deletion of each
     # record can be time consuming when you're removing many records at
@@ -346,8 +336,8 @@ module ActiveRecord
     # ==== Examples
     #
     #   Person.destroy_all("last_login < '2004-04-04'")
-    #   Person.destroy_all(:status => "inactive")
-    #   Person.where(:age => 0..18).destroy_all
+    #   Person.destroy_all(status: "inactive")
+    #   Person.where(age: 0..18).destroy_all
     def destroy_all(conditions = nil)
       if conditions
         where(conditions).destroy_all
@@ -356,7 +346,7 @@ module ActiveRecord
       end
     end
 
-    # Destroy an object (or multiple objects) that has the given id, the object is instantiated first,
+    # Destroy an object (or multiple objects) that has the given id. The object is instantiated first,
     # therefore all callbacks and filters are fired off before the object is deleted. This method is
     # less efficient than ActiveRecord#delete but allows cleanup methods and other actions to be run.
     #
@@ -383,34 +373,41 @@ module ActiveRecord
       end
     end
 
-    # Deletes the records matching +conditions+ without instantiating the records first, and hence not
-    # calling the +destroy+ method nor invoking callbacks. This is a single SQL DELETE statement that
-    # goes straight to the database, much more efficient than +destroy_all+. Be careful with relations
-    # though, in particular <tt>:dependent</tt> rules defined on associations are not honored. Returns
-    # the number of rows affected.
-    #
-    # ==== Parameters
-    #
-    # * +conditions+ - Conditions are specified the same way as with +find+ method.
-    #
-    # ==== Example
+    # Deletes the records matching +conditions+ without instantiating the records
+    # first, and hence not calling the +destroy+ method nor invoking callbacks. This
+    # is a single SQL DELETE statement that goes straight to the database, much more
+    # efficient than +destroy_all+. Be careful with relations though, in particular
+    # <tt>:dependent</tt> rules defined on associations are not honored. Returns the
+    # number of rows affected.
     #
     #   Post.delete_all("person_id = 5 AND (category = 'Something' OR category = 'Else')")
     #   Post.delete_all(["person_id = ? AND (category = ? OR category = ?)", 5, 'Something', 'Else'])
-    #   Post.where(:person_id => 5).where(:category => ['Something', 'Else']).delete_all
+    #   Post.where(person_id: 5).where(category: ['Something', 'Else']).delete_all
     #
     # Both calls delete the affected posts all at once with a single DELETE statement.
     # If you need to destroy dependent associations or call your <tt>before_*</tt> or
     # +after_destroy+ callbacks, use the +destroy_all+ method instead.
+    #
+    # If a limit scope is supplied, +delete_all+ raises an ActiveRecord error:
+    #
+    #   Post.limit(100).delete_all
+    #   # => ActiveRecord::ActiveRecordError: delete_all doesn't support limit scope
     def delete_all(conditions = nil)
       raise ActiveRecordError.new("delete_all doesn't support limit scope") if self.limit_value
 
-      IdentityMap.repository[symbolized_base_class] = {} if IdentityMap.enabled?
       if conditions
         where(conditions).delete_all
       else
-        statement = arel.compile_delete
-        affected = @klass.connection.delete(statement, 'SQL', bind_values)
+        stmt = Arel::DeleteManager.new(arel.engine)
+        stmt.from(table)
+
+        if with_default_scope.joins_values.any?
+          @klass.connection.join_to_delete(stmt, arel, table[primary_key])
+        else
+          stmt.wheres = arel.constraints
+        end
+
+        affected = @klass.connection.delete(stmt, 'SQL', bind_values)
 
         reset
         affected
@@ -420,8 +417,7 @@ module ActiveRecord
     # Deletes the row with a primary key matching the +id+ argument, using a
     # SQL +DELETE+ statement, and returns the number of rows deleted. Active
     # Record objects are not instantiated, so the object's callbacks are not
-    # executed, including any <tt>:dependent</tt> association options or
-    # Observer methods.
+    # executed, including any <tt>:dependent</tt> association options.
     #
     # You can delete multiple rows at once by passing an Array of <tt>id</tt>s.
     #
@@ -438,14 +434,25 @@ module ActiveRecord
     #   # Delete multiple rows
     #   Todo.delete([2,3,4])
     def delete(id_or_array)
-      IdentityMap.remove_by_id(self.symbolized_base_class, id_or_array) if IdentityMap.enabled?
       where(primary_key => id_or_array).delete_all
     end
 
+    # Causes the records to be loaded from the database if they have not
+    # been loaded already. You can use this if for some reason you need
+    # to explicitly load some records before actually using them. The
+    # return value is the relation itself, not the records.
+    #
+    #   Post.where(published: true).load # => #<ActiveRecord::Relation>
+    def load
+      exec_queries unless loaded?
+
+      self
+    end
+
+    # Forces reloading of relation.
     def reload
       reset
-      to_a # force reload
-      self
+      load
     end
 
     def reset
@@ -455,36 +462,51 @@ module ActiveRecord
       self
     end
 
+    # Returns sql statement for the relation.
+    #
+    #   User.where(name: 'Oscar').to_sql
+    #   # => SELECT "users".* FROM "users"  WHERE "users"."name" = 'Oscar'
     def to_sql
-      @to_sql ||= klass.connection.to_sql(arel, @bind_values.dup)
+      @to_sql ||= klass.connection.to_sql(arel, bind_values.dup)
     end
 
+    # Returns a hash of where conditions.
+    #
+    #   User.where(name: 'Oscar').where_values_hash
+    #   # => {name: "Oscar"}
     def where_values_hash
       equalities = with_default_scope.where_values.grep(Arel::Nodes::Equality).find_all { |node|
         node.left.relation.name == table_name
       }
 
-      Hash[equalities.map { |where| [where.left.name, where.right] }].with_indifferent_access
+      binds = Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }]
+
+      Hash[equalities.map { |where|
+        name = where.left.name
+        [name, binds.fetch(name.to_s) { where.right }]
+      }]
     end
 
     def scope_for_create
       @scope_for_create ||= where_values_hash.merge(create_with_value)
     end
 
+    # Returns true if relation needs eager loading.
     def eager_loading?
       @should_eager_load ||=
-        @eager_load_values.any? ||
-        @includes_values.any? && (joined_includes_values.any? || references_eager_loaded_tables?)
+        eager_load_values.any? ||
+        includes_values.any? && (joined_includes_values.any? || references_eager_loaded_tables?)
     end
 
     # Joins that are also marked for preloading. In which case we should just eager load them.
     # Note that this is a naive implementation because we could have strings and symbols which
     # represent the same association, but that aren't matched by this. Also, we could have
-    # nested hashes which partially match, e.g. { :a => :b } & { :a => [:b, :c] }
+    # nested hashes which partially match, e.g. { a: :b } & { a: [:b, :c] }
     def joined_includes_values
-      @includes_values & @joins_values
+      includes_values & joins_values
     end
 
+    # Compares two relations for equality.
     def ==(other)
       case other
       when Relation
@@ -494,8 +516,8 @@ module ActiveRecord
       end
     end
 
-    def inspect
-      to_a.inspect
+    def pretty_print(q)
+      q.pp(self.to_a)
     end
 
     def with_default_scope #:nodoc:
@@ -508,8 +530,48 @@ module ActiveRecord
       end
     end
 
+    # Returns true if relation is blank.
+    def blank?
+      to_a.blank?
+    end
+
+    def values
+      Hash[@values]
+    end
+
+    def inspect
+      entries = to_a.take([limit_value, 11].compact.min).map!(&:inspect)
+      entries[10] = '...' if entries.size == 11
+
+      "#<#{self.class.name} [#{entries.join(', ')}]>"
+    end
+
     private
 
+    def exec_queries
+      default_scoped = with_default_scope
+
+      if default_scoped.equal?(self)
+        @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel, bind_values)
+
+        preload = preload_values
+        preload +=  includes_values unless eager_loading?
+        preload.each do |associations|
+          ActiveRecord::Associations::Preloader.new(@records, associations).run
+        end
+
+        # @readonly_value is true only if set explicitly. @implicit_readonly is true if there
+        # are JOINS and no explicit SELECT.
+        readonly = readonly_value.nil? ? @implicit_readonly : readonly_value
+        @records.each { |record| record.readonly! } if readonly
+      else
+        @records = default_scoped.to_a
+      end
+
+      @loaded = true
+      @records
+    end
+
     def references_eager_loaded_tables?
       joined_tables = arel.join_sources.map do |join|
         if join.is_a?(Arel::Nodes::StringJoin)
@@ -523,8 +585,30 @@ module ActiveRecord
 
       # always convert table names to downcase as in Oracle quoted table names are in uppercase
       joined_tables = joined_tables.flatten.compact.map { |t| t.downcase }.uniq
-
-      (tables_in_string(to_sql) - joined_tables).any?
+      string_tables = tables_in_string(to_sql)
+
+      if (references_values - joined_tables).any?
+        true
+      elsif (string_tables - joined_tables).any?
+        ActiveSupport::Deprecation.warn(
+          "It looks like you are eager loading table(s) (one of: #{string_tables.join(', ')}) " \
+          "that are referenced in a string SQL snippet. For example: \n" \
+          "\n" \
+          "    Post.includes(:comments).where(\"comments.title = 'foo'\")\n" \
+          "\n" \
+          "Currently, Active Record recognises the table in the string, and knows to JOIN the " \
+          "comments table to the query, rather than loading comments in a separate query. " \
+          "However, doing this without writing a full-blown SQL parser is inherently flawed. " \
+          "Since we don't want to write an SQL parser, we are removing this functionality. " \
+          "From now on, you must explicitly tell Active Record when you are referencing a table " \
+          "from a string:\n" \
+          "\n" \
+          "    Post.includes(:comments).where(\"comments.title = 'foo'\").references(:comments)\n\n"
+        )
+        true
+      else
+        false
+      end
     end
 
     def tables_in_string(string)