activerecord 4.2.11.2 → 6.0.2.2

data/lib/active_record/relation/record_fetch_warning.rb

@@ -0,0 +1,51 @@
+# 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
+      # set to an integer, if the number of records a query returns is
+      # 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 ActiveRecord::Batches for more information.
+      def exec_queries
+        QueryRegistry.reset
+
+        super.tap do
+          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(";")}"
+            end
+          end
+        end
+      end
+
+      # :stopdoc:
+      ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
+        QueryRegistry.queries << payload[:sql]
+      end
+      # :startdoc:
+
+      class QueryRegistry # :nodoc:
+        extend ActiveSupport::PerThreadRegistry
+
+        attr_reader :queries
+
+        def initialize
+          @queries = []
+        end
+
+        def reset
+          @queries.clear
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend ActiveRecord::Relation::RecordFetchWarning

data/lib/active_record/relation/spawn_methods.rb

@@ -1,16 +1,17 @@
-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 <tt>ActiveRecord::Relation</tt>.
+    # Merges in the conditions from <tt>other</tt>, if <tt>other</tt> is an ActiveRecord::Relation.
     # Returns an array representing the intersection of the resulting records with <tt>other</tt>, if <tt>other</tt> is an array.
     #
     #   Post.where(published: true).joins(:comments).merge( Comment.where(spam: false) )
@@ -29,11 +30,11 @@ module ActiveRecord
     # This is mainly intended for sharing common conditions between multiple associations.
     def merge(other)
       if other.is_a?(Array)
-        to_a & other
+        records & other
       elsif other
         spawn.merge!(other)
       else
-        self
+        raise ArgumentError, "invalid argument: #{other.inspect}."
       end
     end
 
@@ -62,16 +63,13 @@ module ActiveRecord
     #   Post.order('id asc').only(:where)         # discards the order condition
     #   Post.order('id asc').only(:where, :order) # uses the specified order
     def only(*onlies)
-      if onlies.any? { |o| o == :where }
-        onlies << :bind
-      end
       relation_with values.slice(*onlies)
     end
 
     private
 
-      def relation_with(values) # :nodoc:
-        result = Relation.create(klass, table, 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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Relation
+    class WhereClause # :nodoc:
+      delegate :any?, :empty?, to: :predicates
+
+      def initialize(predicates)
+        @predicates = predicates
+      end
+
+      def +(other)
+        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,
+        )
+      end
+
+      def except(*columns)
+        WhereClause.new(except_predicates(columns))
+      end
+
+      def or(other)
+        left = self - other
+        common = self - left
+        right = other - common
+
+        if left.empty? || right.empty?
+          common
+        else
+          or_clause = WhereClause.new(
+            [left.ast.or(right.ast)],
+          )
+          common + or_clause
+        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|
+          name = node.left.name.to_s
+          value = extract_node_value(node.right)
+          [name, value]
+        }.to_h
+      end
+
+      def ast
+        Arel::Nodes::And.new(predicates_with_wrapped_sql_literals)
+      end
+
+      def ==(other)
+        other.is_a?(WhereClause) &&
+          predicates == other.predicates
+      end
+
+      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([])
+      end
+
+      protected
+
+        attr_reader :predicates
+
+        def referenced_columns
+          @referenced_columns ||= begin
+            equality_nodes = predicates.select { |n| equality_node?(n) }
+            Set.new(equality_nodes, &:left)
+          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
+
+          equalities
+        end
+
+        def predicates_unreferenced_by(other)
+          predicates.reject do |n|
+            equality_node?(n) && other.referenced_columns.include?(n.left)
+          end
+        end
+
+        def equality_node?(node)
+          node.respond_to?(:operator) && node.operator == :==
+        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)
+          end
+        end
+
+        def except_predicates(columns)
+          predicates.reject do |node|
+            Arel.fetch_attribute(node) { |attr| columns.include?(attr.name.to_s) }
+          end
+        end
+
+        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
+
+        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)
+          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
+    end
+  end
+end

data/lib/active_record/relation/where_clause_factory.rb

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

data/lib/active_record/result.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   ###
-  # This class encapsulates a Result returned from calling +exec_query+ on any
-  # database connection adapter. For example:
+  # This class encapsulates a result returned from calling
+  # {#exec_query}[rdoc-ref:ConnectionAdapters::DatabaseStatements#exec_query]
+  # on any database connection adapter. For example:
   #
   #   result = ActiveRecord::Base.connection.exec_query('SELECT id, title, body FROM posts')
   #   result # => #<ActiveRecord::Result:0xdeadbeef>
@@ -18,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"},
   #         ...
@@ -31,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 = {})
@@ -42,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 }
@@ -55,36 +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
-      hash_rows.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.type_cast_from_database(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)
@@ -96,36 +133,36 @@ module ActiveRecord
 
     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