Jointures multiples dans ActiveRecord grâce à include

Rails est génial. Mais quand les choses se compliquent, ses détracteurs disent que le framework est limité. J’y ai cru un instant lorsque j’ai rencontré le problème que je vous décris ci-dessous. J’ai finalement constaté que Rails était génial même dans les situations compliquées.

Pour exposer le problème, rien de tel qu’un petit exemple:

L’application qui me pose problème est destinée à gérer un ensemble de bibliothèques (Library) contentant plusieurs livres (Book) qui eux-même ont un ou plusieurs auteurs (Author). Un auteur peut bien entendu avoir écrit plusieurs livres et un livre peut se trouver dans plusieurs bibliothèques (le lecteur attentif aura compris que nous ne parlons pas de l’exemplaire du livre mais bien de son édition).

Pour mettre en avant la cardinalité multiple, nous allons utiliser has_many :through. Nous créons donc deux tables de jointure : “propriété” (Ownership) pour joindre bibliothèque et livre et “autorat” (Authorship) pour joindre livre et auteur.

Le modèle est le suivant :

class Library < ActiveRecord::Base
  has_many :ownerships
  has_many :books, :through => :ownerships
end

class Book < ActiveRecord::Base
  has_many :ownerships
  has_many :libraries, :through => :ownerships

  has_many :authorships
  has_many :authors, :through => :authorships
end

class Author < ActiveRecord::Base
  has_many :authorships
  has_many :books, :through => :authorships
end

Et les tables de jointure:

class Ownership < ActiveRecord::Base
  belongs_to :library
  belongs_to :book
end

class Authorship < ActiveRecord::Base
  belongs_to :book
  belongs_to :author
end

Dans notre exemple, nous voulons simplement récupérer la liste de tous les auteurs d’une bibliothèque.

class Library < ActiveRecord::Base
  has_many :ownerships
  has_many :books, :through => :ownerships

  def find_all_authors
    books.inject([]){|authors,book| authors + book.authors}.uniq
  end
end

L’opération que nous faisons ici est potentiellement très lourde. En effet, elle va générer autant de requêtes SQL qu’il y a de livres dans la bibliothèque (lors de l’appel à book.authors).

En SQL, nous aurions fait une jointure multiple pour récupérer l’information recherchée. Allons-nous devoir utiliser find_by_sql? Lorsque je me suis retrouvé confronté à ce problème, j’ai bien pensé que j’allais devoir y passer. Mais, comme je le disais, Rails est génial.

L’option Activerecord utilisée ici est :include. D’habitude, :include est utilisée pour précharger les objets associé à un objet donné. Ce que réalise cette option est en réalité une jointure externe à droite. Il ne reste alors plus qu’à poser les bonnes :conditions pour obtenir le résultat désiré.

class Library < ActiveRecord::Base
  has_many :ownerships
  has_many :books, :through => :ownerships

  def find_all_authors
    Author.find(:all, :include => [:books => :libraries], 
                      :conditions => ["libraries.id = ?", self.id])
  end
end

Plusieurs remarques peuvent être faites à propos de ce exemple:

• Nous utilisons la version imbriquée de include. En effet, la table Author sur laquelle nous faisons la requête ne contient aucune référence vers libraries.

• Nous n’avons pas besoin de mentionner les classes d’associations (ownership et authorship) dans include, elle seront automatiquement ajoutées par rails.

• Dans la condition, "libraries" est écrit au pluriel pour désigner le nom de la table.

• Les imbrications du include peuvent être réalisées autant de fois que désiré et peuvent être combinées. Cependant, bien que cette technique permette de réaliser un nombre important de requêtes en une seule, il ne faut pas oublier que l’opération JOIN en SQL est lourde et qu’il faut donc essayer de l’éviter tant que possible.

Pour cloturer ce billet, je préciserai que je n’ai trouvé que très peu d’informations sur :include tant au niveau de la communauté anglophone que francophone. Ai-je raté un point important? Y a-t-il une solution plus élégante? Et vous, comment faites-vous?