Limpe ou recrie um banco de dados Ruby on Rails

582

Eu tenho um banco de dados de desenvolvimento Ruby on Rails cheio de dados. Quero excluir tudo e reconstruir o banco de dados. Estou pensando em usar algo como:

rake db:recreate

Isso é possível?

Um aprendiz
fonte
Eu sugiro olhar além da resposta mais votada. Na minha opinião, rake db:drop db:create db:schema:loadpode ser mais apropriado do que rake db:drop db:create db:migrate(embora eu esteja pronto para estar errado sobre isso).
21715 Jason Swett
2
rake db:drop db:create db:migrate
William Hampshire
db:drop + db:create + db:migrate == db:migrate:reset. Eu costumo recorrer db:schema:load, quando as migrações são interrompidas. Raramente preciso recriar o banco de dados, portanto a velocidade não importa muito. Além disso, se você tiver migrações não aplicadas db:schema:loade db:resetnão as aplicará. Não tenho certeza se isso é um grande argumento.
X-yuri

Respostas:

1074

Conheço duas maneiras de fazer isso:

Isso redefinirá seu banco de dados e recarregará seu esquema atual com todos:

rake db:reset db:migrate

Isso destruirá seu banco de dados e, em seguida, criará e migrará seu esquema atual:

rake db:drop db:create db:migrate

Todos os dados serão perdidos nos dois cenários.

thenengah
fonte
36
Parece que rake db:resettambém executa todas as migrações (pelo menos no Rails 3), então isso deve ser tudo o que é necessário, certo?
Plindberg
1
Ou melhor, deixa o esquema idêntico ao que todas as migrações em execução teriam. Mas as migrações não são executadas por si só (por isso, se você tiver migrações que inserem dados, isso não acontecerá; para isso, você realmente deve usar um arquivo db / seeds.rb).
PLindberg
1
Eu sei que para o aplicativo Tracks GTD db: migrate não funcionou. Eu tive que fazer db: reset ao passar do Sqlite3 para o Postgres.
labyrinth
11
Você também precisará executar os rake db:test:preparetestes ou obterá um erro como:Could not find table 'things' (ActiveRecord::StatementInvalid)
s2t2
31
Alguém deve deixar claro isso rake db:resete rake db:drop db:create db:migrate fazer duas coisas totalmente diferentes . O último apaga todo o banco de dados do aplicativo, o recria e depois passa por todas as migrações para atualizar o esquema ( db/schema.rbou db/structure.sql), mas não o preenche com dados iniciais. O primeiro é um alias para rake db:drop db:schema:load db:seed, portanto, elimina todo o banco de dados do aplicativo, mas não atualiza o esquema e, em seguida, preenche com dados iniciais. Portanto, se você não alterou nada em suas migrações, a primeira é mais rápida e a segunda é mais segura.
Claudio Floreani 08/07/2015
157

No Rails 4, tudo o que é necessário

$ rake db:schema:load

Isso excluiria todo o conteúdo do seu banco de dados e recriaria o esquema do arquivo schema.rb, sem a necessidade de aplicar todas as migrações uma a uma.

Eneko Alonso
fonte
6
funciona para os trilhos 3 também. útil para quando você apenas desarrumada seu banco de dados de teste e quiser redefini-lo para uma versão de trabalho que corresponde ao seu db dev
bigpotato
Obrigado por isso. Não percebi isso db:drope fui db:createredundante.
Grant Birchmeier 07/07
3
Isso não atualiza o esquema, não é uma maneira segura se você refatorar suas migrações.
Claudio Floreani 08/07/2015
esta é a melhor resposta para mim.
Roxdurazo 30/04
2
A migração de refatoração da @ClaudioFloreani está pedindo problemas. Uma vez executados, eles devem ser deixados sozinhos, permanentemente.
N
45

Eu uso o seguinte liner no Terminal.

$ rake db:drop && rake db:create && rake db:migrate && rake db:schema:dump && rake db:test:prepare

Coloquei isso como um apelido de shell e o nomeei remigrate

Até agora, você pode facilmente "encadear" tarefas do Rails:

$ rake db:drop db:create db:migrate db:schema:dump db:test:prepare # db:test:prepare no longer available since Rails 4.1.0.rc1+
TK.
fonte
12
Isso executará todas as suas migrações uma após a outra, o que não é escalável e propenso a erros. Além disso, tenho certeza de que o db: migrate atualiza o schema.rb, portanto, o schema: dump não está fazendo nada útil.
Coreyward #
Então, como alguém esvazia o banco de dados? em desenvolvimento ... esclarecer tudo.
AnApprentice
3
@AnApprentice Você pode executar db:reset, que fica a apenas um Google (ou consulte os Guias ). Meu comentário não foi contra isso, mas para evitar db:migratequando o que você realmente quer é db:schema:load.
coreyward
7
A propósito, @TK, você realmente não precisa executar tudo isso como processos separados, dependendo do status de saída do último. Em vez disso, basta passar todas as tarefas desejadas para rake, assim: rake db:drop db:create db:schema:load.
coreyward
1
É anedótico, mas nunca tive um problema em execução db:migrate... enquanto db:schema:loadé sensível a alguém que esquece de verificar o schema.rb no controle de versão ao lado de uma nova migração.
johncip
37

Atualização: No Rails 5, este comando estará acessível através deste comando:

rails db:purge db:create db:migrate RAILS_ENV=test


A partir da versão mais recente do rails 4.2, agora você pode executar:

rake db:purge 

Fonte: commit

# 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

Pode ser usado em conjunto, como mencionado acima:

rake db:purge db:create db:migrate RAILS_ENV=test
Robbie Guilfoyle
fonte
Como @bekicot diz em inglês mais claro db:purge"remova todos os dados, mas preserve todas as tabelas e colunas"
MCB 15/15
@ MCB Eu estava errado, sory sobre isso, db:purge não está preservando as tabelas.
Yana Agun Siswanto 06/04
29

Dependendo do que você está querendo, você pode usar…

rake db:create

… Para construir o banco de dados a partir do zero config/database.ymlou…

rake db:schema:load

… Para construir o banco de dados do zero a partir do seu schema.rbarquivo.

coreyward
fonte
1
Você precisa eliminar o banco de dados primeiro ... ou pode simplesmente excluir as tabelas, se preferir.
Coreyward #
5
+1 para carregamento do esquema. às vezes, as migrações ficam confusas, mas o esquema deve ser o que é mantido intacto.
Danny
Eu li no The Rails 3 Way que carregar o esquema é o caminho a percorrer, em vez de executar todas as migrações. Não me lembro exatamente qual era o raciocínio deles, mas parece fazer sentido. Se o resultado final for o mesmo de qualquer maneira, parece mais simples e menos propenso a erros apenas carregar o banco de dados do esquema do que executar várias migrações.
Jason Swett
3
O raciocínio é que as migrações são destinadas a migrar dados e se tornam cada vez mais frágeis com o tempo, à medida que seus modelos mudam. Você pode (e deve) incorporar modelos com escopo mínimo e mínimo às suas migrações sempre que possível, para garantir que elas sejam executadas, mas isso não é escalável e é muito menos eficiente do que apenas construir o banco de dados a partir do que o aplicativo sabe que é o ponto final . Por que confiar nas migrações para criar um banco de dados parecido com o seu esquema quando você pode apenas construir a partir do próprio blueprint?
coreyward
13

Na linha de comando, execute

rake db:migrate:reset
user2747051
fonte
essa é a única maneira de fazer com que o aplicativo execute todas as migrações novamente. Porque cada migração faz alterações schema.rbe, se você apenas drope create, migratenão fará nada (testado nos trilhos 6)
shampoo
12

Use como

rake db:drop db:create db:migrate db:seed

Tudo em uma linha. Isso é mais rápido, pois o ambiente não é recarregado novamente.

db: drop - descartará o banco de dados.

db: create - criará o banco de dados (host / db / password será obtido em config / database.yml)

db: migrate - executará migrações existentes do diretório (db / migration / .rb) *.

db: seed - executará os dados da semente possíveis no diretório (db / migration / seed.rb) .

Eu geralmente prefiro:

rake db:reset

fazer tudo de uma vez.

Felicidades!

Manish Shrivastava
fonte
1
Eu gosto de adicionar db: test: prepare-se para isso, por uma boa medida. Isso depende, é claro, se você está testando ou não.
ctc
db:reset == db:drop + db:schema:load + db:seed,db:migrate:reset == db:drop + db:create + db:migrate
x-yuri
11

Emita apenas a sequência das etapas: descarte o banco de dados, recrie-o novamente, migre dados e, se houver sementes, semeie o banco de dados:

rake db:drop db:create db:migrate db:seed

Como o ambiente padrão para o desenvolvimentorake é , se você vir a exceção nos testes de especificação, recrie o db para o ambiente de teste da seguinte maneira:

RAILS_ENV=test rake db:drop db:create db:migrate

Na maioria dos casos, o banco de dados de teste está sendo semeado durante os procedimentos de teste, portanto, db:seednão é necessário que a ação da tarefa seja aprovada. Caso contrário, você deve preparar o banco de dados:

rake db:test:prepare

ou

RAILS_ENV=test rake db:seed

Além disso, para usar a tarefa de recriação , você pode adicionar ao Rakefile o seguinte código:

namespace :db do
   task :recreate => [ :drop, :create, :migrate ] do
      if ENV[ 'RAILS_ENV' ] !~ /test|cucumber/
         Rake::Task[ 'db:seed' ].invoke
      end
   end
end

Emita então:

rake db:recreate
Малъ Скрылевъ
fonte
8

Você pode fazer manualmente:

rake db:drop
rake db:create
rake db:migrate

Ou apenas rake db:reset, que executará as etapas acima, mas também executará seu db/seeds.rbarquivo.

Uma nuance adicional é que é rake db:resetcarregado diretamente do seu schema.rbarquivo, em vez de executar todos os arquivos de migração novamente.

Seus dados são surpreendidos em todos os casos.

Erik Trautman
fonte
6

Você pode usar esta seguinte linha de comando:

rake db:drop db:create db:migrate db:seed db:test:clone
user1358180
fonte
4

Para eliminar um banco de dados específico, você pode fazer isso no console do Rails:

$rails console
Loading development environment
1.9.3 > ActiveRecord::Migration.drop_table(:<table_name>)
1.9.3 > exit

E depois migre o DB novamente

$bundle exec rake db:migrate 
Kush
fonte
4

No trilhos 4.2, para remover todos os dados, mas preservar o banco de dados

$ bin/rake db:purge && bin/rake db:schema:load

https://github.com/rails/rails/blob/4-2-stable/activerecord/CHANGELOG.md

Yana Agun Siswanto
fonte
Bem ... Apenas tentei, mas não preserva tabelas e colunas. Você precisa executar um db: migrate após executar o db: purge. Portanto, isso não preserva tabelas e colunas. Isto, contudo, preservar o próprio banco de dados para que você não tem que db: criar
Freddo
1
@ Cedric Você está certo, db: purgar não é preservar a tabela. Eu atualizei o código.
Yana Agun Siswanto 06/04
3

Você pode usar db:reset- para executar db: drop e db: setup ou db:migrate:reset- que executa db: drop, db: create e db: migrate.

depende em que você deseja usar o exist schema.rb

Aleksandr Babak
fonte
2

De acordo com o guia do Rails , esse liner deve ser usado porque seria carregado a partir do em schema.rbvez de recarregar os arquivos de migração, um por um:

rake db:reset
Vencedor
fonte
1

Como no desenvolvimento, você sempre desejará recriar o banco de dados, pode definir uma tarefa rake na sua pasta lib / tasks assim.

  namespace :db do
      task :all => [:environment, :drop, :create, :migrate] do
   end 
end

e no terminal você vai correr

rake db:all

ele irá reconstruir seu banco de dados

Obed Lorisson
fonte
1

Eu acho que a melhor maneira de executar este comando:

**rake db:reset** it does db:drop, db:setup
 rake db:setup does db:create, db:schema:load, db:seed
Thorin
fonte
1

Simplesmente você pode executar

rake db:setup

Ele eliminará o banco de dados, criará um novo banco de dados e preencherá o banco de dados a partir da semente se você criou o arquivo de semente com alguns dados.

Touseef Murtaza
fonte
1

3 opções, mesmo resultado:

1. Todas as etapas:

  $ rake db:drop           # deletes the database for the current env
  $ rake db:create         # creates the database for the current env
  $ rake db:schema:load    # loads the schema already generated from schema.rb / erases data
  $ rake db:seed           # seed with initial data

2. Redefinir:

  $ rake db:reset          # drop / schema:load / seed

3. Migrar: redefinir:

  $ rake db:migrate:reset  # drop / create / migrate
  $ rake db:seed

Notas:

  • Se schema: load for usado for mais rápido do que todas as migrações, mas o mesmo resultado.
  • Todos os dados serão perdidos.
  • Você pode executar vários ancinhos em uma linha.
  • Funciona com trilhos 3.
urko
fonte
0

Hoje fiz algumas mudanças no meu esquema de trilhos. Percebi que precisava de mais dois modelos em uma hierarquia e alguns outros a serem excluídos. Foram necessárias muitas pequenas alterações nos modelos e controladores.

Eu adicionei os dois novos modelos e os criei, usando:

rake db:migrate

Depois editei o arquivo schema.rb. Eu removi manualmente os modelos antigos que não eram mais necessários, alterei o campo de chave estrangeira conforme necessário e apenas o reordenei um pouco para torná-lo mais claro. I eliminado todas as migrações, em seguida, re-correu a compilação via:

rake db:reset

Funcionou perfeitamente. Todos os dados precisam ser recarregados, é claro. Os Rails perceberam que as migrações haviam sido excluídas e redefiniram a marca d'água máxima:

-- assume_migrated_upto_version(20121026094813, ["/Users/sean/rails/f4/db/migrate"])
ardochhigh
fonte