activerecord 5.0.7.2 → 6.0.3.4

data/lib/active_record/relation/record_fetch_warning.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class Relation
     module RecordFetchWarning
       # When this module is prepended to ActiveRecord::Relation and
-      # `config.active_record.warn_on_records_fetched_greater_than` is
+      # +config.active_record.warn_on_records_fetched_greater_than+ is
       # set to an integer, if the number of records a query returns is
-      # greater than the value of `warn_on_records_fetched_greater_than`,
+      # greater than the value of +warn_on_records_fetched_greater_than+,
       # a warning is logged. This allows for the detection of queries that
       # return a large number of records, which could cause memory bloat.
       #
       # In most cases, fetching large number of records can be performed
       # efficiently using the ActiveRecord::Batches methods.
-      # See active_record/lib/relation/batches.rb for more information.
+      # See ActiveRecord::Batches for more information.
       def exec_queries
         QueryRegistry.reset
 

data/lib/active_record/relation/spawn_methods.rb

@@ -1,13 +1,14 @@
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/hash/slice'
-require 'active_record/relation/merger'
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/hash/slice"
+require "active_record/relation/merger"
 
 module ActiveRecord
   module SpawnMethods
-
     # This is overridden by Associations::CollectionProxy
     def spawn #:nodoc:
-      clone
+      already_in_scope? ? klass.all : clone
     end
 
     # Merges in the conditions from <tt>other</tt>, if <tt>other</tt> is an ActiveRecord::Relation.
@@ -66,9 +67,8 @@ module ActiveRecord
     end
 
     private
-
-      def relation_with(values) # :nodoc:
-        result = Relation.create(klass, table, predicate_builder, values)
+      def relation_with(values)
+        result = Relation.create(klass, values: values)
         result.extend(*extending_values) if extending_values.any?
         result
       end

data/lib/active_record/relation/where_clause.rb

@@ -1,68 +1,63 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class Relation
     class WhereClause # :nodoc:
-      attr_reader :binds
-
       delegate :any?, :empty?, to: :predicates
 
-      def initialize(predicates, binds)
+      def initialize(predicates)
         @predicates = predicates
-        @binds = binds
       end
 
       def +(other)
         WhereClause.new(
           predicates + other.predicates,
-          binds + other.binds,
+        )
+      end
+
+      def -(other)
+        WhereClause.new(
+          predicates - other.predicates,
         )
       end
 
       def merge(other)
         WhereClause.new(
           predicates_unreferenced_by(other) + other.predicates,
-          non_conflicting_binds(other) + other.binds,
         )
       end
 
       def except(*columns)
-        WhereClause.new(
-          predicates_except(columns),
-          binds_except(columns),
-        )
+        WhereClause.new(except_predicates(columns))
       end
 
       def or(other)
-        if empty?
-          self
-        elsif other.empty?
-          other
+        left = self - other
+        common = self - left
+        right = other - common
+
+        if left.empty? || right.empty?
+          common
         else
-          WhereClause.new(
-            [ast.or(other.ast)],
-            binds + other.binds
+          or_clause = WhereClause.new(
+            [left.ast.or(right.ast)],
           )
+          common + or_clause
         end
       end
 
       def to_h(table_name = nil)
-        equalities = predicates.grep(Arel::Nodes::Equality)
+        equalities = equalities(predicates)
         if table_name
           equalities = equalities.select do |node|
             node.left.relation.name == table_name
           end
         end
 
-        binds = self.binds.map { |attr| [attr.name, attr.value] }.to_h
-
         equalities.map { |node|
-          name = node.left.name
-          [name, binds.fetch(name.to_s) {
-            case node.right
-            when Array then node.right.map(&:val)
-            when Arel::Nodes::Casted, Arel::Nodes::Quoted
-              node.right.val
-            end
-          }]
+          name = node.left.name.to_s
+          value = extract_node_value(node.right)
+          [name, value]
         }.to_h
       end
 
@@ -72,103 +67,123 @@ module ActiveRecord
 
       def ==(other)
         other.is_a?(WhereClause) &&
-          predicates == other.predicates &&
-          binds == other.binds
+          predicates == other.predicates
       end
 
-      def invert
-        WhereClause.new(inverted_predicates, binds)
+      def invert(as = :nand)
+        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
+
+        WhereClause.new(inverted_predicates)
       end
 
       def self.empty
-        @empty ||= new([], [])
+        @empty ||= new([])
       end
 
       protected
+        attr_reader :predicates
 
-      attr_reader :predicates
-
-      def referenced_columns
-        @referenced_columns ||= begin
-          equality_nodes = predicates.select { |n| equality_node?(n) }
-          Set.new(equality_nodes, &:left)
+        def referenced_columns
+          @referenced_columns ||= begin
+            equality_nodes = predicates.select { |n| equality_node?(n) }
+            Set.new(equality_nodes, &:left)
+          end
         end
-      end
 
       private
+        def equalities(predicates)
+          equalities = []
+
+          predicates.each do |node|
+            case node
+            when Arel::Nodes::Equality
+              equalities << node
+            when Arel::Nodes::And
+              equalities.concat equalities(node.children)
+            end
+          end
 
-      def predicates_unreferenced_by(other)
-        predicates.reject do |n|
-          equality_node?(n) && other.referenced_columns.include?(n.left)
+          equalities
         end
-      end
 
-      def equality_node?(node)
-        node.respond_to?(:operator) && node.operator == :==
-      end
-
-      def non_conflicting_binds(other)
-        conflicts = referenced_columns & other.referenced_columns
-        conflicts.map! { |node| node.name.to_s }
-        binds.reject { |attr| conflicts.include?(attr.name) }
-      end
-
-      def inverted_predicates
-        predicates.map { |node| invert_predicate(node) }
-      end
+        def predicates_unreferenced_by(other)
+          predicates.reject do |n|
+            equality_node?(n) && other.referenced_columns.include?(n.left)
+          end
+        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::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)
+        def equality_node?(node)
+          node.respond_to?(:operator) && node.operator == :==
         end
-      end
 
-      def predicates_except(columns)
-        predicates.reject do |node|
+        def invert_predicate(node)
           case node
-          when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
-            subrelation = (node.left.kind_of?(Arel::Attributes::Attribute) ? node.left : node.right)
-            columns.include?(subrelation.name.to_s)
+          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)
           end
         end
-      end
 
-      def binds_except(columns)
-        binds.reject do |attr|
-          columns.include?(attr.name)
+        def except_predicates(columns)
+          predicates.reject do |node|
+            Arel.fetch_attribute(node) { |attr| columns.include?(attr.name.to_s) }
+          end
         end
-      end
 
-      def predicates_with_wrapped_sql_literals
-        non_empty_predicates.map do |node|
-          if Arel::Nodes::Equality === node
-            node
-          else
-            wrap_sql_literal(node)
+        def predicates_with_wrapped_sql_literals
+          non_empty_predicates.map do |node|
+            case node
+            when Arel::Nodes::SqlLiteral, ::String
+              wrap_sql_literal(node)
+            else node
+            end
           end
         end
-      end
 
-      ARRAY_WITH_EMPTY_STRING = ['']
-      def non_empty_predicates
-        predicates - ARRAY_WITH_EMPTY_STRING
-      end
+        ARRAY_WITH_EMPTY_STRING = [""]
+        def non_empty_predicates
+          predicates - ARRAY_WITH_EMPTY_STRING
+        end
 
-      def wrap_sql_literal(node)
-        if ::String === node
-          node = Arel.sql(node)
+        def wrap_sql_literal(node)
+          if ::String === node
+            node = Arel.sql(node)
+          end
+          Arel::Nodes::Grouping.new(node)
+        end
+
+        def extract_node_value(node)
+          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
+          end
         end
-        Arel::Nodes::Grouping.new(node)
-      end
     end
   end
 end

data/lib/active_record/relation/where_clause_factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class Relation
     class WhereClauseFactory # :nodoc:
@@ -7,32 +9,25 @@ module ActiveRecord
       end
 
       def build(opts, other)
-        binds = []
-
         case opts
         when String, Array
-          parts = [klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
+          parts = [klass.sanitize_sql(other.empty? ? opts : ([opts] + other))]
         when Hash
           attributes = predicate_builder.resolve_column_aliases(opts)
-          attributes = klass.send(:expand_hash_conditions_for_aggregates, attributes)
           attributes.stringify_keys!
 
-          attributes, binds = predicate_builder.create_binds(attributes)
-
           parts = predicate_builder.build_from_hash(attributes)
         when Arel::Nodes::Node
           parts = [opts]
-          binds = other
         else
           raise ArgumentError, "Unsupported argument type: #{opts} (#{opts.class})"
         end
 
-        WhereClause.new(parts, binds)
+        WhereClause.new(parts)
       end
 
-      protected
-
-      attr_reader :klass, :predicate_builder
+      private
+        attr_reader :klass, :predicate_builder
     end
   end
 end

data/lib/active_record/result.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   ###
   # This class encapsulates a result returned from calling
@@ -19,7 +21,7 @@ module ActiveRecord
   #        ]
   #
   #   # Get an array of hashes representing the result (column => value):
-  #   result.to_hash
+  #   result.to_a
   #   # => [{"id" => 1, "title" => "title_1", "body" => "body_1"},
   #         {"id" => 2, "title" => "title_2", "body" => "body_2"},
   #         ...
@@ -32,8 +34,6 @@ module ActiveRecord
   class Result
     include Enumerable
 
-    IDENTITY_TYPE = Type::Value.new # :nodoc:
-
     attr_reader :columns, :rows, :column_types
 
     def initialize(columns, rows, column_types = {})
@@ -43,10 +43,20 @@ module ActiveRecord
       @column_types = column_types
     end
 
+    # Returns true if this result set includes the column named +name+
+    def includes_column?(name)
+      @columns.include? name
+    end
+
+    # Returns the number of elements in the rows array.
     def length
       @rows.length
     end
 
+    # Calls the given block once for each element in row collection, passing
+    # row as parameter.
+    #
+    # Returns an +Enumerator+ if no block is given.
     def each
       if block_given?
         hash_rows.each { |row| yield row }
@@ -56,42 +66,62 @@ module ActiveRecord
     end
 
     def to_hash
-      hash_rows
+      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
 
-    # Returns true if there are no records.
+    # Returns true if there are no records, otherwise false.
     def empty?
       rows.empty?
     end
 
+    # Returns an array of hashes representing each row record.
     def to_ary
       hash_rows
     end
 
+    alias :to_a :to_ary
+
     def [](idx)
       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)]
     end
 
     def cast_values(type_overrides = {}) # :nodoc:
-      types = columns.map { |name| column_type(name, type_overrides) }
-      result = rows.map do |values|
-        types.zip(values).map { |type, value| type.deserialize(value) }
-      end
+      if columns.one?
+        # Separated to avoid allocating an array per row
+
+        type = column_type(columns.first, type_overrides)
 
-      columns.one? ? result.map!(&:first) : result
+        rows.map do |(value)|
+          type.deserialize(value)
+        end
+      else
+        types = columns.map { |name| column_type(name, type_overrides) }
+
+        rows.map do |values|
+          Array.new(values.size) { |i| types[i].deserialize(values[i]) }
+        end
+      end
     end
 
     def initialize_copy(other)
@@ -102,37 +132,36 @@ module ActiveRecord
     end
 
     private
-
-    def column_type(name, type_overrides = {})
-      type_overrides.fetch(name) do
-        column_types.fetch(name, IDENTITY_TYPE)
+      def column_type(name, type_overrides = {})
+        type_overrides.fetch(name) do
+          column_types.fetch(name, Type.default_value)
+        end
       end
-    end
 
-    def hash_rows
-      @hash_rows ||=
-        begin
-          # We freeze the strings to prevent them getting duped when
-          # used as keys in ActiveRecord::Base's @attributes hash
-          columns = @columns.map { |c| c.dup.freeze }
-          @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
-            length = columns.length
-
-            while index < length
-              hash[columns[index]] = row[index]
-              index += 1
-            end
-
-            hash
-          }
-        end
-    end
+      def hash_rows
+        @hash_rows ||=
+          begin
+            # We freeze the strings to prevent them getting duped when
+            # used as keys in ActiveRecord::Base's @attributes hash
+            columns = @columns.map(&:-@)
+            length  = columns.length
+
+            @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
+              end
+
+              hash
+            }
+          end
+      end
   end
 end