activerecord 3.0.0 → 4.0.0

data/lib/active_record/relation/delegation.rb

@@ -0,0 +1,125 @@
+require 'thread'
+require 'thread_safe'
+
+module ActiveRecord
+  module Delegation # :nodoc:
+    extend ActiveSupport::Concern
+
+    # This module creates compiled delegation methods dynamically at runtime, which makes
+    # subsequent calls to that method faster by avoiding method_missing. The delegations
+    # may vary depending on the klass of a relation, so we create a subclass of Relation
+    # for each different klass, and the delegations are compiled into that subclass only.
+
+    delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, :to => :to_a
+    delegate :table_name, :quoted_table_name, :primary_key, :quoted_primary_key,
+             :connection, :columns_hash, :to => :klass
+
+    module ClassSpecificRelation # :nodoc:
+      extend ActiveSupport::Concern
+
+      included do
+        @delegation_mutex = Mutex.new
+      end
+
+      module ClassMethods # :nodoc:
+        def name
+          superclass.name
+        end
+
+        def delegate_to_scoped_klass(method)
+          @delegation_mutex.synchronize do
+            return if method_defined?(method)
+
+            if method.to_s =~ /\A[a-zA-Z_]\w*[!?]?\z/
+              module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{method}(*args, &block)
+                  scoping { @klass.#{method}(*args, &block) }
+                end
+              RUBY
+            else
+              define_method method do |*args, &block|
+                scoping { @klass.send(method, *args, &block) }
+              end
+            end
+          end
+        end
+
+        def delegate(method, opts = {})
+          @delegation_mutex.synchronize do
+            return if method_defined?(method)
+            super
+          end
+        end
+      end
+
+      protected
+
+      def method_missing(method, *args, &block)
+        if @klass.respond_to?(method)
+          self.class.delegate_to_scoped_klass(method)
+          scoping { @klass.send(method, *args, &block) }
+        elsif Array.method_defined?(method)
+          self.class.delegate method, :to => :to_a
+          to_a.send(method, *args, &block)
+        elsif arel.respond_to?(method)
+          self.class.delegate method, :to => :arel
+          arel.send(method, *args, &block)
+        else
+          super
+        end
+      end
+    end
+
+    module ClassMethods # :nodoc:
+      @@subclasses = ThreadSafe::Cache.new(:initial_capacity => 2)
+
+      def new(klass, *args)
+        relation = relation_class_for(klass).allocate
+        relation.__send__(:initialize, klass, *args)
+        relation
+      end
+
+      # This doesn't have to be thread-safe. relation_class_for guarantees that this will only be
+      # called exactly once for a given const name.
+      def const_missing(name)
+        const_set(name, Class.new(self) { include ClassSpecificRelation })
+      end
+
+      private
+      # Cache the constants in @@subclasses because looking them up via const_get
+      # make instantiation significantly slower.
+      def relation_class_for(klass)
+        if klass && (klass_name = klass.name)
+          my_cache = @@subclasses.compute_if_absent(self) { ThreadSafe::Cache.new }
+          # This hash is keyed by klass.name to avoid memory leaks in development mode
+          my_cache.compute_if_absent(klass_name) do
+            # Cache#compute_if_absent guarantees that the block will only executed once for the given klass_name
+            const_get("#{name.gsub('::', '_')}_#{klass_name.gsub('::', '_')}", false)
+          end
+        else
+          ActiveRecord::Relation
+        end
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      super || Array.method_defined?(method) ||
+        @klass.respond_to?(method, include_private) ||
+        arel.respond_to?(method, include_private)
+    end
+
+    protected
+
+    def method_missing(method, *args, &block)
+      if @klass.respond_to?(method)
+        scoping { @klass.send(method, *args, &block) }
+      elsif Array.method_defined?(method)
+        to_a.send(method, *args, &block)
+      elsif arel.respond_to?(method)
+        arel.send(method, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/active_record/relation/finder_methods.rb

@@ -1,150 +1,137 @@
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/indifferent_access'
-
 module ActiveRecord
   module FinderMethods
-    # Find operates with four different retrieval approaches:
-    #
-    # * Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
-    #   If no record can be found for all of the listed ids, then RecordNotFound will be raised.
-    # * Find first - This will return the first record matched by the options used. These options can either be specific
-    #   conditions or merely an order. If no record can be matched, +nil+ is returned. Use
-    #   <tt>Model.find(:first, *args)</tt> or its shortcut <tt>Model.first(*args)</tt>.
-    # * Find last - This will return the last record matched by the options used. These options can either be specific
-    #   conditions or merely an order. If no record can be matched, +nil+ is returned. Use
-    #   <tt>Model.find(:last, *args)</tt> or its shortcut <tt>Model.last(*args)</tt>.
-    # * Find all - This will return all the records matched by the options used.
-    #   If no records are found, an empty array is returned. Use
-    #   <tt>Model.find(:all, *args)</tt> or its shortcut <tt>Model.all(*args)</tt>.
-    #
-    # All approaches accept an options hash as their last parameter.
-    #
-    # ==== Parameters
-    #
-    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>[ "user_name = ?", username ]</tt>,
-    #   or <tt>["user_name = :user_name", { :user_name => user_name }]</tt>. See conditions in the intro.
-    # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name".
-    # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the <tt>GROUP BY</tt> SQL-clause.
-    # * <tt>:having</tt> - Combined with +:group+ this can be used to filter the records that a
-    #   <tt>GROUP BY</tt> returns. Uses the <tt>HAVING</tt> SQL-clause.
-    # * <tt>:limit</tt> - An integer determining the limit on the number of rows that should be returned.
-    # * <tt>:offset</tt> - An integer determining the offset from where the rows should be fetched. So at 5,
-    #   it would skip rows 0 through 4.
-    # * <tt>:joins</tt> - Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed),
-    #   named associations in the same form used for the <tt>:include</tt> option, which will perform an
-    #   <tt>INNER JOIN</tt> on the associated table(s),
-    #   or an array containing a mixture of both strings and named associations.
-    #   If the value is a string, then the records will be returned read-only since they will
-    #   have attributes that do not correspond to the table's columns.
-    #   Pass <tt>:readonly => false</tt> to override.
-    # * <tt>:include</tt> - Names associations that should be loaded alongside. The symbols named refer
-    #   to already defined associations. See eager loading under Associations.
-    # * <tt>:select</tt> - By default, this is "*" as in "SELECT * FROM", but can be changed if you,
-    #   for example, want to do a join but not include the joined columns. Takes a string with the SELECT SQL fragment (e.g. "id, name").
-    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed
-    #   to an alternate table name (or even the name of a database view).
-    # * <tt>:readonly</tt> - Mark the returned records read-only so they cannot be saved or updated.
-    # * <tt>:lock</tt> - An SQL fragment like "FOR UPDATE" or "LOCK IN SHARE MODE".
-    #   <tt>:lock => true</tt> gives connection's default exclusive lock, usually "FOR UPDATE".
+    # Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
+    # If no record can be found for all of the listed ids, then RecordNotFound will be raised. If the primary key
+    # is an integer, find by id coerces its arguments using +to_i+.
     #
-    # ==== Examples
-    #
-    #   # find by id
     #   Person.find(1)       # returns the object for ID = 1
+    #   Person.find("1")     # returns the object for ID = 1
     #   Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6)
     #   Person.find([7, 17]) # returns an array for objects with IDs in (7, 17)
     #   Person.find([1])     # returns an array for the object with ID = 1
-    #   Person.find(1, :conditions => "administrator = 1", :order => "created_on DESC")
+    #   Person.where("administrator = 1").order("created_on DESC").find(1)
     #
     # Note that returned records may not be in the same order as the ids you
-    # provide since database rows are unordered. Give an explicit <tt>:order</tt>
+    # provide since database rows are unordered. Give an explicit <tt>order</tt>
     # to ensure the results are sorted.
     #
-    # ==== Examples
-    #
-    #   # find first
-    #   Person.find(:first) # returns the first object fetched by SELECT * FROM people
-    #   Person.find(:first, :conditions => [ "user_name = ?", user_name])
-    #   Person.find(:first, :conditions => [ "user_name = :u", { :u => user_name }])
-    #   Person.find(:first, :order => "created_on DESC", :offset => 5)
-    #
-    #   # find last
-    #   Person.find(:last) # returns the last object fetched by SELECT * FROM people
-    #   Person.find(:last, :conditions => [ "user_name = ?", user_name])
-    #   Person.find(:last, :order => "created_on DESC", :offset => 5)
-    #
-    #   # find all
-    #   Person.find(:all) # returns an array of objects for all the rows fetched by SELECT * FROM people
-    #   Person.find(:all, :conditions => [ "category IN (?)", categories], :limit => 50)
-    #   Person.find(:all, :conditions => { :friends => ["Bob", "Steve", "Fred"] }
-    #   Person.find(:all, :offset => 10, :limit => 10)
-    #   Person.find(:all, :include => [ :account, :friends ])
-    #   Person.find(:all, :group => "category")
+    # ==== Find with lock
     #
     # Example for find with a lock: Imagine two concurrent transactions:
     # each will read <tt>person.visits == 2</tt>, add 1 to it, and save, resulting
-    # in two saves of <tt>person.visits = 3</tt>.  By locking the row, the second
+    # in two saves of <tt>person.visits = 3</tt>. By locking the row, the second
     # transaction has to wait until the first is finished; we get the
     # expected <tt>person.visits == 4</tt>.
     #
     #   Person.transaction do
-    #     person = Person.find(1, :lock => true)
+    #     person = Person.lock(true).find(1)
     #     person.visits += 1
     #     person.save!
     #   end
     def find(*args)
-      return to_a.find { |*block_args| yield(*block_args) } if block_given?
-
-      options = args.extract_options!
-
-      if options.present?
-        apply_finder_options(options).find(*args)
+      if block_given?
+        to_a.find { |*block_args| yield(*block_args) }
       else
-        case args.first
-        when :first, :last, :all
-          send(args.first)
-        else
-          find_with_ids(*args)
-        end
+        find_with_ids(*args)
       end
     end
 
-    # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass in all the
-    # same arguments to this method as you can to <tt>find(:first)</tt>.
-    def first(*args)
-      if args.any?
-        if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
-          to_a.first(*args)
+    # Finds the first record matching the specified conditions. There
+    # is no implied ordering so if order matters, you should specify it
+    # yourself.
+    #
+    # If no record is found, returns <tt>nil</tt>.
+    #
+    #   Post.find_by name: 'Spartacus', rating: 4
+    #   Post.find_by "published_at < ?", 2.weeks.ago
+    def find_by(*args)
+      where(*args).take
+    end
+
+    # Like <tt>find_by</tt>, except that if no record is found, raises
+    # an <tt>ActiveRecord::RecordNotFound</tt> error.
+    def find_by!(*args)
+      where(*args).take!
+    end
+
+    # Gives a record (or N records if a parameter is supplied) without any implied
+    # order. The order will depend on the database implementation.
+    # If an order is supplied it will be respected.
+    #
+    #   Person.take # returns an object fetched by SELECT * FROM people LIMIT 1
+    #   Person.take(5) # returns 5 objects fetched by SELECT * FROM people LIMIT 5
+    #   Person.where(["name LIKE '%?'", name]).take
+    def take(limit = nil)
+      limit ? limit(limit).to_a : find_take
+    end
+
+    # Same as +take+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found. Note that <tt>take!</tt> accepts no arguments.
+    def take!
+      take or raise RecordNotFound
+    end
+
+    # Find the first record (or first N records if a parameter is supplied).
+    # If no order is defined it will order by primary key.
+    #
+    #   Person.first # returns the first object fetched by SELECT * FROM people
+    #   Person.where(["user_name = ?", user_name]).first
+    #   Person.where(["user_name = :u", { u: user_name }]).first
+    #   Person.order("created_on DESC").offset(5).first
+    #   Person.first(3) # returns the first three objects fetched by SELECT * FROM people LIMIT 3
+    def first(limit = nil)
+      if limit
+        if order_values.empty? && primary_key
+          order(arel_table[primary_key].asc).limit(limit).to_a
         else
-          apply_finder_options(args.first).first
+          limit(limit).to_a
         end
       else
         find_first
       end
     end
 
-    # A convenience wrapper for <tt>find(:last, *args)</tt>. You can pass in all the
-    # same arguments to this method as you can to <tt>find(:last)</tt>.
-    def last(*args)
-      if args.any?
-        if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
-          to_a.last(*args)
+    # Same as +first+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found. Note that <tt>first!</tt> accepts no arguments.
+    def first!
+      first or raise RecordNotFound
+    end
+
+    # Find the last record (or last N records if a parameter is supplied).
+    # If no order is defined it will order by primary key.
+    #
+    #   Person.last # returns the last object fetched by SELECT * FROM people
+    #   Person.where(["user_name = ?", user_name]).last
+    #   Person.order("created_on DESC").offset(5).last
+    #   Person.last(3) # returns the last three objects fetched by SELECT * FROM people.
+    #
+    # Take note that in that last case, the results are sorted in ascending order:
+    #
+    #   [#<Person id:2>, #<Person id:3>, #<Person id:4>]
+    #
+    # and not:
+    #
+    #   [#<Person id:4>, #<Person id:3>, #<Person id:2>]
+    def last(limit = nil)
+      if limit
+        if order_values.empty? && primary_key
+          order(arel_table[primary_key].desc).limit(limit).reverse
         else
-          apply_finder_options(args.first).last
+          to_a.last(limit)
         end
       else
         find_last
       end
     end
 
-    # A convenience wrapper for <tt>find(:all, *args)</tt>. You can pass in all the
-    # same arguments to this method as you can to <tt>find(:all)</tt>.
-    def all(*args)
-      args.any? ? apply_finder_options(args.first).to_a : to_a
+    # Same as +last+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found. Note that <tt>last!</tt> accepts no arguments.
+    def last!
+      last or raise RecordNotFound
     end
 
-    # Returns true if a record exists in the table that matches the +id+ or
-    # conditions given, or false otherwise. The argument can take five forms:
+    # Returns truthy if a record exists in the table that matches the +id+ or
+    # conditions given, or falsy otherwise. The argument can take six forms:
     #
     # * Integer - Finds the record with this primary key.
     # * String - Finds the record with a primary key corresponding to this
@@ -152,8 +139,9 @@ module ActiveRecord
     # * Array - Finds the record that matches these +find+-style conditions
     #   (such as <tt>['color = ?', 'red']</tt>).
     # * Hash - Finds the record that matches these +find+-style conditions
-    #   (such as <tt>{:color => 'red'}</tt>).
-    # * No args - Returns false if the table is empty, true otherwise.
+    #   (such as <tt>{color: 'red'}</tt>).
+    # * +false+ - Returns always +false+.
+    # * No args - Returns +false+ if the table is empty, +true+ otherwise.
     #
     # For more information about specifying conditions as a Hash or Array,
     # see the Conditions section in the introduction to ActiveRecord::Base.
@@ -162,50 +150,84 @@ module ActiveRecord
     # 'Jamie'</tt>), since it would be sanitized and then queried against
     # the primary key column, like <tt>id = 'name = \'Jamie\''</tt>.
     #
-    # ==== Examples
     #   Person.exists?(5)
     #   Person.exists?('5')
-    #   Person.exists?(:name => "David")
     #   Person.exists?(['name LIKE ?', "%#{query}%"])
+    #   Person.exists?(name: 'David')
+    #   Person.exists?(false)
     #   Person.exists?
-    def exists?(id = nil)
-      id = id.id if ActiveRecord::Base === id
+    def exists?(conditions = :none)
+      conditions = conditions.id if Base === conditions
+      return false if !conditions
+
+      join_dependency = construct_join_dependency_for_association_find
+      relation = construct_relation_for_association_find(join_dependency)
+      relation = relation.except(:select, :order).select("1 AS one").limit(1)
 
-      case id
+      case conditions
       when Array, Hash
-        where(id).exists?
+        relation = relation.where(conditions)
+      else
+        relation = relation.where(table[primary_key].eq(conditions)) if conditions != :none
+      end
+
+      connection.select_value(relation, "#{name} Exists", relation.bind_values)
+    rescue ThrowResult
+      false
+    end
+
+    # This method is called whenever no records are found with either a single
+    # id or multiple ids and raises a +ActiveRecord::RecordNotFound+ exception.
+    #
+    # The error message is different depending on whether a single id or
+    # multiple ids are provided. If multiple ids are provided, then the number
+    # of results obtained should be provided in the +result_size+ argument and
+    # the expected number of results should be provided in the +expected_size+
+    # argument.
+    def raise_record_not_found_exception!(ids, result_size, expected_size) #:nodoc:
+      conditions = arel.where_sql
+      conditions = " [#{conditions}]" if conditions
+
+      if Array(ids).size == 1
+        error = "Couldn't find #{@klass.name} with #{primary_key}=#{ids}#{conditions}"
       else
-        relation = select(primary_key).limit(1)
-        relation = relation.where(primary_key.eq(id)) if id
-        relation.first ? true : false
+        error = "Couldn't find all #{@klass.name.pluralize} with IDs "
+        error << "(#{ids.join(", ")})#{conditions} (found #{result_size} results, but was looking for #{expected_size})"
       end
+
+      raise RecordNotFound, error
     end
 
     protected
 
     def find_with_associations
-      including = (@eager_load_values + @includes_values).uniq
-      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, nil)
-      rows = construct_relation_for_association_find(join_dependency).to_a
+      join_dependency = construct_join_dependency_for_association_find
+      relation = construct_relation_for_association_find(join_dependency)
+      rows = connection.select_all(relation, 'SQL', relation.bind_values.dup)
       join_dependency.instantiate(rows)
     rescue ThrowResult
       []
     end
 
+    def construct_join_dependency_for_association_find
+      including = (eager_load_values + includes_values).uniq
+      ActiveRecord::Associations::JoinDependency.new(@klass, including, [])
+    end
+
     def construct_relation_for_association_calculations
-      including = (@eager_load_values + @includes_values).uniq
-      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, arel.joins(arel))
+      including = (eager_load_values + includes_values).uniq
+      join_dependency = ActiveRecord::Associations::JoinDependency.new(@klass, including, arel.froms.first)
       relation = except(:includes, :eager_load, :preload)
       apply_join_dependency(relation, join_dependency)
     end
 
     def construct_relation_for_association_find(join_dependency)
-      relation = except(:includes, :eager_load, :preload, :select).select(column_aliases(join_dependency))
+      relation = except(:includes, :eager_load, :preload, :select).select(join_dependency.columns)
       apply_join_dependency(relation, join_dependency)
     end
 
     def apply_join_dependency(relation, join_dependency)
-      for association in join_dependency.join_associations
+      join_dependency.join_associations.each do |association|
         relation = association.join_relation(relation)
       end
 
@@ -222,53 +244,18 @@ module ActiveRecord
     end
 
     def construct_limited_ids_condition(relation)
-      orders = relation.order_values.join(", ")
-      values = @klass.connection.distinct("#{@klass.connection.quote_table_name @klass.table_name}.#{@klass.primary_key}", orders)
-
-      ids_array = relation.select(values).collect {|row| row[@klass.primary_key]}
-      ids_array.empty? ? raise(ThrowResult) : primary_key.in(ids_array)
-    end
-
-    def find_by_attributes(match, attributes, *args)
-      conditions = attributes.inject({}) {|h, a| h[a] = args[attributes.index(a)]; h}
-      result = where(conditions).send(match.finder)
-
-      if match.bang? && result.blank?
-        raise RecordNotFound, "Couldn't find #{@klass.name} with #{conditions.to_a.collect {|p| p.join(' = ')}.join(', ')}"
-      else
-        result
-      end
-    end
-
-    def find_or_instantiator_by_attributes(match, attributes, *args)
-      protected_attributes_for_create, unprotected_attributes_for_create = {}, {}
-      args.each_with_index do |arg, i|
-        if arg.is_a?(Hash)
-          protected_attributes_for_create = args[i].with_indifferent_access
-        else
-          unprotected_attributes_for_create[attributes[i]] = args[i]
-        end
-      end
+      orders = relation.order_values.map { |val| val.presence }.compact
+      values = @klass.connection.distinct("#{quoted_table_name}.#{primary_key}", orders)
 
-      conditions = (protected_attributes_for_create.merge(unprotected_attributes_for_create)).slice(*attributes).symbolize_keys
+      relation = relation.dup.select(values)
 
-      record = where(conditions).first
+      id_rows = @klass.connection.select_all(relation.arel, 'SQL', relation.bind_values)
+      ids_array = id_rows.map {|row| row[primary_key]}
 
-      unless record
-        record = @klass.new do |r|
-          r.send(:attributes=, protected_attributes_for_create, true) unless protected_attributes_for_create.empty?
-          r.send(:attributes=, unprotected_attributes_for_create, false) unless unprotected_attributes_for_create.empty?
-        end
-        yield(record) if block_given?
-        record.save if match.instantiator == :create
-      end
-
-      record
+      ids_array.empty? ? raise(ThrowResult) : table[primary_key].in(ids_array)
     end
 
     def find_with_ids(*ids)
-      return to_a.find { |*block_args| yield(*block_args) } if block_given?
-
       expects_array = ids.first.kind_of?(Array)
       return ids.first if expects_array && ids.first.empty?
 
@@ -288,41 +275,44 @@ module ActiveRecord
     def find_one(id)
       id = id.id if ActiveRecord::Base === id
 
-      record = where(primary_key.eq(id)).first
+      column = columns_hash[primary_key]
+      substitute = connection.substitute_at(column, bind_values.length)
+      relation = where(table[primary_key].eq(substitute))
+      relation.bind_values += [[column, id]]
+      record = relation.take
 
-      unless record
-        conditions = arel.wheres.map { |x| x.value }.join(', ')
-        conditions = " [WHERE #{conditions}]" if conditions.present?
-        raise RecordNotFound, "Couldn't find #{@klass.name} with ID=#{id}#{conditions}"
-      end
+      raise_record_not_found_exception!(id, 0, 1) unless record
 
       record
     end
 
     def find_some(ids)
-      result = where(primary_key.in(ids)).all
+      result = where(table[primary_key].in(ids)).to_a
 
       expected_size =
-        if @limit_value && ids.size > @limit_value
-          @limit_value
+        if limit_value && ids.size > limit_value
+          limit_value
         else
           ids.size
         end
 
       # 11 ids with limit 3, offset 9 should give 2 results.
-      if @offset_value && (ids.size - @offset_value < expected_size)
-        expected_size = ids.size - @offset_value
+      if offset_value && (ids.size - offset_value < expected_size)
+        expected_size = ids.size - offset_value
       end
 
       if result.size == expected_size
         result
       else
-        conditions = arel.wheres.map { |x| x.value }.join(', ')
-        conditions = " [WHERE #{conditions}]" if conditions.present?
+        raise_record_not_found_exception!(ids, result.size, expected_size)
+      end
+    end
 
-        error = "Couldn't find all #{@klass.name.pluralize} with IDs "
-        error << "(#{ids.join(", ")})#{conditions} (found #{result.size} results, but was looking for #{expected_size})"
-        raise RecordNotFound, error
+    def find_take
+      if loaded?
+        @records.first
+      else
+        @take ||= limit(1).to_a.first
       end
     end
 
@@ -330,7 +320,12 @@ module ActiveRecord
       if loaded?
         @records.first
       else
-        @first ||= limit(1).to_a[0]
+        @first ||=
+          if with_default_scope.order_values.empty? && primary_key
+            order(arel_table[primary_key].asc).limit(1).to_a.first
+          else
+            limit(1).to_a.first
+          end
       end
     end
 
@@ -338,18 +333,17 @@ module ActiveRecord
       if loaded?
         @records.last
       else
-        @last ||= reverse_order.limit(1).to_a[0]
+        @last ||=
+          if offset_value || limit_value
+            to_a.last
+          else
+            reverse_order.limit(1).to_a.first
+          end
       end
     end
 
-    def column_aliases(join_dependency)
-      join_dependency.joins.collect{|join| join.column_names_with_alias.collect{|column_name, aliased_name|
-          "#{connection.quote_table_name join.aliased_table_name}.#{connection.quote_column_name column_name} AS #{aliased_name}"}}.flatten.join(", ")
-    end
-
     def using_limitable_reflections?(reflections)
       reflections.none? { |r| r.collection? }
     end
-
   end
 end