activerecord 7.2.2.1 → 8.1.2

data/lib/active_record/tasks/database_tasks.rb

@@ -45,7 +45,7 @@ module ActiveRecord
       # Example:
       #   ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = {
       #     mysql2: ['--no-defaults', '--skip-add-drop-table'],
-      #     postgres: '--no-tablespaces'
+      #     postgresql: '--no-tablespaces'
       #   }
       mattr_accessor :structure_dump_flags, instance_accessor: false
 
@@ -66,7 +66,7 @@ module ActiveRecord
         return if ENV["DISABLE_DATABASE_ENVIRONMENT_CHECK"]
 
         configs_for(env_name: environment).each do |db_config|
-          check_current_protected_environment!(db_config)
+          database_adapter_for(db_config).check_current_protected_environment!(db_config, migration_class)
         end
       end
 
@@ -147,8 +147,6 @@ module ActiveRecord
         return if database_configs.count == 1
 
         database_configs.each do |db_config|
-          next unless db_config.database_tasks?
-
           yield db_config.name
         end
       end
@@ -178,22 +176,9 @@ module ActiveRecord
         dump_db_configs = []
 
         each_current_configuration(env) do |db_config|
-          with_temporary_pool(db_config) do
-            begin
-              database_initialized = migration_connection_pool.schema_migration.table_exists?
-            rescue ActiveRecord::NoDatabaseError
-              create(db_config)
-              retry
-            end
+          database_initialized = initialize_database(db_config)
 
-            unless database_initialized
-              if File.exist?(schema_dump_path(db_config))
-                load_schema(db_config, ActiveRecord.schema_format, nil)
-              end
-
-              seed = true
-            end
-          end
+          seed = true if database_initialized && db_config.seeds?
         end
 
         each_current_environment(env) do |environment|
@@ -253,12 +238,33 @@ module ActiveRecord
         end
       end
 
-      def migrate(version = nil)
+      def migrate_all
+        db_configs = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
+        db_configs.each { |db_config| initialize_database(db_config) }
+
+        if db_configs.size == 1 && db_configs.first.primary?
+          ActiveRecord::Tasks::DatabaseTasks.migrate(skip_initialize: true)
+        else
+          mapped_versions = ActiveRecord::Tasks::DatabaseTasks.db_configs_with_versions
+
+          mapped_versions.sort.each do |version, db_configs|
+            db_configs.each do |db_config|
+              ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection(db_config) do
+                ActiveRecord::Tasks::DatabaseTasks.migrate(version, skip_initialize: true)
+              end
+            end
+          end
+        end
+      end
+
+      def migrate(version = nil, skip_initialize: false)
         scope = ENV["SCOPE"]
         verbose_was, Migration.verbose = Migration.verbose, verbose?
 
         check_target_version
 
+        initialize_database(migration_connection_pool.db_config) unless skip_initialize
+
         migration_connection_pool.migration_context.migrate(target_version) do |migration|
           if version.blank?
             scope.blank? || scope == migration.scope
@@ -365,7 +371,8 @@ module ActiveRecord
         database_adapter_for(db_config, *arguments).structure_load(filename, flags)
       end
 
-      def load_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
+      def load_schema(db_config, format = db_config.schema_format, file = nil) # :nodoc:
+        format = format.to_sym
         file ||= schema_dump_path(db_config, format)
         return unless file
 
@@ -386,7 +393,7 @@ module ActiveRecord
         Migration.verbose = verbose_was
       end
 
-      def schema_up_to_date?(configuration, format = ActiveRecord.schema_format, file = nil)
+      def schema_up_to_date?(configuration, _ = nil, file = nil)
         db_config = resolve_configuration(configuration)
 
         file ||= schema_dump_path(db_config)
@@ -402,49 +409,66 @@ module ActiveRecord
         end
       end
 
-      def reconstruct_from_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
-        file ||= schema_dump_path(db_config, format)
+      def reconstruct_from_schema(db_config, file = nil) # :nodoc:
+        file ||= schema_dump_path(db_config, db_config.schema_format)
 
         check_schema_file(file) if file
 
         with_temporary_pool(db_config, clobber: true) do
-          if schema_up_to_date?(db_config, format, file)
+          if schema_up_to_date?(db_config, nil, file)
             truncate_tables(db_config) unless ENV["SKIP_TEST_DATABASE_TRUNCATE"]
           else
             purge(db_config)
-            load_schema(db_config, format, file)
+            load_schema(db_config, db_config.schema_format, file)
           end
         rescue ActiveRecord::NoDatabaseError
           create(db_config)
-          load_schema(db_config, format, file)
+          load_schema(db_config, db_config.schema_format, file)
         end
       end
 
-      def dump_schema(db_config, format = ActiveRecord.schema_format) # :nodoc:
+      def dump_all
+        seen_schemas = []
+
+        ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
+          schema_path = schema_dump_path(db_config, ENV["SCHEMA_FORMAT"] || db_config.schema_format)
+
+          next if seen_schemas.include?(schema_path)
+
+          ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config, ENV["SCHEMA_FORMAT"] || db_config.schema_format)
+          seen_schemas << schema_path
+        end
+      end
+
+      def dump_schema(db_config, format = db_config.schema_format) # :nodoc:
         return unless db_config.schema_dump
 
         require "active_record/schema_dumper"
         filename = schema_dump_path(db_config, format)
         return unless filename
 
-        FileUtils.mkdir_p(db_dir)
-        case format
-        when :ruby
-          File.open(filename, "w:utf-8") do |file|
-            ActiveRecord::SchemaDumper.dump(migration_connection_pool, file)
-          end
-        when :sql
-          structure_dump(db_config, filename)
-          if migration_connection_pool.schema_migration.table_exists?
-            File.open(filename, "a") do |f|
-              f.puts migration_connection.dump_schema_information
-              f.print "\n"
+        with_temporary_pool(db_config) do |pool|
+          FileUtils.mkdir_p(db_dir)
+          case format.to_sym
+          when :ruby
+            File.open(filename, "w:utf-8") do |file|
+              ActiveRecord::SchemaDumper.dump(pool, file)
+            end
+          when :sql
+            structure_dump(db_config, filename)
+            if pool.schema_migration.table_exists?
+              File.open(filename, "a") do |f|
+                pool.with_connection do |connection|
+                  f.puts connection.dump_schema_versions
+                end
+                f.print "\n"
+              end
             end
           end
         end
       end
 
-      def schema_dump_path(db_config, format = ActiveRecord.schema_format)
+      def schema_dump_path(db_config, format = db_config.schema_format)
         return ENV["SCHEMA"] if ENV["SCHEMA"]
 
         filename = db_config.schema_dump(format)
@@ -457,32 +481,16 @@ module ActiveRecord
         end
       end
 
-      def cache_dump_filename(db_config_or_name, schema_cache_path: nil)
-        if db_config_or_name.is_a?(DatabaseConfigurations::DatabaseConfig)
-          schema_cache_path ||
-            db_config_or_name.schema_cache_path ||
-            schema_cache_env ||
-            db_config_or_name.default_schema_cache_path(ActiveRecord::Tasks::DatabaseTasks.db_dir)
-        else
-          ActiveRecord.deprecator.warn(<<~MSG.squish)
-            Passing a database name to `cache_dump_filename` is deprecated and will be removed in Rails 8.0. Pass a
-            `ActiveRecord::DatabaseConfigurations::DatabaseConfig` object instead.
-          MSG
-
-          filename = if ActiveRecord::Base.configurations.primary?(db_config_or_name)
-            "schema_cache.yml"
-          else
-            "#{db_config_or_name}_schema_cache.yml"
-          end
-
-          schema_cache_path || schema_cache_env || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
-        end
+      def cache_dump_filename(db_config, schema_cache_path: nil)
+        schema_cache_path ||
+          db_config.schema_cache_path ||
+          db_config.default_schema_cache_path(ActiveRecord::Tasks::DatabaseTasks.db_dir)
       end
 
-      def load_schema_current(format = ActiveRecord.schema_format, file = nil, environment = env)
+      def load_schema_current(format = nil, file = nil, environment = env)
         each_current_configuration(environment) do |db_config|
           with_temporary_connection(db_config) do
-            load_schema(db_config, format, file)
+            load_schema(db_config, format || db_config.schema_format, file)
           end
         end
       end
@@ -547,17 +555,6 @@ module ActiveRecord
       end
 
       private
-        def schema_cache_env
-          if ENV["SCHEMA_CACHE"]
-            ActiveRecord.deprecator.warn(<<~MSG.squish)
-              Setting `ENV["SCHEMA_CACHE"]` is deprecated and will be removed in Rails 8.0.
-              Configure the `:schema_cache_path` in the database configuration instead.
-            MSG
-
-            nil
-          end
-        end
-
         def with_temporary_pool(db_config, clobber: false)
           original_db_config = migration_class.connection_db_config
           pool = migration_class.connection_handler.establish_connection(db_config, clobber: clobber)
@@ -651,20 +648,23 @@ module ActiveRecord
           end
         end
 
-        def check_current_protected_environment!(db_config)
-          with_temporary_pool(db_config) do |pool|
-            migration_context = pool.migration_context
-            current = migration_context.current_environment
-            stored  = migration_context.last_stored_environment
-
-            if migration_context.protected_environment?
-              raise ActiveRecord::ProtectedEnvironmentError.new(stored)
+        def initialize_database(db_config)
+          with_temporary_pool(db_config) do
+            begin
+              database_already_initialized = migration_connection_pool.schema_migration.table_exists?
+            rescue ActiveRecord::NoDatabaseError
+              create(db_config)
+              retry
             end
 
-            if stored && stored != current
-              raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
+            unless database_already_initialized
+              schema_dump_path = schema_dump_path(db_config)
+              if schema_dump_path && File.exist?(schema_dump_path)
+                load_schema(db_config)
+              end
             end
-          rescue ActiveRecord::NoDatabaseError
+
+            !database_already_initialized
           end
         end
     end

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -2,18 +2,7 @@
 
 module ActiveRecord
   module Tasks # :nodoc:
-    class MySQLDatabaseTasks # :nodoc:
-      ER_DB_CREATE_EXISTS = 1007
-
-      def self.using_database_configurations?
-        true
-      end
-
-      def initialize(db_config)
-        @db_config = db_config
-        @configuration_hash = db_config.configuration_hash
-      end
-
+    class MySQLDatabaseTasks < AbstractTasks # :nodoc:
       def create
         establish_connection(configuration_hash_without_database)
         connection.create_database(db_config.database, creation_options)
@@ -35,10 +24,6 @@ module ActiveRecord
         connection.charset
       end
 
-      def collation
-        connection.collation
-      end
-
       def structure_dump(filename, extra_flags)
         args = prepare_command_options
         args.concat(["--result-file", "#{filename}"])
@@ -55,7 +40,7 @@ module ActiveRecord
         args.concat([db_config.database.to_s])
         args.unshift(*extra_flags) if extra_flags
 
-        run_cmd("mysqldump", args, "dumping")
+        run_cmd("mysqldump", *args)
       end
 
       def structure_load(filename, extra_flags)
@@ -64,24 +49,10 @@ module ActiveRecord
         args.concat(["--database", db_config.database.to_s])
         args.unshift(*extra_flags) if extra_flags
 
-        run_cmd("mysql", args, "loading")
+        run_cmd("mysql", *args)
       end
 
       private
-        attr_reader :db_config, :configuration_hash
-
-        def connection
-          ActiveRecord::Base.lease_connection
-        end
-
-        def establish_connection(config = db_config)
-          ActiveRecord::Base.establish_connection(config)
-        end
-
-        def configuration_hash_without_database
-          configuration_hash.merge(database: nil)
-        end
-
         def creation_options
           Hash.new.tap do |options|
             options[:charset]     = configuration_hash[:encoding]   if configuration_hash.include?(:encoding)
@@ -107,16 +78,6 @@ module ActiveRecord
 
           args
         end
-
-        def run_cmd(cmd, args, action)
-          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
-        end
-
-        def run_cmd_error(cmd, args, action)
-          msg = +"failed to execute: `#{cmd}`\n"
-          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
-          msg
-        end
     end
   end
 end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -4,20 +4,11 @@ require "tempfile"
 
 module ActiveRecord
   module Tasks # :nodoc:
-    class PostgreSQLDatabaseTasks # :nodoc:
+    class PostgreSQLDatabaseTasks < AbstractTasks # :nodoc:
       DEFAULT_ENCODING = ENV["CHARSET"] || "utf8"
       ON_ERROR_STOP_1 = "ON_ERROR_STOP=1"
       SQL_COMMENT_BEGIN = "--"
 
-      def self.using_database_configurations?
-        true
-      end
-
-      def initialize(db_config)
-        @db_config = db_config
-        @configuration_hash = db_config.configuration_hash
-      end
-
       def create(connection_already_established = false)
         establish_connection(public_schema_config) unless connection_already_established
         connection.create_database(db_config.database, configuration_hash.merge(encoding: encoding))
@@ -29,14 +20,6 @@ module ActiveRecord
         connection.drop_database(db_config.database)
       end
 
-      def charset
-        connection.encoding
-      end
-
-      def collation
-        connection.collation
-      end
-
       def purge
         ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
         drop
@@ -72,29 +55,20 @@ module ActiveRecord
         end
 
         args << db_config.database
-        run_cmd("pg_dump", args, "dumping")
+        run_cmd("pg_dump", *args)
         remove_sql_header_comments(filename)
         File.open(filename, "a") { |f| f << "SET search_path TO #{connection.schema_search_path};\n\n" }
       end
 
       def structure_load(filename, extra_flags)
-        args = ["--set", ON_ERROR_STOP_1, "--quiet", "--no-psqlrc", "--output", File::NULL, "--file", filename]
+        args = ["--set", ON_ERROR_STOP_1, "--quiet", "--no-psqlrc", "--output", File::NULL]
         args.concat(Array(extra_flags)) if extra_flags
+        args.concat(["--file", filename])
         args << db_config.database
-        run_cmd("psql", args, "loading")
+        run_cmd("psql", *args)
       end
 
       private
-        attr_reader :db_config, :configuration_hash
-
-        def connection
-          ActiveRecord::Base.lease_connection
-        end
-
-        def establish_connection(config = db_config)
-          ActiveRecord::Base.establish_connection(config)
-        end
-
         def encoding
           configuration_hash[:encoding] || DEFAULT_ENCODING
         end
@@ -116,15 +90,8 @@ module ActiveRecord
           end
         end
 
-        def run_cmd(cmd, args, action)
-          fail run_cmd_error(cmd, args, action) unless Kernel.system(psql_env, cmd, *args)
-        end
-
-        def run_cmd_error(cmd, args, action)
-          msg = +"failed to execute:\n"
-          msg << "#{cmd} #{args.join(' ')}\n\n"
-          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
-          msg
+        def run_cmd(cmd, *args, **opts)
+          fail run_cmd_error(cmd, args) unless Kernel.system(psql_env, cmd, *args, **opts)
         end
 
         def remove_sql_header_comments(filename)
@@ -132,6 +99,13 @@ module ActiveRecord
           tempfile = Tempfile.open("uncommented_structure.sql")
           begin
             File.foreach(filename) do |line|
+              next if line.start_with?("\\restrict ")
+
+              if line.start_with?("\\unrestrict ")
+                removing_comments = true
+                next
+              end
+
               unless removing_comments && (line.start_with?(SQL_COMMENT_BEGIN) || line.blank?)
                 tempfile << line
                 removing_comments = false

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -2,11 +2,7 @@
 
 module ActiveRecord
   module Tasks # :nodoc:
-    class SQLiteDatabaseTasks # :nodoc:
-      def self.using_database_configurations?
-        true
-      end
-
+    class SQLiteDatabaseTasks < AbstractTasks # :nodoc:
       def initialize(db_config, root = ActiveRecord::Tasks::DatabaseTasks.root)
         @db_config = db_config
         @root = root
@@ -37,10 +33,6 @@ module ActiveRecord
         connection.reconnect!
       end
 
-      def charset
-        connection.encoding
-      end
-
       def structure_dump(filename, extra_flags)
         args = []
         args.concat(Array(extra_flags)) if extra_flags
@@ -50,11 +42,12 @@ module ActiveRecord
         if ignore_tables.any?
           ignore_tables = connection.data_sources.select { |table| ignore_tables.any? { |pattern| pattern === table } }
           condition = ignore_tables.map { |table| connection.quote(table) }.join(", ")
-          args << "SELECT sql FROM sqlite_master WHERE tbl_name NOT IN (#{condition}) ORDER BY tbl_name, type DESC, name"
+          args << "SELECT sql || ';' FROM sqlite_master WHERE tbl_name NOT IN (#{condition}) ORDER BY tbl_name, type DESC, name"
         else
-          args << ".schema"
+          args << ".schema --nosys"
         end
-        run_cmd("sqlite3", args, filename)
+
+        run_cmd("sqlite3", *args, out: filename)
       end
 
       def structure_load(filename, extra_flags)
@@ -62,28 +55,23 @@ module ActiveRecord
         `sqlite3 #{flags} #{db_config.database} < "#{filename}"`
       end
 
-      private
-        attr_reader :db_config, :root
-
-        def connection
-          ActiveRecord::Base.lease_connection
+      def check_current_protected_environment!(db_config, migration_class)
+        super
+      rescue ActiveRecord::StatementInvalid => e
+        case e.cause
+        when SQLite3::ReadOnlyException
+        else
+          raise e
         end
+      end
+
+      private
+        attr_reader :root
 
         def establish_connection(config = db_config)
           ActiveRecord::Base.establish_connection(config)
           connection.connect!
         end
-
-        def run_cmd(cmd, args, out)
-          fail run_cmd_error(cmd, args) unless Kernel.system(cmd, *args, out: out)
-        end
-
-        def run_cmd_error(cmd, args)
-          msg = +"failed to execute:\n"
-          msg << "#{cmd} #{args.join(' ')}\n\n"
-          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
-          msg
-        end
     end
   end
 end

data/lib/active_record/test_databases.rb

@@ -4,17 +4,27 @@ require "active_support/testing/parallelization"
 
 module ActiveRecord
   module TestDatabases # :nodoc:
+    ActiveSupport::Testing::Parallelization.before_fork_hook do
+      if ActiveSupport.parallelize_test_databases
+        ActiveRecord::Base.connection_handler.clear_all_connections!
+      end
+    end
+
     ActiveSupport::Testing::Parallelization.after_fork_hook do |i|
-      create_and_load_schema(i, env_name: ActiveRecord::ConnectionHandling::DEFAULT_ENV.call)
+      if ActiveSupport.parallelize_test_databases
+        create_and_load_schema(i, env_name: ActiveRecord::ConnectionHandling::DEFAULT_ENV.call)
+      end
     end
 
     def self.create_and_load_schema(i, env_name:)
       old, ENV["VERBOSE"] = ENV["VERBOSE"], "false"
 
-      ActiveRecord::Base.configurations.configs_for(env_name: env_name).each do |db_config|
-        db_config._database = "#{db_config.database}-#{i}"
+      ActiveRecord::Base.configurations.configs_for(env_name: env_name, include_hidden: true).each do |db_config|
+        db_config._database = "#{db_config.database}_#{i}"
 
-        ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, ActiveRecord.schema_format, nil)
+        if db_config.database_tasks?
+          ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, nil)
+        end
       end
     ensure
       ActiveRecord::Base.establish_connection

data/lib/active_record/test_fixtures.rb

@@ -36,11 +36,26 @@ module ActiveRecord
       class_attribute :pre_loaded_fixtures, default: false
       class_attribute :lock_threads, default: true
       class_attribute :fixture_sets, default: {}
+      class_attribute :database_transactions_config, default: {}
 
       ActiveSupport.run_load_hooks(:active_record_fixtures, self)
     end
 
     module ClassMethods
+      # Do not use transactional tests for the given database. This overrides
+      # the default setting as defined by `use_transactional_tests`, which
+      # applies to all database connection pools not explicitly configured here.
+      def skip_transactional_tests_for_database(database_name)
+        use_transactional_tests_for_database(database_name, false)
+      end
+
+      # Enable or disable transactions per database. This overrides the default
+      # setting as defined by `use_transactional_tests`, which applies to all
+      # database connection pools not explicitly configured here.
+      def use_transactional_tests_for_database(database_name, enabled = true)
+        self.database_transactions_config = database_transactions_config.merge(database_name => enabled)
+      end
+
       # Sets the model class for a fixture when the class name cannot be inferred from the fixture name.
       #
       # Examples:
@@ -106,7 +121,8 @@ module ActiveRecord
 
     private
       def run_in_transaction?
-        use_transactional_tests &&
+        has_explicit_config = database_transactions_config.any? { |_, enabled| enabled }
+        (use_transactional_tests || has_explicit_config) &&
           !self.class.uses_transaction?(name)
       end
 
@@ -137,12 +153,15 @@ module ActiveRecord
           invalidate_already_loaded_fixtures
           @loaded_fixtures = load_fixtures(config)
         end
+        setup_asynchronous_queries_session
 
         # Instantiate fixtures for every test if requested.
         instantiate_fixtures if use_instantiated_fixtures
       end
 
       def teardown_fixtures
+        teardown_asynchronous_queries_session
+
         # Rollback changes if a transaction is active.
         if run_in_transaction?
           teardown_transactional_fixtures
@@ -154,15 +173,31 @@ module ActiveRecord
         ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
       end
 
+      def setup_asynchronous_queries_session
+        @_async_queries_session = ActiveRecord::Base.asynchronous_queries_tracker.start_session
+      end
+
+      def teardown_asynchronous_queries_session
+        ActiveRecord::Base.asynchronous_queries_tracker.finalize_session(true) if @_async_queries_session
+      end
+
       def invalidate_already_loaded_fixtures
         @@already_loaded_fixtures.clear
       end
 
+      def transactional_tests_for_pool?(pool)
+        database_transactions_config.fetch(pool.db_config.name.to_sym, use_transactional_tests)
+      end
+
       def setup_transactional_fixtures
         setup_shared_connection_pool
 
         # Begin transactions for connections already established
         @fixture_connection_pools = ActiveRecord::Base.connection_handler.connection_pool_list(:writing)
+
+        # Filter to pools that want to use transactions
+        @fixture_connection_pools.select! { |pool| transactional_tests_for_pool?(pool) }
+
         @fixture_connection_pools.each do |pool|
           pool.pin_connection!(lock_threads)
           pool.lease_connection
@@ -178,7 +213,8 @@ module ActiveRecord
             if pool
               setup_shared_connection_pool
 
-              unless @fixture_connection_pools.include?(pool)
+              # Don't begin a transaction if we've already done so, or are not using them for this pool
+              if !@fixture_connection_pools.include?(pool) && transactional_tests_for_pool?(pool)
                 pool.pin_connection!(lock_threads)
                 pool.lease_connection
                 @fixture_connection_pools << pool
@@ -190,6 +226,7 @@ module ActiveRecord
 
       def teardown_transactional_fixtures
         ActiveSupport::Notifications.unsubscribe(@connection_subscriber) if @connection_subscriber
+
         unless @fixture_connection_pools.map(&:unpin_connection!).all?
           # Something caused the transaction to be committed or rolled back
           # We can no longer trust the database is in a clean state.