activerecord 3.2.22.5 → 4.2.11.3

data/lib/active_record/railties/databases.rake

@@ -1,207 +1,59 @@
-require 'active_support/core_ext/object/inclusion'
 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
-  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
-  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
+    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
+      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 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 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 it defaults to dropping the development and test databases.'
+  task :drop => [:load_config] do
+    ActiveRecord::Tasks::DatabaseTasks.drop_current
   end
 
-  namespace :drop do
-    # desc 'Drops all the local databases defined in config/database.yml'
+  namespace :purge do
     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
+      ActiveRecord::Tasks::DatabaseTasks.purge_all
     end
   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) }
-    end
+  # desc "Empty 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 it defaults to purging the development and test databases."
+  task :purge => [:load_config] do
+    ActiveRecord::Tasks::DatabaseTasks.purge_current
   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
-  end
-
-  desc "Migrate the database (options: VERSION=x, VERBOSE=false)."
+  desc "Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)."
   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
+    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.
@@ -211,6 +63,8 @@ db_namespace = namespace :db do
   namespace :migrate do
     # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
     task :redo => [:environment, :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
@@ -225,46 +79,34 @@ db_namespace = namespace :db do
 
     # desc 'Runs the "up" for a given migration VERSION.'
     task :up => [:environment, :load_config] do
+      raise "VERSION is required" if ENV["VERSION"] && ENV["VERSION"].empty?
+
       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
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
     task :down => [:environment, :load_config] do
+      raise "VERSION is required - To go down one migration, use db:rollback" if ENV["VERSION"] && ENV["VERSION"].empty?
       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
     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 **********']
+      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]}"
+      paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+      ActiveRecord::Migrator.migrations_status(paths).each do |status, version, name|
+        puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
       end
       puts
     end
@@ -292,31 +134,15 @@ db_namespace = namespace :db do
 
   # 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
+    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'
+    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
 
@@ -326,11 +152,11 @@ db_namespace = namespace :db do
   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 => :environment do
+    pending_migrations = ActiveRecord::Migrator.open(ActiveRecord::Migrator.migrations_paths).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]
       end
@@ -338,13 +164,13 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first)'
+  desc 'Create the database, load the schema, and initialize 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'
   task :seed do
     db_namespace['abort_if_pending_migrations'].invoke
-    Rails.application.load_seed
+    ActiveRecord::Tasks::DatabaseTasks.load_seed
   end
 
   namespace :fixtures do
@@ -352,12 +178,22 @@ db_namespace = namespace :db do
     task :load => [:environment, :load_config] do
       require 'active_record/fixtures'
 
-      base_dir     = File.join [Rails.root, ENV['FIXTURES_PATH'] || %w{test fixtures}].flatten
-      fixtures_dir = File.join [base_dir, ENV['FIXTURES_DIR']].compact
+      base_dir = ActiveRecord::Tasks::DatabaseTasks.fixtures_path
 
-      (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)
-      end
+      fixtures_dir = if ENV['FIXTURES_DIR']
+                       File.join base_dir, ENV['FIXTURES_DIR']
+                     else
+                       base_dir
+                     end
+
+      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."
@@ -367,13 +203,14 @@ db_namespace = namespace :db do
       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::Fixtures.identify(label)}.) if label
+      puts %Q(The fixture ID for "#{label}" is #{ActiveRecord::FixtureSet.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)
+          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,10 +222,10 @@ 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'
+    desc 'Create a db/schema.rb file that is portable 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"
+      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
@@ -397,87 +234,53 @@ db_namespace = namespace :db do
 
     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
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:ruby, ENV['SCHEMA'])
     end
 
     task :load_if_ruby => ['db:create', :environment] do
       db_namespace["schema:load"].invoke if ActiveRecord::Base.schema_format == :ruby
     end
+
+    namespace :cache do
+      desc 'Create a db/schema_cache.dump file.'
+      task :dump => [:environment, :load_config] do
+        con = ActiveRecord::Base.connection
+        filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.dump")
+
+        con.schema_cache.clear!
+        con.tables.each { |table| con.schema_cache.add(table) }
+        open(filename, 'wb') { |f| f.write(Marshal.dump(con.schema_cache)) }
+      end
+
+      desc 'Clear a db/schema_cache.dump file.'
+      task :clear => [:environment, :load_config] do
+        filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.dump")
+        FileUtils.rm(filename) if File.exist?(filename)
+      end
+    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(" ")
+      filename = ENV['DB_STRUCTURE'] || 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::Base.connection.supports_migrations? &&
+          ActiveRecord::SchemaMigration.table_exists?
+        File.open(filename, "a") do |f|
+          f.puts ActiveRecord::Base.connection.dump_schema_information
+          f.print "\n"
         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']}'"
-      end
-
-      if ActiveRecord::Base.connection.supports_migrations?
-        File.open(filename, "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
       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
-      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
+    desc "Recreate the databases from the structure.sql file"
+    task :load => [:load_config] do
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:sql, ENV['DB_STRUCTURE'])
     end
 
     task :load_if_sql => ['db:create', :environment] do
@@ -487,8 +290,15 @@ db_namespace = namespace :db do
 
   namespace :test do
 
+    task :deprecated do
+      Rake.application.top_level_tasks.grep(/^db:test:/).each do |task|
+        $stderr.puts "WARNING: #{task} is deprecated. The Rails test helper now maintains " \
+                     "your test schema automatically, see the release notes for details."
+      end
+    end
+
     # 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
@@ -497,93 +307,61 @@ db_namespace = namespace :db do
       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_for ActiveRecord::Base.configurations['test'], :ruby, ENV['SCHEMA']
       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_for ActiveRecord::Base.configurations['test'], :sql, ENV['SCHEMA']
+    end
+
+    # desc "Recreate the test database from a fresh schema"
+    task :clone => %w(db:test:deprecated environment) do
+      case ActiveRecord::Base.schema_format
+        when :ruby
+          db_namespace["test:clone_schema"].invoke
+        when :sql
+          db_namespace["test:clone_structure"].invoke
+      end
     end
 
     # desc "Recreate the test database from a fresh schema.rb file"
-    task :clone => %w(db:schema:dump db:test:load_schema)
+    task :clone_schema => %w(db:test:deprecated 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" ]
+    task :clone_structure => %w(db:test:deprecated 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(environment load_config) 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
+    task :prepare => %w(environment 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"
+    # 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 {|n| n.strip }
-      railties = ActiveSupport::OrderedHash.new
-      Rails.application.railties.all do |railtie|
+      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)
@@ -595,7 +373,7 @@ 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
 
@@ -604,56 +382,3 @@ namespace :railties do
     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