activerecord 6.1.7.4 → 7.0.0

data/lib/active_record/railtie.rb

@@ -15,6 +15,7 @@ module ActiveRecord
   # = Active Record Railtie
   class Railtie < Rails::Railtie # :nodoc:
     config.active_record = ActiveSupport::OrderedOptions.new
+    config.active_record.encryption = ActiveSupport::OrderedOptions.new
 
     config.app_generators.orm :active_record, migration: true,
                                               timestamps: true
@@ -30,6 +31,10 @@ module ActiveRecord
     config.active_record.check_schema_cache_dump_version = true
     config.active_record.maintain_test_schema = true
     config.active_record.has_many_inversing = false
+    config.active_record.sqlite3_production_warning = true
+    config.active_record.query_log_tags_enabled = false
+    config.active_record.query_log_tags = [ :application ]
+    config.active_record.cache_query_log_tags = false
 
     config.active_record.queues = ActiveSupport::InheritableOptions.new
 
@@ -60,7 +65,7 @@ module ActiveRecord
         console.level = Rails.logger.level
         Rails.logger.extend ActiveSupport::Logger.broadcast console
       end
-      ActiveRecord::Base.verbose_query_logs = false
+      ActiveRecord.verbose_query_logs = false
     end
 
     runner do
@@ -70,7 +75,6 @@ module ActiveRecord
     initializer "active_record.initialize_timezone" do
       ActiveSupport.on_load(:active_record) do
         self.time_zone_aware_attributes = true
-        self.default_timezone = :utc
       end
     end
 
@@ -83,7 +87,7 @@ module ActiveRecord
     end
 
     initializer "active_record.migration_error" do |app|
-      if config.active_record.delete(:migration_error) == :page_load
+      if config.active_record.migration_error == :page_load
         config.app_middleware.insert_after ::ActionDispatch::Callbacks,
           ActiveRecord::Migration::CheckPending,
           file_watcher: app.config.file_watcher
@@ -91,13 +95,21 @@ module ActiveRecord
     end
 
     initializer "active_record.database_selector" do
-      if options = config.active_record.delete(:database_selector)
-        resolver = config.active_record.delete(:database_resolver)
-        operations = config.active_record.delete(:database_resolver_context)
+      if options = config.active_record.database_selector
+        resolver = config.active_record.database_resolver
+        operations = config.active_record.database_resolver_context
         config.app_middleware.use ActiveRecord::Middleware::DatabaseSelector, resolver, operations, options
       end
     end
 
+    initializer "active_record.shard_selector" do
+      if resolver = config.active_record.shard_resolver
+        options = config.active_record.shard_selector || {}
+
+        config.app_middleware.use ActiveRecord::Middleware::ShardSelector, resolver, options
+      end
+    end
+
     initializer "Check for cache versioning support" do
       config.after_initialize do |app|
         ActiveSupport.on_load(:active_record) do
@@ -124,9 +136,9 @@ To keep using the current cache store, you can turn off cache versioning entirel
     end
 
     initializer "active_record.check_schema_cache_dump" do
-      check_schema_cache_dump_version = config.active_record.delete(:check_schema_cache_dump_version)
+      check_schema_cache_dump_version = config.active_record.check_schema_cache_dump_version
 
-      if config.active_record.delete(:use_schema_cache_dump)
+      if config.active_record.use_schema_cache_dump && !config.active_record.lazily_load_schema_cache
         config.after_initialize do |app|
           ActiveSupport.on_load(:active_record) do
             db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).first
@@ -149,11 +161,12 @@ To keep using the current cache store, you can turn off cache versioning entirel
               next if current_version.nil?
 
               if cache.version != current_version
-                warn "Ignoring #{filename} because it has expired. The current schema version is #{current_version}, but the one in the cache is #{cache.version}."
+                warn "Ignoring #{filename} because it has expired. The current schema version is #{current_version}, but the one in the schema cache file is #{cache.version}."
                 next
               end
             end
 
+            Rails.logger.info("Using schema cache file #{filename}")
             connection_pool.set_schema_cache(cache)
           end
         end
@@ -166,10 +179,6 @@ To keep using the current cache store, you can turn off cache versioning entirel
           if app.config.eager_load
             begin
               descendants.each do |model|
-                # SchemaMigration and InternalMetadata both override `table_exists?`
-                # to bypass the schema cache, so skip them to avoid the extra queries.
-                next if model._internal?
-
                 # If the schema cache was loaded from a dump, we can use it without connecting
                 schema_cache = model.connection_pool.schema_cache
 
@@ -201,12 +210,58 @@ To keep using the current cache store, you can turn off cache versioning entirel
       end
     end
 
+    SQLITE3_PRODUCTION_WARN = "You are running SQLite in production, this is generally not recommended."\
+      " You can disable this warning by setting \"config.active_record.sqlite3_production_warning=false\"."
+    initializer "active_record.sqlite3_production_warning" do
+      if config.active_record.sqlite3_production_warning && Rails.env.production?
+        ActiveSupport.on_load(:active_record_sqlite3adapter) do
+          Rails.logger.warn(SQLITE3_PRODUCTION_WARN)
+        end
+      end
+    end
+
     initializer "active_record.set_configs" do |app|
+      configs = app.config.active_record
+
+      config.after_initialize do
+        configs.each do |k, v|
+          next if k == :encryption
+          setter = "#{k}="
+          if ActiveRecord.respond_to?(setter)
+            ActiveRecord.send(setter, v)
+          end
+        end
+      end
+
       ActiveSupport.on_load(:active_record) do
-        configs = app.config.active_record
+        # Configs used in other initializers
+        configs = configs.except(
+          :migration_error,
+          :database_selector,
+          :database_resolver,
+          :database_resolver_context,
+          :shard_selector,
+          :shard_resolver,
+          :query_log_tags_enabled,
+          :query_log_tags,
+          :cache_query_log_tags,
+          :sqlite3_production_warning,
+          :check_schema_cache_dump_version,
+          :use_schema_cache_dump
+        )
 
         configs.each do |k, v|
-          send "#{k}=", v
+          next if k == :encryption
+          setter = "#{k}="
+          # Some existing initializers might rely on Active Record configuration
+          # being copied from the config object to their actual destination when
+          # `ActiveRecord::Base` is loaded.
+          # So to preserve backward compatibility we copy the config a second time.
+          if ActiveRecord.respond_to?(setter)
+            ActiveRecord.send(setter, v)
+          else
+            send(setter, v)
+          end
         end
       end
     end
@@ -215,10 +270,11 @@ To keep using the current cache store, you can turn off cache versioning entirel
     # and then establishes the connection.
     initializer "active_record.initialize_database" do
       ActiveSupport.on_load(:active_record) do
-        if ActiveRecord::Base.legacy_connection_handling
-          self.connection_handlers = { writing_role => ActiveRecord::Base.default_connection_handler }
+        if ActiveRecord.legacy_connection_handling
+          self.connection_handlers = { ActiveRecord.writing_role => ActiveRecord::Base.default_connection_handler }
         end
         self.configurations = Rails.application.config.database_configuration
+
         establish_connection
       end
     end
@@ -244,6 +300,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
 
     initializer "active_record.set_executor_hooks" do
       ActiveRecord::QueryCache.install_executor_hooks
+      ActiveRecord::AsynchronousQueriesTracker.install_executor_hooks
     end
 
     initializer "active_record.add_watchable_files" do |app|
@@ -279,5 +336,58 @@ To keep using the current cache store, you can turn off cache versioning entirel
         self.signed_id_verifier_secret ||= -> { Rails.application.key_generator.generate_key("active_record/signed_id") }
       end
     end
+
+    initializer "active_record_encryption.configuration" do |app|
+      ActiveRecord::Encryption.configure \
+         primary_key: app.credentials.dig(:active_record_encryption, :primary_key),
+         deterministic_key: app.credentials.dig(:active_record_encryption, :deterministic_key),
+         key_derivation_salt: app.credentials.dig(:active_record_encryption, :key_derivation_salt),
+         **config.active_record.encryption
+
+      ActiveSupport.on_load(:active_record) do
+        # Support extended queries for deterministic attributes and validations
+        if ActiveRecord::Encryption.config.extend_queries
+          ActiveRecord::Encryption::ExtendedDeterministicQueries.install_support
+          ActiveRecord::Encryption::ExtendedDeterministicUniquenessValidator.install_support
+        end
+      end
+
+      ActiveSupport.on_load(:active_record_fixture_set) do
+        # Encrypt active record fixtures
+        if ActiveRecord::Encryption.config.encrypt_fixtures
+          ActiveRecord::Fixture.prepend ActiveRecord::Encryption::EncryptedFixtures
+        end
+      end
+
+      # Filtered params
+      ActiveSupport.on_load(:action_controller) do
+        if ActiveRecord::Encryption.config.add_to_filter_parameters
+          ActiveRecord::Encryption.install_auto_filtered_parameters(app)
+        end
+      end
+    end
+
+    initializer "active_record.query_log_tags_config" do |app|
+      config.after_initialize do
+        if app.config.active_record.query_log_tags_enabled
+          ActiveRecord.query_transformers << ActiveRecord::QueryLogs
+          ActiveRecord::QueryLogs.taggings.merge!(
+            application:  Rails.application.class.name.split("::").first,
+            pid:          -> { Process.pid },
+            socket:       -> { ActiveRecord::Base.connection_db_config.socket },
+            db_host:      -> { ActiveRecord::Base.connection_db_config.host },
+            database:     -> { ActiveRecord::Base.connection_db_config.database }
+          )
+
+          if app.config.active_record.query_log_tags.present?
+            ActiveRecord::QueryLogs.tags = app.config.active_record.query_log_tags
+          end
+
+          if app.config.active_record.cache_query_log_tags
+            ActiveRecord::QueryLogs.cache_query_log_tags = true
+          end
+        end
+      end
+    end
   end
 end

data/lib/active_record/railties/controller_runtime.rb

@@ -5,7 +5,7 @@ require "active_record/log_subscriber"
 
 module ActiveRecord
   module Railties # :nodoc:
-    module ControllerRuntime #:nodoc:
+    module ControllerRuntime # :nodoc:
       extend ActiveSupport::Concern
 
       module ClassMethods # :nodoc:

data/lib/active_record/railties/databases.rake

@@ -86,19 +86,30 @@ db_namespace = namespace :db do
 
   desc "Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)."
   task migrate: :load_config do
-    original_db_config = ActiveRecord::Base.connection_db_config
-    ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
-      ActiveRecord::Base.establish_connection(db_config)
+    db_configs = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
+
+    if db_configs.size == 1
       ActiveRecord::Tasks::DatabaseTasks.migrate
+    else
+      original_db_config = ActiveRecord::Base.connection_db_config
+      mapped_versions = ActiveRecord::Tasks::DatabaseTasks.db_configs_with_versions(db_configs)
+
+      mapped_versions.sort.each do |version, db_configs|
+        db_configs.each do |db_config|
+          ActiveRecord::Base.establish_connection(db_config)
+          ActiveRecord::Tasks::DatabaseTasks.migrate(version)
+        end
+      end
     end
+
     db_namespace["_dump"].invoke
   ensure
-    ActiveRecord::Base.establish_connection(original_db_config)
+    ActiveRecord::Base.establish_connection(original_db_config) if original_db_config
   end
 
-  # IMPORTANT: This task won't dump the schema if ActiveRecord::Base.dump_schema_after_migration is set to false
+  # IMPORTANT: This task won't dump the schema if ActiveRecord.dump_schema_after_migration is set to false
   task :_dump do
-    if ActiveRecord::Base.dump_schema_after_migration
+    if ActiveRecord.dump_schema_after_migration
       db_namespace["schema:dump"].invoke
     end
     # Allow this task to be called as many times as required. An example is the
@@ -108,11 +119,15 @@ db_namespace = namespace :db do
 
   namespace :_dump do
     ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
-      # IMPORTANT: This task won't dump the schema if ActiveRecord::Base.dump_schema_after_migration is set to false
+      # IMPORTANT: This task won't dump the schema if ActiveRecord.dump_schema_after_migration is set to false
       task name do
-        if ActiveRecord::Base.dump_schema_after_migration
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env, name: name)
+
+        if ActiveRecord.dump_schema_after_migration && db_config.schema_dump
+          ActiveRecord::Base.establish_connection(db_config)
           db_namespace["schema:dump:#{name}"].invoke
         end
+
         # Allow this task to be called as many times as required. An example is the
         # migrate:redo task, which calls other two internally that depend on this one.
         db_namespace["_dump:#{name}"].reenable
@@ -275,6 +290,7 @@ db_namespace = namespace :db do
   desc "Rolls the schema back to the previous version (specify steps w/ STEP=n)."
   task rollback: :load_config do
     ActiveRecord::Tasks::DatabaseTasks.raise_for_multi_db(command: "db:rollback")
+    raise "VERSION is not supported - To rollback a specific version, use db:migrate:down" if ENV["VERSION"]
 
     step = ENV["STEP"] ? ENV["STEP"].to_i : 1
 
@@ -290,7 +306,16 @@ db_namespace = namespace :db do
     db_namespace["_dump"].invoke
   end
 
-  desc "Drops and recreates the database from db/schema.rb for the current environment and loads the seeds."
+  namespace :reset do
+    task all: ["db:drop", "db:setup"]
+
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+      desc "Drops and recreates the #{name} database from its schema for the current environment and loads the seeds."
+      task name => ["db:drop:#{name}", "db:setup:#{name}"]
+    end
+  end
+
+  desc "Drops and recreates all databases from their schema for the current environment and loads the seeds."
   task reset: [ "db:drop", "db:setup" ]
 
   # desc "Retrieves the charset for the current environment's database"
@@ -307,7 +332,7 @@ db_namespace = namespace :db do
 
   desc "Retrieves the current schema version number"
   task version: :load_config do
-    puts "Current version: #{ActiveRecord::Base.connection.migration_context.current_version}"
+    puts "Current version: #{ActiveRecord::Base.connection.schema_version}"
   end
 
   # desc "Raises an error if there are pending migrations"
@@ -349,41 +374,21 @@ db_namespace = namespace :db do
     end
   end
 
-  desc "Creates the database, loads the schema, and initializes with the seed data (use db:reset to also drop the database first)"
+  namespace :setup do
+    task all: ["db:create", :environment, "db:schema:load", :seed]
+
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
+      desc "Creates the #{name} database, loads the schema, and initializes with the seed data (use db:reset:#{name} to also drop the database first)"
+      task name => ["db:create:#{name}", :environment, "db:schema:load:#{name}", "db:seed"]
+    end
+  end
+
+  desc "Creates all databases, loads all schemas, and initializes with the seed data (use db:reset to also drop all databases first)"
   task setup: ["db:create", :environment, "db:schema:load", :seed]
 
   desc "Runs setup if database does not exist, or runs migrations if it does"
   task prepare: :load_config do
-    seed = false
-
-    ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
-      ActiveRecord::Base.establish_connection(db_config)
-
-      # Skipped when no database
-      ActiveRecord::Tasks::DatabaseTasks.migrate
-
-      if ActiveRecord::Base.dump_schema_after_migration
-        ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config, ActiveRecord::Base.schema_format)
-      end
-    rescue ActiveRecord::NoDatabaseError
-      config_name = db_config.name
-      ActiveRecord::Tasks::DatabaseTasks.create_current(db_config.env_name, config_name)
-
-      if File.exist?(ActiveRecord::Tasks::DatabaseTasks.dump_filename(config_name))
-        ActiveRecord::Tasks::DatabaseTasks.load_schema(
-          db_config,
-          ActiveRecord::Base.schema_format,
-          nil
-        )
-      else
-        ActiveRecord::Tasks::DatabaseTasks.migrate
-      end
-
-      seed = true
-    end
-
-    ActiveRecord::Base.establish_connection
-    ActiveRecord::Tasks::DatabaseTasks.load_seed if seed
+    ActiveRecord::Tasks::DatabaseTasks.prepare_all
   end
 
   desc "Loads the seed data from db/seeds.rb"
@@ -450,8 +455,10 @@ db_namespace = namespace :db do
     desc "Creates a database schema file (either db/schema.rb or db/structure.sql, depending on `config.active_record.schema_format`)"
     task dump: :load_config do
       ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
-        ActiveRecord::Base.establish_connection(db_config)
-        ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config)
+        if db_config.schema_dump
+          ActiveRecord::Base.establish_connection(db_config)
+          ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config)
+        end
       end
 
       db_namespace["schema:dump"].reenable
@@ -459,15 +466,7 @@ db_namespace = namespace :db do
 
     desc "Loads a database schema file (either db/schema.rb or db/structure.sql, depending on `config.active_record.schema_format`) into the database"
     task load: [:load_config, :check_protected_environments] do
-      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(ActiveRecord::Base.schema_format, ENV["SCHEMA"])
-    end
-
-    task load_if_ruby: ["db:create", :environment] do
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        Using `bin/rails db:schema:load_if_ruby` is deprecated and will be removed in Rails 7.0.
-        Configure the format using `config.active_record.schema_format = :ruby` to use `schema.rb` and run `bin/rails db:schema:load` instead.
-      MSG
-      db_namespace["schema:load"].invoke if ActiveRecord::Base.schema_format == :ruby
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(ActiveRecord.schema_format, ENV["SCHEMA"])
     end
 
     namespace :dump do
@@ -486,8 +485,11 @@ db_namespace = namespace :db do
       ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
         desc "Loads a database schema file (either db/schema.rb or db/structure.sql, depending on `config.active_record.schema_format`) into the #{name} database"
         task name => :load_config do
+          original_db_config = ActiveRecord::Base.connection_db_config
           db_config = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env, name: name)
-          ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config, ActiveRecord::Base.schema_format, ENV["SCHEMA"])
+          ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config)
+        ensure
+          ActiveRecord::Base.establish_connection(original_db_config) if original_db_config
         end
       end
     end
@@ -523,60 +525,17 @@ db_namespace = namespace :db do
     end
   end
 
-  namespace :structure do
-    desc "Dumps the database structure to db/structure.sql. Specify another file with SCHEMA=db/my_structure.sql"
-    task dump: :load_config do
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        Using `bin/rails db:structure:dump` is deprecated and will be removed in Rails 7.0.
-        Configure the format using `config.active_record.schema_format = :sql` to use `structure.sql` and run `bin/rails db:schema:dump` instead.
-      MSG
-
-      db_namespace["schema:dump"].invoke
-      db_namespace["structure:dump"].reenable
-    end
+  namespace :encryption do
+    desc "Generate a set of keys for configuring Active Record encryption in a given environment"
+    task :init do
+      puts <<~MSG
+        Add this entry to the credentials of the target environment:#{' '}
 
-    desc "Recreates the databases from the structure.sql file"
-    task load: [:load_config, :check_protected_environments] do
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        Using `bin/rails db:structure:load` is deprecated and will be removed in Rails 7.0.
-        Configure the format using `config.active_record.schema_format = :sql` to use `structure.sql` and run `bin/rails db:schema:load` instead.
+        active_record_encryption:
+          primary_key: #{SecureRandom.alphanumeric(32)}
+          deterministic_key: #{SecureRandom.alphanumeric(32)}
+          key_derivation_salt: #{SecureRandom.alphanumeric(32)}
       MSG
-      db_namespace["schema:load"].invoke
-    end
-
-    task load_if_sql: ["db:create", :environment] do
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        Using `bin/rails db:structure:load_if_sql` is deprecated and will be removed in Rails 7.0.
-        Configure the format using `config.active_record.schema_format = :sql` to use `structure.sql` and run `bin/rails db:schema:load` instead.
-      MSG
-      db_namespace["schema:load"].invoke if ActiveRecord::Base.schema_format == :sql
-    end
-
-    namespace :dump do
-      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
-        desc "Dumps the #{name} database structure to db/structure.sql. Specify another file with SCHEMA=db/my_structure.sql"
-        task name => :load_config do
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Using `bin/rails db:structure:dump:#{name}` is deprecated and will be removed in Rails 7.0.
-            Configure the format using `config.active_record.schema_format = :sql` to use `structure.sql` and run `bin/rails db:schema:dump:#{name}` instead.
-          MSG
-          db_namespace["schema:dump:#{name}"].invoke
-          db_namespace["structure:dump:#{name}"].reenable
-        end
-      end
-    end
-
-    namespace :load do
-      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
-        desc "Recreates the #{name} database from the structure.sql file"
-        task name => :load_config do
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Using `bin/rails db:structure:load:#{name}` is deprecated and will be removed in Rails 7.0.
-            Configure the format using `config.active_record.schema_format = :sql` to use `structure.sql` and run `bin/rails db:schema:load:#{name}` instead.
-          MSG
-          db_namespace["schema:load:#{name}"].invoke
-        end
-      end
     end
   end
 
@@ -591,8 +550,7 @@ db_namespace = namespace :db do
       should_reconnect = ActiveRecord::Base.connection_pool.active_connection?
       ActiveRecord::Schema.verbose = false
       ActiveRecord::Base.configurations.configs_for(env_name: "test").each do |db_config|
-        filename = ActiveRecord::Tasks::DatabaseTasks.dump_filename(db_config.name)
-        ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config, ActiveRecord::Base.schema_format, filename)
+        ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config)
       end
     ensure
       if should_reconnect
@@ -600,15 +558,6 @@ db_namespace = namespace :db do
       end
     end
 
-    # desc "Recreate the test database from an existent structure.sql file"
-    task load_structure: %w(db:test:purge) do
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        Using `bin/rails db:test:load_structure` is deprecated and will be removed in Rails 7.0.
-        Configure the format using `config.active_record.schema_format = :sql` to use `structure.sql` and run `bin/rails db:test:load_schema` instead.
-      MSG
-      db_namespace["test:load_schema"].invoke
-    end
-
     # desc "Empty the test database"
     task purge: %w(load_config check_protected_environments) do
       ActiveRecord::Base.configurations.configs_for(env_name: "test").each do |db_config|
@@ -636,9 +585,8 @@ db_namespace = namespace :db do
         task name => "db:test:purge:#{name}" do
           should_reconnect = ActiveRecord::Base.connection_pool.active_connection?
           ActiveRecord::Schema.verbose = false
-          filename = ActiveRecord::Tasks::DatabaseTasks.dump_filename(name)
           db_config = ActiveRecord::Base.configurations.configs_for(env_name: "test", name: name)
-          ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config, ActiveRecord::Base.schema_format, filename)
+          ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config)
         ensure
           if should_reconnect
             ActiveRecord::Base.establish_connection(ActiveRecord::Tasks::DatabaseTasks.env.to_sym)
@@ -646,17 +594,6 @@ db_namespace = namespace :db do
         end
       end
 
-      # desc "Recreate the #{name} test database from an existent structure.sql file"
-      namespace :load_structure do
-        task name => "db:test:purge:#{name}" do
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Using `bin/rails db:test:load_structure:#{name}` is deprecated and will be removed in Rails 7.0.
-            Configure the format using `config.active_record.schema_format = :sql` to use `structure.sql` and run `bin/rails db:test:load_structure:#{name}` instead.
-          MSG
-          db_namespace["test:load_schema:#{name}"].invoke
-        end
-      end
-
       # desc "Empty the #{name} test database"
       namespace :purge do
         task name => %w(load_config check_protected_environments) do

data/lib/active_record/readonly_attributes.rb

@@ -11,6 +11,17 @@ module ActiveRecord
     module ClassMethods
       # Attributes listed as readonly will be used to create a new record but update operations will
       # ignore these fields.
+      #
+      # You can assign a new value to a readonly attribute, but it will be ignored when the record is updated.
+      #
+      # ==== Examples
+      #
+      #   class Post < ActiveRecord::Base
+      #     attr_readonly :title
+      #   end
+      #
+      #   post = Post.create!(title: "Introducing Ruby on Rails!")
+      #   post.update(title: "a different title") # change to title will be ignored
       def attr_readonly(*attributes)
         self._attr_readonly = Set.new(attributes.map(&:to_s)) + (_attr_readonly || [])
       end