activerecord 7.0.0.alpha1 → 7.0.0.rc3

data/lib/active_record/model_schema.rb

@@ -571,7 +571,6 @@ module ActiveRecord
           @columns_hash.each do |name, column|
             type = connection.lookup_cast_type_from_column(column)
             type = _convert_type_from_options(type)
-            warn_if_deprecated_type(column)
             define_attribute(
               name,
               type,
@@ -595,7 +594,7 @@ module ActiveRecord
           @schema_loaded = false
           @attribute_names = nil
           @yaml_encoder = nil
-          direct_descendants.each do |descendant|
+          subclasses.each do |descendant|
             descendant.send(:reload_schema_from_cache)
           end
         end
@@ -630,32 +629,6 @@ module ActiveRecord
             type
           end
         end
-
-        def warn_if_deprecated_type(column)
-          return if attributes_to_define_after_schema_loads.key?(column.name)
-          return unless column.respond_to?(:array?)
-
-          if column.array?
-            array_arguments = ", array: true"
-          else
-            array_arguments = ""
-          end
-
-          if column.sql_type.start_with?("interval")
-            precision_arguments = column.precision.presence && ", precision: #{column.precision}"
-            ActiveSupport::Deprecation.warn(<<~WARNING)
-              The behavior of the `:interval` type will be changing in Rails 7.0
-              to return an `ActiveSupport::Duration` object. If you'd like to keep
-              the old behavior, you can add this line to #{self.name} model:
-
-                attribute :#{column.name}, :string#{precision_arguments}#{array_arguments}
-
-              If you'd like the new behavior today, you can add this line:
-
-                attribute :#{column.name}, :interval#{precision_arguments}#{array_arguments}
-            WARNING
-          end
-        end
     end
   end
 end

data/lib/active_record/nested_attributes.rb

@@ -245,18 +245,19 @@ module ActiveRecord
     #
     # === Validating the presence of a parent model
     #
-    # If you want to validate that a child record is associated with a parent
-    # record, you can use the +validates_presence_of+ method and the +:inverse_of+
-    # key as this example illustrates:
-    #
-    #   class Member < ActiveRecord::Base
-    #     has_many :posts, inverse_of: :member
-    #     accepts_nested_attributes_for :posts
+    # The +belongs_to+ association validates the presence of the parent model
+    # by default. You can disable this behavior by specifying <code>optional: true</code>.
+    # This can be used, for example, when conditionally validating the presence
+    # of the parent model:
+    #
+    #   class Veterinarian < ActiveRecord::Base
+    #     has_many :patients, inverse_of: :veterinarian
+    #     accepts_nested_attributes_for :patients
     #   end
     #
-    #   class Post < ActiveRecord::Base
-    #     belongs_to :member, inverse_of: :posts
-    #     validates_presence_of :member
+    #   class Patient < ActiveRecord::Base
+    #     belongs_to :veterinarian, inverse_of: :patients, optional: true
+    #     validates :veterinarian, presence: true, unless: -> { awaiting_intake }
     #   end
     #
     # Note that if you do not specify the +:inverse_of+ option, then

data/lib/active_record/no_touching.rb

@@ -39,7 +39,7 @@ module ActiveRecord
 
       private
         def klasses
-          Thread.current[:no_touching_classes] ||= []
+          ActiveSupport::IsolatedExecutionState[:active_record_no_touching_classes] ||= []
         end
     end
 

data/lib/active_record/persistence.rb

@@ -63,8 +63,8 @@ module ActiveRecord
       # go through Active Record's type casting and serialization.
       #
       # See <tt>ActiveRecord::Persistence#insert_all</tt> for documentation.
-      def insert(attributes, returning: nil, unique_by: nil)
-        insert_all([ attributes ], returning: returning, unique_by: unique_by)
+      def insert(attributes, returning: nil, unique_by: nil, record_timestamps: nil)
+        insert_all([ attributes ], returning: returning, unique_by: unique_by, record_timestamps: record_timestamps)
       end
 
       # Inserts multiple records into the database in a single SQL INSERT
@@ -110,6 +110,17 @@ module ActiveRecord
       #     unique_by: %i[ author_id name ]
       #     unique_by: :index_books_on_isbn
       #
+      # [:record_timestamps]
+      #   By default, automatic setting of timestamp columns is controlled by
+      #   the model's <tt>record_timestamps</tt> config, matching typical
+      #   behavior.
+      #
+      #   To override this and force automatic setting of timestamp columns one
+      #   way or the other, pass <tt>:record_timestamps</tt>:
+      #
+      #     record_timestamps: true  # Always set timestamps automatically
+      #     record_timestamps: false # Never set timestamps automatically
+      #
       # Because it relies on the index information from the database
       # <tt>:unique_by</tt> is recommended to be paired with
       # Active Record's schema_cache.
@@ -131,8 +142,8 @@ module ActiveRecord
       #     { id: 1, title: "Rework" },
       #     { id: 2, title: "Eloquent Ruby" }
       #   ])
-      def insert_all(attributes, returning: nil, unique_by: nil)
-        InsertAll.new(self, attributes, on_duplicate: :skip, returning: returning, unique_by: unique_by).execute
+      def insert_all(attributes, returning: nil, unique_by: nil, record_timestamps: nil)
+        InsertAll.new(self, attributes, on_duplicate: :skip, returning: returning, unique_by: unique_by, record_timestamps: record_timestamps).execute
       end
 
       # Inserts a single record into the database in a single SQL INSERT
@@ -141,8 +152,8 @@ module ActiveRecord
       # go through Active Record's type casting and serialization.
       #
       # See <tt>ActiveRecord::Persistence#insert_all!</tt> for more.
-      def insert!(attributes, returning: nil)
-        insert_all!([ attributes ], returning: returning)
+      def insert!(attributes, returning: nil, record_timestamps: nil)
+        insert_all!([ attributes ], returning: returning, record_timestamps: record_timestamps)
       end
 
       # Inserts multiple records into the database in a single SQL INSERT
@@ -174,6 +185,17 @@ module ActiveRecord
       #   You can also pass an SQL string if you need more control on the return values
       #   (for example, <tt>returning: "id, name as new_name"</tt>).
       #
+      # [:record_timestamps]
+      #   By default, automatic setting of timestamp columns is controlled by
+      #   the model's <tt>record_timestamps</tt> config, matching typical
+      #   behavior.
+      #
+      #   To override this and force automatic setting of timestamp columns one
+      #   way or the other, pass <tt>:record_timestamps</tt>:
+      #
+      #     record_timestamps: true  # Always set timestamps automatically
+      #     record_timestamps: false # Never set timestamps automatically
+      #
       # ==== Examples
       #
       #   # Insert multiple records
@@ -188,8 +210,8 @@ module ActiveRecord
       #     { id: 1, title: "Rework", author: "David" },
       #     { id: 1, title: "Eloquent Ruby", author: "Russ" }
       #   ])
-      def insert_all!(attributes, returning: nil)
-        InsertAll.new(self, attributes, on_duplicate: :raise, returning: returning).execute
+      def insert_all!(attributes, returning: nil, record_timestamps: nil)
+        InsertAll.new(self, attributes, on_duplicate: :raise, returning: returning, record_timestamps: record_timestamps).execute
       end
 
       # Updates or inserts (upserts) a single record into the database in a
@@ -198,8 +220,8 @@ module ActiveRecord
       # go through Active Record's type casting and serialization.
       #
       # See <tt>ActiveRecord::Persistence#upsert_all</tt> for documentation.
-      def upsert(attributes, on_duplicate: :update, returning: nil, unique_by: nil)
-        upsert_all([ attributes ], on_duplicate: on_duplicate, returning: returning, unique_by: unique_by)
+      def upsert(attributes, on_duplicate: :update, returning: nil, unique_by: nil, record_timestamps: nil)
+        upsert_all([ attributes ], on_duplicate: on_duplicate, returning: returning, unique_by: unique_by, record_timestamps: record_timestamps)
       end
 
       # Updates or inserts (upserts) multiple records into the database in a
@@ -213,6 +235,10 @@ module ActiveRecord
       # Returns an <tt>ActiveRecord::Result</tt> with its contents based on
       # <tt>:returning</tt> (see below).
       #
+      # By default, +upsert_all+ will update all the columns that can be updated when
+      # there is a conflict. These are all the columns except primary keys, read-only
+      # columns, and columns covered by the optional +unique_by+.
+      #
       # ==== Options
       #
       # [:returning]
@@ -246,9 +272,52 @@ module ActiveRecord
       # Active Record's schema_cache.
       #
       # [:on_duplicate]
-      #   Specify a custom SQL for updating rows on conflict.
+      #   Configure the SQL update sentence that will be used in case of conflict.
+      #
+      #   NOTE: If you use this option you must provide all the columns you want to update
+      #   by yourself.
+      #
+      #   Example:
+      #
+      #     Commodity.upsert_all(
+      #       [
+      #         { id: 2, name: "Copper", price: 4.84 },
+      #         { id: 4, name: "Gold", price: 1380.87 },
+      #         { id: 6, name: "Aluminium", price: 0.35 }
+      #       ],
+      #       on_duplicate: Arel.sql("price = GREATEST(commodities.price, EXCLUDED.price)")
+      #     )
+      #
+      #   See the related +:update_only+ option. Both options can't be used at the same time.
       #
-      #   NOTE: in this case you must provide all the columns you want to update by yourself.
+      # [:update_only]
+      #   Provide a list of column names that will be updated in case of conflict. If not provided,
+      #   +upsert_all+ will update all the columns that can be updated. These are all the columns
+      #   except primary keys, read-only columns, and columns covered by the optional +unique_by+
+      #
+      #   Example:
+      #
+      #     Commodity.upsert_all(
+      #       [
+      #         { id: 2, name: "Copper", price: 4.84 },
+      #         { id: 4, name: "Gold", price: 1380.87 },
+      #         { id: 6, name: "Aluminium", price: 0.35 }
+      #       ],
+      #       update_only: [:price] # Only prices will be updated
+      #     )
+      #
+      #   See the related +:on_duplicate+ option. Both options can't be used at the same time.
+      #
+      # [:record_timestamps]
+      #   By default, automatic setting of timestamp columns is controlled by
+      #   the model's <tt>record_timestamps</tt> config, matching typical
+      #   behavior.
+      #
+      #   To override this and force automatic setting of timestamp columns one
+      #   way or the other, pass <tt>:record_timestamps</tt>:
+      #
+      #     record_timestamps: true  # Always set timestamps automatically
+      #     record_timestamps: false # Never set timestamps automatically
       #
       # ==== Examples
       #
@@ -261,8 +330,8 @@ module ActiveRecord
       #   ], unique_by: :isbn)
       #
       #   Book.find_by(isbn: "1").title # => "Eloquent Ruby"
-      def upsert_all(attributes, on_duplicate: :update, returning: nil, unique_by: nil)
-        InsertAll.new(self, attributes, on_duplicate: on_duplicate, returning: returning, unique_by: unique_by).execute
+      def upsert_all(attributes, on_duplicate: :update, update_only: nil, returning: nil, unique_by: nil, record_timestamps: nil)
+        InsertAll.new(self, attributes, on_duplicate: on_duplicate, update_only: update_only, returning: returning, unique_by: unique_by, record_timestamps: record_timestamps).execute
       end
 
       # Given an attributes hash, +instantiate+ returns a new instance of
@@ -431,9 +500,8 @@ module ActiveRecord
       def _update_record(values, constraints) # :nodoc:
         constraints = constraints.map { |name, value| predicate_builder[name, value] }
 
-        if default_scopes?(all_queries: true)
-          constraints << default_scoped(all_queries: true).where_clause.ast
-        end
+        default_constraint = build_default_constraint
+        constraints << default_constraint if default_constraint
 
         if current_scope = self.global_current_scope
           constraints << current_scope.where_clause.ast
@@ -449,9 +517,8 @@ module ActiveRecord
       def _delete_record(constraints) # :nodoc:
         constraints = constraints.map { |name, value| predicate_builder[name, value] }
 
-        if default_scopes?(all_queries: true)
-          constraints << default_scoped(all_queries: true).where_clause.ast
-        end
+        default_constraint = build_default_constraint
+        constraints << default_constraint if default_constraint
 
         if current_scope = self.global_current_scope
           constraints << current_scope.where_clause.ast
@@ -479,6 +546,16 @@ module ActiveRecord
         def discriminate_class_for_record(record)
           self
         end
+
+        # Called by +_update_record+ and +_delete_record+
+        # to build `where` clause from default scopes.
+        # Skips empty scopes.
+        def build_default_constraint
+          return unless default_scopes?(all_queries: true)
+
+          default_where_clause = default_scoped(all_queries: true).where_clause
+          default_where_clause.ast unless default_where_clause.empty?
+        end
     end
 
     # Returns true if this object hasn't been saved yet -- that is, a record
@@ -1035,7 +1112,8 @@ module ActiveRecord
 
     def _raise_record_not_destroyed
       @_association_destroy_exception ||= nil
-      raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy the record", self)
+      key = self.class.primary_key
+      raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy #{self.class} with #{key}=#{send(key)}", self)
     ensure
       @_association_destroy_exception = nil
     end

data/lib/active_record/query_logs.rb

@@ -38,24 +38,24 @@ module ActiveRecord
   #    tags = [
   #      :application,
   #      {
-  #        custom_tag: ->(context) { context[:controller].controller_name },
+  #        custom_tag: ->(context) { context[:controller]&.controller_name },
   #        custom_value: -> { Custom.value },
   #      }
   #    ]
   #    ActiveRecord::QueryLogs.tags = tags
   #
-  # The QueryLogs +context+ can be manipulated via +update_context+ & +set_context+ methods.
-  #
-  # Direct updates to a context value:
-  #
-  #    ActiveRecord::QueryLogs.update_context(foo: Bar.new)
+  # The QueryLogs +context+ can be manipulated via the +ActiveSupport::ExecutionContext.set+ method.
   #
   # Temporary updates limited to the execution of a block:
   #
-  #    ActiveRecord::QueryLogs.set_context(foo: Bar.new) do
+  #    ActiveSupport::ExecutionContext.set(foo: Bar.new) do
   #      posts = Post.all
   #    end
   #
+  # Direct updates to a context value:
+  #
+  #    ActiveSupport::ExecutionContext[:foo] = Bar.new
+  #
   # Tag comments can be prepended to the query:
   #
   #    ActiveRecord::QueryLogs.prepend_comment = true
@@ -75,66 +75,22 @@ module ActiveRecord
     mattr_accessor :cache_query_log_tags, instance_accessor: false, default: false
     thread_mattr_accessor :cached_comment, instance_accessor: false
 
-    class NullObject # :nodoc:
-      def method_missing(method, *args, &block)
-        NullObject.new
-      end
-
-      def nil?
-        true
-      end
-
-      private
-        def respond_to_missing?(method, include_private = false)
-          true
-        end
-    end
-
     class << self
-      # Updates the context used to construct tags in the SQL comment.
-      # Resets the cached comment if <tt>cache_query_log_tags</tt> is +true+.
-      def update_context(**options)
-        context.merge!(**options.symbolize_keys)
-        self.cached_comment = nil
-      end
-
-      # Updates the context used to construct tags in the SQL comment during
-      # execution of the provided block. Resets the provided keys to their
-      # previous value once the block exits.
-      def set_context(**options)
-        keys = options.keys
-        previous_context = keys.zip(context.values_at(*keys)).to_h
-        update_context(**options)
-        yield if block_given?
-      ensure
-        update_context(**previous_context)
-      end
-
-      # Temporarily tag any query executed within `&block`. Can be nested.
-      def with_tag(tag, &block)
-        inline_tags.push(tag)
-        yield if block_given?
-      ensure
-        inline_tags.pop
-      end
-
       def call(sql) # :nodoc:
-        parts = self.comments
         if prepend_comment
-          parts << sql
+          "#{self.comment} #{sql}"
         else
-          parts.unshift(sql)
-        end
-        parts.join(" ")
+          "#{sql} #{self.comment}"
+        end.strip
       end
 
-      private
-        # Returns an array of comments which need to be added to the query, comprised
-        # of configured and inline tags.
-        def comments
-          [ comment, inline_comment ].compact
-        end
+      def clear_cache # :nodoc:
+        self.cached_comment = nil
+      end
+
+      ActiveSupport::ExecutionContext.after_change { ActiveRecord::QueryLogs.clear_cache }
 
+      private
         # Returns an SQL comment +String+ containing the query log tags.
         # Sets and returns a cached comment if <tt>cache_query_log_tags</tt> is +true+.
         def comment
@@ -152,30 +108,13 @@ module ActiveRecord
           end
         end
 
-        # Returns a +String+ containing any inline comments from +with_tag+.
-        def inline_comment
-          return nil unless inline_tags.present?
-          "/*#{escape_sql_comment(inline_tag_content)}*/"
-        end
-
-        # Return the set of active inline tags from +with_tag+.
-        def inline_tags
-          if context[:inline_tags].nil?
-            context[:inline_tags] = []
-          else
-            context[:inline_tags]
-          end
-        end
-
-        def context
-          Thread.current[:active_record_query_log_tags_context] ||= Hash.new { NullObject.new }
-        end
-
         def escape_sql_comment(content)
           content.to_s.gsub(%r{ (/ (?: | \g<1>) \*) \+? \s* | \s* (\* (?: | \g<2>) /) }x, "")
         end
 
         def tag_content
+          context = ActiveSupport::ExecutionContext.to_h
+
           tags.flat_map { |i| [*i] }.filter_map do |tag|
             key, handler = tag
             handler ||= taggings[key]
@@ -194,10 +133,6 @@ module ActiveRecord
             "#{key}:#{val}" unless val.nil?
           end.join(",")
         end
-
-        def inline_tag_content
-          inline_tags.join
-        end
     end
   end
 end

data/lib/active_record/railtie.rb

@@ -102,6 +102,14 @@ module ActiveRecord
       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
@@ -130,7 +138,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
     initializer "active_record.check_schema_cache_dump" do
       check_schema_cache_dump_version = config.active_record.check_schema_cache_dump_version
 
-      if config.active_record.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
@@ -232,6 +240,8 @@ To keep using the current cache store, you can turn off cache versioning entirel
           :database_selector,
           :database_resolver,
           :database_resolver_context,
+          :shard_selector,
+          :shard_resolver,
           :query_log_tags_enabled,
           :query_log_tags,
           :cache_query_log_tags,

data/lib/active_record/railties/databases.rake

@@ -332,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"
@@ -469,14 +469,6 @@ db_namespace = namespace :db do
       ActiveRecord::Tasks::DatabaseTasks.load_schema_current(ActiveRecord.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.schema_format == :ruby
-    end
-
     namespace :dump do
       ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
         desc "Creates a database schema file (either db/schema.rb or db/structure.sql, depending on `config.active_record.schema_format`) for #{name} database"
@@ -495,7 +487,7 @@ db_namespace = namespace :db do
         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.schema_format, ENV["SCHEMA"])
+          ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config)
         ensure
           ActiveRecord::Base.establish_connection(original_db_config) if original_db_config
         end
@@ -533,63 +525,6 @@ 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
-
-    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.
-      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.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
-
   namespace :encryption do
     desc "Generate a set of keys for configuring Active Record encryption in a given environment"
     task :init do
@@ -615,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.schema_format, filename)
+        ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config)
       end
     ensure
       if should_reconnect
@@ -624,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|
@@ -660,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.schema_format, filename)
+          ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config)
         ensure
           if should_reconnect
             ActiveRecord::Base.establish_connection(ActiveRecord::Tasks::DatabaseTasks.env.to_sym)
@@ -670,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