activerecord 6.0.5.1 → 6.1.0.rc1

data/lib/active_record/fixtures.rb

@@ -10,7 +10,6 @@ require "active_record/fixture_set/file"
 require "active_record/fixture_set/render_context"
 require "active_record/fixture_set/table_rows"
 require "active_record/test_fixtures"
-require "active_record/errors"
 
 module ActiveRecord
   class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
@@ -41,7 +40,7 @@ module ActiveRecord
   # separated by a blank line for your viewing pleasure.
   #
   # Note: Fixtures are unordered. If you want ordered fixtures, use the omap YAML type.
-  # See http://yaml.org/type/omap.html
+  # See https://yaml.org/type/omap.html
   # for the specification. You will need ordered fixtures when you have foreign key constraints
   # on keys in the same table. This is commonly needed for tree structures. Example:
   #
@@ -60,7 +59,7 @@ module ActiveRecord
   # Since fixtures are a testing construct, we use them in our unit and functional tests. There
   # are two ways to use the fixtures, but first let's take a look at a sample unit test:
   #
-  #   require 'test_helper'
+  #   require "test_helper"
   #
   #   class WebSiteTest < ActiveSupport::TestCase
   #     test "web_site_count" do
@@ -182,7 +181,7 @@ module ActiveRecord
   #     end
   #   end
   #
-  # If you preload your test database with all fixture data (probably by running `rails db:fixtures:load`)
+  # If you preload your test database with all fixture data (probably by running `bin/rails db:fixtures:load`)
   # and use transactional tests, then you may omit all fixtures declarations in your test cases since
   # all the data's already there and every case rolls back its changes.
   #
@@ -420,12 +419,35 @@ module ActiveRecord
   #
   # Any fixture labeled "DEFAULTS" is safely ignored.
   #
+  # Besides using "DEFAULTS", you can also specify what fixtures will
+  # be ignored by setting "ignore" in "_fixture" section.
+  #
+  #   # users.yml
+  #   _fixture:
+  #     ignore:
+  #       - base
+  #     # or use "ignore: base" when there is only one fixture needs to be ignored.
+  #
+  #   base: &base
+  #     admin: false
+  #     introduction: "This is a default description"
+  #
+  #   admin:
+  #     <<: *base
+  #     admin: true
+  #
+  #   visitor:
+  #     <<: *base
+  #
+  # In the above example, 'base' will be ignored when creating fixtures.
+  # This can be used for common attributes inheriting.
+  #
   # == Configure the fixture model class
   #
   # It's possible to set the fixture's model class directly in the YAML file.
   # This is helpful when fixtures are loaded outside tests and
   # +set_fixture_class+ is not available (e.g.
-  # when running <tt>rails db:fixtures:load</tt>).
+  # when running <tt>bin/rails db:fixtures:load</tt>).
   #
   #   _fixture:
   #     model_class: User
@@ -563,6 +585,14 @@ module ActiveRecord
         end
       end
 
+      def signed_global_id(fixture_set_name, label, column_type: :integer, **options)
+        identifier = identify(label, column_type)
+        model_name = default_fixture_model_name(fixture_set_name)
+        uri = URI::GID.build([GlobalID.app, model_name, identifier, {}])
+
+        SignedGlobalID.new(uri, **options)
+      end
+
       # Superclass for the evaluation contexts used by ERB fixtures.
       def context_class
         @context_class ||= Class.new
@@ -619,7 +649,7 @@ module ActiveRecord
         end
     end
 
-    attr_reader :table_name, :name, :fixtures, :model_class, :config
+    attr_reader :table_name, :name, :fixtures, :model_class, :ignored_fixtures, :config
 
     def initialize(_, name, class_name, path, config = ActiveRecord::Base)
       @name     = name
@@ -652,8 +682,8 @@ module ActiveRecord
     # Returns a hash of rows to be inserted. The key is the table, the value is
     # a list of rows to insert to that table.
     def table_rows
-      # allow a standard key to be used for doing defaults in YAML
-      fixtures.delete("DEFAULTS")
+      # allow specifying fixtures to be ignored by setting `ignore` in `_fixture` section
+      fixtures.except!(*ignored_fixtures)
 
       TableRows.new(
         table_name,
@@ -672,6 +702,21 @@ module ActiveRecord
         end
       end
 
+      def ignored_fixtures=(base)
+        @ignored_fixtures =
+            case base
+            when Array
+              base
+            when String
+              [base]
+            else
+              []
+            end
+
+        @ignored_fixtures << "DEFAULTS" unless @ignored_fixtures.include?("DEFAULTS")
+        @ignored_fixtures.compact
+      end
+
       # Loads the fixtures from the YAML file at +path+.
       # If the file sets the +model_class+ and current instance value is not set,
       # it uses the file value.
@@ -683,6 +728,7 @@ module ActiveRecord
         yaml_files.each_with_object({}) do |file, fixtures|
           FixtureSet::File.open(file) do |fh|
             self.model_class ||= fh.model_class if fh.model_class
+            self.ignored_fixtures ||= fh.ignored_fixtures
             fh.each do |fixture_name, row|
               fixtures[fixture_name] = ActiveRecord::Fixture.new(row, model_class)
             end

data/lib/active_record/gem_version.rb

@@ -8,9 +8,9 @@ module ActiveRecord
 
   module VERSION
     MAJOR = 6
-    MINOR = 0
-    TINY  = 5
-    PRE   = "1"
+    MINOR = 1
+    TINY  = 0
+    PRE   = "rc1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/inheritance.rb

@@ -38,6 +38,8 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
+      class_attribute :store_full_class_name, instance_writer: false, default: true
+
       # Determines whether to store the full constant name including namespace when using STI.
       # This is true, by default.
       class_attribute :store_full_sti_class, instance_writer: false, default: true
@@ -52,7 +54,7 @@ module ActiveRecord
           raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated."
         end
 
-        if has_attribute?(inheritance_column)
+        if _has_attribute?(inheritance_column)
           subclass = subclass_from_attributes(attributes)
 
           if subclass.nil? && scope_attributes = current_scope&.scope_for_create
@@ -162,12 +164,42 @@ module ActiveRecord
         defined?(@abstract_class) && @abstract_class == true
       end
 
+      # Returns the value to be stored in the inheritance column for STI.
       def sti_name
-        store_full_sti_class ? name : name.demodulize
+        store_full_sti_class && store_full_class_name ? name : name.demodulize
+      end
+
+      # Returns the class for the provided +type_name+.
+      #
+      # It is used to find the class correspondent to the value stored in the inheritance column.
+      def sti_class_for(type_name)
+        if store_full_sti_class && store_full_class_name
+          ActiveSupport::Dependencies.constantize(type_name)
+        else
+          compute_type(type_name)
+        end
+      rescue NameError
+        raise SubclassNotFound,
+          "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " \
+          "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " \
+          "Please rename this column if you didn't intend it to be used for storing the inheritance class " \
+          "or overwrite #{name}.inheritance_column to use another column for that information."
       end
 
+      # Returns the value to be stored in the polymorphic type column for Polymorphic Associations.
       def polymorphic_name
-        base_class.name
+        store_full_class_name ? base_class.name : base_class.name.demodulize
+      end
+
+      # Returns the class for the provided +name+.
+      #
+      # It is used to find the class correspondent to the value stored in the polymorphic type column.
+      def polymorphic_class_for(name)
+        if store_full_class_name
+          ActiveSupport::Dependencies.constantize(name)
+        else
+          compute_type(name)
+        end
       end
 
       def inherited(subclass)
@@ -219,32 +251,22 @@ module ActiveRecord
         end
 
         def using_single_table_inheritance?(record)
-          record[inheritance_column].present? && has_attribute?(inheritance_column)
+          record[inheritance_column].present? && _has_attribute?(inheritance_column)
         end
 
         def find_sti_class(type_name)
           type_name = base_class.type_for_attribute(inheritance_column).cast(type_name)
-          subclass = begin
-            if store_full_sti_class
-              ActiveSupport::Dependencies.constantize(type_name)
-            else
-              compute_type(type_name)
-            end
-          rescue NameError
-            raise SubclassNotFound,
-              "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " \
-              "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " \
-              "Please rename this column if you didn't intend it to be used for storing the inheritance class " \
-              "or overwrite #{name}.inheritance_column to use another column for that information."
-          end
+          subclass = sti_class_for(type_name)
+
           unless subclass == self || descendants.include?(subclass)
             raise SubclassNotFound, "Invalid single-table inheritance type: #{subclass.name} is not a subclass of #{name}"
           end
+
           subclass
         end
 
         def type_condition(table = arel_table)
-          sti_column = arel_attribute(inheritance_column, table)
+          sti_column = table[inheritance_column]
           sti_names  = ([self] + descendants).map(&:sti_name)
 
           predicate_builder.build(sti_column, sti_names)

data/lib/active_record/insert_all.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/enumerable"
+
 module ActiveRecord
   class InsertAll # :nodoc:
     attr_reader :model, :connection, :inserts, :keys
@@ -8,13 +10,19 @@ module ActiveRecord
     def initialize(model, inserts, on_duplicate:, returning: nil, unique_by: nil)
       raise ArgumentError, "Empty list of attributes passed" if inserts.blank?
 
-      @model, @connection, @inserts, @keys = model, model.connection, inserts, inserts.first.keys.map(&:to_s).to_set
+      @model, @connection, @inserts, @keys = model, model.connection, inserts, inserts.first.keys.map(&:to_s)
       @on_duplicate, @returning, @unique_by = on_duplicate, returning, unique_by
 
+      if model.scope_attributes?
+        @scope_attributes = model.scope_attributes
+        @keys |= @scope_attributes.keys
+      end
+      @keys = @keys.to_set
+
       @returning = (connection.supports_insert_returning? ? primary_keys : false) if @returning.nil?
       @returning = false if @returning == []
 
-      @unique_by = find_unique_index_for(unique_by) if unique_by
+      @unique_by = find_unique_index_for(unique_by)
       @on_duplicate = :skip if @on_duplicate == :update && updatable_columns.empty?
 
       ensure_valid_options_for_connection!
@@ -32,7 +40,7 @@ module ActiveRecord
     end
 
     def primary_keys
-      Array(model.primary_key)
+      Array(connection.schema_cache.primary_keys(model.table_name))
     end
 
 
@@ -47,6 +55,8 @@ module ActiveRecord
     def map_key_with_value
       inserts.map do |attributes|
         attributes = attributes.stringify_keys
+        attributes.merge!(scope_attributes) if scope_attributes
+
         verify_attributes(attributes)
 
         keys.map do |key|
@@ -56,13 +66,18 @@ module ActiveRecord
     end
 
     private
+      attr_reader :scope_attributes
+
       def find_unique_index_for(unique_by)
-        match = Array(unique_by).map(&:to_s)
+        name_or_columns = unique_by || model.primary_key
+        match = Array(name_or_columns).map(&:to_s)
 
         if index = unique_indexes.find { |i| match.include?(i.name) || i.columns == match }
           index
+        elsif match == primary_keys
+          unique_by.nil? ? nil : ActiveRecord::ConnectionAdapters::IndexDefinition.new(model.table_name, "#{model.table_name}_primary_key", true, match)
         else
-          raise ArgumentError, "No unique index found for #{unique_by}"
+          raise ArgumentError, "No unique index found for #{name_or_columns}"
         end
       end
 
@@ -151,9 +166,21 @@ module ActiveRecord
           quote_columns(insert_all.updatable_columns)
         end
 
+        def touch_model_timestamps_unless(&block)
+          model.send(:timestamp_attributes_for_update_in_model).map do |column_name|
+            if touch_timestamp_attribute?(column_name)
+              "#{column_name}=(CASE WHEN (#{updatable_columns.map(&block).join(" AND ")}) THEN #{model.quoted_table_name}.#{column_name} ELSE CURRENT_TIMESTAMP END),"
+            end
+          end.compact.join
+        end
+
         private
           attr_reader :connection, :insert_all
 
+          def touch_timestamp_attribute?(column_name)
+            update_duplicates? && !insert_all.updatable_columns.include?(column_name)
+          end
+
           def columns_list
             format_columns(insert_all.keys)
           end

data/lib/active_record/integration.rb

@@ -93,7 +93,7 @@ module ActiveRecord
     # cache_version, but this method can be overwritten to return something else.
     #
     # Note, this method will return nil if ActiveRecord::Base.cache_versioning is set to
-    # +false+ (which it is by default until Rails 6.0).
+    # +false+.
     def cache_version
       return unless cache_versioning
 
@@ -104,10 +104,8 @@ module ActiveRecord
         elsif timestamp = updated_at
           timestamp.utc.to_s(cache_timestamp_format)
         end
-      else
-        if self.class.has_attribute?("updated_at")
-          raise ActiveModel::MissingAttributeError, "missing attribute: updated_at"
-        end
+      elsif self.class.has_attribute?("updated_at")
+        raise ActiveModel::MissingAttributeError, "missing attribute: updated_at"
       end
     end
 

data/lib/active_record/internal_metadata.rb

@@ -6,8 +6,15 @@ require "active_record/scoping/named"
 module ActiveRecord
   # This class is used to create a table that keeps track of values and keys such
   # as which environment migrations were run in.
+  #
+  # This is enabled by default. To disable this functionality set
+  # `use_metadata_table` to false in your database configuration.
   class InternalMetadata < ActiveRecord::Base # :nodoc:
     class << self
+      def enabled?
+        ActiveRecord::Base.connection.use_metadata_table?
+      end
+
       def _internal?
         true
       end
@@ -21,19 +28,21 @@ module ActiveRecord
       end
 
       def []=(key, value)
+        return unless enabled?
+
         find_or_initialize_by(key: key).update!(value: value)
       end
 
       def [](key)
-        where(key: key).pluck(:value).first
-      end
+        return unless enabled?
 
-      def table_exists?
-        connection.table_exists?(table_name)
+        where(key: key).pluck(:value).first
       end
 
       # Creates an internal metadata table with columns +key+ and +value+
       def create_table
+        return unless enabled?
+
         unless table_exists?
           key_options = connection.internal_string_options_for_primary_key
 
@@ -46,6 +55,8 @@ module ActiveRecord
       end
 
       def drop_table
+        return unless enabled?
+
         connection.drop_table table_name, if_exists: true
       end
     end

data/lib/active_record/legacy_yaml_adapter.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  module LegacyYamlAdapter
+  module LegacyYamlAdapter # :nodoc:
     def self.convert(klass, coder)
       return coder unless coder.is_a?(Psych::Coder)
 
       case coder["active_record_yaml_version"]
       when 1, 2 then coder
       else
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          YAML loading from legacy format older than Rails 5.0 is deprecated
+          and will be removed in Rails 6.2.
+        MSG
         if coder["attributes"].is_a?(ActiveModel::AttributeSet)
           Rails420.convert(klass, coder)
         else
@@ -16,7 +20,7 @@ module ActiveRecord
       end
     end
 
-    module Rails420
+    module Rails420 # :nodoc:
       def self.convert(klass, coder)
         attribute_set = coder["attributes"]
 
@@ -32,7 +36,7 @@ module ActiveRecord
       end
     end
 
-    module Rails41
+    module Rails41 # :nodoc:
       def self.convert(klass, coder)
         attributes = klass.attributes_builder
           .build_from_database(coder["attributes"])

data/lib/active_record/locking/optimistic.rb

@@ -89,7 +89,8 @@ module ActiveRecord
 
           begin
             locking_column = self.class.locking_column
-            previous_lock_value = read_attribute_before_type_cast(locking_column)
+            previous_lock_value = attribute_before_type_cast(locking_column)
+            attribute_names = attribute_names.dup if attribute_names.frozen?
             attribute_names << locking_column
 
             self[locking_column] += 1
@@ -97,7 +98,7 @@ module ActiveRecord
             affected_rows = self.class._update_record(
               attributes_with_values(attribute_names),
               @primary_key => id_in_database,
-              locking_column => previous_lock_value
+              locking_column => @attributes[locking_column].original_value_for_database
             )
 
             if affected_rows != 1
@@ -120,7 +121,7 @@ module ActiveRecord
 
           affected_rows = self.class._delete_record(
             @primary_key => id_in_database,
-            locking_column => read_attribute_before_type_cast(locking_column)
+            locking_column => attribute_before_type_cast(locking_column)
           )
 
           if affected_rows != 1
@@ -164,20 +165,12 @@ module ActiveRecord
             super
           end
 
-          private
-            # We need to apply this decorator here, rather than on module inclusion. The closure
-            # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
-            # sub class being decorated. As such, changes to `lock_optimistically`, or
-            # `locking_column` would not be picked up.
-            def inherited(subclass)
-              subclass.class_eval do
-                is_lock_column = ->(name, _) { lock_optimistically && name == locking_column }
-                decorate_matching_attribute_types(is_lock_column, "_optimistic_locking") do |type|
-                  LockingType.new(type)
-                end
-              end
-              super
+          def define_attribute(name, cast_type, **) # :nodoc:
+            if lock_optimistically && name == locking_column
+              cast_type = LockingType.new(cast_type)
             end
+            super
+          end
         end
     end
 
@@ -185,6 +178,10 @@ module ActiveRecord
     # `nil` values to `lock_version`, and not result in `ActiveRecord::StaleObjectError`
     # during update record.
     class LockingType < DelegateClass(Type::Value) # :nodoc:
+      def self.new(subtype)
+        self === subtype ? subtype : super
+      end
+
       def deserialize(value)
         super.to_i
       end

data/lib/active_record/locking/pessimistic.rb

@@ -53,8 +53,12 @@ module ActiveRecord
     #   end
     #
     # Database-specific information on row locking:
-    #   MySQL: https://dev.mysql.com/doc/refman/5.7/en/innodb-locking-reads.html
-    #   PostgreSQL: https://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
+    #
+    # [MySQL]
+    #   https://dev.mysql.com/doc/refman/en/innodb-locking-reads.html
+    #
+    # [PostgreSQL]
+    #   https://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
     module Pessimistic
       # Obtain a row lock on this record. Reloads the record to obtain the requested
       # lock. Pass an SQL locking clause to append the end of the SELECT statement

data/lib/active_record/log_subscriber.rb

@@ -19,6 +19,15 @@ module ActiveRecord
       rt
     end
 
+    def strict_loading_violation(event)
+      debug do
+        owner = event.payload[:owner]
+        association = event.payload[:association]
+
+        color("Strict loading violation: #{association} lazily loaded on #{owner}.", RED)
+      end
+    end
+
     def sql(event)
       self.class.runtime += event.duration
       return unless logger.debug?
@@ -32,11 +41,15 @@ module ActiveRecord
       sql   = payload[:sql]
       binds = nil
 
-      unless (payload[:binds] || []).empty?
+      if payload[:binds]&.any?
         casted_params = type_casted_binds(payload[:type_casted_binds])
-        binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
-          render_bind(attr, value)
-        }.inspect
+
+        binds = []
+        payload[:binds].each_with_index do |attr, i|
+          binds << render_bind(attr, casted_params[i])
+        end
+        binds = binds.inspect
+        binds.prepend("  ")
       end
 
       name = colorize_payload_name(name, payload[:name])
@@ -51,13 +64,18 @@ module ActiveRecord
       end
 
       def render_bind(attr, value)
-        if attr.is_a?(Array)
+        case attr
+        when ActiveModel::Attribute
+          if attr.type.binary? && attr.value
+            value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+          end
+        when Array
           attr = attr.first
-        elsif attr.type.binary? && attr.value
-          value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+        else
+          attr = nil
         end
 
-        [attr && attr.name, value]
+        [attr&.name, value]
       end
 
       def colorize_payload_name(name, payload_name)

data/lib/active_record/middleware/database_selector/resolver/session.rb

@@ -38,6 +38,9 @@ module ActiveRecord
           def update_last_write_timestamp
             session[:last_write] = self.class.convert_time_to_timestamp(Time.now)
           end
+
+          def save(response)
+          end
         end
       end
     end

data/lib/active_record/middleware/database_selector/resolver.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_record/middleware/database_selector/resolver/session"
+require "active_support/core_ext/numeric/time"
 
 module ActiveRecord
   module Middleware
@@ -43,6 +44,10 @@ module ActiveRecord
           write_to_primary(&blk)
         end
 
+        def update_context(response)
+          context.save(response)
+        end
+
         private
           def read_from_primary(&blk)
             ActiveRecord::Base.connected_to(role: ActiveRecord::Base.writing_role, prevent_writes: true) do

data/lib/active_record/middleware/database_selector.rb

@@ -59,11 +59,14 @@ module ActiveRecord
           context = context_klass.call(request)
           resolver = resolver_klass.call(context, options)
 
-          if reading_request?(request)
+          response = if reading_request?(request)
             resolver.read(&blk)
           else
             resolver.write(&blk)
           end
+
+          resolver.update_context(response)
+          response
         end
 
         def reading_request?(request)