activerecord 6.0.0 → 6.1.7.4

data/lib/active_record/tasks/database_tasks.rb

@@ -4,7 +4,6 @@ require "active_record/database_configurations"
 
 module ActiveRecord
   module Tasks # :nodoc:
-    class DatabaseAlreadyExists < StandardError; end # :nodoc:
     class DatabaseNotSupported < StandardError; end # :nodoc:
 
     # ActiveRecord::Tasks::DatabaseTasks is a utility class, which encapsulates
@@ -39,17 +38,18 @@ module ActiveRecord
     module DatabaseTasks
       ##
       # :singleton-method:
-      # Extra flags passed to database CLI tool (mysqldump/pg_dump) when calling db:structure:dump
+      # Extra flags passed to database CLI tool (mysqldump/pg_dump) when calling db:schema:dump
       mattr_accessor :structure_dump_flags, instance_accessor: false
 
       ##
       # :singleton-method:
-      # Extra flags passed to database CLI tool when calling db:structure:load
+      # Extra flags passed to database CLI tool when calling db:schema:load
       mattr_accessor :structure_load_flags, instance_accessor: false
 
       extend self
 
       attr_writer :current_config, :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
+      deprecate :current_config=
       attr_accessor :database_configuration
 
       LOCAL_HOSTS = ["127.0.0.1", "localhost"]
@@ -106,38 +106,45 @@ module ActiveRecord
       def spec
         @spec ||= "primary"
       end
+      deprecate spec: "please use name instead"
+
+      def name
+        @name ||= "primary"
+      end
 
       def seed_loader
         @seed_loader ||= Rails.application
       end
 
       def current_config(options = {})
-        options.reverse_merge! env: env
-        options[:spec] ||= "primary"
         if options.has_key?(:config)
           @current_config = options[:config]
         else
-          @current_config ||= ActiveRecord::Base.configurations.configs_for(env_name: options[:env], spec_name: options[:spec]).config
+          env_name = options[:env] || env
+          name = options[:spec] || "primary"
+
+          @current_config ||= ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: name)&.configuration_hash
         end
       end
+      deprecate :current_config
 
-      def create(*arguments)
-        configuration = arguments.first
-        class_for_adapter(configuration["adapter"]).new(*arguments).create
-        $stdout.puts "Created database '#{configuration['database']}'" if verbose?
+      def create(configuration, *arguments)
+        db_config = resolve_configuration(configuration)
+        database_adapter_for(db_config, *arguments).create
+        $stdout.puts "Created database '#{db_config.database}'" if verbose?
       rescue DatabaseAlreadyExists
-        $stderr.puts "Database '#{configuration['database']}' already exists" if verbose?
+        $stderr.puts "Database '#{db_config.database}' already exists" if verbose?
       rescue Exception => error
         $stderr.puts error
-        $stderr.puts "Couldn't create '#{configuration['database']}' database. Please check your configuration."
+        $stderr.puts "Couldn't create '#{db_config.database}' database. Please check your configuration."
         raise
       end
 
       def create_all
         old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.connection_specification_name)
-        each_local_configuration { |configuration| create configuration }
+        each_local_configuration { |db_config| create(db_config) }
         if old_pool
-          ActiveRecord::Base.connection_handler.establish_connection(old_pool.spec.to_hash)
+          ActiveRecord::Base.connection_handler.establish_connection(old_pool.db_config)
         end
       end
 
@@ -147,7 +154,9 @@ module ActiveRecord
         begin
           Rails.application.config.load_database_yaml
         rescue
-          $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."
+          unless ActiveRecord::Base.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
@@ -162,7 +171,7 @@ module ActiveRecord
         return if database_configs.count == 1
 
         database_configs.each do |db_config|
-          yield db_config.spec_name
+          yield db_config.name
         end
       end
 
@@ -173,59 +182,49 @@ module ActiveRecord
           dbs_list = []
 
           db_configs.each do |db|
-            dbs_list << "#{command}:#{db.spec_name}"
+            dbs_list << "#{command}:#{db.name}"
           end
 
           raise "You're using a multiple database application. To use `#{command}` you must run the namespaced task with a VERSION. Available tasks are #{dbs_list.to_sentence}."
         end
       end
 
-      def create_current(environment = env, spec_name = nil)
-        each_current_configuration(environment, spec_name) { |configuration|
-          create configuration
-        }
+      def create_current(environment = env, name = nil)
+        each_current_configuration(environment, name) { |db_config| create(db_config) }
         ActiveRecord::Base.establish_connection(environment.to_sym)
       end
 
-      def drop(*arguments)
-        configuration = arguments.first
-        class_for_adapter(configuration["adapter"]).new(*arguments).drop
-        $stdout.puts "Dropped database '#{configuration['database']}'" if verbose?
+      def drop(configuration, *arguments)
+        db_config = resolve_configuration(configuration)
+        database_adapter_for(db_config, *arguments).drop
+        $stdout.puts "Dropped database '#{db_config.database}'" if verbose?
       rescue ActiveRecord::NoDatabaseError
-        $stderr.puts "Database '#{configuration['database']}' does not exist"
+        $stderr.puts "Database '#{db_config.database}' does not exist"
       rescue Exception => error
         $stderr.puts error
-        $stderr.puts "Couldn't drop database '#{configuration['database']}'"
+        $stderr.puts "Couldn't drop database '#{db_config.database}'"
         raise
       end
 
       def drop_all
-        each_local_configuration { |configuration| drop configuration }
+        each_local_configuration { |db_config| drop(db_config) }
       end
 
       def drop_current(environment = env)
-        each_current_configuration(environment) { |configuration|
-          drop configuration
-        }
+        each_current_configuration(environment) { |db_config| drop(db_config) }
       end
 
-      def truncate_tables(configuration)
-        ActiveRecord::Base.connected_to(database: { truncation: configuration }) do
-          conn = ActiveRecord::Base.connection
-          table_names = conn.tables
-          table_names -= [
-            conn.schema_migration.table_name,
-            InternalMetadata.table_name
-          ]
+      def truncate_tables(db_config)
+        ActiveRecord::Base.establish_connection(db_config)
 
-          ActiveRecord::Base.connection.truncate_tables(*table_names)
-        end
+        connection = ActiveRecord::Base.connection
+        connection.truncate_tables(*connection.tables)
       end
       private :truncate_tables
 
       def truncate_all(environment = env)
         ActiveRecord::Base.configurations.configs_for(env_name: environment).each do |db_config|
-          truncate_tables db_config.config
+          truncate_tables(db_config)
         end
       end
 
@@ -250,7 +249,7 @@ module ActiveRecord
         end
 
         # output
-        puts "\ndatabase: #{ActiveRecord::Base.connection_config[:database]}\n\n"
+        puts "\ndatabase: #{ActiveRecord::Base.connection_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|
@@ -269,115 +268,126 @@ module ActiveRecord
         ENV["VERSION"].to_i if ENV["VERSION"] && !ENV["VERSION"].empty?
       end
 
-      def charset_current(environment = env, specification_name = spec)
-        charset ActiveRecord::Base.configurations.configs_for(env_name: environment, spec_name: specification_name).config
+      def charset_current(env_name = env, db_name = name)
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: db_name)
+        charset(db_config)
       end
 
-      def charset(*arguments)
-        configuration = arguments.first
-        class_for_adapter(configuration["adapter"]).new(*arguments).charset
+      def charset(configuration, *arguments)
+        db_config = resolve_configuration(configuration)
+        database_adapter_for(db_config, *arguments).charset
       end
 
-      def collation_current(environment = env, specification_name = spec)
-        collation ActiveRecord::Base.configurations.configs_for(env_name: environment, spec_name: specification_name).config
+      def collation_current(env_name = env, db_name = name)
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: db_name)
+        collation(db_config)
       end
 
-      def collation(*arguments)
-        configuration = arguments.first
-        class_for_adapter(configuration["adapter"]).new(*arguments).collation
+      def collation(configuration, *arguments)
+        db_config = resolve_configuration(configuration)
+        database_adapter_for(db_config, *arguments).collation
       end
 
       def purge(configuration)
-        class_for_adapter(configuration["adapter"]).new(configuration).purge
+        db_config = resolve_configuration(configuration)
+        database_adapter_for(db_config).purge
       end
 
       def purge_all
-        each_local_configuration { |configuration|
-          purge configuration
-        }
+        each_local_configuration { |db_config| purge(db_config) }
       end
 
       def purge_current(environment = env)
-        each_current_configuration(environment) { |configuration|
-          purge configuration
-        }
+        each_current_configuration(environment) { |db_config| purge(db_config) }
         ActiveRecord::Base.establish_connection(environment.to_sym)
       end
 
-      def structure_dump(*arguments)
-        configuration = arguments.first
-        filename = arguments.delete_at 1
-        class_for_adapter(configuration["adapter"]).new(*arguments).structure_dump(filename, structure_dump_flags)
+      def structure_dump(configuration, *arguments)
+        db_config = resolve_configuration(configuration)
+        filename = arguments.delete_at(0)
+        database_adapter_for(db_config, *arguments).structure_dump(filename, structure_dump_flags)
       end
 
-      def structure_load(*arguments)
-        configuration = arguments.first
-        filename = arguments.delete_at 1
-        class_for_adapter(configuration["adapter"]).new(*arguments).structure_load(filename, structure_load_flags)
+      def structure_load(configuration, *arguments)
+        db_config = resolve_configuration(configuration)
+        filename = arguments.delete_at(0)
+        database_adapter_for(db_config, *arguments).structure_load(filename, structure_load_flags)
       end
 
-      def load_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = env, spec_name = "primary") # :nodoc:
-        file ||= dump_filename(spec_name, format)
+      def load_schema(db_config, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
+        file ||= dump_filename(db_config.name, format)
 
         verbose_was, Migration.verbose = Migration.verbose, verbose? && ENV["VERBOSE"]
         check_schema_file(file)
-        ActiveRecord::Base.establish_connection(configuration)
+        ActiveRecord::Base.establish_connection(db_config)
 
         case format
         when :ruby
           load(file)
         when :sql
-          structure_load(configuration, file)
+          structure_load(db_config, file)
         else
           raise ArgumentError, "unknown format #{format.inspect}"
         end
         ActiveRecord::InternalMetadata.create_table
-        ActiveRecord::InternalMetadata[:environment] = environment
+        ActiveRecord::InternalMetadata[:environment] = db_config.env_name
         ActiveRecord::InternalMetadata[:schema_sha1] = schema_sha1(file)
       ensure
         Migration.verbose = verbose_was
       end
 
-      def schema_up_to_date?(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = env, spec_name = "primary")
-        file ||= dump_filename(spec_name, format)
+      def schema_up_to_date?(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = nil, name = nil)
+        db_config = resolve_configuration(configuration)
+
+        if environment || name
+          ActiveSupport::Deprecation.warn("`environment` and `name` will be removed as parameters in 7.0.0, you may now pass an ActiveRecord::DatabaseConfigurations::DatabaseConfig as `configuration` instead.")
+        end
+
+        name ||= db_config.name
+
+        file ||= dump_filename(name, format)
 
         return true unless File.exist?(file)
 
-        ActiveRecord::Base.establish_connection(configuration)
+        ActiveRecord::Base.establish_connection(db_config)
+
+        return false unless ActiveRecord::InternalMetadata.enabled?
         return false unless ActiveRecord::InternalMetadata.table_exists?
+
         ActiveRecord::InternalMetadata[:schema_sha1] == schema_sha1(file)
       end
 
-      def reconstruct_from_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = env, spec_name = "primary") # :nodoc:
-        file ||= dump_filename(spec_name, format)
+      def reconstruct_from_schema(db_config, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
+        file ||= dump_filename(db_config.name, format)
 
         check_schema_file(file)
 
-        ActiveRecord::Base.establish_connection(configuration)
+        ActiveRecord::Base.establish_connection(db_config)
 
-        if schema_up_to_date?(configuration, format, file, environment, spec_name)
-          truncate_tables(configuration)
+        if schema_up_to_date?(db_config, format, file)
+          truncate_tables(db_config)
         else
-          purge(configuration)
-          load_schema(configuration, format, file, environment, spec_name)
+          purge(db_config)
+          load_schema(db_config, format, file)
         end
       rescue ActiveRecord::NoDatabaseError
-        create(configuration)
-        load_schema(configuration, format, file, environment, spec_name)
+        create(db_config)
+        load_schema(db_config, format, file)
       end
 
-      def dump_schema(configuration, format = ActiveRecord::Base.schema_format, spec_name = "primary") # :nodoc:
+      def dump_schema(db_config, format = ActiveRecord::Base.schema_format) # :nodoc:
         require "active_record/schema_dumper"
-        filename = dump_filename(spec_name, format)
+        filename = dump_filename(db_config.name, format)
         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)
           end
         when :sql
-          structure_dump(configuration, filename)
+          structure_dump(db_config, filename)
           if connection.schema_migration.table_exists?
             File.open(filename, "a") do |f|
               f.puts connection.dump_schema_information
@@ -400,36 +410,36 @@ module ActiveRecord
         end
       end
 
-      def dump_filename(namespace, format = ActiveRecord::Base.schema_format)
-        filename = if namespace == "primary"
+      def dump_filename(db_config_name, format = ActiveRecord::Base.schema_format)
+        filename = if ActiveRecord::Base.configurations.primary?(db_config_name)
           schema_file_type(format)
         else
-          "#{namespace}_#{schema_file_type(format)}"
+          "#{db_config_name}_#{schema_file_type(format)}"
         end
 
         ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
       end
 
-      def cache_dump_filename(namespace)
-        filename = if namespace == "primary"
+      def cache_dump_filename(db_config_name, schema_cache_path: nil)
+        filename = if ActiveRecord::Base.configurations.primary?(db_config_name)
           "schema_cache.yml"
         else
-          "#{namespace}_schema_cache.yml"
+          "#{db_config_name}_schema_cache.yml"
         end
 
-        ENV["SCHEMA_CACHE"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
+        schema_cache_path || ENV["SCHEMA_CACHE"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
       end
 
       def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
-        each_current_configuration(environment) { |configuration, spec_name, env|
-          load_schema(configuration, format, file, env, spec_name)
-        }
+        each_current_configuration(environment) do |db_config|
+          load_schema(db_config, format, file)
+        end
         ActiveRecord::Base.establish_connection(environment.to_sym)
       end
 
       def check_schema_file(filename)
         unless File.exist?(filename)
-          message = +%{#{filename} doesn't exist yet. Run `rails db:migrate` to create it, then try again.}
+          message = +%{#{filename} doesn't exist yet. Run `bin/rails db:migrate` to create it, then try again.}
           message << %{ If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded.} if defined?(::Rails.root)
           Kernel.abort message
         end
@@ -450,16 +460,33 @@ module ActiveRecord
       # ==== Examples:
       #   ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.connection, "tmp/schema_dump.yaml")
       def dump_schema_cache(conn, filename)
-        conn.schema_cache.clear!
-        conn.data_sources.each { |table| conn.schema_cache.add(table) }
-        open(filename, "wb") { |f| f.write(YAML.dump(conn.schema_cache)) }
+        conn.schema_cache.dump_to(filename)
+      end
+
+      def clear_schema_cache(filename)
+        FileUtils.rm_f filename, verbose: false
       end
 
       private
+        def resolve_configuration(configuration)
+          Base.configurations.resolve(configuration)
+        end
+
         def verbose?
           ENV["VERBOSE"] ? ENV["VERBOSE"] != "false" : true
         end
 
+        # Create a new instance for the specified db configuration object
+        # For classes that have been converted to use db_config objects, pass a
+        # `DatabaseConfig`, otherwise pass a `Hash`
+        def database_adapter_for(db_config, *arguments)
+          klass = class_for_adapter(db_config.adapter)
+          converted = klass.respond_to?(:using_database_configurations?) && klass.using_database_configurations?
+
+          config = converted ? db_config : db_config.configuration_hash
+          klass.new(config, *arguments)
+        end
+
         def class_for_adapter(adapter)
           _key, task = @tasks.each_pair.detect { |pattern, _task| adapter[pattern] }
           unless task
@@ -468,34 +495,34 @@ module ActiveRecord
           task.is_a?(String) ? task.constantize : task
         end
 
-        def each_current_configuration(environment, spec_name = nil)
+        def each_current_configuration(environment, name = nil)
           environments = [environment]
-          environments << "test" if environment == "development"
+          environments << "test" if environment == "development" && !ENV["SKIP_TEST_DATABASE"] && !ENV["DATABASE_URL"]
 
           environments.each do |env|
             ActiveRecord::Base.configurations.configs_for(env_name: env).each do |db_config|
-              next if spec_name && spec_name != db_config.spec_name
+              next if name && name != db_config.name
 
-              yield db_config.config, db_config.spec_name, env
+              yield db_config
             end
           end
         end
 
         def each_local_configuration
           ActiveRecord::Base.configurations.configs_for.each do |db_config|
-            configuration = db_config.config
-            next unless configuration["database"]
+            next unless db_config.database
 
-            if local_database?(configuration)
-              yield configuration
+            if local_database?(db_config)
+              yield db_config
             else
-              $stderr.puts "This task only modifies local databases. #{configuration['database']} is on a remote host."
+              $stderr.puts "This task only modifies local databases. #{db_config.database} is on a remote host."
             end
           end
         end
 
-        def local_database?(configuration)
-          configuration["host"].blank? || LOCAL_HOSTS.include?(configuration["host"])
+        def local_database?(db_config)
+          host = db_config.host
+          host.blank? || LOCAL_HOSTS.include?(host)
         end
 
         def schema_sha1(file)

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -7,30 +7,29 @@ module ActiveRecord
 
       delegate :connection, :establish_connection, to: ActiveRecord::Base
 
-      def initialize(configuration)
-        @configuration = configuration
+      def self.using_database_configurations?
+        true
+      end
+
+      def initialize(db_config)
+        @db_config = db_config
+        @configuration_hash = db_config.configuration_hash
       end
 
       def create
-        establish_connection configuration_without_database
-        connection.create_database configuration["database"], creation_options
-        establish_connection configuration
-      rescue ActiveRecord::StatementInvalid => error
-        if connection.error_number(error.cause) == ER_DB_CREATE_EXISTS
-          raise DatabaseAlreadyExists
-        else
-          raise
-        end
+        establish_connection(configuration_hash_without_database)
+        connection.create_database(db_config.database, creation_options)
+        establish_connection(db_config)
       end
 
       def drop
-        establish_connection configuration
-        connection.drop_database configuration["database"]
+        establish_connection(db_config)
+        connection.drop_database(db_config.database)
       end
 
       def purge
-        establish_connection configuration
-        connection.recreate_database configuration["database"], creation_options
+        establish_connection(db_config)
+        connection.recreate_database(db_config.database, creation_options)
       end
 
       def charset
@@ -50,10 +49,10 @@ module ActiveRecord
 
         ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
         if ignore_tables.any?
-          args += ignore_tables.map { |table| "--ignore-table=#{configuration['database']}.#{table}" }
+          args += ignore_tables.map { |table| "--ignore-table=#{db_config.database}.#{table}" }
         end
 
-        args.concat(["#{configuration['database']}"])
+        args.concat([db_config.database.to_s])
         args.unshift(*extra_flags) if extra_flags
 
         run_cmd("mysqldump", args, "dumping")
@@ -62,41 +61,40 @@ module ActiveRecord
       def structure_load(filename, extra_flags)
         args = prepare_command_options
         args.concat(["--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}])
-        args.concat(["--database", "#{configuration['database']}"])
+        args.concat(["--database", db_config.database.to_s])
         args.unshift(*extra_flags) if extra_flags
 
         run_cmd("mysql", args, "loading")
       end
 
       private
+        attr_reader :db_config, :configuration_hash
 
-        attr_reader :configuration
-
-        def configuration_without_database
-          configuration.merge("database" => nil)
+        def configuration_hash_without_database
+          configuration_hash.merge(database: nil)
         end
 
         def creation_options
           Hash.new.tap do |options|
-            options[:charset]     = configuration["encoding"]   if configuration.include? "encoding"
-            options[:collation]   = configuration["collation"]  if configuration.include? "collation"
+            options[:charset]     = configuration_hash[:encoding]   if configuration_hash.include?(:encoding)
+            options[:collation]   = configuration_hash[:collation]  if configuration_hash.include?(:collation)
           end
         end
 
         def prepare_command_options
           args = {
-            "host"      => "--host",
-            "port"      => "--port",
-            "socket"    => "--socket",
-            "username"  => "--user",
-            "password"  => "--password",
-            "encoding"  => "--default-character-set",
-            "sslca"     => "--ssl-ca",
-            "sslcert"   => "--ssl-cert",
-            "sslcapath" => "--ssl-capath",
-            "sslcipher" => "--ssl-cipher",
-            "sslkey"    => "--ssl-key"
-          }.map { |opt, arg| "#{arg}=#{configuration[opt]}" if configuration[opt] }.compact
+            host:      "--host",
+            port:      "--port",
+            socket:    "--socket",
+            username:  "--user",
+            password:  "--password",
+            encoding:  "--default-character-set",
+            sslca:     "--ssl-ca",
+            sslcert:   "--ssl-cert",
+            sslcapath: "--ssl-capath",
+            sslcipher: "--ssl-cipher",
+            sslkey:    "--ssl-key"
+          }.map { |opt, arg| "#{arg}=#{configuration_hash[opt]}" if configuration_hash[opt] }.compact
 
           args
         end