activerecord 6.0.0 → 6.1.0

data/lib/active_record/relation/record_fetch_warning.rb

@@ -16,10 +16,10 @@ module ActiveRecord
       def exec_queries
         QueryRegistry.reset
 
-        super.tap do
+        super.tap do |records|
           if logger && warn_on_records_fetched_greater_than
-            if @records.length > warn_on_records_fetched_greater_than
-              logger.warn "Query fetched #{@records.size} #{@klass} records: #{QueryRegistry.queries.join(";")}"
+            if records.length > warn_on_records_fetched_greater_than
+              logger.warn "Query fetched #{records.size} #{@klass} records: #{QueryRegistry.queries.join(";")}"
             end
           end
         end

data/lib/active_record/relation/spawn_methods.rb

@@ -28,21 +28,22 @@ module ActiveRecord
     #   # => Post.where(published: true).joins(:comments)
     #
     # This is mainly intended for sharing common conditions between multiple associations.
-    def merge(other)
+    def merge(other, *rest)
       if other.is_a?(Array)
         records & other
       elsif other
-        spawn.merge!(other)
+        spawn.merge!(other, *rest)
       else
         raise ArgumentError, "invalid argument: #{other.inspect}."
       end
     end
 
-    def merge!(other) # :nodoc:
+    def merge!(other, *rest) # :nodoc:
+      options = rest.extract_options!
       if other.is_a?(Hash)
-        Relation::HashMerger.new(self, other).merge
+        Relation::HashMerger.new(self, other, options[:rewhere]).merge
       elsif other.is_a?(Relation)
-        Relation::Merger.new(self, other).merge
+        Relation::Merger.new(self, other, options[:rewhere]).merge
       elsif other.respond_to?(:to_proc)
         instance_exec(&other)
       else
@@ -67,10 +68,9 @@ module ActiveRecord
     end
 
     private
-
       def relation_with(values)
-        result = Relation.create(klass, values: values)
-        result.extend(*extending_values) if extending_values.any?
+        result = spawn
+        result.instance_variable_set(:@values, values)
         result
       end
   end

data/lib/active_record/relation/where_clause.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/array/extract"
+
 module ActiveRecord
   class Relation
     class WhereClause # :nodoc:
@@ -10,21 +12,25 @@ module ActiveRecord
       end
 
       def +(other)
-        WhereClause.new(
-          predicates + other.predicates,
-        )
+        WhereClause.new(predicates + other.predicates)
       end
 
       def -(other)
-        WhereClause.new(
-          predicates - other.predicates,
-        )
+        WhereClause.new(predicates - other.predicates)
+      end
+
+      def |(other)
+        WhereClause.new(predicates | other.predicates)
       end
 
-      def merge(other)
-        WhereClause.new(
-          predicates_unreferenced_by(other) + other.predicates,
-        )
+      def merge(other, rewhere = nil)
+        predicates = if rewhere
+          except_predicates(other.extract_attributes)
+        else
+          predicates_unreferenced_by(other)
+        end
+
+        WhereClause.new(predicates | other.predicates)
       end
 
       def except(*columns)
@@ -39,30 +45,31 @@ module ActiveRecord
         if left.empty? || right.empty?
           common
         else
-          or_clause = WhereClause.new(
-            [left.ast.or(right.ast)],
-          )
-          common + or_clause
+          left = left.ast
+          left = left.expr if left.is_a?(Arel::Nodes::Grouping)
+
+          right = right.ast
+          right = right.expr if right.is_a?(Arel::Nodes::Grouping)
+
+          or_clause = Arel::Nodes::Or.new(left, right)
+
+          common.predicates << Arel::Nodes::Grouping.new(or_clause)
+          common
         end
       end
 
       def to_h(table_name = nil)
-        equalities = equalities(predicates)
-        if table_name
-          equalities = equalities.select do |node|
-            node.left.relation.name == table_name
-          end
-        end
-
-        equalities.map { |node|
+        equalities(predicates).each_with_object({}) do |node, hash|
+          next if table_name&.!= node.left.relation.name
           name = node.left.name.to_s
           value = extract_node_value(node.right)
-          [name, value]
-        }.to_h
+          hash[name] = value
+        end
       end
 
       def ast
-        Arel::Nodes::And.new(predicates_with_wrapped_sql_literals)
+        predicates = predicates_with_wrapped_sql_literals
+        predicates.one? ? predicates.first : Arel::Nodes::And.new(predicates)
       end
 
       def ==(other)
@@ -70,11 +77,9 @@ module ActiveRecord
           predicates == other.predicates
       end
 
-      def invert(as = :nand)
+      def invert
         if predicates.size == 1
           inverted_predicates = [ invert_predicate(predicates.first) ]
-        elsif as == :nor
-          inverted_predicates = predicates.map { |node| invert_predicate(node) }
         else
           inverted_predicates = [ Arel::Nodes::Not.new(ast) ]
         end
@@ -83,29 +88,59 @@ module ActiveRecord
       end
 
       def self.empty
-        @empty ||= new([])
+        @empty ||= new([]).freeze
       end
 
-      protected
+      def contradiction?
+        predicates.any? do |x|
+          case x
+          when Arel::Nodes::In
+            Array === x.right && x.right.empty?
+          when Arel::Nodes::Equality
+            x.right.respond_to?(:unboundable?) && x.right.unboundable?
+          end
+        end
+      end
+
+      def extract_attributes
+        predicates.each_with_object([]) do |node, attrs|
+          attr = extract_attribute(node) || begin
+            node.left if node.equality? && node.left.is_a?(Arel::Predications)
+          end
+          attrs << attr if attr
+        end
+      end
 
+      protected
         attr_reader :predicates
 
         def referenced_columns
-          @referenced_columns ||= begin
-            equality_nodes = predicates.select { |n| equality_node?(n) }
-            Set.new(equality_nodes, &:left)
+          predicates.each_with_object({}) do |node, hash|
+            attr = extract_attribute(node) || begin
+              node.left if equality_node?(node) && node.left.is_a?(Arel::Predications)
+            end
+
+            hash[attr] = node if attr
           end
         end
 
       private
+        def extract_attribute(node)
+          attr_node = nil
+          Arel.fetch_attribute(node) do |attr|
+            return if attr_node&.!= attr # all attr nodes should be the same
+            attr_node = attr
+          end
+          attr_node
+        end
+
         def equalities(predicates)
           equalities = []
 
           predicates.each do |node|
-            case node
-            when Arel::Nodes::Equality
+            if equality_node?(node)
               equalities << node
-            when Arel::Nodes::And
+            elsif node.is_a?(Arel::Nodes::And)
               equalities.concat equalities(node.children)
             end
           end
@@ -114,37 +149,55 @@ module ActiveRecord
         end
 
         def predicates_unreferenced_by(other)
-          predicates.reject do |n|
-            equality_node?(n) && other.referenced_columns.include?(n.left)
+          referenced_columns = other.referenced_columns
+
+          predicates.reject do |node|
+            attr = extract_attribute(node) || begin
+              node.left if equality_node?(node) && node.left.is_a?(Arel::Predications)
+            end
+            next false unless attr
+
+            ref = referenced_columns[attr]
+            next false unless ref
+
+            if equality_node?(node) && equality_node?(ref) || node == ref
+              true
+            else
+              ActiveSupport::Deprecation.warn(<<-MSG.squish)
+                Merging (#{node.to_sql}) and (#{ref.to_sql}) no longer maintain
+                both conditions, and will be replaced by the latter in Rails 6.2.
+                To migrate to Rails 6.2's behavior, use `relation.merge(other, rewhere: true)`.
+              MSG
+              false
+            end
           end
         end
 
         def equality_node?(node)
-          node.respond_to?(:operator) && node.operator == :==
+          !node.is_a?(String) && node.equality?
         end
 
         def invert_predicate(node)
           case node
           when NilClass
             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
             Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new(node))
           else
-            Arel::Nodes::Not.new(node)
+            node.invert
           end
         end
 
         def except_predicates(columns)
+          attrs = columns.extract! { |node| node.is_a?(Arel::Attribute) }
+          non_attrs = columns.extract! { |node| node.is_a?(Arel::Predications) }
+
           predicates.reject do |node|
-            Arel.fetch_attribute(node) { |attr| columns.include?(attr.name.to_s) }
+            if !non_attrs.empty? && node.equality? && node.left.is_a?(Arel::Predications)
+              non_attrs.include?(node.left)
+            end || Arel.fetch_attribute(node) do |attr|
+              attrs.include?(attr) || columns.include?(attr.name.to_s)
+            end
           end
         end
 
@@ -174,15 +227,8 @@ module ActiveRecord
           case node
           when Array
             node.map { |v| extract_node_value(v) }
-          when Arel::Nodes::Casted, Arel::Nodes::Quoted
-            node.val
-          when Arel::Nodes::BindParam
-            value = node.value
-            if value.respond_to?(:value_before_type_cast)
-              value.value_before_type_cast
-            else
-              value
-            end
+          when Arel::Nodes::BindParam, Arel::Nodes::Casted, Arel::Nodes::Quoted
+            node.value_before_type_cast
           end
         end
     end

data/lib/active_record/result.rb

@@ -65,16 +65,10 @@ module ActiveRecord
       end
     end
 
-    def to_hash
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        `ActiveRecord::Result#to_hash` has been renamed to `to_a`.
-        `to_hash` is deprecated and will be removed in Rails 6.1.
-      MSG
-      to_a
-    end
-
     alias :map! :map
     alias :collect! :map
+    deprecate "map!": :map
+    deprecate "collect!": :map
 
     # Returns true if there are no records, otherwise false.
     def empty?
@@ -92,31 +86,30 @@ module ActiveRecord
       hash_rows[idx]
     end
 
-    # Returns the first record from the rows collection.
-    # If the rows collection is empty, returns +nil+.
-    def first
-      return nil if @rows.empty?
-      Hash[@columns.zip(@rows.first)]
-    end
-
     # Returns the last record from the rows collection.
-    # If the rows collection is empty, returns +nil+.
-    def last
-      return nil if @rows.empty?
-      Hash[@columns.zip(@rows.last)]
+    def last(n = nil)
+      n ? hash_rows.last(n) : hash_rows.last
     end
 
     def cast_values(type_overrides = {}) # :nodoc:
       if columns.one?
         # Separated to avoid allocating an array per row
 
-        type = column_type(columns.first, type_overrides)
+        type = if type_overrides.is_a?(Array)
+          type_overrides.first
+        else
+          column_type(columns.first, type_overrides)
+        end
 
         rows.map do |(value)|
           type.deserialize(value)
         end
       else
-        types = columns.map { |name| column_type(name, type_overrides) }
+        types = if type_overrides.is_a?(Array)
+          type_overrides
+        else
+          columns.map { |name| column_type(name, type_overrides) }
+        end
 
         rows.map do |values|
           Array.new(values.size) { |i| types[i].deserialize(values[i]) }
@@ -132,7 +125,6 @@ module ActiveRecord
     end
 
     private
-
       def column_type(name, type_overrides = {})
         type_overrides.fetch(name) do
           column_types.fetch(name, Type.default_value)
@@ -146,21 +138,36 @@ module ActiveRecord
             # used as keys in ActiveRecord::Base's @attributes hash
             columns = @columns.map(&:-@)
             length  = columns.length
+            template = nil
 
             @rows.map { |row|
-              # In the past we used Hash[columns.zip(row)]
-              #  though elegant, the verbose way is much more efficient
-              #  both time and memory wise cause it avoids a big array allocation
-              #  this method is called a lot and needs to be micro optimised
-              hash = {}
-
-              index = 0
-              while index < length
-                hash[columns[index]] = row[index]
-                index += 1
+              if template
+                # We use transform_values to build subsequent rows from the
+                # hash of the first row. This is faster because we avoid any
+                # reallocs and in Ruby 2.7+ avoid hashing entirely.
+                index = -1
+                template.transform_values do
+                  row[index += 1]
+                end
+              else
+                # In the past we used Hash[columns.zip(row)]
+                #  though elegant, the verbose way is much more efficient
+                #  both time and memory wise cause it avoids a big array allocation
+                #  this method is called a lot and needs to be micro optimised
+                hash = {}
+
+                index = 0
+                while index < length
+                  hash[columns[index]] = row[index]
+                  index += 1
+                end
+
+                # It's possible to select the same column twice, in which case
+                # we can't use a template
+                template = hash if hash.length == length
+
+                hash
               end
-
-              hash
             }
           end
       end

data/lib/active_record/runtime_registry.rb

@@ -14,9 +14,9 @@ module ActiveRecord
   class RuntimeRegistry # :nodoc:
     extend ActiveSupport::PerThreadRegistry
 
-    attr_accessor :connection_handler, :sql_runtime
+    attr_accessor :sql_runtime
 
-    [:connection_handler, :sql_runtime].each do |val|
+    [:sql_runtime].each do |val|
       class_eval %{ def self.#{val}; instance.#{val}; end }, __FILE__, __LINE__
       class_eval %{ def self.#{val}=(x); instance.#{val}=x; end }, __FILE__, __LINE__
     end

data/lib/active_record/sanitization.rb

@@ -67,7 +67,7 @@ module ActiveRecord
           )
 
           # Ensure we aren't dealing with a subclass of String that might
-          # override methods we use (eg. Arel::Nodes::SqlLiteral).
+          # override methods we use (e.g. Arel::Nodes::SqlLiteral).
           if condition.first.kind_of?(String) && !condition.first.instance_of?(String)
             condition = [String.new(condition.first), *condition[1..-1]]
           end
@@ -141,19 +141,7 @@ module ActiveRecord
           (unexpected ||= []) << arg
         end
 
-        return unless unexpected
-
-        if allow_unsafe_raw_sql == :deprecated
-          ActiveSupport::Deprecation.warn(
-            "Dangerous query method (method whose arguments are used as raw " \
-            "SQL) called with non-attribute argument(s): " \
-            "#{unexpected.map(&:inspect).join(", ")}. Non-attribute " \
-            "arguments will be disallowed in Rails 6.1. This method should " \
-            "not be called with user-provided values, such as request " \
-            "parameters or model attributes. Known-safe values can be passed " \
-            "by wrapping them in Arel.sql()."
-          )
-        else
+        if unexpected
           raise(ActiveRecord::UnknownAttributeReference,
             "Query method called with non-attribute argument(s): " +
             unexpected.map(&:inspect).join(", ")
@@ -193,13 +181,14 @@ module ActiveRecord
 
         def quote_bound_value(value, c = connection)
           if value.respond_to?(:map) && !value.acts_like?(:string)
-            quoted = value.map { |v| c.quote(v) }
-            if quoted.empty?
+            values = value.map { |v| v.respond_to?(:id_for_database) ? v.id_for_database : v }
+            if values.empty?
               c.quote(nil)
             else
-              quoted.join(",")
+              values.map! { |v| c.quote(v) }.join(",")
             end
           else
+            value = value.id_for_database if value.respond_to?(:id_for_database)
             c.quote(value)
           end
         end