activerecord 7.0.8.7 → 7.1.5.1

data/lib/active_record/tasks/database_tasks.rb

@@ -6,14 +6,16 @@ module ActiveRecord
   module Tasks # :nodoc:
     class DatabaseNotSupported < StandardError; end # :nodoc:
 
+    # = Active Record \DatabaseTasks
+    #
     # ActiveRecord::Tasks::DatabaseTasks is a utility class, which encapsulates
     # logic behind common tasks used to manage database and migrations.
     #
-    # The tasks defined here are used with Rails commands provided by Active Record.
+    # The tasks defined here are used with \Rails commands provided by Active Record.
     #
     # In order to use DatabaseTasks, a few config values need to be set. All the needed
-    # config values are set by Rails already, so it's necessary to do it only if you
-    # want to change the defaults or when you want to use Active Record outside of Rails
+    # config values are set by \Rails already, so it's necessary to do it only if you
+    # want to change the defaults or when you want to use Active Record outside of \Rails
     # (in such case after configuring the database tasks, you can also use the rake tasks
     # defined in Active Record).
     #
@@ -27,7 +29,7 @@ module ActiveRecord
     # * +seed_loader+: an object which will load seeds, it needs to respond to the +load_seed+ method.
     # * +root+: a path to the root of the application.
     #
-    # Example usage of DatabaseTasks outside Rails could look as such:
+    # Example usage of DatabaseTasks outside \Rails could look as such:
     #
     #   include ActiveRecord::Tasks
     #   DatabaseTasks.database_configuration = YAML.load_file('my_database_config.yml')
@@ -60,20 +62,12 @@ module ActiveRecord
 
       LOCAL_HOSTS = ["127.0.0.1", "localhost"]
 
-      def check_protected_environments!
-        unless ENV["DISABLE_DATABASE_ENVIRONMENT_CHECK"]
-          current = ActiveRecord::Base.connection.migration_context.current_environment
-          stored  = ActiveRecord::Base.connection.migration_context.last_stored_environment
-
-          if ActiveRecord::Base.connection.migration_context.protected_environment?
-            raise ActiveRecord::ProtectedEnvironmentError.new(stored)
-          end
+      def check_protected_environments!(environment = env)
+        return if ENV["DISABLE_DATABASE_ENVIRONMENT_CHECK"]
 
-          if stored && stored != current
-            raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
-          end
+        configs_for(env_name: environment).each do |db_config|
+          check_current_protected_environment!(db_config)
         end
-      rescue ActiveRecord::NoDatabaseError
       end
 
       def register_task(pattern, task)
@@ -82,6 +76,7 @@ module ActiveRecord
       end
 
       register_task(/mysql/,        "ActiveRecord::Tasks::MySQLDatabaseTasks")
+      register_task(/trilogy/,      "ActiveRecord::Tasks::MySQLDatabaseTasks")
       register_task(/postgresql/,   "ActiveRecord::Tasks::PostgreSQLDatabaseTasks")
       register_task(/sqlite/,       "ActiveRecord::Tasks::SQLiteDatabaseTasks")
 
@@ -130,28 +125,20 @@ module ActiveRecord
       end
 
       def create_all
-        old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.connection_specification_name)
-        each_local_configuration { |db_config| create(db_config) }
-        if old_pool
-          ActiveRecord::Base.connection_handler.establish_connection(old_pool.db_config)
+        each_local_configuration do |db_config|
+          with_temporary_connection(db_config) do
+            create(db_config)
+          end
         end
       end
 
-      def setup_initial_database_yaml
+      def setup_initial_database_yaml # :nodoc:
         return {} unless defined?(Rails)
 
-        begin
-          Rails.application.config.load_database_yaml
-        rescue
-          unless ActiveRecord.suppress_multiple_database_warning
-            $stderr.puts "Rails couldn't infer whether you are using multiple databases from your database.yml and can't generate the tasks for the non-primary databases. If you'd like to use this feature, please simplify your ERB."
-          end
-
-          {}
-        end
+        Rails.application.config.load_database_yaml
       end
 
-      def for_each(databases)
+      def for_each(databases) # :nodoc:
         return {} unless defined?(Rails)
 
         database_configs = ActiveRecord::DatabaseConfigurations.new(databases).configs_for(env_name: Rails.env)
@@ -166,7 +153,7 @@ module ActiveRecord
         end
       end
 
-      def raise_for_multi_db(environment = env, command:)
+      def raise_for_multi_db(environment = env, command:) # :nodoc:
         db_configs = configs_for(env_name: environment)
 
         if db_configs.count > 1
@@ -182,40 +169,54 @@ module ActiveRecord
 
       def create_current(environment = env, name = nil)
         each_current_configuration(environment, name) { |db_config| create(db_config) }
-        ActiveRecord::Base.establish_connection(environment.to_sym)
+
+        migration_class.establish_connection(environment.to_sym)
       end
 
       def prepare_all
         seed = false
+        dump_db_configs = []
 
         each_current_configuration(env) do |db_config|
-          ActiveRecord::Base.establish_connection(db_config)
+          with_temporary_pool(db_config) do
+            begin
+              database_initialized = migration_connection.schema_migration.table_exists?
+            rescue ActiveRecord::NoDatabaseError
+              create(db_config)
+              retry
+            end
 
-          begin
-            # Skipped when no database
-            migrate
+            unless database_initialized
+              if File.exist?(schema_dump_path(db_config))
+                load_schema(db_config, ActiveRecord.schema_format, nil)
+              end
 
-            if ActiveRecord.dump_schema_after_migration
-              dump_schema(db_config, ActiveRecord.schema_format)
+              seed = true
             end
-          rescue ActiveRecord::NoDatabaseError
-            create(db_config)
+          end
+        end
 
-            if File.exist?(schema_dump_path(db_config))
-              load_schema(
-                db_config,
-                ActiveRecord.schema_format,
-                nil
-              )
-            else
-              migrate
+        each_current_environment(env) do |environment|
+          db_configs_with_versions(environment).sort.each do |version, db_configs|
+            dump_db_configs |= db_configs
+
+            db_configs.each do |db_config|
+              with_temporary_pool(db_config) do
+                migrate(version)
+              end
             end
+          end
+        end
 
-            seed = true
+        # Dump schema for databases that were migrated.
+        if ActiveRecord.dump_schema_after_migration
+          dump_db_configs.each do |db_config|
+            with_temporary_pool(db_config) do
+              dump_schema(db_config)
+            end
           end
         end
 
-        ActiveRecord::Base.establish_connection
         load_seed if seed
       end
 
@@ -240,10 +241,9 @@ module ActiveRecord
       end
 
       def truncate_tables(db_config)
-        ActiveRecord::Base.establish_connection(db_config)
-
-        connection = ActiveRecord::Base.connection
-        connection.truncate_tables(*connection.tables)
+        with_temporary_connection(db_config) do |conn|
+          conn.truncate_tables(*conn.tables)
+        end
       end
       private :truncate_tables
 
@@ -254,12 +254,12 @@ module ActiveRecord
       end
 
       def migrate(version = nil)
-        check_target_version
-
         scope = ENV["SCOPE"]
         verbose_was, Migration.verbose = Migration.verbose, verbose?
 
-        Base.connection.migration_context.migrate(target_version) do |migration|
+        check_target_version
+
+        migration_connection.migration_context.migrate(target_version) do |migration|
           if version.blank?
             scope.blank? || scope == migration.scope
           else
@@ -269,17 +269,17 @@ module ActiveRecord
           Migration.write("No migrations ran. (using #{scope} scope)") if scope.present? && migrations_ran.empty?
         end
 
-        ActiveRecord::Base.clear_cache!
+        migration_connection.schema_cache.clear!
       ensure
         Migration.verbose = verbose_was
       end
 
-      def db_configs_with_versions(db_configs) # :nodoc:
+      def db_configs_with_versions(environment = env) # :nodoc:
         db_configs_with_versions = Hash.new { |h, k| h[k] = [] }
 
-        db_configs.each do |db_config|
-          ActiveRecord::Base.establish_connection(db_config)
-          versions_to_run = ActiveRecord::Base.connection.migration_context.pending_migration_versions
+        with_temporary_connection_for_each(env: environment) do |conn|
+          db_config = conn.pool.db_config
+          versions_to_run = conn.migration_context.pending_migration_versions
           target_version = ActiveRecord::Tasks::DatabaseTasks.target_version
 
           versions_to_run.each do |version|
@@ -292,22 +292,22 @@ module ActiveRecord
       end
 
       def migrate_status
-        unless ActiveRecord::Base.connection.schema_migration.table_exists?
+        unless migration_connection.schema_migration.table_exists?
           Kernel.abort "Schema migrations table does not exist yet."
         end
 
         # output
-        puts "\ndatabase: #{ActiveRecord::Base.connection_db_config.database}\n\n"
+        puts "\ndatabase: #{migration_connection.pool.db_config.database}\n\n"
         puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
         puts "-" * 50
-        ActiveRecord::Base.connection.migration_context.migrations_status.each do |status, version, name|
+        migration_connection.migration_context.migrations_status.each do |status, version, name|
           puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
         end
         puts
       end
 
       def check_target_version
-        if target_version && !(Migration::MigrationFilenameRegexp.match?(ENV["VERSION"]) || /\A\d+\z/.match?(ENV["VERSION"]))
+        if target_version && !Migration.valid_version_format?(ENV["VERSION"])
           raise "Invalid format of target version: `VERSION=#{ENV['VERSION']}`"
         end
       end
@@ -347,7 +347,8 @@ module ActiveRecord
 
       def purge_current(environment = env)
         each_current_configuration(environment) { |db_config| purge(db_config) }
-        ActiveRecord::Base.establish_connection(environment.to_sym)
+
+        migration_class.establish_connection(environment.to_sym)
       end
 
       def structure_dump(configuration, *arguments)
@@ -370,7 +371,6 @@ module ActiveRecord
 
         verbose_was, Migration.verbose = Migration.verbose, verbose? && ENV["VERBOSE"]
         check_schema_file(file)
-        ActiveRecord::Base.establish_connection(db_config)
 
         case format
         when :ruby
@@ -380,9 +380,8 @@ module ActiveRecord
         else
           raise ArgumentError, "unknown format #{format.inspect}"
         end
-        ActiveRecord::InternalMetadata.create_table
-        ActiveRecord::InternalMetadata[:environment] = db_config.env_name
-        ActiveRecord::InternalMetadata[:schema_sha1] = schema_sha1(file)
+
+        migration_connection.internal_metadata.create_table_and_set_flags(db_config.env_name, schema_sha1(file))
       ensure
         Migration.verbose = verbose_was
       end
@@ -394,12 +393,12 @@ module ActiveRecord
 
         return true unless file && File.exist?(file)
 
-        ActiveRecord::Base.establish_connection(db_config)
+        with_temporary_connection(db_config) do |connection|
+          return false unless connection.internal_metadata.enabled?
+          return false unless connection.internal_metadata.table_exists?
 
-        return false unless ActiveRecord::InternalMetadata.enabled?
-        return false unless ActiveRecord::InternalMetadata.table_exists?
-
-        ActiveRecord::InternalMetadata[:schema_sha1] == schema_sha1(file)
+          connection.internal_metadata[:schema_sha1] == schema_sha1(file)
+        end
       end
 
       def reconstruct_from_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
@@ -407,53 +406,43 @@ module ActiveRecord
 
         check_schema_file(file) if file
 
-        ActiveRecord::Base.establish_connection(db_config)
-
-        if schema_up_to_date?(db_config, format, file)
-          truncate_tables(db_config)
-        else
-          purge(db_config)
+        with_temporary_pool(db_config, clobber: true) do
+          if schema_up_to_date?(db_config, format, file)
+            truncate_tables(db_config)
+          else
+            purge(db_config)
+            load_schema(db_config, format, file)
+          end
+        rescue ActiveRecord::NoDatabaseError
+          create(db_config)
           load_schema(db_config, format, file)
         end
-      rescue ActiveRecord::NoDatabaseError
-        create(db_config)
-        load_schema(db_config, format, file)
       end
 
       def dump_schema(db_config, format = ActiveRecord.schema_format) # :nodoc:
+        return unless db_config.schema_dump
+
         require "active_record/schema_dumper"
         filename = schema_dump_path(db_config, format)
         return unless filename
 
-        connection = ActiveRecord::Base.connection
-
         FileUtils.mkdir_p(db_dir)
         case format
         when :ruby
           File.open(filename, "w:utf-8") do |file|
-            ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+            ActiveRecord::SchemaDumper.dump(migration_connection, file)
           end
         when :sql
           structure_dump(db_config, filename)
-          if connection.schema_migration.table_exists?
+          if migration_connection.schema_migration.table_exists?
             File.open(filename, "a") do |f|
-              f.puts connection.dump_schema_information
+              f.puts migration_connection.dump_schema_information
               f.print "\n"
             end
           end
         end
       end
 
-      def schema_file_type(format = ActiveRecord.schema_format)
-        case format
-        when :ruby
-          "schema.rb"
-        when :sql
-          "structure.sql"
-        end
-      end
-      deprecate :schema_file_type
-
       def schema_dump_path(db_config, format = ActiveRecord.schema_format)
         return ENV["SCHEMA"] if ENV["SCHEMA"]
 
@@ -479,9 +468,10 @@ module ActiveRecord
 
       def load_schema_current(format = ActiveRecord.schema_format, file = nil, environment = env)
         each_current_configuration(environment) do |db_config|
-          load_schema(db_config, format, file)
+          with_temporary_connection(db_config) do
+            load_schema(db_config, format, file)
+          end
         end
-        ActiveRecord::Base.establish_connection(environment.to_sym)
       end
 
       def check_schema_file(filename)
@@ -504,7 +494,7 @@ module ActiveRecord
 
       # Dumps the schema cache in YAML format for the connection into the file
       #
-      # ==== Examples:
+      # ==== Examples
       #   ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.connection, "tmp/schema_dump.yaml")
       def dump_schema_cache(conn, filename)
         conn.schema_cache.dump_to(filename)
@@ -514,7 +504,41 @@ module ActiveRecord
         FileUtils.rm_f filename, verbose: false
       end
 
+      def with_temporary_connection_for_each(env: ActiveRecord::Tasks::DatabaseTasks.env, name: nil, clobber: false, &block) # :nodoc:
+        if name
+          db_config = ActiveRecord::Base.configurations.configs_for(env_name: env, name: name)
+          with_temporary_connection(db_config, clobber: clobber, &block)
+        else
+          ActiveRecord::Base.configurations.configs_for(env_name: env, name: name).each do |db_config|
+            with_temporary_connection(db_config, clobber: clobber, &block)
+          end
+        end
+      end
+
+      def with_temporary_connection(db_config, clobber: false) # :nodoc:
+        with_temporary_pool(db_config, clobber: clobber) do |pool|
+          yield pool.connection
+        end
+      end
+
+      def migration_class # :nodoc:
+        ActiveRecord::Base
+      end
+
+      def migration_connection # :nodoc:
+        migration_class.connection
+      end
+
       private
+        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)
+
+          yield pool
+        ensure
+          migration_class.connection_handler.establish_connection(original_db_config, clobber: clobber)
+        end
+
         def configs_for(**options)
           Base.configurations.configs_for(**options)
         end
@@ -547,10 +571,7 @@ module ActiveRecord
         end
 
         def each_current_configuration(environment, name = nil)
-          environments = [environment]
-          environments << "test" if environment == "development" && !ENV["SKIP_TEST_DATABASE"] && !ENV["DATABASE_URL"]
-
-          environments.each do |env|
+          each_current_environment(environment) do |env|
             configs_for(env_name: env).each do |db_config|
               next if name && name != db_config.name
 
@@ -559,6 +580,12 @@ module ActiveRecord
           end
         end
 
+        def each_current_environment(environment, &block)
+          environments = [environment]
+          environments << "test" if environment == "development" && !ENV["SKIP_TEST_DATABASE"] && !ENV["DATABASE_URL"]
+          environments.each(&block)
+        end
+
         def each_local_configuration
           configs_for.each do |db_config|
             next unless db_config.database
@@ -595,6 +622,23 @@ module ActiveRecord
             structure_load_flags
           end
         end
+
+        def check_current_protected_environment!(db_config)
+          with_temporary_pool(db_config) do |pool|
+            connection = pool.connection
+            current = connection.migration_context.current_environment
+            stored  = connection.migration_context.last_stored_environment
+
+            if connection.migration_context.protected_environment?
+              raise ActiveRecord::ProtectedEnvironmentError.new(stored)
+            end
+
+            if stored && stored != current
+              raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
+            end
+          rescue ActiveRecord::NoDatabaseError
+          end
+        end
     end
   end
 end

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -5,8 +5,6 @@ module ActiveRecord
     class MySQLDatabaseTasks # :nodoc:
       ER_DB_CREATE_EXISTS = 1007
 
-      delegate :connection, :establish_connection, to: ActiveRecord::Base
-
       def self.using_database_configurations?
         true
       end
@@ -19,17 +17,18 @@ module ActiveRecord
       def create
         establish_connection(configuration_hash_without_database)
         connection.create_database(db_config.database, creation_options)
-        establish_connection(db_config)
+        establish_connection
       end
 
       def drop
-        establish_connection(db_config)
+        establish_connection
         connection.drop_database(db_config.database)
       end
 
       def purge
-        establish_connection(db_config)
+        establish_connection(configuration_hash_without_database)
         connection.recreate_database(db_config.database, creation_options)
+        establish_connection
       end
 
       def charset
@@ -49,6 +48,7 @@ module ActiveRecord
 
         ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
         if ignore_tables.any?
+          ignore_tables = connection.data_sources.select { |table| ignore_tables.any? { |pattern| pattern === table } }
           args += ignore_tables.map { |table| "--ignore-table=#{db_config.database}.#{table}" }
         end
 
@@ -70,6 +70,14 @@ module ActiveRecord
       private
         attr_reader :db_config, :configuration_hash
 
+        def connection
+          ActiveRecord::Base.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
@@ -93,7 +101,8 @@ module ActiveRecord
             sslcert:   "--ssl-cert",
             sslcapath: "--ssl-capath",
             sslcipher: "--ssl-cipher",
-            sslkey:    "--ssl-key"
+            sslkey:    "--ssl-key",
+            ssl_mode:  "--ssl-mode"
           }.filter_map { |opt, arg| "#{arg}=#{configuration_hash[opt]}" if configuration_hash[opt] }
 
           args

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -9,9 +9,6 @@ module ActiveRecord
       ON_ERROR_STOP_1 = "ON_ERROR_STOP=1"
       SQL_COMMENT_BEGIN = "--"
 
-      delegate :connection, :establish_connection, :clear_active_connections!,
-        to: ActiveRecord::Base
-
       def self.using_database_configurations?
         true
       end
@@ -21,14 +18,14 @@ module ActiveRecord
         @configuration_hash = db_config.configuration_hash
       end
 
-      def create(master_established = false)
-        establish_master_connection unless master_established
+      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))
-        establish_connection(db_config)
+        establish_connection
       end
 
       def drop
-        establish_master_connection
+        establish_connection(public_schema_config)
         connection.drop_database(db_config.database)
       end
 
@@ -41,7 +38,7 @@ module ActiveRecord
       end
 
       def purge
-        clear_active_connections!
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
         drop
         create true
       end
@@ -70,6 +67,7 @@ module ActiveRecord
 
         ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
         if ignore_tables.any?
+          ignore_tables = connection.data_sources.select { |table| ignore_tables.any? { |pattern| pattern === table } }
           args += ignore_tables.flat_map { |table| ["-T", table] }
         end
 
@@ -89,15 +87,20 @@ module ActiveRecord
       private
         attr_reader :db_config, :configuration_hash
 
+        def connection
+          ActiveRecord::Base.connection
+        end
+
+        def establish_connection(config = db_config)
+          ActiveRecord::Base.establish_connection(config)
+        end
+
         def encoding
           configuration_hash[:encoding] || DEFAULT_ENCODING
         end
 
-        def establish_master_connection
-          establish_connection configuration_hash.merge(
-            database: "postgres",
-            schema_search_path: "public"
-          )
+        def public_schema_config
+          configuration_hash.merge(database: "postgres", schema_search_path: "public")
         end
 
         def psql_env

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -3,8 +3,6 @@
 module ActiveRecord
   module Tasks # :nodoc:
     class SQLiteDatabaseTasks # :nodoc:
-      delegate :connection, :establish_connection, to: ActiveRecord::Base
-
       def self.using_database_configurations?
         true
       end
@@ -17,25 +15,26 @@ module ActiveRecord
       def create
         raise DatabaseAlreadyExists if File.exist?(db_config.database)
 
-        establish_connection(db_config)
+        establish_connection
         connection
       end
 
       def drop
-        require "pathname"
-        path = Pathname.new(db_config.database)
-        file = path.absolute? ? path.to_s : File.join(root, path)
-
+        db_path = db_config.database
+        file = File.absolute_path?(db_path) ? db_path : File.join(root, db_path)
         FileUtils.rm(file)
+        FileUtils.rm_f(["#{file}-shm", "#{file}-wal"])
       rescue Errno::ENOENT => error
         raise NoDatabaseError.new(error.message)
       end
 
       def purge
+        connection.disconnect!
         drop
       rescue NoDatabaseError
       ensure
         create
+        connection.reconnect!
       end
 
       def charset
@@ -49,6 +48,7 @@ module ActiveRecord
 
         ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
         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"
         else
@@ -65,6 +65,14 @@ module ActiveRecord
       private
         attr_reader :db_config, :root
 
+        def connection
+          ActiveRecord::Base.connection
+        end
+
+        def establish_connection(config = db_config)
+          ActiveRecord::Base.establish_connection(config)
+        end
+
         def run_cmd(cmd, args, out)
           fail run_cmd_error(cmd, args) unless Kernel.system(cmd, *args, out: out)
         end