activerecord 6.0.0 → 6.1.4

data/lib/active_record/relation.rb

@@ -7,7 +7,7 @@ module ActiveRecord
                             :order, :joins, :left_outer_joins, :references,
                             :extending, :unscope, :optimizer_hints, :annotate]
 
-    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :reordering,
+    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :reordering, :strict_loading,
                             :reverse_order, :distinct, :create_with, :skip_query_cache]
 
     CLAUSE_METHODS = [:where, :having, :from]
@@ -28,7 +28,6 @@ module ActiveRecord
       @klass  = klass
       @table  = table
       @values = values
-      @offsets = {}
       @loaded = false
       @predicate_builder = predicate_builder
       @delegate_to_klass = false
@@ -40,8 +39,9 @@ module ActiveRecord
     end
 
     def arel_attribute(name) # :nodoc:
-      klass.arel_attribute(name, table)
+      table[name]
     end
+    deprecate :arel_attribute
 
     def bind_attribute(name, value) # :nodoc:
       if reflection = klass._reflect_on_association(name)
@@ -49,7 +49,7 @@ module ActiveRecord
         value = value.read_attribute(reflection.klass.primary_key) unless value.nil?
       end
 
-      attr = arel_attribute(name)
+      attr = table[name]
       bind = predicate_builder.build_bind_attribute(attr.name, value)
       yield attr, bind
     end
@@ -67,10 +67,9 @@ module ActiveRecord
     #   user = users.new { |user| user.name = 'Oscar' }
     #   user.name # => Oscar
     def new(attributes = nil, &block)
-      block = _deprecated_scope_block("new", &block)
-      scoping { klass.new(attributes, &block) }
+      block = current_scope_restoring_block(&block)
+      scoping { _new(attributes, &block) }
     end
-
     alias build new
 
     # Tries to create a new record with the same scoped attributes
@@ -96,8 +95,8 @@ module ActiveRecord
       if attributes.is_a?(Array)
         attributes.collect { |attr| create(attr, &block) }
       else
-        block = _deprecated_scope_block("create", &block)
-        scoping { klass.create(attributes, &block) }
+        block = current_scope_restoring_block(&block)
+        scoping { _create(attributes, &block) }
       end
     end
 
@@ -111,8 +110,8 @@ module ActiveRecord
       if attributes.is_a?(Array)
         attributes.collect { |attr| create!(attr, &block) }
       else
-        block = _deprecated_scope_block("create!", &block)
-        scoping { klass.create!(attributes, &block) }
+        block = current_scope_restoring_block(&block)
+        scoping { _create!(attributes, &block) }
       end
     end
 
@@ -308,7 +307,7 @@ module ActiveRecord
     # last updated record.
     #
     #   Product.where("name like ?", "%Game%").cache_key(:last_reviewed_at)
-    def cache_key(timestamp_column = :updated_at)
+    def cache_key(timestamp_column = "updated_at")
       @cache_keys ||= {}
       @cache_keys[timestamp_column] ||= klass.collection_cache_key(self, timestamp_column)
     end
@@ -317,7 +316,7 @@ module ActiveRecord
       query_signature = ActiveSupport::Digest.hexdigest(to_sql)
       key = "#{klass.model_name.cache_key}/query-#{query_signature}"
 
-      if cache_version(timestamp_column)
+      if collection_cache_versioning
         key
       else
         "#{key}-#{compute_cache_version(timestamp_column)}"
@@ -343,15 +342,17 @@ module ActiveRecord
     end
 
     def compute_cache_version(timestamp_column) # :nodoc:
+      timestamp_column = timestamp_column.to_s
+
       if loaded? || distinct_value
         size = records.size
         if size > 0
-          timestamp = max_by(&timestamp_column)._read_attribute(timestamp_column)
+          timestamp = records.map { |record| record.read_attribute(timestamp_column) }.max
         end
       else
         collection = eager_loading? ? apply_join_dependency : self
 
-        column = connection.visitor.compile(arel_attribute(timestamp_column))
+        column = connection.visitor.compile(table[timestamp_column])
         select_values = "COUNT(*) AS #{connection.quote_column_name("size")}, MAX(%s) AS timestamp"
 
         if collection.has_limit_or_offset?
@@ -365,14 +366,12 @@ module ActiveRecord
           arel = query.arel
         end
 
-        result = connection.select_one(arel, nil)
+        size, timestamp = connection.select_rows(arel, nil).first
 
-        if result
+        if size
           column_type = klass.type_for_attribute(timestamp_column)
-          timestamp = column_type.deserialize(result["timestamp"])
-          size = result["size"]
+          timestamp = column_type.deserialize(timestamp)
         else
-          timestamp = nil
           size = 0
         end
       end
@@ -385,6 +384,15 @@ module ActiveRecord
     end
     private :compute_cache_version
 
+    # Returns a cache key along with the version.
+    def cache_key_with_version
+      if version = cache_version
+        "#{cache_key}-#{version}"
+      else
+        cache_key
+      end
+    end
+
     # Scope all queries to the current scope.
     #
     #   Comment.where(post_id: 1).scoping do
@@ -398,9 +406,9 @@ module ActiveRecord
       already_in_scope? ? yield : _scoping(self) { yield }
     end
 
-    def _exec_scope(name, *args, &block) # :nodoc:
+    def _exec_scope(*args, &block) # :nodoc:
       @delegate_to_klass = true
-      _scoping(_deprecated_spawn(name)) { instance_exec(*args, &block) || self }
+      _scoping(nil) { instance_exec(*args, &block) || self }
     ensure
       @delegate_to_klass = false
     end
@@ -408,7 +416,7 @@ module ActiveRecord
     # Updates all records in the current relation with details given. This method constructs a single SQL UPDATE
     # statement and sends it straight to the database. It does not instantiate the involved models and it does not
     # trigger Active Record callbacks or validations. However, values passed to #update_all will still go through
-    # Active Record's normal type casting and serialization.
+    # Active Record's normal type casting and serialization. Returns the number of rows affected.
     #
     # Note: As Active Record callbacks are not triggered, this method will not automatically update +updated_at+/+updated_on+ columns.
     #
@@ -432,14 +440,12 @@ module ActiveRecord
     def update_all(updates)
       raise ArgumentError, "Empty list of attributes to change" if updates.blank?
 
-      if eager_loading?
-        relation = apply_join_dependency
-        return relation.update_all(updates)
-      end
+      arel = eager_loading? ? apply_join_dependency.arel : build_arel
+      arel.source.left = table
 
       stmt = Arel::UpdateManager.new
-      stmt.table(arel.join_sources.empty? ? table : arel.source)
-      stmt.key = arel_attribute(primary_key)
+      stmt.table(arel.source)
+      stmt.key = table[primary_key]
       stmt.take(arel.limit)
       stmt.offset(arel.offset)
       stmt.order(*arel.orders)
@@ -449,7 +455,7 @@ module ActiveRecord
         if klass.locking_enabled? &&
             !updates.key?(klass.locking_column) &&
             !updates.key?(klass.locking_column.to_sym)
-          attr = arel_attribute(klass.locking_column)
+          attr = table[klass.locking_column]
           updates[attr.name] = _increment_attribute(attr)
         end
         stmt.set _substitute_values(updates)
@@ -457,7 +463,7 @@ module ActiveRecord
         stmt.set Arel.sql(klass.sanitize_sql_for_assignment(updates, table.name))
       end
 
-      @klass.connection.update stmt, "#{@klass} Update All"
+      klass.connection.update(stmt, "#{klass} Update All").tap { reset }
     end
 
     def update(id = :all, attributes) # :nodoc:
@@ -468,26 +474,40 @@ module ActiveRecord
       end
     end
 
-    def update_counters(counters) # :nodoc:
+    # Updates the counters of the records in the current relation.
+    #
+    # ==== Parameters
+    #
+    # * +counter+ - A Hash containing the names of the fields to update as keys and the amount to update as values.
+    # * <tt>:touch</tt> option - Touch the timestamp columns when updating.
+    # * If attributes names are passed, they are updated along with update_at/on attributes.
+    #
+    # ==== Examples
+    #
+    #   # For Posts by a given author increment the comment_count by 1.
+    #   Post.where(author_id: author.id).update_counters(comment_count: 1)
+    def update_counters(counters)
       touch = counters.delete(:touch)
 
       updates = {}
       counters.each do |counter_name, value|
-        attr = arel_attribute(counter_name)
+        attr = table[counter_name]
         updates[attr.name] = _increment_attribute(attr, value)
       end
 
       if touch
         names = touch if touch != true
-        touch_updates = klass.touch_attributes_with_time(*names)
+        names = Array.wrap(names)
+        options = names.extract_options!
+        touch_updates = klass.touch_attributes_with_time(*names, **options)
         updates.merge!(touch_updates) unless touch_updates.empty?
       end
 
       update_all updates
     end
 
-    # Touches all records in the current relation without instantiating records first with the +updated_at+/+updated_on+ attributes
-    # set to the current time or the time specified.
+    # Touches all records in the current relation, setting the +updated_at+/+updated_on+ attributes to the current time or the time specified.
+    # It does not instantiate the involved models, and it does not trigger Active Record callbacks or validations.
     # This method can be passed attribute names and an optional time argument.
     # If attribute names are passed, they are updated along with +updated_at+/+updated_on+ attributes.
     # If no time argument is passed, the current time is used as default.
@@ -560,23 +580,18 @@ module ActiveRecord
         raise ActiveRecordError.new("delete_all doesn't support #{invalid_methods.join(', ')}")
       end
 
-      if eager_loading?
-        relation = apply_join_dependency
-        return relation.delete_all
-      end
+      arel = eager_loading? ? apply_join_dependency.arel : build_arel
+      arel.source.left = table
 
       stmt = Arel::DeleteManager.new
-      stmt.from(arel.join_sources.empty? ? table : arel.source)
-      stmt.key = arel_attribute(primary_key)
+      stmt.from(arel.source)
+      stmt.key = table[primary_key]
       stmt.take(arel.limit)
       stmt.offset(arel.offset)
       stmt.order(*arel.orders)
       stmt.wheres = arel.constraints
 
-      affected = @klass.connection.delete(stmt, "#{@klass} Destroy")
-
-      reset
-      affected
+      klass.connection.delete(stmt, "#{klass} Destroy").tap { reset }
     end
 
     # Finds and destroys all records matching the specified conditions.
@@ -612,7 +627,10 @@ module ActiveRecord
     #
     #   Post.where(published: true).load # => #<ActiveRecord::Relation>
     def load(&block)
-      exec_queries(&block) unless loaded?
+      unless loaded?
+        @records = exec_queries(&block)
+        @loaded = true
+      end
 
       self
     end
@@ -625,10 +643,10 @@ module ActiveRecord
 
     def reset
       @delegate_to_klass = false
-      @_deprecated_scope_source = nil
       @to_sql = @arel = @loaded = @should_eager_load = nil
+      @offsets = @take = nil
+      @cache_keys = nil
       @records = [].freeze
-      @offsets = {}
       self
     end
 
@@ -659,7 +677,9 @@ module ActiveRecord
     end
 
     def scope_for_create
-      where_values_hash.merge!(create_with_value.stringify_keys)
+      hash = where_clause.to_h(klass.table_name, equality_only: true)
+      create_with_value.each { |k, v| hash[k.to_s] = v } unless create_with_value.empty?
+      hash
     end
 
     # Returns true if relation needs eager loading.
@@ -703,7 +723,7 @@ module ActiveRecord
     end
 
     def inspect
-      subject = loaded? ? records : self
+      subject = loaded? ? records : annotate("loading for inspect")
       entries = subject.take([limit_value, 11].compact.min).map!(&:inspect)
 
       entries[10] = "..." if entries.size == 11
@@ -720,25 +740,31 @@ module ActiveRecord
     end
 
     def alias_tracker(joins = [], aliases = nil) # :nodoc:
-      joins += [aliases] if aliases
-      ActiveRecord::Associations::AliasTracker.create(connection, table.name, joins)
+      ActiveRecord::Associations::AliasTracker.create(connection, table.name, joins, aliases)
+    end
+
+    class StrictLoadingScope # :nodoc:
+      def self.empty_scope?
+        true
+      end
+
+      def self.strict_loading_value
+        true
+      end
     end
 
     def preload_associations(records) # :nodoc:
       preload = preload_values
       preload += includes_values unless eager_loading?
       preloader = nil
+      scope = strict_loading_value ? StrictLoadingScope : nil
       preload.each do |associations|
         preloader ||= build_preloader
-        preloader.preload records, associations
+        preloader.preload records, associations, scope
       end
     end
 
-    attr_reader :_deprecated_scope_source # :nodoc:
-
     protected
-      attr_writer :_deprecated_scope_source # :nodoc:
-
       def load_records(records)
         @records = records.freeze
         @loaded = true
@@ -750,23 +776,29 @@ module ActiveRecord
 
     private
       def already_in_scope?
-        @delegate_to_klass && begin
-          scope = klass.current_scope(true)
-          scope && !scope._deprecated_scope_source
-        end
+        @delegate_to_klass && klass.current_scope(true)
       end
 
-      def _deprecated_spawn(name)
-        spawn.tap { |scope| scope._deprecated_scope_source = name }
-      end
-
-      def _deprecated_scope_block(name, &block)
+      def current_scope_restoring_block(&block)
+        current_scope = klass.current_scope(true)
         -> record do
-          klass.current_scope = _deprecated_spawn(name)
+          klass.current_scope = current_scope
           yield record if block_given?
         end
       end
 
+      def _new(attributes, &block)
+        klass.new(attributes, &block)
+      end
+
+      def _create(attributes, &block)
+        klass.create(attributes, &block)
+      end
+
+      def _create!(attributes, &block)
+        klass.create!(attributes, &block)
+      end
+
       def _scoping(scope)
         previous, klass.current_scope = klass.current_scope(true), scope
         yield
@@ -776,7 +808,7 @@ module ActiveRecord
 
       def _substitute_values(values)
         values.map do |name, value|
-          attr = arel_attribute(name)
+          attr = table[name]
           unless Arel.arel_node?(value)
             type = klass.type_for_attribute(attr.name)
             value = predicate_builder.build_bind_attribute(attr.name, type.cast(value))
@@ -794,27 +826,29 @@ module ActiveRecord
 
       def exec_queries(&block)
         skip_query_cache_if_necessary do
-          @records =
-            if eager_loading?
+          records =
+            if where_clause.contradiction?
+              []
+            elsif eager_loading?
               apply_join_dependency do |relation, join_dependency|
                 if relation.null_relation?
                   []
                 else
                   relation = join_dependency.apply_column_aliases(relation)
                   rows = connection.select_all(relation.arel, "SQL")
-                  join_dependency.instantiate(rows, &block)
+                  join_dependency.instantiate(rows, strict_loading_value, &block)
                 end.freeze
               end
             else
               klass.find_by_sql(arel, &block).freeze
             end
 
-          preload_associations(@records) unless skip_preloading_value
+          preload_associations(records) unless skip_preloading_value
 
-          @records.each(&:readonly!) if readonly_value
+          records.each(&:readonly!) if readonly_value
+          records.each(&:strict_loading!) if strict_loading_value
 
-          @loaded = true
-          @records
+          records
         end
       end
 
@@ -833,27 +867,27 @@ module ActiveRecord
       end
 
       def references_eager_loaded_tables?
-        joined_tables = arel.join_sources.map do |join|
+        joined_tables = build_joins([]).flat_map do |join|
           if join.is_a?(Arel::Nodes::StringJoin)
             tables_in_string(join.left)
           else
-            [join.left.table_name, join.left.table_alias]
+            join.left.name
           end
         end
 
-        joined_tables += [table.name, table.table_alias]
+        joined_tables << table.name
 
         # always convert table names to downcase as in Oracle quoted table names are in uppercase
-        joined_tables = joined_tables.flatten.compact.map(&:downcase).uniq
+        joined_tables.map!(&:downcase)
 
-        (references_values - joined_tables).any?
+        !(references_values.map(&:to_s) - joined_tables).empty?
       end
 
       def tables_in_string(string)
         return [] if string.blank?
         # always convert table names to downcase as in Oracle quoted table names are in uppercase
         # ignore raw_sql_ that is used by Oracle adapter as alias for limit/offset subqueries
-        string.scan(/([a-zA-Z_][.\w]+).?\./).flatten.map(&:downcase).uniq - ["raw_sql_"]
+        string.scan(/[a-zA-Z_][.\w]+(?=.?\.)/).map!(&:downcase) - ["raw_sql_"]
       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