activerecord 5.2.8.1 → 6.0.0.beta1

data/lib/active_record/relation/finder_methods.rb

@@ -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
@@ -312,6 +307,8 @@ module ActiveRecord
 
       return false if !conditions || limit_value == 0
 
+      conditions = sanitize_forbidden_attributes(conditions)
+
       if eager_loading?
         relation = apply_join_dependency(eager_loading: false)
         return relation.exists?(conditions)
@@ -319,9 +316,7 @@ module ActiveRecord
 
       relation = construct_relation_for_exists(conditions)
 
-      skip_query_cache_if_necessary { connection.select_one(relation.arel, "#{name} Exists") } ? true : false
-    rescue ::RangeError
-      false
+      skip_query_cache_if_necessary { connection.select_value(relation.arel, "#{name} Exists") } ? true : false
     end
 
     # This method is called whenever no records are found with either a single
@@ -338,14 +333,14 @@ module ActiveRecord
       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
         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)
@@ -359,11 +354,7 @@ module ActiveRecord
       end
 
       def construct_relation_for_exists(conditions)
-        if distinct_value && offset_value
-          relation = except(:order).limit!(1)
-        else
-          relation = except(:select, :distinct, :order)._select!(ONE_AS_ONE).limit!(1)
-        end
+        relation = except(:select, :distinct, :order)._select!(ONE_AS_ONE).limit!(1)
 
         case conditions
         when Array, Hash
@@ -375,15 +366,14 @@ module ActiveRecord
         relation
       end
 
-      def construct_join_dependency
-        including = eager_load_values + includes_values
+      def construct_join_dependency(associations)
         ActiveRecord::Associations::JoinDependency.new(
-          klass, table, including
+          klass, table, associations
         )
       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)
         relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
 
         if eager_loading && !using_limitable_reflections?(join_dependency.reflections)
@@ -403,7 +393,7 @@ 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(arel_attribute(primary_key)),
           relation.order_values
         )
 
@@ -437,9 +427,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)
@@ -555,8 +542,8 @@ 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)
+          order(arel_attribute(implicit_order_column || primary_key).asc)
         else
           self
         end

data/lib/active_record/relation/merger.rb

@@ -120,9 +120,7 @@ module ActiveRecord
             joins_dependency = other.joins_values.map do |join|
               case join
               when Hash, Symbol, Array
-                ActiveRecord::Associations::JoinDependency.new(
-                  other.klass, other.table, join
-                )
+                other.send(:construct_join_dependency, join)
               else
                 join
               end
@@ -141,9 +139,7 @@ module ActiveRecord
             joins_dependency = other.left_outer_joins_values.map do |join|
               case join
               when Hash, Symbol, Array
-                ActiveRecord::Associations::JoinDependency.new(
-                  other.klass, other.table, join
-                )
+                other.send(:construct_join_dependency, join)
               else
                 join
               end

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,8 +13,8 @@ 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
@@ -34,8 +36,7 @@ module ActiveRecord
         array_predicates.inject(&:or)
       end
 
-      protected
-
+      private
         attr_reader :predicate_builder
 
         module NullPredicate # :nodoc:

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

@@ -12,12 +12,9 @@ module ActiveRecord
         [associated_table.association_join_foreign_key.to_s => 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

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

@@ -11,8 +11,7 @@ module ActiveRecord
         predicate_builder.build(attribute, value.id)
       end
 
-      protected
-
+      private
         attr_reader :predicate_builder
     end
   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

@@ -17,12 +17,9 @@ module ActiveRecord
         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|

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.rb

@@ -27,7 +27,7 @@ module ActiveRecord
           key
         else
           key = key.to_s
-          key.split(".".freeze).first if key.include?(".".freeze)
+          key.split(".").first if key.include?(".")
         end
       end.compact
     end
@@ -62,9 +62,6 @@ module ActiveRecord
     end
 
     protected
-
-      attr_reader :table
-
       def expand_from_hash(attributes)
         return ["1=0"] if attributes.empty?
 
@@ -115,6 +112,7 @@ module ActiveRecord
       end
 
     private
+      attr_reader :table
 
       def associated_predicate_builder(association_name)
         self.class.new(table.associated_table(association_name))
@@ -122,11 +120,11 @@ module ActiveRecord
 
       def convert_dot_notation_to_hash(attributes)
         dot_notation = attributes.select do |k, v|
-          k.include?(".".freeze) && !v.is_a?(Hash)
+          k.include?(".") && !v.is_a?(Hash)
         end
 
         dot_notation.each_key do |key|
-          table_name, column_name = key.split(".".freeze)
+          table_name, column_name = key.split(".")
           value = attributes.delete(key)
           attributes[table_name] ||= {}
 

data/lib/active_record/relation/query_attribute.rb

@@ -18,26 +18,29 @@ module ActiveRecord
       end
 
       def nil?
-        unless value_before_type_cast.is_a?(StatementCache::Substitute)
-          value_before_type_cast.nil? ||
-            type.respond_to?(:subtype, true) && value_for_database.nil?
-        end
+        !value_before_type_cast.is_a?(StatementCache::Substitute) &&
+          (value_before_type_cast.nil? || value_for_database.nil?)
+      rescue ::RangeError
       end
 
-      def boundable?
-        return @_boundable if defined?(@_boundable)
-        value_for_database unless value_before_type_cast.is_a?(StatementCache::Substitute)
-        @_boundable = true
+      def infinite?
+        infinity?(value_before_type_cast) || infinity?(value_for_database)
       rescue ::RangeError
-        @_boundable = false
       end
 
-      def infinity?
-        _infinity?(value_before_type_cast) || boundable? && _infinity?(value_for_database)
+      def unboundable?
+        if defined?(@_unboundable)
+          @_unboundable
+        else
+          value_for_database
+          @_unboundable = nil
+        end
+      rescue ::RangeError
+        @_unboundable = type.cast(value_before_type_cast) <=> 0
       end
 
       private
-        def _infinity?(value)
+        def infinity?(value)
           value.respond_to?(:infinite?) && value.infinite?
         end
     end

data/lib/active_record/relation/query_methods.rb

@@ -231,7 +231,11 @@ module ActiveRecord
     end
 
     def _select!(*fields) # :nodoc:
+      fields.reject!(&:blank?)
       fields.flatten!
+      fields.map! do |field|
+        klass.attribute_alias?(field) ? klass.attribute_alias(field).to_sym : field
+      end
       self.select_values += fields
       self
     end
@@ -895,26 +899,28 @@ module ActiveRecord
       self
     end
 
+    def skip_preloading! # :nodoc:
+      self.skip_preloading_value = true
+      self
+    end
+
     # Returns the Arel object associated with the relation.
     def arel(aliases = nil) # :nodoc:
       @arel ||= build_arel(aliases)
     end
 
-    # Returns a relation value with a given name
-    def get_value(name) # :nodoc:
-      @values.fetch(name, DEFAULT_VALUES[name])
-    end
-
-    protected
+    private
+      # Returns a relation value with a given name
+      def get_value(name)
+        @values.fetch(name, DEFAULT_VALUES[name])
+      end
 
       # Sets the relation value with the given name
-      def set_value(name, value) # :nodoc:
+      def set_value(name, value)
         assert_mutability!
         @values[name] = value
       end
 
-    private
-
       def assert_mutability!
         raise ImmutableRelation if @loaded
         raise ImmutableRelation if defined?(@arel) && @arel
@@ -930,7 +936,7 @@ module ActiveRecord
         arel.having(having_clause.ast) unless having_clause.empty?
         if limit_value
           limit_attribute = ActiveModel::Attribute.with_cast_value(
-            "LIMIT".freeze,
+            "LIMIT",
             connection.sanitize_limit(limit_value),
             Type.default_value,
           )
@@ -938,7 +944,7 @@ module ActiveRecord
         end
         if offset_value
           offset_attribute = ActiveModel::Attribute.with_cast_value(
-            "OFFSET".freeze,
+            "OFFSET",
             offset_value.to_i,
             Type.default_value,
           )
@@ -1017,9 +1023,7 @@ module ActiveRecord
         join_list = join_nodes + convert_join_strings_to_ast(string_joins)
         alias_tracker = alias_tracker(join_list, aliases)
 
-        join_dependency = ActiveRecord::Associations::JoinDependency.new(
-          klass, table, association_joins
-        )
+        join_dependency = construct_join_dependency(association_joins)
 
         joins = join_dependency.join_constraints(stashed_joins, join_type, alias_tracker)
         joins.each { |join| manager.from(join) }
@@ -1048,14 +1052,11 @@ module ActiveRecord
 
       def arel_columns(columns)
         columns.flat_map do |field|
-          case field
-          when Symbol
-            arel_column(field.to_s) do |attr_name|
-              connection.quote_table_name(attr_name)
-            end
-          when String
-            arel_column(field, &:itself)
-          when Proc
+          if (Symbol === field || String === field) && (klass.has_attribute?(field) || klass.attribute_alias?(field)) && !from_clause.value
+            arel_attribute(field)
+          elsif Symbol === field
+            connection.quote_table_name(field.to_s)
+          elsif Proc === field
             field.call
           else
             field
@@ -1063,21 +1064,6 @@ module ActiveRecord
         end
       end
 
-      def arel_column(field)
-        field = klass.attribute_alias(field) if klass.attribute_alias?(field)
-        from = from_clause.name || from_clause.value
-
-        if klass.columns_hash.key?(field) && (!from || table_name_matches?(from))
-          arel_attribute(field)
-        else
-          yield field
-        end
-      end
-
-      def table_name_matches?(from)
-        /(?:\A|(?<!FROM)\s)(?:\b#{table.name}\b|#{connection.quote_table_name(table.name)})(?!\.)/i.match?(from.to_s)
-      end
-
       def reverse_sql_order(order_query)
         if order_query.empty?
           return [arel_attribute(primary_key).desc] if primary_key
@@ -1144,9 +1130,9 @@ module ActiveRecord
         end
         order_args.flatten!
 
-        @klass.enforce_raw_sql_whitelist(
+        @klass.disallow_raw_sql!(
           order_args.flat_map { |a| a.is_a?(Hash) ? a.keys : a },
-          whitelist: AttributeMethods::ClassMethods::COLUMN_NAME_ORDER_WHITELIST
+          permit: AttributeMethods::ClassMethods::COLUMN_NAME_WITH_ORDER
         )
 
         validate_order_args(order_args)
@@ -1159,14 +1145,14 @@ module ActiveRecord
         order_args.map! do |arg|
           case arg
           when Symbol
-            order_column(arg.to_s).asc
+            arel_attribute(arg).asc
           when Hash
             arg.map { |field, dir|
               case field
               when Arel::Nodes::SqlLiteral
                 field.send(dir.downcase)
               else
-                order_column(field.to_s).send(dir.downcase)
+                arel_attribute(field).send(dir.downcase)
               end
             }
           else
@@ -1175,16 +1161,6 @@ module ActiveRecord
         end.flatten!
       end
 
-      def order_column(field)
-        arel_column(field) do |attr_name|
-          if attr_name == "count" && !group_values.empty?
-            arel_attribute(attr_name)
-          else
-            Arel.sql(connection.quote_table_name(attr_name))
-          end
-        end
-      end
-
       # Checks to make sure that the arguments are not blank. Note that if some
       # blank-like object were initially passed into the query method, then this
       # method will not raise an error.
@@ -1209,8 +1185,9 @@ module ActiveRecord
 
       STRUCTURAL_OR_METHODS = Relation::VALUE_METHODS - [:extending, :where, :having, :unscope, :references]
       def structurally_incompatible_values_for_or(other)
+        values = other.values
         STRUCTURAL_OR_METHODS.reject do |method|
-          get_value(method) == other.get_value(method)
+          get_value(method) == values.fetch(method, DEFAULT_VALUES[method])
         end
       end
 

data/lib/active_record/relation/where_clause.rb

@@ -125,6 +125,10 @@ module ActiveRecord
             raise ArgumentError, "Invalid argument for .where.not(), got nil."
           when Arel::Nodes::In
             Arel::Nodes::NotIn.new(node.left, node.right)
+          when Arel::Nodes::IsNotDistinctFrom
+            Arel::Nodes::IsDistinctFrom.new(node.left, node.right)
+          when Arel::Nodes::IsDistinctFrom
+            Arel::Nodes::IsNotDistinctFrom.new(node.left, node.right)
           when Arel::Nodes::Equality
             Arel::Nodes::NotEqual.new(node.left, node.right)
           when String

data/lib/active_record/relation/where_clause_factory.rb

@@ -26,8 +26,7 @@ module ActiveRecord
         WhereClause.new(parts)
       end
 
-      protected
-
+      private
         attr_reader :klass, :predicate_builder
     end
   end