On va utiliser la lib ActiveRecord pour créer une table dans MySQL et y ajouter des entrées. Au préalable, il faut que vous ayez installé MySQL et ActiveRecord, comme je l’ai expliqué hier et avant-hier.

Se connecter à la base de données

Il faut au préalable créer une base de données dans MySQL. Utilisez phpmyadmin ou la console/terminal. C’est pas vraiment compliqué mais je n’en parlerai pas ici. Si vraiment vous n’y arrivez pas, demandez-moi.

On va utiliser le module ActiveRecord pour se connecter, en utilisant la méthode .establish_connection.

require 'rubygems'
require 'activerecord'
 
ActiveRecord::Base.establish_connection(
:adapter => "mysql",
:host => "localhost",
:database => "discography",
:username => "root",
:password => ""
)

J’avais donc créé au préalable la base “discography”.

Création de la table

Alors ici je vais créer une table où je vais stocker des albums. Il y aura 4 informations :

  • le nom de l’artiste
  • le nom de l’album
  • l’année de sortie
  • la note

On utilise encore le module ActiveRecord avec la classe Schema.

ActiveRecord::Schema.define do
	create_table :albums do |table|
		table.column :artist, :string
		table.column :title, :string
		table.column :year, :integer
		table.column :rating, :integer 
	end
end

La classe Schema a plusieurs méthodes du type create_table qui permettent de générer des requêtes SQL sans qu’on le voit. C’est la magie de l’ORM.
Avec ce code Ruby on a donc créé une table avec 4 colonnes. Attention : n’éxécutez pas ce code Ruby deux fois sinon vous allez essayer de créer deux fois la même table. :-)

C’est pour ça que j’ai mis ce code dans un fichier Ruby à part.

Ajouter des entrées

On a notre table, maintenant il faut la remplir.

class Album < ActiveRecord::Base
end
 
Album.create(:artist => 'Radiohead', :title => 'Amnesiac', :year => 2003, :rating => 4)
Album.create(:artist => 'Arcade Fire', :title => 'Funeral', :year => 2004, :rating => 4)
Album.create(:artist => 'Animal Collective', :title => 'Strawberry Jam', :year => 2007, :rating => 4)
Album.create(:artist => 'Beatles', :title => 'Sgt. Pepper\'s Lonely Hearts Club Band', :year => 1967, :rating => 4)
Album.create(:artist => 'Radiohead', :title => 'Ok Computer', :year => 1997, :rating => 4)

On crée d’abord la class Album qui hérite de la classe ActiveRecord::Base. Vous allez me dire “mais elle a pas de méthode ta classe!”. En fait, le simple fait de créer la classe permet d’utilise les méthodes héritées, comme .create que l’on va utiliser par la suite. On aura alors pleins de méthodes pour générer des requêtes SQL, pour ajouter, mettre à jour, supprimer… des entrées. Super pratique!

Importance du nom de la classe

Il est important de bien nommer la classe Album. Rappelez-vous : on a créé une table “albums” (en minuscule et au pluriel). Il faut alors que l’on crée la classe “Album” (avec la majuscule et au singulier). Le simple fait d’avoir bien nommé ces deux éléments fait en sorte que les deux sont liés! Si on veut une table “collections”, on créera la classe “Collection”. C’est une convention de la lib ActiveRecord. C’est très simple, il faut juste bien y penser.

Ajout des entrées

Pour ajouter des entrées, il faut appeler la méthode .create suivi d’une sorte de tableau associatif où, pour chaque donnée, on ajoute l’info correspondante. Il faut faire attention au type de la variable. En créant la table, j’ai défini les deux premières données comme étant des String, et les deux dernières comme étant des nombres.

En exécutant ce code, vous verrez votre base MySQL mise à jour. J’utilise phpmyadmin pour bien vérifier que c’est fait correctement. :-)

Améliorer l’ajout des entrées

En regardant le code ci-dessus, on remarque que j’écris très souvent la même chose. J’écris à chaque ligne “Album.create” puis “:artist”, “:title” etc. C’est très redondant. J’ai essayé de simplifier ça en créant des boucles.

a = ['Bat For Lashes', 'Fur And Gold', 2007, 3]
b = ['Jamie T', 'Panic Prevention', 2007, 3]
c = ['Klaxons', 'Myths Of The Near Future', 2007, 4]
d = ['Massive Attack', 'Blue Lines', 1991, 3]
e = ['Scott Walker', 'Scott 4', 2007, 3]
f = ['Sufjan Stevens', 'Come On Feel The Illinoise', '2005', 3]
g = ['XTC', 'Drums And Wires', 1979, 3]
all = [a,b,c,d,e,f,g]
 
all.each do |t|
	if t.size == 4
		if (t[0].class == String) and (t[1].class == String) and (t[2].class == Fixnum) and (t[3].class == Fixnum)
			Album.create(:artist => t[0], :title => t[1], :year => t[2], :rating => t[3])
		end
	end
end

Ici, j’ai mis chaque nouvelle entrée dans un simple tableau. Je crée d’abord tous mes tableaux un à un. Puis je crée le tableau “all” qui est un tableau de tableau.
Puis vient la boucle du tableau “all”. Pour chaque tableau, j’effectue une autre boucle où je vérifier deux choses : la taille du tableau (4 entrées) et le type d’objet de chaque entrée du tableau.
Si tout est ok, je lance le script pour rajouter les infos dans ma base.

C’est peut-être pas la manière la plus optimale encore pour faire ça encore, mais j’ai déjà gagné pas mal de temps en évitant les répétitions. Et puis je vérifie les données avant de les rentrer. D’ailleurs, si un tableau n’est pas correct, il est tout simplement oublié. J’aurais pu mettre une alerte pour savoir quel tableau n’est pas correct et pourquoi. Mais bon, c’est déjà pas mal pour l’instant. :-) Et puis, Rails utilise beaucoup mieux ActiveRecord que moi. Là, c’était juste pour comprendre un peu comment cette lib fonctionnait.

Il est fort possible que je me mette à Rails très vite. Le but de faire du Ruby était avant tout pour faire du Rails après et comprendre comment Rails marchait. Après plus d’un mois de Ruby, je vais donc faire du Rails maintenant!