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.

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 (in such case after configuring the database tasks, you can also use the rake tasks defined in Active Record).

The possible config values are:

  • env: current environment (like Rails.env).

  • database_configuration: configuration of your databases (as in config/database.yml).

  • db_dir: your db directory.

  • fixtures_path: a path to fixtures directory.

  • migrations_paths: a list of paths to directories with migrations.

  • 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:

include ActiveRecord::Tasks
DatabaseTasks.database_configuration = YAML.load_file('my_database_config.yml')
DatabaseTasks.db_dir = 'db'
# other settings...

DatabaseTasks.create_current('production')

Methods

Constants

LOCAL_HOSTS = ["127.0.0.1", "localhost"]

Attributes

[W] current_config
[RW] database_configuration
[W] db_dir
[W] env
[W] fixtures_path
[W] migrations_paths
[W] root
[W] seed_loader

Class Public methods

structure_dump_flags

Extra flags passed to database CLI tool (mysqldump/pg_dump) when calling db:structure:dump

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 43
      mattr_accessor :structure_dump_flags, instance_accessor: false
🔎 See on GitHub

structure_load_flags

Extra flags passed to database CLI tool when calling db:structure:load

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 48
      mattr_accessor :structure_load_flags, instance_accessor: false
🔎 See on GitHub

Instance Public methods

cache_dump_filename(namespace)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 413
      def cache_dump_filename(namespace)
        filename = if namespace == "primary"
          "schema_cache.yml"
        else
          "#{namespace}_schema_cache.yml"
        end

        ENV["SCHEMA_CACHE"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
      end
🔎 See on GitHub

charset(*arguments)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 276
      def charset(*arguments)
        configuration = arguments.first
        class_for_adapter(configuration["adapter"]).new(*arguments).charset
      end
🔎 See on GitHub

charset_current(environment = env, specification_name = spec)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 272
      def charset_current(environment = env, specification_name = spec)
        charset ActiveRecord::Base.configurations.configs_for(env_name: environment, spec_name: specification_name).config
      end
🔎 See on GitHub

check_protected_environments!()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 57
      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
🔎 See on GitHub

check_schema_file(filename)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 430
      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 << %{ 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
🔎 See on GitHub

check_target_version()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 262
      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
🔎 See on GitHub

collation(*arguments)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 285
      def collation(*arguments)
        configuration = arguments.first
        class_for_adapter(configuration["adapter"]).new(*arguments).collation
      end
🔎 See on GitHub

collation_current(environment = env, specification_name = spec)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 281
      def collation_current(environment = env, specification_name = spec)
        collation ActiveRecord::Base.configurations.configs_for(env_name: environment, spec_name: specification_name).config
      end
🔎 See on GitHub

create(*arguments)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 124
      def create(*arguments)
        configuration = arguments.first
        class_for_adapter(configuration["adapter"]).new(*arguments).create
        $stdout.puts "Created database '#{configuration['database']}'" if verbose?
      rescue DatabaseAlreadyExists
        $stderr.puts "Database '#{configuration['database']}' already exists" if verbose?
      rescue Exception => error
        $stderr.puts error
        $stderr.puts "Couldn't create '#{configuration['database']}' database. Please check your configuration."
        raise
      end
🔎 See on GitHub

create_all()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 136
      def create_all
        old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.connection_specification_name)
        each_local_configuration { |configuration| create configuration }
        if old_pool
          ActiveRecord::Base.connection_handler.establish_connection(old_pool.spec.to_hash)
        end
      end
🔎 See on GitHub

create_current(environment = env, spec_name = nil)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 183
      def create_current(environment = env, spec_name = nil)
        each_current_configuration(environment, spec_name) { |configuration|
          create configuration
        }
        ActiveRecord::Base.establish_connection(environment.to_sym)
      end
🔎 See on GitHub

current_config(options = {})

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 114
      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
        end
      end
🔎 See on GitHub

db_dir()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 82
      def db_dir
        @db_dir ||= Rails.application.config.paths["db"].first
      end
🔎 See on GitHub

drop(*arguments)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 190
      def drop(*arguments)
        configuration = arguments.first
        class_for_adapter(configuration["adapter"]).new(*arguments).drop
        $stdout.puts "Dropped database '#{configuration['database']}'" if verbose?
      rescue ActiveRecord::NoDatabaseError
        $stderr.puts "Database '#{configuration['database']}' does not exist"
      rescue Exception => error
        $stderr.puts error
        $stderr.puts "Couldn't drop database '#{configuration['database']}'"
        raise
      end
🔎 See on GitHub

drop_all()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 202
      def drop_all
        each_local_configuration { |configuration| drop configuration }
      end
🔎 See on GitHub

drop_current(environment = env)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 206
      def drop_current(environment = env)
        each_current_configuration(environment) { |configuration|
          drop configuration
        }
      end
🔎 See on GitHub

dump_filename(namespace, format = ActiveRecord::Base.schema_format)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 403
      def dump_filename(namespace, format = ActiveRecord::Base.schema_format)
        filename = if namespace == "primary"
          schema_file_type(format)
        else
          "#{namespace}_#{schema_file_type(format)}"
        end

        ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
      end
🔎 See on GitHub

dump_schema_cache(conn, filename)

Dumps the schema cache in YAML format for the connection into the file

Examples:

ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.connection, "tmp/schema_dump.yaml")
📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 452
      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)) }
      end
🔎 See on GitHub

env()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 102
      def env
        @env ||= Rails.env
      end
🔎 See on GitHub

fixtures_path()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 90
      def fixtures_path
        @fixtures_path ||= if ENV["FIXTURES_PATH"]
          File.join(root, ENV["FIXTURES_PATH"])
        else
          File.join(root, "test", "fixtures")
        end
      end
🔎 See on GitHub

for_each(databases)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 156
      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|
          yield db_config.spec_name
        end
      end
🔎 See on GitHub

load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 423
      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)
        }
        ActiveRecord::Base.establish_connection(environment.to_sym)
      end
🔎 See on GitHub

load_seed()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 438
      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
🔎 See on GitHub

migrate()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 232
      def migrate
        check_target_version

        scope = ENV["SCOPE"]
        verbose_was, Migration.verbose = Migration.verbose, verbose?

        Base.connection.migration_context.migrate(target_version) do |migration|
          scope.blank? || scope == migration.scope
        end

        ActiveRecord::Base.clear_cache!
      ensure
        Migration.verbose = verbose_was
      end
🔎 See on GitHub

migrate_status()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 247
      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_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
🔎 See on GitHub

migrations_paths()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 86
      def migrations_paths
        @migrations_paths ||= Rails.application.paths["db/migrate"].to_a
      end
🔎 See on GitHub

purge(configuration)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 290
      def purge(configuration)
        class_for_adapter(configuration["adapter"]).new(configuration).purge
      end
🔎 See on GitHub

purge_all()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 294
      def purge_all
        each_local_configuration { |configuration|
          purge configuration
        }
      end
🔎 See on GitHub

purge_current(environment = env)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 300
      def purge_current(environment = env)
        each_current_configuration(environment) { |configuration|
          purge configuration
        }
        ActiveRecord::Base.establish_connection(environment.to_sym)
      end
🔎 See on GitHub

raise_for_multi_db(environment = env, command:)

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

        if db_configs.count > 1
          dbs_list = []

          db_configs.each do |db|
            dbs_list << "#{command}:#{db.spec_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
🔎 See on GitHub

register_task(pattern, task)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 73
      def register_task(pattern, task)
        @tasks ||= {}
        @tasks[pattern] = task
      end
🔎 See on GitHub

root()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 98
      def root
        @root ||= Rails.root
      end
🔎 See on GitHub

schema_file(format = ActiveRecord::Base.schema_format)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 390
      def schema_file(format = ActiveRecord::Base.schema_format)
        File.join(db_dir, schema_file_type(format))
      end
🔎 See on GitHub

schema_file_type(format = ActiveRecord::Base.schema_format)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 394
      def schema_file_type(format = ActiveRecord::Base.schema_format)
        case format
        when :ruby
          "schema.rb"
        when :sql
          "structure.sql"
        end
      end
🔎 See on GitHub

schema_up_to_date?(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = env, spec_name = "primary")

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 341
      def schema_up_to_date?(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = env, spec_name = "primary")
        file ||= dump_filename(spec_name, format)

        return true unless File.exist?(file)

        ActiveRecord::Base.establish_connection(configuration)
        return false unless ActiveRecord::InternalMetadata.table_exists?
        ActiveRecord::InternalMetadata[:schema_sha1] == schema_sha1(file)
      end
🔎 See on GitHub

seed_loader()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 110
      def seed_loader
        @seed_loader ||= Rails.application
      end
🔎 See on GitHub

setup_initial_database_yaml()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 144
      def setup_initial_database_yaml
        return {} unless defined?(Rails)

        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."

          {}
        end
      end
🔎 See on GitHub

spec()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 106
      def spec
        @spec ||= "primary"
      end
🔎 See on GitHub

structure_dump(*arguments)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 307
      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)
      end
🔎 See on GitHub

structure_load(*arguments)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 313
      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)
      end
🔎 See on GitHub

target_version()

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 268
      def target_version
        ENV["VERSION"].to_i if ENV["VERSION"] && !ENV["VERSION"].empty?
      end
🔎 See on GitHub

truncate_all(environment = env)

📝 Source code 
# File activerecord/lib/active_record/tasks/database_tasks.rb, line 226
      def truncate_all(environment = env)
        ActiveRecord::Base.configurations.configs_for(env_name: environment).each do |db_config|
          truncate_tables db_config.config
        end
      end
🔎 See on GitHub