activerecord 5.2.3 → 6.1.0

data/lib/active_record/relation/finder_methods.rb

@@ -7,8 +7,8 @@ module ActiveRecord
     ONE_AS_ONE = "1 AS one"
 
     # 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 one or more records can not be found for the requested ids, then RecordNotFound will be raised. If the primary key
-    # is an integer, find by id coerces its arguments using +to_i+.
+    # If one or more records cannot be found for the requested ids, then ActiveRecord::RecordNotFound will be raised.
+    # If the primary key is an integer, find by id coerces its arguments by using +to_i+.
     #
     #   Person.find(1)          # returns the object for ID = 1
     #   Person.find("1")        # returns the object for ID = 1
@@ -79,17 +79,12 @@ module ActiveRecord
     #   Post.find_by "published_at < ?", 2.weeks.ago
     def find_by(arg, *args)
       where(arg, *args).take
-    rescue ::RangeError
-      nil
     end
 
     # Like #find_by, except that if no record is found, raises
     # an ActiveRecord::RecordNotFound error.
     def find_by!(arg, *args)
       where(arg, *args).take!
-    rescue ::RangeError
-      raise RecordNotFound.new("Couldn't find #{@klass.name} with an out of range value",
-                               @klass.name, @klass.primary_key)
     end
 
     # Gives a record (or N records if a parameter is supplied) without any implied
@@ -119,6 +114,8 @@ module ActiveRecord
     #   Person.first(3) # returns the first three objects fetched by SELECT * FROM people ORDER BY people.id LIMIT 3
     #
     def first(limit = nil)
+      check_reorder_deprecation unless loaded?
+
       if limit
         find_nth_with_limit(0, limit)
       else
@@ -280,9 +277,9 @@ module ActiveRecord
     # * Integer - Finds the record with this primary key.
     # * String - Finds the record with a primary key corresponding to this
     #   string (such as <tt>'5'</tt>).
-    # * Array - Finds the record that matches these +find+-style conditions
+    # * Array - Finds the record that matches these +where+-style conditions
     #   (such as <tt>['name LIKE ?', "%#{query}%"]</tt>).
-    # * Hash - Finds the record that matches these +find+-style conditions
+    # * Hash - Finds the record that matches these +where+-style conditions
     #   (such as <tt>{name: 'David'}</tt>).
     # * +false+ - Returns always +false+.
     # * No args - Returns +false+ if the relation is empty, +true+ otherwise.
@@ -318,12 +315,26 @@ module ActiveRecord
       end
 
       relation = construct_relation_for_exists(conditions)
+      return false if relation.where_clause.contradiction?
+
+      skip_query_cache_if_necessary { connection.select_rows(relation.arel, "#{name} Exists?").size == 1 }
+    end
 
-      skip_query_cache_if_necessary { connection.select_one(relation.arel, "#{name} Exists") } ? true : false
-    rescue ::RangeError
-      false
+    # Returns true if the relation contains the given record or false otherwise.
+    #
+    # No query is performed if the relation is loaded; the given record is
+    # compared to the records in memory. If the relation is unloaded, an
+    # efficient existence query is performed, as in #exists?.
+    def include?(record)
+      if loaded? || offset_value || limit_value
+        records.include?(record)
+      else
+        record.is_a?(klass) && exists?(record.id)
+      end
     end
 
+    alias :member? :include?
+
     # This method is called whenever no records are found with either a single
     # id or multiple ids and raises an ActiveRecord::RecordNotFound exception.
     #
@@ -333,19 +344,19 @@ module ActiveRecord
     # the expected number of results should be provided in the +expected_size+
     # argument.
     def raise_record_not_found_exception!(ids = nil, result_size = nil, expected_size = nil, key = primary_key, not_found_ids = nil) # :nodoc:
-      conditions = arel.where_sql(@klass)
-      conditions = " [#{conditions}]" if conditions
+      conditions = " [#{arel.where_sql(klass)}]" unless where_clause.empty?
+
       name = @klass.name
 
       if ids.nil?
-        error = "Couldn't find #{name}".dup
+        error = +"Couldn't find #{name}"
         error << " with#{conditions}" if conditions
         raise RecordNotFound.new(error, name, key)
-      elsif Array(ids).size == 1
+      elsif Array.wrap(ids).size == 1
         error = "Couldn't find #{name} with '#{key}'=#{ids}#{conditions}"
         raise RecordNotFound.new(error, name, key, ids)
       else
-        error = "Couldn't find all #{name.pluralize} with '#{key}': ".dup
+        error = +"Couldn't find all #{name.pluralize} with '#{key}': "
         error << "(#{ids.join(", ")})#{conditions} (found #{result_size} results, but was looking for #{expected_size})."
         error << " Couldn't find #{name.pluralize(not_found_ids.size)} with #{key.to_s.pluralize(not_found_ids.size)} #{not_found_ids.join(', ')}." if not_found_ids
         raise RecordNotFound.new(error, name, key, ids)
@@ -353,14 +364,22 @@ module ActiveRecord
     end
 
     private
-
-      def offset_index
-        offset_value || 0
+      def check_reorder_deprecation
+        if !order_values.empty? && order_values.all?(&:blank?)
+          blank_value = order_values.first
+          ActiveSupport::Deprecation.warn(<<~MSG.squish)
+            `.reorder(#{blank_value.inspect})` with `.first` / `.first!` no longer
+            takes non-deterministic result in Rails 6.2.
+            To continue taking non-deterministic result, use `.take` / `.take!` instead.
+          MSG
+        end
       end
 
       def construct_relation_for_exists(conditions)
+        conditions = sanitize_forbidden_attributes(conditions)
+
         if distinct_value && offset_value
-          relation = limit(1)
+          relation = except(:order).limit!(1)
         else
           relation = except(:select, :distinct, :order)._select!(ONE_AS_ONE).limit!(1)
         end
@@ -375,18 +394,22 @@ module ActiveRecord
         relation
       end
 
-      def construct_join_dependency
-        including = eager_load_values + includes_values
-        ActiveRecord::Associations::JoinDependency.new(
-          klass, table, including
-        )
-      end
-
       def apply_join_dependency(eager_loading: group_values.empty?)
-        join_dependency = construct_join_dependency
+        join_dependency = construct_join_dependency(
+          eager_load_values | includes_values, Arel::Nodes::OuterJoin
+        )
         relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
 
-        if eager_loading && !using_limitable_reflections?(join_dependency.reflections)
+        if eager_loading && !(
+            using_limitable_reflections?(join_dependency.reflections) &&
+            using_limitable_reflections?(
+              construct_join_dependency(
+                select_association_list(joins_values).concat(
+                  select_association_list(left_outer_joins_values)
+                ), nil
+              ).reflections
+            )
+        )
           if has_limit_or_offset?
             limited_ids = limited_ids_for(relation)
             limited_ids.empty? ? relation.none! : relation.where!(primary_key => limited_ids)
@@ -403,14 +426,14 @@ module ActiveRecord
 
       def limited_ids_for(relation)
         values = @klass.connection.columns_for_distinct(
-          connection.column_name_from_arel_node(arel_attribute(primary_key)),
+          connection.visitor.compile(table[primary_key]),
           relation.order_values
         )
 
         relation = relation.except(:select).select(values).distinct!
 
-        id_rows = skip_query_cache_if_necessary { @klass.connection.select_all(relation.arel, "SQL") }
-        id_rows.map { |row| row[primary_key] }
+        id_rows = skip_query_cache_if_necessary { @klass.connection.select_rows(relation.arel, "SQL") }
+        id_rows.map(&:last)
       end
 
       def using_limitable_reflections?(reflections)
@@ -437,9 +460,6 @@ module ActiveRecord
         else
           find_some(ids)
         end
-      rescue ::RangeError
-        error_message = "Couldn't find #{model_name} with an out of range ID"
-        raise RecordNotFound.new(error_message, model_name, primary_key, ids)
       end
 
       def find_one(id)
@@ -514,7 +534,8 @@ module ActiveRecord
       end
 
       def find_nth(index)
-        @offsets[offset_index + index] ||= find_nth_with_limit(index, 1).first
+        @offsets ||= {}
+        @offsets[index] ||= find_nth_with_limit(index, 1).first
       end
 
       def find_nth_with_limit(index, limit)
@@ -528,7 +549,7 @@ module ActiveRecord
           end
 
           if limit > 0
-            relation = relation.offset(offset_index + index) unless index.zero?
+            relation = relation.offset((offset_value || 0) + index) unless index.zero?
             relation.limit(limit).to_a
           else
             []
@@ -555,8 +576,12 @@ module ActiveRecord
       end
 
       def ordered_relation
-        if order_values.empty? && primary_key
-          order(arel_attribute(primary_key).asc)
+        if order_values.empty? && (implicit_order_column || primary_key)
+          if implicit_order_column && primary_key && implicit_order_column != primary_key
+            order(table[implicit_order_column].asc, table[primary_key].asc)
+          else
+            order(table[implicit_order_column || primary_key].asc)
+          end
         else
           self
         end

data/lib/active_record/relation/from_clause.rb

@@ -18,8 +18,12 @@ module ActiveRecord
         value.nil?
       end
 
+      def ==(other)
+        self.class == other.class && value == other.value && name == other.name
+      end
+
       def self.empty
-        @empty ||= new(nil, nil)
+        @empty ||= new(nil, nil).freeze
       end
     end
   end

data/lib/active_record/relation/merger.rb

@@ -7,15 +7,16 @@ module ActiveRecord
     class HashMerger # :nodoc:
       attr_reader :relation, :hash
 
-      def initialize(relation, hash)
+      def initialize(relation, hash, rewhere = nil)
         hash.assert_valid_keys(*Relation::VALUE_METHODS)
 
         @relation = relation
         @hash     = hash
+        @rewhere  = rewhere
       end
 
-      def merge #:nodoc:
-        Merger.new(relation, other).merge
+      def merge
+        Merger.new(relation, other, @rewhere).merge
       end
 
       # Applying values to a relation has some side effects. E.g.
@@ -28,19 +29,14 @@ module ActiveRecord
           table: relation.table,
           predicate_builder: relation.predicate_builder
         )
-        hash.each { |k, v|
-          if k == :joins
-            if Hash === v
-              other.joins!(v)
-            else
-              other.joins!(*v)
-            end
-          elsif k == :select
-            other._select!(v)
+        hash.each do |k, v|
+          k = :_select if k == :select
+          if Array === v
+            other.public_send("#{k}!", *v)
           else
-            other.send("#{k}!", v)
+            other.public_send("#{k}!", v)
           end
-        }
+        end
         other
       end
     end
@@ -48,10 +44,11 @@ module ActiveRecord
     class Merger # :nodoc:
       attr_reader :relation, :values, :other
 
-      def initialize(relation, other)
+      def initialize(relation, other, rewhere = nil)
         @relation = relation
         @values   = other.values
         @other    = other
+        @rewhere  = rewhere
       end
 
       NORMAL_VALUES = Relation::VALUE_METHODS -
@@ -73,7 +70,7 @@ module ActiveRecord
             if name == :select
               relation._select!(*value)
             else
-              relation.send("#{name}!", *value)
+              relation.public_send("#{name}!", *value)
             end
           end
         end
@@ -89,13 +86,12 @@ module ActiveRecord
       end
 
       private
-
         def merge_preloads
           return if other.preload_values.empty? && other.includes_values.empty?
 
           if other.klass == relation.klass
-            relation.preload!(*other.preload_values) unless other.preload_values.empty?
-            relation.includes!(other.includes_values) unless other.includes_values.empty?
+            relation.preload_values |= other.preload_values unless other.preload_values.empty?
+            relation.includes_values |= other.includes_values unless other.includes_values.empty?
           else
             reflection = relation.klass.reflect_on_all_associations.find do |r|
               r.class_name == other.klass.name
@@ -112,44 +108,40 @@ module ActiveRecord
         end
 
         def merge_joins
-          return if other.joins_values.blank?
+          return if other.joins_values.empty?
 
           if other.klass == relation.klass
-            relation.joins!(*other.joins_values)
+            relation.joins_values |= other.joins_values
           else
-            joins_dependency = other.joins_values.map do |join|
+            associations, others = other.joins_values.partition do |join|
               case join
-              when Hash, Symbol, Array
-                ActiveRecord::Associations::JoinDependency.new(
-                  other.klass, other.table, join
-                )
-              else
-                join
+              when Hash, Symbol, Array; true
               end
             end
 
-            relation.joins!(*joins_dependency)
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::InnerJoin
+            )
+            relation.joins!(join_dependency, *others)
           end
         end
 
         def merge_outer_joins
-          return if other.left_outer_joins_values.blank?
+          return if other.left_outer_joins_values.empty?
 
           if other.klass == relation.klass
-            relation.left_outer_joins!(*other.left_outer_joins_values)
+            relation.left_outer_joins_values |= other.left_outer_joins_values
           else
-            joins_dependency = other.left_outer_joins_values.map do |join|
+            associations, others = other.left_outer_joins_values.partition do |join|
               case join
-              when Hash, Symbol, Array
-                ActiveRecord::Associations::JoinDependency.new(
-                  other.klass, other.table, join
-                )
-              else
-                join
+              when Hash, Symbol, Array; true
               end
             end
 
-            relation.left_outer_joins!(*joins_dependency)
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::OuterJoin
+            )
+            relation.left_outer_joins!(join_dependency, *others)
           end
         end
 
@@ -177,7 +169,7 @@ module ActiveRecord
         def merge_clauses
           relation.from_clause = other.from_clause if replace_from_clause?
 
-          where_clause = relation.where_clause.merge(other.where_clause)
+          where_clause = relation.where_clause.merge(other.where_clause, @rewhere)
           relation.where_clause = where_clause unless where_clause.empty?
 
           having_clause = relation.having_clause.merge(other.having_clause)

data/lib/active_record/relation/predicate_builder/array_handler.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/array/extract"
+
 module ActiveRecord
   class PredicateBuilder
     class ArrayHandler # :nodoc:
@@ -11,31 +13,29 @@ module ActiveRecord
         return attribute.in([]) if value.empty?
 
         values = value.map { |x| x.is_a?(Base) ? x.id : x }
-        nils, values = values.partition(&:nil?)
-        ranges, values = values.partition { |v| v.is_a?(Range) }
+        nils = values.extract!(&:nil?)
+        ranges = values.extract! { |v| v.is_a?(Range) }
 
         values_predicate =
           case values.length
           when 0 then NullPredicate
           when 1 then predicate_builder.build(attribute, values.first)
-          else
-            values.map! do |v|
-              predicate_builder.build_bind_attribute(attribute.name, v)
-            end
-            values.empty? ? NullPredicate : attribute.in(values)
+          else Arel::Nodes::HomogeneousIn.new(values, attribute, :in)
           end
 
         unless nils.empty?
-          values_predicate = values_predicate.or(predicate_builder.build(attribute, nil))
+          values_predicate = values_predicate.or(attribute.eq(nil))
         end
 
-        array_predicates = ranges.map { |range| predicate_builder.build(attribute, range) }
-        array_predicates.unshift(values_predicate)
-        array_predicates.inject(&:or)
+        if ranges.empty?
+          values_predicate
+        else
+          array_predicates = ranges.map! { |range| predicate_builder.build(attribute, range) }
+          array_predicates.inject(values_predicate, &:or)
+        end
       end
 
-      protected
-
+      private
         attr_reader :predicate_builder
 
         module NullPredicate # :nodoc:

data/lib/active_record/relation/predicate_builder/association_query_value.rb

@@ -9,15 +9,12 @@ module ActiveRecord
       end
 
       def queries
-        [associated_table.association_join_foreign_key.to_s => ids]
+        [associated_table.join_foreign_key => ids]
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      private
         attr_reader :associated_table, :value
 
-      private
         def ids
           case value
           when Relation
@@ -30,13 +27,12 @@ module ActiveRecord
         end
 
         def primary_key
-          associated_table.association_join_primary_key
+          associated_table.join_primary_key
         end
 
         def convert_to_id(value)
-          case value
-          when Base
-            value._read_attribute(primary_key)
+          if value.respond_to?(:id)
+            value.id
           else
             value
           end

data/lib/active_record/relation/predicate_builder/basic_object_handler.rb

@@ -12,8 +12,7 @@ module ActiveRecord
         attribute.eq(bind)
       end
 
-      protected
-
+      private
         attr_reader :predicate_builder
     end
   end

data/lib/active_record/relation/predicate_builder/polymorphic_array_value.rb

@@ -11,18 +11,15 @@ module ActiveRecord
       def queries
         type_to_ids_mapping.map do |type, ids|
           {
-            associated_table.association_foreign_type.to_s => type,
-            associated_table.association_foreign_key.to_s => ids
+            associated_table.join_foreign_type => type,
+            associated_table.join_foreign_key => ids
           }
         end
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      private
         attr_reader :associated_table, :values
 
-      private
         def type_to_ids_mapping
           default_hash = Hash.new { |hsh, key| hsh[key] = [] }
           values.each_with_object(default_hash) do |value, hash|
@@ -31,7 +28,7 @@ module ActiveRecord
         end
 
         def primary_key(value)
-          associated_table.association_join_primary_key(klass(value))
+          associated_table.join_primary_key(klass(value))
         end
 
         def klass(value)

data/lib/active_record/relation/predicate_builder/range_handler.rb

@@ -3,11 +3,7 @@
 module ActiveRecord
   class PredicateBuilder
     class RangeHandler # :nodoc:
-      class RangeWithBinds < Struct.new(:begin, :end)
-        def exclude_end?
-          false
-        end
-      end
+      RangeWithBinds = Struct.new(:begin, :end, :exclude_end?)
 
       def initialize(predicate_builder)
         @predicate_builder = predicate_builder
@@ -16,26 +12,10 @@ module ActiveRecord
       def call(attribute, value)
         begin_bind = predicate_builder.build_bind_attribute(attribute.name, value.begin)
         end_bind = predicate_builder.build_bind_attribute(attribute.name, value.end)
-
-        if begin_bind.value.infinity?
-          if end_bind.value.infinity?
-            attribute.not_in([])
-          elsif value.exclude_end?
-            attribute.lt(end_bind)
-          else
-            attribute.lteq(end_bind)
-          end
-        elsif end_bind.value.infinity?
-          attribute.gteq(begin_bind)
-        elsif value.exclude_end?
-          attribute.gteq(begin_bind).and(attribute.lt(end_bind))
-        else
-          attribute.between(RangeWithBinds.new(begin_bind, end_bind))
-        end
+        attribute.between(RangeWithBinds.new(begin_bind, end_bind, value.exclude_end?))
       end
 
-      protected
-
+      private
         attr_reader :predicate_builder
     end
   end

data/lib/active_record/relation/predicate_builder/relation_handler.rb

@@ -9,7 +9,7 @@ module ActiveRecord
         end
 
         if value.select_values.empty?
-          value = value.select(value.arel_attribute(value.klass.primary_key))
+          value = value.select(value.table[value.klass.primary_key])
         end
 
         attribute.in(value.arel)