activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/railties/databases.rake

@@ -1,379 +1,237 @@
-require 'active_support/core_ext/object/inclusion'
-require 'active_record'
+# frozen_string_literal: true
+
+require "active_record"
 
 db_namespace = namespace :db do
-  def database_url_config
-    @database_url_config ||=
-        ActiveRecord::Base::ConnectionSpecification::Resolver.new(ENV["DATABASE_URL"], {}).spec.config.stringify_keys
+  desc "Set the environment value for the database"
+  task "environment:set" => :load_config do
+    ActiveRecord::InternalMetadata.create_table
+    ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Base.connection.migration_context.current_environment
   end
 
-  def current_config(options = {})
-    options = { :env => Rails.env }.merge! options
-
-    if options[:config]
-      @current_config = options[:config]
-    else
-      @current_config ||= if ENV['DATABASE_URL']
-                            database_url_config
-                          else
-                            ActiveRecord::Base.configurations[options[:env]]
-                          end
-    end
+  task check_protected_environments: :load_config do
+    ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
   end
 
-  task :load_config do
-    ActiveRecord::Base.configurations = Rails.application.config.database_configuration
-    ActiveRecord::Migrator.migrations_paths = Rails.application.paths['db/migrate'].to_a
-
-    if defined?(ENGINE_PATH) && engine = Rails::Engine.find(ENGINE_PATH)
-      if engine.paths['db/migrate'].existent
-        ActiveRecord::Migrator.migrations_paths += engine.paths['db/migrate'].to_a
-      end
-    end
+  task load_config: :environment do
+    ActiveRecord::Base.configurations       = ActiveRecord::Tasks::DatabaseTasks.database_configuration || {}
+    ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
   end
 
   namespace :create do
-    # desc 'Create all the local databases defined in config/database.yml'
-    task :all => :load_config do
-      ActiveRecord::Base.configurations.each_value do |config|
-        # Skip entries that don't have a database key, such as the first entry here:
-        #
-        #  defaults: &defaults
-        #    adapter: mysql
-        #    username: root
-        #    password:
-        #    host: localhost
-        #
-        #  development:
-        #    database: blog_development
-        #    *defaults
-        next unless config['database']
-        # Only connect to local databases
-        local_database?(config) { create_database(config) }
-      end
+    task all: :load_config do
+      ActiveRecord::Tasks::DatabaseTasks.create_all
     end
   end
 
-  desc 'Create the database from DATABASE_URL or config/database.yml for the current Rails.env (use db:create:all to create all dbs in the config)'
-  task :create => [:load_config, :rails_env] do
-    if ENV['DATABASE_URL']
-      create_database(database_url_config)
-    else
-      configs_for_environment.each { |config| create_database(config) }
-      ActiveRecord::Base.establish_connection(configs_for_environment.first)
-    end
+  desc "Creates the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:create:all to create all databases in the config). Without RAILS_ENV or when RAILS_ENV is development, it defaults to creating the development and test databases."
+  task create: [:load_config] do
+    ActiveRecord::Tasks::DatabaseTasks.create_current
   end
 
-  # If neither encoding nor collation is specified, use the utf-8 defaults.
-  def mysql_creation_options(config)
-    default_charset   = ENV['CHARSET']    || 'utf8'
-    default_collation = ENV['COLLATION']  || 'utf8_unicode_ci'
-
-    Hash.new.tap do |options|
-      options[:charset]     = config['encoding']   if config.include? 'encoding'
-      options[:collation]   = config['collation']  if config.include? 'collation'
-
-      # Set default charset only when collation isn't set.
-      options[:charset]   ||= default_charset unless options[:collation]
-
-      # Set default collation only when charset is also default.
-      options[:collation] ||= default_collation if options[:charset] == default_charset
+  namespace :drop do
+    task all: [:load_config, :check_protected_environments] do
+      ActiveRecord::Tasks::DatabaseTasks.drop_all
     end
   end
 
-  def create_database(config)
-    begin
-      if config['adapter'] =~ /sqlite/
-        if File.exist?(config['database'])
-          $stderr.puts "#{config['database']} already exists"
-        else
-          begin
-            # Create the SQLite database
-            ActiveRecord::Base.establish_connection(config)
-            ActiveRecord::Base.connection
-          rescue Exception => e
-            $stderr.puts e, *(e.backtrace)
-            $stderr.puts "Couldn't create database for #{config.inspect}"
-          end
-        end
-        return # Skip the else clause of begin/rescue
-      else
-        ActiveRecord::Base.establish_connection(config)
-        ActiveRecord::Base.connection
-      end
-    rescue
-      case config['adapter']
-      when /mysql/
-        if config['adapter'] =~ /jdbc/
-          #FIXME After Jdbcmysql gives this class
-          require 'active_record/railties/jdbcmysql_error'
-          error_class = ArJdbcMySQL::Error
-        else
-          error_class = config['adapter'] =~ /mysql2/ ? Mysql2::Error : Mysql::Error
-        end
-        access_denied_error = 1045
-
-        create_options = mysql_creation_options(config)
-
-        begin
-          ActiveRecord::Base.establish_connection(config.merge('database' => nil))
-          ActiveRecord::Base.connection.create_database(config['database'], create_options)
-          ActiveRecord::Base.establish_connection(config)
-        rescue error_class => sqlerr
-          if sqlerr.errno == access_denied_error
-            print "#{sqlerr.error}. \nPlease provide the root password for your mysql installation\n>"
-            root_password = $stdin.gets.strip
-            grant_statement = "GRANT ALL PRIVILEGES ON #{config['database']}.* " \
-              "TO '#{config['username']}'@'localhost' " \
-              "IDENTIFIED BY '#{config['password']}' WITH GRANT OPTION;"
-            ActiveRecord::Base.establish_connection(config.merge(
-                'database' => nil, 'username' => 'root', 'password' => root_password))
-            ActiveRecord::Base.connection.create_database(config['database'], mysql_creation_options(config))
-            ActiveRecord::Base.connection.execute grant_statement
-            ActiveRecord::Base.establish_connection(config)
-          else
-            $stderr.puts sqlerr.error
-            $stderr.puts "Couldn't create database for #{config.inspect}, charset: #{create_options[:charset]}, collation: #{create_options[:collation]}"
-            $stderr.puts "(if you set the charset manually, make sure you have a matching collation)" if config['encoding']
-          end
-        end
-      when /postgresql/
-        @encoding = config['encoding'] || ENV['CHARSET'] || 'utf8'
-        begin
-          ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
-          ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => @encoding))
-          ActiveRecord::Base.establish_connection(config)
-        rescue Exception => e
-          $stderr.puts e, *(e.backtrace)
-          $stderr.puts "Couldn't create database for #{config.inspect}"
-        end
-      end
-    else
-      # Bug with 1.9.2 Calling return within begin still executes else
-      $stderr.puts "#{config['database']} already exists" unless config['adapter'] =~ /sqlite/
-    end
+  desc "Drops the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:drop:all to drop all databases in the config). Without RAILS_ENV or when RAILS_ENV is development, it defaults to dropping the development and test databases."
+  task drop: [:load_config, :check_protected_environments] do
+    db_namespace["drop:_unsafe"].invoke
   end
 
-  namespace :drop do
-    # desc 'Drops all the local databases defined in config/database.yml'
-    task :all => :load_config do
-      ActiveRecord::Base.configurations.each_value do |config|
-        # Skip entries that don't have a database key
-        next unless config['database']
-        begin
-          # Only connect to local databases
-          local_database?(config) { drop_database(config) }
-        rescue Exception => e
-          $stderr.puts "Couldn't drop #{config['database']} : #{e.inspect}"
-        end
-      end
-    end
+  task "drop:_unsafe" => [:load_config] do
+    ActiveRecord::Tasks::DatabaseTasks.drop_current
   end
 
-  desc 'Drops the database using DATABASE_URL or the current Rails.env (use db:drop:all to drop all databases)'
-  task :drop => [:load_config, :rails_env] do
-    if ENV['DATABASE_URL']
-      drop_database_and_rescue(database_url_config)
-    else
-      configs_for_environment.each { |config| drop_database_and_rescue(config) }
+  namespace :purge do
+    task all: [:load_config, :check_protected_environments] do
+      ActiveRecord::Tasks::DatabaseTasks.purge_all
     end
   end
 
-  def local_database?(config, &block)
-    if config['host'].in?(['127.0.0.1', 'localhost']) || config['host'].blank?
-      yield
-    else
-      $stderr.puts "This task only modifies local databases. #{config['database']} is on a remote host."
-    end
+  # desc "Empty the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:purge:all to purge all databases in the config). Without RAILS_ENV it defaults to purging the development and test databases."
+  task purge: [:load_config, :check_protected_environments] do
+    ActiveRecord::Tasks::DatabaseTasks.purge_current
   end
 
-  desc "Migrate the database (options: VERSION=x, VERBOSE=false)."
-  task :migrate => [:environment, :load_config] do
-    ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
-    ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, ENV["VERSION"] ? ENV["VERSION"].to_i : nil) do |migration|
-      ENV["SCOPE"].blank? || (ENV["SCOPE"] == migration.scope)
-    end
-    db_namespace['_dump'].invoke
+  desc "Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)."
+  task migrate: :load_config do
+    ActiveRecord::Tasks::DatabaseTasks.migrate
+    db_namespace["_dump"].invoke
   end
 
+  # IMPORTANT: This task won't dump the schema if ActiveRecord::Base.dump_schema_after_migration is set to false
   task :_dump do
-    case ActiveRecord::Base.schema_format
-    when :ruby then db_namespace["schema:dump"].invoke
-    when :sql  then db_namespace["structure:dump"].invoke
-    else
-      raise "unknown schema format #{ActiveRecord::Base.schema_format}"
+    if ActiveRecord::Base.dump_schema_after_migration
+      case ActiveRecord::Base.schema_format
+      when :ruby then db_namespace["schema:dump"].invoke
+      when :sql  then db_namespace["structure:dump"].invoke
+      else
+        raise "unknown schema format #{ActiveRecord::Base.schema_format}"
+      end
     end
     # Allow this task to be called as many times as required. An example is the
     # migrate:redo task, which calls other two internally that depend on this one.
-    db_namespace['_dump'].reenable
+    db_namespace["_dump"].reenable
   end
 
   namespace :migrate do
     # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
-    task :redo => [:environment, :load_config] do
-      if ENV['VERSION']
-        db_namespace['migrate:down'].invoke
-        db_namespace['migrate:up'].invoke
+    task redo: :load_config do
+      raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
+
+      if ENV["VERSION"]
+        db_namespace["migrate:down"].invoke
+        db_namespace["migrate:up"].invoke
       else
-        db_namespace['rollback'].invoke
-        db_namespace['migrate'].invoke
+        db_namespace["rollback"].invoke
+        db_namespace["migrate"].invoke
       end
     end
 
     # desc 'Resets your database using your migrations for the current environment'
-    task :reset => ['db:drop', 'db:create', 'db:migrate']
+    task reset: ["db:drop", "db:create", "db:migrate"]
 
     # desc 'Runs the "up" for a given migration VERSION.'
-    task :up => [:environment, :load_config] do
-      version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required' unless version
-      ActiveRecord::Migrator.run(:up, ActiveRecord::Migrator.migrations_paths, version)
-      db_namespace['_dump'].invoke
+    task up: :load_config do
+      raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
+
+      ActiveRecord::Tasks::DatabaseTasks.check_target_version
+
+      ActiveRecord::Base.connection.migration_context.run(
+        :up,
+        ActiveRecord::Tasks::DatabaseTasks.target_version
+      )
+      db_namespace["_dump"].invoke
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
-    task :down => [:environment, :load_config] do
-      version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required' unless version
-      ActiveRecord::Migrator.run(:down, ActiveRecord::Migrator.migrations_paths, version)
-      db_namespace['_dump'].invoke
+    task down: :load_config do
+      raise "VERSION is required - To go down one migration, use db:rollback" if !ENV["VERSION"] || ENV["VERSION"].empty?
+
+      ActiveRecord::Tasks::DatabaseTasks.check_target_version
+
+      ActiveRecord::Base.connection.migration_context.run(
+        :down,
+        ActiveRecord::Tasks::DatabaseTasks.target_version
+      )
+      db_namespace["_dump"].invoke
     end
 
-    desc 'Display status of migrations'
-    task :status => [:environment, :load_config] do
-      unless ActiveRecord::Base.connection.table_exists?(ActiveRecord::Migrator.schema_migrations_table_name)
-        puts 'Schema migrations table does not exist yet.'
-        next  # means "return" for rake task
-      end
-      db_list = ActiveRecord::Base.connection.select_values("SELECT version FROM #{ActiveRecord::Migrator.schema_migrations_table_name}")
-      file_list = []
-      ActiveRecord::Migrator.migrations_paths.each do |path|
-        Dir.foreach(path) do |file|
-          # only files matching "20091231235959_some_name.rb" pattern
-          if match_data = /^(\d{14})_(.+)\.rb$/.match(file)
-            status = db_list.delete(match_data[1]) ? 'up' : 'down'
-            file_list << [status, match_data[1], match_data[2].humanize]
-          end
-        end
-      end
-      db_list.map! do |version|
-        ['up', version, '********** NO FILE **********']
+    desc "Display status of migrations"
+    task status: :load_config do
+      unless ActiveRecord::SchemaMigration.table_exists?
+        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
-      (db_list + file_list).sort_by {|migration| migration[1]}.each do |migration|
-        puts "#{migration[0].center(8)}  #{migration[1].ljust(14)}  #{migration[2]}"
+      ActiveRecord::Base.connection.migration_context.migrations_status.each do |status, version, name|
+        puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
       end
       puts
     end
   end
 
-  desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n).'
-  task :rollback => [:environment, :load_config] do
-    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-    ActiveRecord::Migrator.rollback(ActiveRecord::Migrator.migrations_paths, step)
-    db_namespace['_dump'].invoke
+  desc "Rolls the schema back to the previous version (specify steps w/ STEP=n)."
+  task rollback: :load_config do
+    step = ENV["STEP"] ? ENV["STEP"].to_i : 1
+    ActiveRecord::Base.connection.migration_context.rollback(step)
+    db_namespace["_dump"].invoke
   end
 
   # desc 'Pushes the schema to the next version (specify steps w/ STEP=n).'
-  task :forward => [:environment, :load_config] do
-    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-    ActiveRecord::Migrator.forward(ActiveRecord::Migrator.migrations_paths, step)
-    db_namespace['_dump'].invoke
+  task forward: :load_config do
+    step = ENV["STEP"] ? ENV["STEP"].to_i : 1
+    ActiveRecord::Base.connection.migration_context.forward(step)
+    db_namespace["_dump"].invoke
   end
 
   # desc 'Drops and recreates the database from db/schema.rb for the current environment and loads the seeds.'
-  task :reset => [:environment, :load_config] do
-    db_namespace["drop"].invoke
-    db_namespace["setup"].invoke
-  end
+  task reset: [ "db:drop", "db:setup" ]
 
   # desc "Retrieves the charset for the current environment's database"
-  task :charset => [:environment, :load_config] do
-    config = ActiveRecord::Base.configurations[Rails.env]
-    case config['adapter']
-    when /mysql/
-      ActiveRecord::Base.establish_connection(config)
-      puts ActiveRecord::Base.connection.charset
-    when /postgresql/
-      ActiveRecord::Base.establish_connection(config)
-      puts ActiveRecord::Base.connection.encoding
-    when /sqlite/
-      ActiveRecord::Base.establish_connection(config)
-      puts ActiveRecord::Base.connection.encoding
-    else
-      $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
-    end
+  task charset: :load_config do
+    puts ActiveRecord::Tasks::DatabaseTasks.charset_current
   end
 
   # desc "Retrieves the collation for the current environment's database"
-  task :collation => [:environment, :load_config] do
-    config = ActiveRecord::Base.configurations[Rails.env]
-    case config['adapter']
-    when /mysql/
-      ActiveRecord::Base.establish_connection(config)
-      puts ActiveRecord::Base.connection.collation
-    else
-      $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+  task collation: :load_config do
+    begin
+      puts ActiveRecord::Tasks::DatabaseTasks.collation_current
+    rescue NoMethodError
+      $stderr.puts "Sorry, your database adapter is not supported yet. Feel free to submit a patch."
     end
   end
 
-  desc 'Retrieves the current schema version number'
-  task :version => [:environment, :load_config] do
-    puts "Current version: #{ActiveRecord::Migrator.current_version}"
+  desc "Retrieves the current schema version number"
+  task version: :load_config do
+    puts "Current version: #{ActiveRecord::Base.connection.migration_context.current_version}"
   end
 
   # desc "Raises an error if there are pending migrations"
-  task :abort_if_pending_migrations => [:environment, :load_config] do
-    pending_migrations = ActiveRecord::Migrator.new(:up, ActiveRecord::Migrator.migrations_paths).pending_migrations
+  task abort_if_pending_migrations: :load_config do
+    pending_migrations = ActiveRecord::Base.connection.migration_context.open.pending_migrations
 
     if pending_migrations.any?
-      puts "You have #{pending_migrations.size} pending migrations:"
+      puts "You have #{pending_migrations.size} pending #{pending_migrations.size > 1 ? 'migrations:' : 'migration:'}"
       pending_migrations.each do |pending_migration|
-        puts '  %4d %s' % [pending_migration.version, pending_migration.name]
+        puts "  %4d %s" % [pending_migration.version, pending_migration.name]
       end
-      abort %{Run `rake db:migrate` to update your database then try again.}
+      abort %{Run `rails db:migrate` to update your database then try again.}
     end
   end
 
-  desc 'Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first)'
-  task :setup => ['db:schema:load_if_ruby', 'db:structure:load_if_sql', :seed]
+  desc "Creates the database, loads the schema, and initializes with the seed data (use db:reset to also drop the database first)"
+  task setup: ["db:schema:load_if_ruby", "db:structure:load_if_sql", :seed]
 
-  desc 'Load the seed data from db/seeds.rb'
+  desc "Loads the seed data from db/seeds.rb"
   task :seed do
-    db_namespace['abort_if_pending_migrations'].invoke
-    Rails.application.load_seed
+    db_namespace["abort_if_pending_migrations"].invoke
+    ActiveRecord::Tasks::DatabaseTasks.load_seed
   end
 
   namespace :fixtures do
-    desc "Load fixtures into the current environment's database. Load specific fixtures using FIXTURES=x,y. Load from subdirectory in test/fixtures using FIXTURES_DIR=z. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
-    task :load => [:environment, :load_config] do
-      require 'active_record/fixtures'
+    desc "Loads fixtures into the current environment's database. Load specific fixtures using FIXTURES=x,y. Load from subdirectory in test/fixtures using FIXTURES_DIR=z. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
+    task load: :load_config do
+      require "active_record/fixtures"
+
+      base_dir = ActiveRecord::Tasks::DatabaseTasks.fixtures_path
 
-      base_dir     = File.join [Rails.root, ENV['FIXTURES_PATH'] || %w{test fixtures}].flatten
-      fixtures_dir = File.join [base_dir, ENV['FIXTURES_DIR']].compact
+      fixtures_dir = if ENV["FIXTURES_DIR"]
+        File.join base_dir, ENV["FIXTURES_DIR"]
+      else
+        base_dir
+      end
 
-      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir["#{fixtures_dir}/**/*.yml"].map {|f| f[(fixtures_dir.size + 1)..-5] }).each do |fixture_file|
-        ActiveRecord::Fixtures.create_fixtures(fixtures_dir, fixture_file)
+      fixture_files = if ENV["FIXTURES"]
+        ENV["FIXTURES"].split(",")
+      else
+        # The use of String#[] here is to support namespaced fixtures.
+        Dir["#{fixtures_dir}/**/*.yml"].map { |f| f[(fixtures_dir.size + 1)..-5] }
       end
+
+      ActiveRecord::FixtureSet.create_fixtures(fixtures_dir, fixture_files)
     end
 
     # desc "Search for a fixture given a LABEL or ID. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
-    task :identify => [:environment, :load_config] do
-      require 'active_record/fixtures'
+    task identify: :load_config do
+      require "active_record/fixtures"
+
+      label, id = ENV["LABEL"], ENV["ID"]
+      raise "LABEL or ID required" if label.blank? && id.blank?
 
-      label, id = ENV['LABEL'], ENV['ID']
-      raise 'LABEL or ID required' if label.blank? && id.blank?
+      puts %Q(The fixture ID for "#{label}" is #{ActiveRecord::FixtureSet.identify(label)}.) if label
 
-      puts %Q(The fixture ID for "#{label}" is #{ActiveRecord::Fixtures.identify(label)}.) if label
+      base_dir = ActiveRecord::Tasks::DatabaseTasks.fixtures_path
 
-      base_dir = ENV['FIXTURES_PATH'] ? File.join(Rails.root, ENV['FIXTURES_PATH']) : File.join(Rails.root, 'test', 'fixtures')
       Dir["#{base_dir}/**/*.yml"].each do |file|
-        if data = YAML::load(ERB.new(IO.read(file)).result)
-          data.keys.each do |key|
-            key_id = ActiveRecord::Fixtures.identify(key)
+        if data = YAML.load(ERB.new(IO.read(file)).result)
+          data.each_key do |key|
+            key_id = ActiveRecord::FixtureSet.identify(key)
 
             if key == label || key_id == id.to_i
               puts "#{file}: #{key} (#{key_id})"
@@ -385,208 +243,121 @@ db_namespace = namespace :db do
   end
 
   namespace :schema do
-    desc 'Create a db/schema.rb file that can be portably used against any DB supported by AR'
-    task :dump => [:environment, :load_config] do
-      require 'active_record/schema_dumper'
-      filename = ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb"
+    desc "Creates a db/schema.rb file that is portable against any DB supported by Active Record"
+    task dump: :load_config do
+      require "active_record/schema_dumper"
+      filename = ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema.rb")
       File.open(filename, "w:utf-8") do |file|
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
       end
-      db_namespace['schema:dump'].reenable
+      db_namespace["schema:dump"].reenable
     end
 
-    desc 'Load a schema.rb file into the database'
-    task :load => [:environment, :load_config] do
-      file = ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb"
-      if File.exists?(file)
-        load(file)
-      else
-        abort %{#{file} doesn't exist yet. Run `rake db:migrate` to create it then try again. 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}
-      end
+    desc "Loads a schema.rb file into the database"
+    task load: [:load_config, :check_protected_environments] do
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:ruby, ENV["SCHEMA"])
     end
 
-    task :load_if_ruby => ['db:create', :environment] do
+    task load_if_ruby: ["db:create", :environment] do
       db_namespace["schema:load"].invoke if ActiveRecord::Base.schema_format == :ruby
     end
-  end
 
-  namespace :structure do
-    desc 'Dump the database structure to db/structure.sql. Specify another file with DB_STRUCTURE=db/my_structure.sql'
-    task :dump => [:environment, :load_config] do
-      config = current_config
-      filename = ENV['DB_STRUCTURE'] || File.join(Rails.root, "db", "structure.sql")
-      case config['adapter']
-      when /mysql/, 'oci', 'oracle'
-        ActiveRecord::Base.establish_connection(config)
-        File.open(filename, "w:utf-8") { |f| f << ActiveRecord::Base.connection.structure_dump }
-      when /postgresql/
-        set_psql_env(config)
-        search_path = config['schema_search_path']
-        unless search_path.blank?
-          search_path = search_path.split(",").map{|search_path_part| "--schema=#{Shellwords.escape(search_path_part.strip)}" }.join(" ")
-        end
-        `pg_dump -i -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(config['database'])}`
-        raise 'Error dumping database' if $?.exitstatus == 1
-        File.open(filename, "a") { |f| f << "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n" }
-      when /sqlite/
-        dbfile = config['database']
-        `sqlite3 #{dbfile} .schema > #{filename}`
-      when 'sqlserver'
-        `smoscript -s #{config['host']} -d #{config['database']} -u #{config['username']} -p #{config['password']} -f #{filename} -A -U`
-      when "firebird"
-        set_firebird_env(config)
-        db_string = firebird_db_string(config)
-        sh "isql -a #{db_string} > #{filename}"
-      else
-        raise "Task not supported by '#{config['adapter']}'"
+    namespace :cache do
+      desc "Creates a db/schema_cache.yml file."
+      task dump: :load_config do
+        conn = ActiveRecord::Base.connection
+        filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.yml")
+        ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(conn, filename)
       end
 
-      if ActiveRecord::Base.connection.supports_migrations?
-        File.open(filename, "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+      desc "Clears a db/schema_cache.yml file."
+      task clear: :load_config do
+        filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.yml")
+        rm_f filename, verbose: false
       end
-      db_namespace['structure:dump'].reenable
     end
 
-    # desc "Recreate the databases from the structure.sql file"
-    task :load => [:environment, :load_config] do
-      config = current_config
-      filename = ENV['DB_STRUCTURE'] || File.join(Rails.root, "db", "structure.sql")
-      case config['adapter']
-      when /mysql/
-        ActiveRecord::Base.establish_connection(config)
-        ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
-        IO.read(filename).split("\n\n").each do |table|
-          ActiveRecord::Base.connection.execute(table)
-        end
-      when /postgresql/
-        set_psql_env(config)
-        `psql -f "#{filename}" #{config['database']}`
-      when /sqlite/
-        dbfile = config['database']
-        `sqlite3 #{dbfile} < "#{filename}"`
-      when 'sqlserver'
-        `sqlcmd -S #{config['host']} -d #{config['database']} -U #{config['username']} -P #{config['password']} -i #{filename}`
-      when 'oci', 'oracle'
-        ActiveRecord::Base.establish_connection(config)
-        IO.read(filename).split(";\n\n").each do |ddl|
-          ActiveRecord::Base.connection.execute(ddl)
+  end
+
+  namespace :structure do
+    desc "Dumps the database structure to db/structure.sql. Specify another file with SCHEMA=db/my_structure.sql"
+    task dump: :load_config do
+      filename = ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure.sql")
+      current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
+      ActiveRecord::Tasks::DatabaseTasks.structure_dump(current_config, filename)
+
+      if ActiveRecord::SchemaMigration.table_exists?
+        File.open(filename, "a") do |f|
+          f.puts ActiveRecord::Base.connection.dump_schema_information
+          f.print "\n"
         end
-      when 'firebird'
-        set_firebird_env(config)
-        db_string = firebird_db_string(config)
-        sh "isql -i #{filename} #{db_string}"
-      else
-        raise "Task not supported by '#{config['adapter']}'"
       end
+      db_namespace["structure:dump"].reenable
+    end
+
+    desc "Recreates the databases from the structure.sql file"
+    task load: [:load_config, :check_protected_environments] do
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:sql, ENV["SCHEMA"])
     end
 
-    task :load_if_sql => ['db:create', :environment] do
+    task load_if_sql: ["db:create", :environment] do
       db_namespace["structure:load"].invoke if ActiveRecord::Base.schema_format == :sql
     end
   end
 
   namespace :test do
-
     # desc "Recreate the test database from the current schema"
-    task :load => 'db:test:purge' do
+    task load: %w(db:test:purge) do
       case ActiveRecord::Base.schema_format
-        when :ruby
-          db_namespace["test:load_schema"].invoke
-        when :sql
-          db_namespace["test:load_structure"].invoke
+      when :ruby
+        db_namespace["test:load_schema"].invoke
+      when :sql
+        db_namespace["test:load_structure"].invoke
       end
     end
 
-    # desc "Recreate the test database from an existent structure.sql file"
-    task :load_structure => 'db:test:purge' do
+    # desc "Recreate the test database from an existent schema.rb file"
+    task load_schema: %w(db:test:purge) do
       begin
-        current_config(:config => ActiveRecord::Base.configurations['test'])
-        db_namespace["structure:load"].invoke
+        should_reconnect = ActiveRecord::Base.connection_pool.active_connection?
+        ActiveRecord::Schema.verbose = false
+        ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations["test"], :ruby, ENV["SCHEMA"], "test"
       ensure
-        current_config(:config => nil)
+        if should_reconnect
+          ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[ActiveRecord::Tasks::DatabaseTasks.env])
+        end
       end
     end
 
-    # desc "Recreate the test database from an existent schema.rb file"
-    task :load_schema => 'db:test:purge' do
-      ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
-      ActiveRecord::Schema.verbose = false
-      db_namespace["schema:load"].invoke
+    # desc "Recreate the test database from an existent structure.sql file"
+    task load_structure: %w(db:test:purge) do
+      ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations["test"], :sql, ENV["SCHEMA"], "test"
     end
 
-    # desc "Recreate the test database from a fresh schema.rb file"
-    task :clone => %w(db:schema:dump db:test:load_schema)
-
-    # desc "Recreate the test database from a fresh structure.sql file"
-    task :clone_structure => [ "db:structure:dump", "db:test:load_structure" ]
-
     # desc "Empty the test database"
-    task :purge => [:environment, :load_config] do
-      abcs = ActiveRecord::Base.configurations
-      case abcs['test']['adapter']
-      when /mysql/
-        ActiveRecord::Base.establish_connection(:test)
-        ActiveRecord::Base.connection.recreate_database(abcs['test']['database'], mysql_creation_options(abcs['test']))
-      when /postgresql/
-        ActiveRecord::Base.clear_active_connections!
-        drop_database(abcs['test'])
-        create_database(abcs['test'])
-      when /sqlite/
-        dbfile = abcs['test']['database']
-        File.delete(dbfile) if File.exist?(dbfile)
-      when 'sqlserver'
-        test = abcs.deep_dup['test']
-        test_database = test['database']
-        test['database'] = 'master'
-        ActiveRecord::Base.establish_connection(test)
-        ActiveRecord::Base.connection.recreate_database!(test_database)
-      when "oci", "oracle"
-        ActiveRecord::Base.establish_connection(:test)
-        ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
-          ActiveRecord::Base.connection.execute(ddl)
-        end
-      when 'firebird'
-        ActiveRecord::Base.establish_connection(:test)
-        ActiveRecord::Base.connection.recreate_database!
-      else
-        raise "Task not supported by '#{abcs['test']['adapter']}'"
-      end
+    task purge: %w(load_config check_protected_environments) do
+      ActiveRecord::Tasks::DatabaseTasks.purge ActiveRecord::Base.configurations["test"]
     end
 
-    # desc 'Check for pending migrations and load the test schema'
-    task :prepare => 'db:abort_if_pending_migrations' do
+    # desc 'Load the test schema'
+    task prepare: :load_config do
       unless ActiveRecord::Base.configurations.blank?
-        db_namespace[{ :sql  => 'test:clone_structure', :ruby => 'test:load' }[ActiveRecord::Base.schema_format]].invoke
+        db_namespace["test:load"].invoke
       end
     end
   end
-
-  namespace :sessions do
-    # desc "Creates a sessions migration for use with ActiveRecord::SessionStore"
-    task :create => [:environment, :load_config] do
-      raise 'Task unavailable to this database (no migration support)' unless ActiveRecord::Base.connection.supports_migrations?
-      Rails.application.load_generators
-      require 'rails/generators/rails/session_migration/session_migration_generator'
-      Rails::Generators::SessionMigrationGenerator.start [ ENV['MIGRATION'] || 'add_sessions_table' ]
-    end
-
-    # desc "Clear the sessions table"
-    task :clear => [:environment, :load_config] do
-      ActiveRecord::Base.connection.execute "DELETE FROM #{session_table_name}"
-    end
-  end
 end
 
 namespace :railties do
   namespace :install do
-    # desc "Copies missing migrations from Railties (e.g. plugins, engines). You can specify Railties to use with FROM=railtie1,railtie2"
-    task :migrations => :'db:load_config' do
-      to_load = ENV['FROM'].blank? ? :all : ENV['FROM'].split(",").map {|n| n.strip }
-      railties = ActiveSupport::OrderedHash.new
-      Rails.application.railties.all do |railtie|
+    # desc "Copies missing migrations from Railties (e.g. engines). You can specify Railties to use with FROM=railtie1,railtie2"
+    task migrations: :'db:load_config' do
+      to_load = ENV["FROM"].blank? ? :all : ENV["FROM"].split(",").map(&:strip)
+      railties = {}
+      Rails.application.migration_railties.each do |railtie|
         next unless to_load == :all || to_load.include?(railtie.railtie_name)
 
-        if railtie.respond_to?(:paths) && (path = railtie.paths['db/migrate'].first)
+        if railtie.respond_to?(:paths) && (path = railtie.paths["db/migrate"].first)
           railties[railtie.railtie_name] = path
         end
       end
@@ -595,65 +366,12 @@ namespace :railties do
         puts "NOTE: Migration #{migration.basename} from #{name} has been skipped. Migration with the same name already exists."
       end
 
-      on_copy = Proc.new do |name, migration, old_path|
+      on_copy = Proc.new do |name, migration|
         puts "Copied migration #{migration.basename} from #{name}"
       end
 
-      ActiveRecord::Migration.copy(ActiveRecord::Migrator.migrations_paths.first, railties,
-                                    :on_skip => on_skip, :on_copy => on_copy)
+      ActiveRecord::Migration.copy(ActiveRecord::Tasks::DatabaseTasks.migrations_paths.first, railties,
+                                    on_skip: on_skip, on_copy: on_copy)
     end
   end
 end
-
-task 'test:prepare' => 'db:test:prepare'
-
-def drop_database(config)
-  case config['adapter']
-  when /mysql/
-    ActiveRecord::Base.establish_connection(config)
-    ActiveRecord::Base.connection.drop_database config['database']
-  when /sqlite/
-    require 'pathname'
-    path = Pathname.new(config['database'])
-    file = path.absolute? ? path.to_s : File.join(Rails.root, path)
-
-    FileUtils.rm(file)
-  when /postgresql/
-    ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
-    ActiveRecord::Base.connection.drop_database config['database']
-  end
-end
-
-def drop_database_and_rescue(config)
-  begin
-    drop_database(config)
-  rescue Exception => e
-    $stderr.puts "Couldn't drop #{config['database']} : #{e.inspect}"
-  end
-end
-
-def configs_for_environment
-  environments = [Rails.env]
-  environments << 'test' if Rails.env.development?
-  ActiveRecord::Base.configurations.values_at(*environments).compact.reject { |config| config['database'].blank? }
-end
-
-def session_table_name
-  ActiveRecord::SessionStore::Session.table_name
-end
-
-def set_firebird_env(config)
-  ENV['ISC_USER']     = config['username'].to_s if config['username']
-  ENV['ISC_PASSWORD'] = config['password'].to_s if config['password']
-end
-
-def firebird_db_string(config)
-  FireRuby::Database.db_string_for(config.symbolize_keys)
-end
-
-def set_psql_env(config)
-  ENV['PGHOST']     = config['host']          if config['host']
-  ENV['PGPORT']     = config['port'].to_s     if config['port']
-  ENV['PGPASSWORD'] = config['password'].to_s if config['password']
-  ENV['PGUSER']     = config['username'].to_s if config['username']
-end