Pregunta Diferencia entre rake db: migrate db: reset y db: schema: load


La diferencia entre rake db:migrate y rake db:reset es bastante claro en mi cabeza. Lo que no entiendo es cómo rake db:schema:load diferente de los dos anteriores.

Solo para estar seguro de que estoy en la misma página:

  • rake db:migrate - Ejecuta las migraciones que aún no se han ejecutado.
  • rake db:reset - Borra la base de datos (presumiblemente hace una rake db:drop + rake db:create + rake db:migrate) y ejecuta la migración en una nueva base de datos.

Por favor, ayúdenme a aclarar, si mi entendimiento ha ido mal.


530
2018-04-24 16:11


origen


Respuestas:


  • db: migrar ejecuta migraciones (únicas) que aún no se han ejecutado.
  • db: crear crea la base de datos
  • db: gota borra la base de datos
  • db: schema: carga crea tablas y columnas dentro de la base de datos (existente) siguiendo a schema.rb

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

  • db: restablecer hace db: drop, db: setup

Normalmente, utilizará db: migrate después de haber realizado cambios en el esquema a través de nuevos archivos de migración (esto tiene sentido solo si ya hay datos en la base de datos). db: schema: load se usa cuando configura una nueva instancia de su aplicación.

Espero que eso ayude.


ACTUALIZACIÓN para los carriles 3.2.12:

Acabo de verificar la fuente y las dependencias son así ahora:

  • db: crear crea la base de datos para el env actual
  • db: crear: todos crea las bases de datos para todos los envs
  • db: gota descarta la base de datos para el env actual
  • db: gota: todo deja caer las bases de datos para todos los envs
  • db: migrar ejecuta migraciones para el env actual que aún no se ha ejecutado
  • db: migrar: hasta ejecuta una migración específica
  • db: migrar: abajo revierte una migración específica
  • db: migrar: estado muestra el estado actual de la migración
  • db: retroceso revierte la última migración
  • db: adelante avanza la versión de esquema actual a la siguiente
  • db: semilla (solo) ejecuta el archivo db / seed.rb
  • db: schema: carga carga el esquema en la base de datos de env actual
  • db: schema: dump vuelca el esquema de env actual (y parece crear el db también)

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

  • db: restablecer ejecuta db: drop db: setup
  • db: migrar: rehacer runs (db: migrate: down db: migrate: up) o (db: rollback db: migrate) dependiendo de la migración especificada
  • db: migrar: restablecer ejecuta db: drop db: create db: migrate

Para más información, por favor eche un vistazo a https://github.com/rails/rails/blob/v3.2.12/activerecord/lib/active_record/railties/databases.rake (para Rails 3.2.x) y https://github.com/rails/rails/blob/v4.0.5/activerecord/lib/active_record/railties/databases.rake (para Rails 4.0.x)


1124
2018-04-24 16:48



TLDR

Utilizar

  • rake db:migrate Si quieres hacer cambios en el esquema
  • rake db:reset Si quiere eliminar la base de datos, vuelva a cargar el esquema schema.rby resembrar la base de datos
  • rake db:schema:load Si quiere restablecer la base de datos a un esquema como está provisto en schema.rb (Esto eliminará todos los datos)

Explicaciones

rake db:schema:load configurará el esquema como se proporciona en schema.rb archivo. Esto es útil para una nueva instalación de la aplicación ya que no toma tanto tiempo como db:migrate

Nota IMPORTANTE, db:schema:load será borrar datos en el servidor.

rake db:migrate realiza cambios en el esquema existente. Es como crear versiones de esquema. db:migrate mirará en db/migrate/ para cualquier archivo de ruby ​​y ejecutar las migraciones que aún no se ejecutan comenzando con el más antiguo. Rails sabe qué archivo es el más antiguo al mirar la marca de tiempo al comienzo del nombre de archivo de la migración. db:migrate viene con un beneficio de que los datos también se pueden poner en la base de datos. Esta no es una buena práctica. Es mejor usar rake db:seed para agregar datos

rake db:migrate proporciona tareas arriba, abajo etc. que permite comandos como rake db:rollback y lo convierte en el comando más útil.

rake db:reset hace un db:drop y db:setup
Cae la base de datos, la crea de nuevo, carga el esquema y se inicializa con los datos de inicialización

Parte relevante de los comandos de 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

16
2018-04-07 07:12



Por lo que yo entiendo, va a soltar su base de datos y volver a crearla en función de su db/schema.rb archivo. Es por eso que necesita asegurarse de que su schema.rb el archivo está siempre actualizado y bajo control de versión.


2
2018-04-24 16:25



Simplemente podría mirar en las tareas de Active Record Rake ya que es donde creo que viven como en este archivo. https://github.com/rails/rails/blob/fe1f4b2ad56f010a4e9b93d547d63a15953d9dc2/activerecord/lib/active_record/tasks/database_tasks.rb

Lo que hacen es tu pregunta, ¿verdad?

Eso depende de dónde vienen y esto es justo y ejemplo para mostrar que varían dependiendo de la tarea. Aquí tenemos un archivo diferente lleno de tareas.

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

que tiene estas tareas.

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

Es posible que esto no responda a su pregunta, pero podría darle una idea de cómo continuar y buscar la fuente, especialmente los archivos y las tareas de rake. Como hacen un buen trabajo al ayudarlo a usar los rieles, no siempre documentan bien el código. Todos podemos ayudar allí si sabemos lo que se supone que debe hacer.


0
2018-02-07 18:20