activerecord 5.2.5 → 6.0.0.beta1

data/lib/active_record/relation/batches.rb

@@ -251,25 +251,28 @@ module ActiveRecord
           end
         end
 
-        attr = Relation::QueryAttribute.new(primary_key, primary_key_offset, klass.type_for_attribute(primary_key))
-        batch_relation = relation.where(arel_attribute(primary_key).gt(Arel::Nodes::BindParam.new(attr)))
+        batch_relation = relation.where(
+          bind_attribute(primary_key, primary_key_offset) { |attr, bind| attr.gt(bind) }
+        )
       end
     end
 
     private
 
       def apply_limits(relation, start, finish)
-        if start
-          attr = Relation::QueryAttribute.new(primary_key, start, klass.type_for_attribute(primary_key))
-          relation = relation.where(arel_attribute(primary_key).gteq(Arel::Nodes::BindParam.new(attr)))
-        end
-        if finish
-          attr = Relation::QueryAttribute.new(primary_key, finish, klass.type_for_attribute(primary_key))
-          relation = relation.where(arel_attribute(primary_key).lteq(Arel::Nodes::BindParam.new(attr)))
-        end
+        relation = apply_start_limit(relation, start) if start
+        relation = apply_finish_limit(relation, finish) if finish
         relation
       end
 
+      def apply_start_limit(relation, start)
+        relation.where(bind_attribute(primary_key, start) { |attr, bind| attr.gteq(bind) })
+      end
+
+      def apply_finish_limit(relation, finish)
+        relation.where(bind_attribute(primary_key, finish) { |attr, bind| attr.lteq(bind) })
+      end
+
       def batch_order
         arel_attribute(primary_key).asc
       end

data/lib/active_record/relation/calculations.rb

@@ -41,15 +41,13 @@ module ActiveRecord
     def count(column_name = nil)
       if block_given?
         unless column_name.nil?
-          ActiveSupport::Deprecation.warn \
-            "When `count' is called with a block, it ignores other arguments. " \
-            "This behavior is now deprecated and will result in an ArgumentError in Rails 6.0."
+          raise ArgumentError, "Column name argument is not supported when a block is passed."
         end
 
-        return super()
+        super()
+      else
+        calculate(:count, column_name)
       end
-
-      calculate(:count, column_name)
     end
 
     # Calculates the average value on a given column. Returns +nil+ if there's
@@ -86,15 +84,13 @@ module ActiveRecord
     def sum(column_name = nil)
       if block_given?
         unless column_name.nil?
-          ActiveSupport::Deprecation.warn \
-            "When `sum' is called with a block, it ignores other arguments. " \
-            "This behavior is now deprecated and will result in an ArgumentError in Rails 6.0."
+          raise ArgumentError, "Column name argument is not supported when a block is passed."
         end
 
-        return super()
+        super()
+      else
+        calculate(:sum, column_name)
       end
-
-      calculate(:sum, column_name)
     end
 
     # This calculates aggregate values in the given column. Methods for #count, #sum, #average,
@@ -133,12 +129,11 @@ module ActiveRecord
         relation = apply_join_dependency
 
         if operation.to_s.downcase == "count"
-          unless distinct_value || distinct_select?(column_name || select_for_count)
-            relation.distinct!
-            relation.select_values = [ klass.primary_key || table[Arel.star] ]
-          end
+          relation.distinct!
           # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
-          relation.order_values = []
+          if (column_name == :all || column_name.nil?) && select_values.empty?
+            relation.order_values = []
+          end
         end
 
         relation.calculate(operation, column_name)
@@ -191,14 +186,34 @@ module ActiveRecord
         relation = apply_join_dependency
         relation.pluck(*column_names)
       else
-        klass.enforce_raw_sql_whitelist(column_names)
+        disallow_raw_sql!(column_names)
         relation = spawn
-        relation.select_values = column_names
+        relation.select_values = column_names.map { |cn|
+          @klass.has_attribute?(cn) || @klass.attribute_alias?(cn) ? arel_attribute(cn) : cn
+        }
         result = skip_query_cache_if_necessary { klass.connection.select_all(relation.arel, nil) }
         result.cast_values(klass.attribute_types)
       end
     end
 
+    # Pick the value(s) from the named column(s) in the current relation.
+    # This is short-hand for <tt>relation.limit(1).pluck(*column_names).first</tt>, and is primarily useful
+    # when you have a relation that's already narrowed down to a single row.
+    #
+    # Just like #pluck, #pick will only load the actual value, not the entire record object, so it's also
+    # more efficient. The value is, again like with pluck, typecast by the column type.
+    #
+    #   Person.where(id: 1).pick(:name)
+    #   # SELECT people.name FROM people WHERE id = 1 LIMIT 1
+    #   # => 'David'
+    #
+    #   Person.where(id: 1).pick(:name, :email_address)
+    #   # SELECT people.name, people.email_address FROM people WHERE id = 1 LIMIT 1
+    #   # => [ 'David', 'david@loudthinking.com' ]
+    def pick(*column_names)
+      limit(1).pluck(*column_names).first
+    end
+
     # Pluck all the ID's for the relation using the table's primary key
     #
     #   Person.ids # SELECT people.id FROM people
@@ -208,6 +223,7 @@ module ActiveRecord
     end
 
     private
+
       def has_include?(column_name)
         eager_loading? || (includes_values.present? && column_name && column_name != :all)
       end
@@ -222,12 +238,10 @@ module ActiveRecord
         if operation == "count"
           column_name ||= select_for_count
           if column_name == :all
-            if !distinct
-              distinct = distinct_select?(select_for_count) if group_values.empty?
-            elsif group_values.any? || select_values.empty? && order_values.empty?
+            if distinct && (group_values.any? || select_values.empty? && order_values.empty?)
               column_name = primary_key
             end
-          elsif distinct_select?(column_name)
+          elsif column_name.is_a?(::String) && /\bDISTINCT[\s(]/i.match?(column_name)
             distinct = nil
           end
         end
@@ -239,10 +253,6 @@ module ActiveRecord
         end
       end
 
-      def distinct_select?(column_name)
-        column_name.is_a?(::String) && /\bDISTINCT[\s(]/i.match?(column_name)
-      end
-
       def aggregate_column(column_name)
         return column_name if Arel::Expressions === column_name
 
@@ -387,7 +397,7 @@ module ActiveRecord
         case operation
         when "count"   then value.to_i
         when "sum"     then type.deserialize(value || 0)
-        when "average" then value && value.respond_to?(:to_d) ? value.to_d : value
+        when "average" then value&.respond_to?(:to_d) ? value.to_d : value
         else type.deserialize(value)
         end
       end

data/lib/active_record/relation/delegation.rb

@@ -18,7 +18,7 @@ module ActiveRecord
             include ClassSpecificRelation
           }
           include_relation_methods(delegate)
-          mangled_name = klass.name.gsub("::".freeze, "_".freeze)
+          mangled_name = klass.name.gsub("::", "_")
           const_set mangled_name, delegate
           private_constant mangled_name
 
@@ -33,7 +33,7 @@ module ActiveRecord
 
       protected
         def include_relation_methods(delegate)
-          superclass.include_relation_methods(delegate) unless base_class == self
+          superclass.include_relation_methods(delegate) unless base_class?
           delegate.include generated_relation_methods
         end
 
@@ -54,7 +54,7 @@ module ActiveRecord
               end
             RUBY
           else
-            generated_relation_methods.send(:define_method, method) do |*args, &block|
+            generated_relation_methods.define_method(method) do |*args, &block|
               scoping { klass.public_send(method, *args, &block) }
             end
           end
@@ -68,7 +68,7 @@ module ActiveRecord
     # 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, :encode_with, :length, :each, :uniq, :join,
+    delegate :to_xml, :encode_with, :length, :each, :join,
              :[], :&, :|, :+, :-, :sample, :reverse, :rotate, :compact, :in_groups, :in_groups_of,
              :to_sentence, :to_formatted_s, :as_json,
              :shuffle, :split, :slice, :index, :rindex, to: :records
@@ -112,15 +112,6 @@ module ActiveRecord
           if @klass.respond_to?(method)
             self.class.delegate_to_scoped_klass(method)
             scoping { @klass.public_send(method, *args, &block) }
-          elsif @delegate_to_klass && @klass.respond_to?(method, true)
-            ActiveSupport::Deprecation.warn \
-              "Delegating missing #{method} method to #{@klass}. " \
-              "Accessibility of private/protected class methods in :scope is deprecated and will be removed in Rails 6.0."
-            @klass.send(method, *args, &block)
-          elsif arel.respond_to?(method)
-            ActiveSupport::Deprecation.warn \
-              "Delegating #{method} to arel is deprecated and will be removed in Rails 6.0."
-            arel.public_send(method, *args, &block)
           else
             super
           end

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