Overzicht artikelen:

Ruby on Rails Migrations

10 april 2006, 14:13

Het ontwikkelen van een Ruby on Rails project begint bij het aanmaken van een rails applicatie ( rails NaamVanDeApplicatie ), het aanmaken van een database, en het instellen van de verbinding met deze database (in het config/database.yml bestand).
Vervolgens is het de bedoeling om een databaseschema aan te maken (= de database van een aantal tabellen, kolommen,… voorzien). Migrations zijn hier uitermate geschikt voor. Ze bieden talloze voordelen ten opzichte van het gebruik van SQL code of van een SQL administratie tool.

Wat zijn migrations?

Een migration is een beschrijving van een databaseschema (of de veranderingen eraan) in Ruby code. Hierdoor is het schema databaseonafhankelijk. Je kan het Ruby schema automatisch laten vertalen naar eender welke ondersteunde SQL variant: MySQL, PostgreSQL,…
Migrations zijn ontworpen om een database schema te laten evolueren terwijl je een applicatie bouwt (tabellen aanmaken wanneer je ze nodig hebt, kolommen toevoegen of verwijderen, data invoeren,…). Kortom, migrations maken database upgrades en veranderingen eenvoudig.
Veranderingen worden bijgehouden door middel van versies. Je kan dus steeds naar gelijk welke versie “migrate-en”.
Bestaande data gaat niet verloren bij veranderingen aan de database. Migrations zijn met andere woorden “data-safe”.

Hoe migrations gebruiken?

Stel dat je een blog wil ontwikkelen. Om de database van een “post” tabel te voorzien volg je deze werkwijze:

Maak een migration aan:
```
script/generate migration posts
```
Dit commando maakt een migrate map aan binnen de db map.
In deze migrate map wordt de migration 001_posts.rb aangemaakt.
De naam van deze migration is samengesteld uit een automatisch toegekend versienummer en de naam die je opgaf.
Let er wel op dat deze naam steeds beschrijft wat de migration doet; gebruik geen standaard naam als migration (dit zou leiden tot 001_migration, 002_migration,…).
Dit is niet enkel logisch, maar voorkomt ook foutmeldingen.
Je beschikt nu over een lege migration:
```
class Posts < ActiveRecord::Migration
  def self.up
  end

  def self.down
  end
end
```
Deze migration bestaat uit een klasse (met dezelfde naam als de migration: Posts) die twee methodes (up & down) bevat.
In de up methode beschrijf je wat er moet gebeuren als de database geüpgrade wordt naar een nieuwe versie. In ons geval willen we een Posts tabel met twee kolommen (title en body) aanmaken:
```
create_table :posts do |table|
        table.column :title, :string
        table.column :body,  :string
end
```
Een ID kolom hoef je nooit aan te maken. Dit gebeurt automatisch.
Een overzicht van alle mogelijke manipulaties vind je in de API.

In de down methode beschrijf je wat er moet gebeuren als de aangebrachte veranderingen ongedaan gemaakt moeten worden (als de database gedowngrade wordt naar een vorige versie). In ons geval betekent dit dat de Posts tabel verwijderd moet worden:
```
drop_table :posts
```
Tenslotte voer je de migration uit:
```
Rake migrate
```
Dit commando werkt je database bij tot de meest recente versie (dit is meteen ook een manier om je database verbinding te testen… indien de migration faalt heeft dit waarschijnlijk met een slecht geconfigureerde database verbinding te maken).
```
Rake migrate VERSION=x
```
Brengt je database terug naar een gekozen versie.
Wie dit alles aan het werk wil zien kan de migrations screencast op rubyonrails.org bekijken.

Reageer

Recent