The difference between
rake db:migrate and
rake db:reset is pretty clear in my head. The thing which I don’t understand is how
rake db:schema:load different from the former two.
Just to be sure that I am on the same page:
rake db:migrate– Runs the migrations which haven’t been run yet.
rake db:reset– Clears the database (presumably does a
rake db:migrate) and runs migration on a fresh database.
Please help to clarify, if my understanding has gone wrong.
db:migrate runs (single) migrations that have not run yet.
db:create creates the database
db:drop deletes the database
db:schema:load creates tables and columns within the existing database following schema.rb. This will delete existing data.
db:setup does db:create, db:schema:load, db:seed
db:reset does db:drop, db:setup
db:migrate:reset does db:drop, db:create, db:migrate
Typically, you would use db:migrate after having made changes to the schema via new migration files (this makes sense only if there is already data in the database). db:schema:load is used when you setup a new instance of your app.
I hope that helps.
UPDATE for rails 3.2.12:
I just checked the source and the dependencies are like this now:
db:create creates the database for the current env
db:create:all creates the databases for all envs
db:drop drops the database for the current env
db:drop:all drops the databases for all envs
db:migrate runs migrations for the current env that have not run yet
db:migrate:up runs one specific migration
db:migrate:down rolls back one specific migration
db:migrate:status shows current migration status
db:rollback rolls back the last migration
db:forward advances the current schema version to the next one
db:seed (only) runs the db/seed.rb file
db:schema:load loads the schema into the current env’s database
db:schema:dump dumps the current env’s schema (and seems to create the db as well)
db:setup runs db:schema:load, db:seed
db:reset runs db:drop db:setup
db:migrate:redo runs (db:migrate:down db:migrate:up) or (db:rollback db:migrate) depending on the specified migration
db:migrate:reset runs db:drop db:create db:migrate
For further information please have a look at https://github.com/rails/rails/blob/v3.2.12/activerecord/lib/active_record/railties/databases.rake (for Rails 3.2.x) and https://github.com/rails/rails/blob/v4.0.5/activerecord/lib/active_record/railties/databases.rake (for Rails 4.0.x)
rake db:migrateIf you wanna make changes to the schema
rake db:resetIf you wanna drop the database, reload the schema from
schema.rb, and reseed the database
rake db:schema:loadIf you wanna reset database to schema as provided in
schema.rb(This will delete all data)
rake db:schema:load will set up the schema as provided in
schema.rb file. This is useful for a fresh install of app as it doesn’t take as much time as
db:schema:loadwill delete data on server.
rake db:migrate makes changes to the existing schema. Its like creating versions of schema.
db:migrate will look in
db/migrate/ for any ruby files and execute the migrations that aren’t run yet starting with the oldest. Rails knows which file is the oldest by looking at the timestamp at the beginning of the migration filename.
db:migrate comes with a benefit that data can also be put in the database. This is actually not a good practice. Its better to use
rake db:seed to add data.
rake db:reset does a
It drops the database, create it again, loads the schema, and initializes with the seed data
Relevant part of the commands from databases.rake
namespace :schema do desc 'Creates a db/schema.rb file that is portable against any DB supported by Active Record' task :dump => [:environment, :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 end desc 'Loads a schema.rb file into the database' task :load => [:environment, :load_config, :check_protected_environments] do ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:ruby, ENV['SCHEMA']) end
# desc 'Drops and recreates the database from db/schema.rb for the current environment and loads the seeds.' task :reset => [ 'db:drop', 'db:setup' ]
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 else db_namespace['rollback'].invoke db_namespace['migrate'].invoke end end
db:create – Creates the database for the current RAILS_ENV environment. If RAILS_ENV is not specified it defaults to the development and test databases.
db:create:all – Creates the database for all environments.
db:drop – Drops the database for the current RAILS_ENV environment. If RAILS_ENV is not specified it defaults to the development and test databases.
db:drop:all – Drops the database for all environments.
db:migrate – Runs migrations for the current environment that have not run yet. By default it will run migrations only in the development environment.
db:migrate:redo – Runs db:migrate:down and db:migrate:up or db:migrate:rollback and db:migrate:up depending on the specified migration.
db:migrate:up – Runs the up for the given migration VERSION.
db:migrate:down – Runs the down for the given migration VERSION.
db:migrate:status – Displays the current migration status.
db:migrate:rollback – Rolls back the last migration.
db:version – Prints the current schema version.
db:forward – Pushes the schema to the next version.
db:seed – Runs the db/seeds.rb file.
db:schema:load Recreates the database from the schema.rb file. Deletes existing data.
db:schema:dump Dumps the current environment’s schema to db/schema.rb.
db:structure:load – Recreates the database from the structure.sql file.
db:structure:dump – Dumps the current environment’s schema to db/structure.sql.
(You can specify another file with
db:setup Runs db:create, db:schema:load and db:seed.
db:reset Runs db:drop and db:setup.
db:migrate:reset – Runs db:drop, db:create and db:migrate.
db:test:prepare – Check for pending migrations and load the test schema. (If you run rake without any arguments it will do this by default.)
db:test:clone – Recreate the test database from the current environment’s database schema.
db:test:clone_structure – Similar to db:test:clone, but it will ensure that your test database has the same structure, including charsets and collations, as your current environment’s database.
db:environment:set – Set the current RAILS_ENV environment in the ar_internal_metadata table. (Used as part of the protected environment check.)
db:check_protected_environments – Checks if a destructive action can be performed in the current RAILS_ENV environment. Used internally when running a destructive action such as db:drop or db:schema:load.
As far as I understand, it is going to drop your database and re-create it based on your
db/schema.rb file. That is why you need to make sure that your
schema.rb file is always up to date and under version control.
You could simply look in the Active Record Rake tasks as that is where I believe they live as in this file.
What they do is your question right?
That depends on where they come from and this is just and example to show that they vary depending upon the task. Here we have a different file full of tasks.
which has these tasks.
namespace :db do task create: ["db:mysql:build", "db:postgresql:build"] task drop: ["db:mysql:drop", "db:postgresql:drop"] end
This may not answer your question but could give you some insight into go ahead and look the source over especially the rake files and tasks. As they do a pretty good job of helping you use rails they don’t always document the code that well. We could all help there if we know what it is supposed to do.
List all tasks
You can find all the database tasks Rails provides by running the following command from a Rails application directory.
➜ blog (main) ✗ bin/rails help | grep db: db:create db:drop ...
db:create: Creates the database unless it already exists.
db:drop: Drops the database if it exists.
db:environment:set: Fixes the
NoEnvironmentInSchemaError, raised if the environment data is not found in the schema, by setting the current environment in the internal table.
db:fixtures:load: It loads the fixtures, i.e., the sample data that you want to test against. They are stored in the YAML file under the
db:migrate: Runs all the migrations that have not run yet, for the current environment.
db:migrate:down: Reverts the transformations performed by the last migration’s
up method by running the
db:migrate:redo: Rolls back the database one migration and re-migrates up.
db:migrate:status: Displays the status of migrations.
db:migrate:up: Runs the
up method for a given migration.
setup if the database does not exist. Otherwise, it runs the migrations.
db:reset: Resets your database using your migrations for the current environment. It does this by running the
db:rollback: Rolls the schema back to the previous version, undoing the migration that you just ran. If you want to undo previous
n migrations, pass
STEP=n to this task.
db:schema:cache:clear: Clears the db/schema_cache.yml file generated by the
db:schema:cache:dump: Creates a db/schema_cache.yml file.
db:schema:dump: Creates a database schema file (either
db/structure.sql, depending on
db:schema:load: Loads a database schema file (either
db/structure.sql, depending on
config.active_record.schema_format) into the database.
db:seed: Loads the seed data from
db:seed:replant: Truncates tables of each database for the current environment and loads the seeds
db:setup: Creates all databases
db:create, loads all schemas
db:schema:load, and initializes with the seed data
db:seed. However, it won’t drop the database first if it exists. Use
db:reset to also drop all databases first.
db:structure:dump: Deprecated. It was used to dump the
db:structure:load: Deprecated. It was used to load the
rails new generator without specifying a database sets your app with
sqlite. It’s a hassle to change the database later. This task helps you easily change the database by delegating to the
rails db:change SYSTEM=postgresql|mysql|whatever generator.
db:version: Prints the current schema version number.
Source: All the Database Tasks in Rails