Differenza tra rake db: migrate db: reset e db: schema: load

La differenza tra rake db:migrate ed rake db:resetè abbastanza chiara nella mia testa. La cosa che non capisco è quanto rake db:schema:loaddiversa dalle prime due.

Solo per essere sicuro di trovarmi sulla stessa pagina:

• rake db:migrate - Esegue le migrazioni che non sono ancora state eseguite.
• rake db:reset- Cancella il database (presumibilmente fa un rake db:drop+ rake db:create+ rake db:migrate) ed esegue la migrazione su un nuovo database.

Per favore aiutatemi a chiarire se la mia comprensione è andata storta.

• db: migrate esegue (singole) migrazioni che non sono ancora state eseguite.
• db: create crea il database
• db: drop elimina il database

• db: schema: load crea tabelle e colonne all'interno del database (esistente) dopo schema.rb

• db: setup fa db: create, db: schema: load, db: seed

• db: reset fa db: drop, db: setup
• db: migrate: reset fa db: drop, db: create, db: migrate

In genere, si utilizza db: migrate dopo aver apportato modifiche allo schema tramite nuovi file di migrazione (ciò ha senso solo se sono già presenti dati nel database). db: schema: load viene utilizzato quando si configura una nuova istanza dell'app.

Spero che aiuti.

AGGIORNAMENTO per binari 3.2.12:

Ho appena controllato la fonte e le dipendenze sono così:

• db: create crea il database per l'attuale env
• db: create: all crea i database per tutti gli envs
• db: drop elimina il database per l'ambiente corrente
• db: drop: tutto elimina i database per tutti gli envs
• db: migrate esegue le migrazioni per l'env corrente che non sono ancora state eseguite
• db: migrate: up esegue una migrazione specifica
• db: migrate: down esegue il rollback di una migrazione specifica
• db: migrate: status mostra lo stato corrente della migrazione
• db: rollback ripristina l'ultima migrazione
• db: forward avanza dalla versione dello schema corrente a quella successiva
• db: seed (solo) esegue il file db / seed.rb
• db: schema: load carica lo schema nel database env corrente

• db: schema: dump scarica lo schema dell'env corrente (e sembra creare anche il db)

• db: setup esegue db: schema: load, db: seed

• db: reset esegue db: drop db: setup
• db: migrate: redo esegue (db: migrate: down db: migrate: up) o (db: rollback db: migrate) a seconda della migrazione specificata
• db: migrate: reset esegue db: drop db: create db: migrate

Per ulteriori informazioni, consultare https://github.com/rails/rails/blob/v3.2.12/activerecord/lib/active_record/railties/d Database.rake (per Rails 3.2.x) e https: // github .com / rails / rails / blob / v4.0.5 / activerecord / lib / active_record / railties / d database.rake (per Rails 4.0.x)

TLDR

Uso

• rake db:migrate Se si desidera apportare modifiche allo schema
• rake db:resetSe si desidera eliminare il database, ricaricare lo schema schema.rbe ridimensionare il database
• rake db:schema:loadSe si desidera reimpostare il database sullo schema come indicato in schema.rb(Ciò eliminerà tutti i dati)

spiegazioni

rake db:schema:loadimposterà lo schema come indicato nel schema.rbfile. Questo è utile per una nuova installazione dell'app in quanto non richiede molto tempodb:migrate

Nota importante, db:schema:loadsarà cancellare i dati sul server.

rake db:migrateapporta modifiche allo schema esistente. È come creare versioni di schema. db:migratecercherà db/migrate/eventuali file ruby ​​ed eseguirà le migrazioni che non sono ancora in esecuzione a partire dal più vecchio. Rails sa quale file è il più vecchio guardando il timestamp all'inizio del nome del file di migrazione. db:migrateha il vantaggio che i dati possono anche essere inseriti nel database. Questa non è in realtà una buona pratica. È meglio usare rake db:seedper aggiungere dati.

rake db:migratefornisce attività su , giù , ecc. che abilita comandi simili rake db:rollbacke lo rende il comando più utile.

rake db:resetfa un db:drope db:setup
rilascia il database, lo crea di nuovo, carica lo schema e si inizializza con i dati seed

Parte pertinente dei comandi da d database.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

Per quanto ho capito, sta per eliminare il database e ricrearlo in base al db/schema.rbfile. Ecco perché è necessario assicurarsi che il schema.rbfile sia sempre aggiornato e sotto il controllo della versione.

Potresti semplicemente guardare nelle attività di Active Record Rake poiché è lì che credo che vivano come in questo file. https://github.com/rails/rails/blob/fe1f4b2ad56f010a4e9b93d547d63a15953d9dc2/activerecord/lib/active_record/tasks/database_tasks.rb

Quello che fanno è la tua domanda giusta?

Dipende da dove vengono e questo è solo ed esempio per mostrare che variano a seconda dell'attività. Qui abbiamo un file diverso pieno di attività.

https://github.com/rails/rails/blob/fe1f4b2ad56f010a4e9b93d547d63a15953d9dc2/activerecord/Rakefile

che ha questi compiti.

namespace :db do
  task create: ["db:mysql:build", "db:postgresql:build"]
  task drop: ["db:mysql:drop", "db:postgresql:drop"]
end

Questo potrebbe non rispondere alla tua domanda, ma potrebbe darti un'idea di come procedere e di esaminare l'origine, in particolare i file e le attività di rake. Dato che fanno un ottimo lavoro nell'aiutarti a usare le rotaie, non sempre documentano così bene il codice. Potremmo aiutare tutti lì se sappiamo cosa dovrebbe fare.

AGGIORNATO per Rails 5:

db:create- Crea il database per l' ambiente RAILS_ENV corrente . Se RAILS_ENV non viene specificato , per impostazione predefinita vengono impostati i database di sviluppo e test.

db:create:all - Crea il database per tutti gli ambienti.

db:drop- Elimina il database per l' ambiente RAILS_ENV corrente . Se non viene specificato RAILS_ENV , per impostazione predefinita vengono impostati i database di sviluppo e test.

db:drop:all - Elimina il database per tutti gli ambienti.

db:migrate- Esegue migrazioni per l'ambiente corrente che non sono ancora state eseguite. Per impostazione predefinita, eseguirà le migrazioni solo nell'ambiente di sviluppo.

db:migrate:redo- Esegue db: migrate: down e db: migrate: up o db: migrate: rollback e db: migrate: up a seconda della migrazione specificata.

db:migrate:up - Esegue il up per la VERSIONE di migrazione specificata.

db:migrate:down - Esegue il down per la VERSIONE di migrazione specificata.

db:migrate:status - Visualizza lo stato corrente della migrazione.

db:migrate:rollback - Esegue il rollback dell'ultima migrazione.

db:version - Stampa la versione corrente dello schema.

db:forward - Invia lo schema alla versione successiva.

db:seed- Esegue il file db / seeds.rb .

db:schema:loadRicrea il database dal file schema.rb .

db:schema:dumpScarica lo schema dell'ambiente corrente su db / schema.rb .

db:structure:load- Ricrea il database dal file structure.sql .

db:structure:dump- Scarica lo schema dell'ambiente corrente su db / structure.sql . (Puoi specificare un altro file con SCHEMA=db/my_structure.sql)

db:setupEsegue db: create , db: schema: load e db: seed .

db:resetEsegue db: drop e db: setup . db:migrate:reset- Esegue db: drop , db: create e db: migrate .

db:test:prepare- Controlla le migrazioni in sospeso e carica lo schema di prova. (Se esegui rake senza argomenti, lo farà per impostazione predefinita.)

db:test:clone - Ricrea il database di test dallo schema del database dell'ambiente corrente.

db:test:clone_structure- Simile a db: test: clone , ma assicurerà che il database di test abbia la stessa struttura, inclusi set di caratteri e regole di confronto, del database del tuo ambiente attuale.

db:environment:set- Imposta l' ambiente RAILS_ENV corrente nella tabella ar_internal_metadata . (Utilizzato come parte del controllo dell'ambiente protetto.)

db:check_protected_environments- Verifica se è possibile eseguire un'azione distruttiva nell'attuale ambiente RAILS_ENV . Utilizzato internamente quando si esegue un'azione distruttiva come db: drop o db: schema: load .