ActiveRecord::Tasks::DatabaseTasks

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 48
      mattr_accessor :structure_dump_flags, instance_accessor: false

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 54
      mattr_accessor :structure_load_flags, instance_accessor: false

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 470
      def cache_dump_filename(db_config_name, schema_cache_path: nil)
        filename = if ActiveRecord::Base.configurations.primary?(db_config_name)
          "schema_cache.yml"
        else
          "#{db_config_name}_schema_cache.yml"
        end

        schema_cache_path || ENV["SCHEMA_CACHE"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 324
      def charset(configuration, *arguments)
        db_config = resolve_configuration(configuration)
        database_adapter_for(db_config, *arguments).charset
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 319
      def charset_current(env_name = env, db_name = name)
        db_config = configs_for(env_name: env_name, name: db_name)
        charset(db_config)
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 63
      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

          if stored && stored != current
            raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
          end
        end
      rescue ActiveRecord::NoDatabaseError
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 487
      def check_schema_file(filename)
        unless File.exist?(filename)
          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
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 309
      def check_target_version
        if target_version && !(Migration::MigrationFilenameRegexp.match?(ENV["VERSION"]) || /\A\d+\z/.match?(ENV["VERSION"]))
          raise "Invalid format of target version: `VERSION=#{ENV['VERSION']}`"
        end
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 513
      def clear_schema_cache(filename)
        FileUtils.rm_f filename, verbose: false
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 334
      def collation(configuration, *arguments)
        db_config = resolve_configuration(configuration)
        database_adapter_for(db_config, *arguments).collation
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 329
      def collation_current(env_name = env, db_name = name)
        db_config = configs_for(env_name: env_name, name: db_name)
        collation(db_config)
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 120
      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 '#{db_config.database}' already exists" if verbose?
      rescue Exception => error
        $stderr.puts error
        $stderr.puts "Couldn't create '#{db_config.database}' database. Please check your configuration."
        raise
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 132
      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)
        end
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 183
      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

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 88
      def db_dir
        @db_dir ||= Rails.application.config.paths["db"].first
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 222
      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 '#{db_config.database}' does not exist"
      rescue Exception => error
        $stderr.puts error
        $stderr.puts "Couldn't drop database '#{db_config.database}'"
        raise
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 234
      def drop_all
        each_local_configuration { |db_config| drop(db_config) }
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 238
      def drop_current(environment = env)
        each_current_configuration(environment) { |db_config| drop(db_config) }
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 509
      def dump_schema_cache(conn, filename)
        conn.schema_cache.dump_to(filename)
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 108
      def env
        @env ||= Rails.env
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 96
      def fixtures_path
        @fixtures_path ||= if ENV["FIXTURES_PATH"]
          File.join(root, ENV["FIXTURES_PATH"])
        else
          File.join(root, "test", "fixtures")
        end
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 154
      def for_each(databases)
        return {} unless defined?(Rails)

        database_configs = ActiveRecord::DatabaseConfigurations.new(databases).configs_for(env_name: Rails.env)

        # if this is a single database application we don't want tasks for each primary database
        return if database_configs.count == 1

        database_configs.each do |db_config|
          next unless db_config.database_tasks?

          yield db_config.name
        end
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 480
      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)
        end
        ActiveRecord::Base.establish_connection(environment.to_sym)
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 495
      def load_seed
        if seed_loader
          seed_loader.load_seed
        else
          raise "You tried to load seed data, but no seed loader is specified. Please specify seed " \
                "loader with ActiveRecord::Tasks::DatabaseTasks.seed_loader = your_seed_loader\n" \
                "Seed loader should respond to load_seed method"
        end
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 256
      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|
          if version.blank?
            scope.blank? || scope == migration.scope
          else
            migration.version == version
          end
        end.tap do |migrations_ran|
          Migration.write("No migrations ran. (using #{scope} scope)") if scope.present? && migrations_ran.empty?
        end

        ActiveRecord::Base.clear_cache!
      ensure
        Migration.verbose = verbose_was
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 294
      def migrate_status
        unless ActiveRecord::Base.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 "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
        puts "-" * 50
        ActiveRecord::Base.connection.migration_context.migrations_status.each do |status, version, name|
          puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
        end
        puts
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 92
      def migrations_paths
        @migrations_paths ||= Rails.application.paths["db/migrate"].to_a
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 112
      def name
        @name ||= "primary"
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 188
      def prepare_all
        seed = false

        each_current_configuration(env) do |db_config|
          ActiveRecord::Base.establish_connection(db_config)

          begin
            # Skipped when no database
            migrate

            if ActiveRecord.dump_schema_after_migration
              dump_schema(db_config, ActiveRecord.schema_format)
            end
          rescue ActiveRecord::NoDatabaseError
            create(db_config)

            if File.exist?(schema_dump_path(db_config))
              load_schema(
                db_config,
                ActiveRecord.schema_format,
                nil
              )
            else
              migrate
            end

            seed = true
          end
        end

        ActiveRecord::Base.establish_connection
        load_seed if seed
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 339
      def purge(configuration)
        db_config = resolve_configuration(configuration)
        database_adapter_for(db_config).purge
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 344
      def purge_all
        each_local_configuration { |db_config| purge(db_config) }
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 348
      def purge_current(environment = env)
        each_current_configuration(environment) { |db_config| purge(db_config) }
        ActiveRecord::Base.establish_connection(environment.to_sym)
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 169
      def raise_for_multi_db(environment = env, command:)
        db_configs = configs_for(env_name: environment)

        if db_configs.count > 1
          dbs_list = []

          db_configs.each do |db|
            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

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 79
      def register_task(pattern, task)
        @tasks ||= {}
        @tasks[pattern] = task
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 104
      def root
        @root ||= Rails.root
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 457
      def schema_dump_path(db_config, format = ActiveRecord.schema_format)
        return ENV["SCHEMA"] if ENV["SCHEMA"]

        filename = db_config.schema_dump(format)
        return unless filename

        if File.dirname(filename) == ActiveRecord::Tasks::DatabaseTasks.db_dir
          filename
        else
          File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
        end
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 447
      def schema_file_type(format = ActiveRecord.schema_format)
        case format
        when :ruby
          "schema.rb"
        when :sql
          "structure.sql"
        end
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 390
      def schema_up_to_date?(configuration, format = ActiveRecord.schema_format, file = nil)
        db_config = resolve_configuration(configuration)

        file ||= schema_dump_path(db_config)

        return true unless file && File.exist?(file)

        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

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 116
      def seed_loader
        @seed_loader ||= Rails.application
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 140
      def setup_initial_database_yaml
        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
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 353
      def structure_dump(configuration, *arguments)
        db_config = resolve_configuration(configuration)
        filename = arguments.delete_at(0)
        flags = structure_dump_flags_for(db_config.adapter)
        database_adapter_for(db_config, *arguments).structure_dump(filename, flags)
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 360
      def structure_load(configuration, *arguments)
        db_config = resolve_configuration(configuration)
        filename = arguments.delete_at(0)
        flags = structure_load_flags_for(db_config.adapter)
        database_adapter_for(db_config, *arguments).structure_load(filename, flags)
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 315
      def target_version
        ENV["VERSION"].to_i if ENV["VERSION"] && !ENV["VERSION"].empty?
      end

# File activerecord/lib/active_record/tasks/database_tasks.rb, line 250
      def truncate_all(environment = env)
        configs_for(env_name: environment).each do |db_config|
          truncate_tables(db_config)
        end
      end