Relacionamento muitos-para-muitos com ActiveRecord no Rails

Esta semana recebi dois e-mails com a mesma dúvida: como funciona o relacionamento muitos-para-muitos no ActiveRecord. Aparentemente, este é um assunto que muitas pessoas tem dúvidas, mas cuja resposta é bastante simples, até. Você pode fazer tal relacionamento de duas maneiras diferentes, como veremos neste artigo.

Utilizando o método hasandbelongstomany

O método hasandbelongstomany possui uma convenção para se nomear a tabela que persistirá os relacionamentos. Você deve colocar ambas as tabelas relacionadas no nome da tabela de relacionamentos, ordenados alfabeticamente e separados por underscore. Se você tem as tabelas posts e categories, o nome de sua tabela de relacionamentos será categories_posts. Os campos também possuem uma convenção, que é colocar o nome da tabela no singular, adicionando o sufixo _id. Neste caso, teríamos um arquivo de migração como este:

class AddPostsAndCategories < ActiveRecord::Migration
  def self.up
    create_table :categories_posts do |t|
      t.references :category, :post
    end
  end

  def self.down
    drop_table :categories_posts
  end
end

Para relacionar ambos os modelos, precisaríamos colocar o seguinte método no modelo Post:

class Post < ActiveRecord::Base
  has_and_belongs_to_many :categories
end

Já no modelo Category, o relacionamento seria o seguinte:

class Category < ActiveRecord::Base
  has_and_belongs_to_many :posts
end

Muito simples! Apenas com estas poucas linhas você já pode usar diversos métodos, adicionados pelo próprio ActiveRecord.

post = Post.first
category = Category.first

# creating relationship through post
post.categories << category

# creating relationship through category
category.posts << post

# getting all posts
categories.posts.each do |post|
  puts post.title
end

# getting all categories from a post
post.categories.each do |cat|
  puts cat.title
end

# getting all the post ids
category.post_ids

O método has_and_belongs_to_many possui uma grande desvantagem. Você não pode adicionar campos extras aos relacionamentos. No entanto, o método has_many permite que você faça isso.

Utilizando o método has_many

Ao contrário do método has_and_belongs_to_many, você pode ter quantos campos adicionais precisar se fizer o relacionamento com o método has_many. Isso é extremamente útil e bastante utilizado por plugins que lidam com ActiveRecord. A convenção para este tipo de relacionamento é um pouco diferente. Sua tabela pode ter um nome específico que identifica o tipo de relacionamento que está sendo feito, já que ele terá um modelo próprio, que fará o papel intermediário entre as tabelas relacionadas.

Crie um modelo chamado Categorization. Ele deve ter os seguintes campos:

class CreateCategorizations < ActiveRecord::Migration
  def self.up
    create_table :categorizations do |t|
      t.references :post, :category
      t.timestamps
    end
  end

  def self.down
    drop_table :categorizations
  end
end

Agora, você precisa criar relacionamentos entre este modelo e os demais (Post e Category). No seu modelo Categorization, adicione os seguintes relacionamentos:

class Categorization < ActiveRecord::Base
  belongs_to :category
  belongs_to :post
end

E em cada um dos outros modelos faça o relacionamento contrário, utilizando o método has_many.

class Post < ActiveRecord::Base
  has_many :categorizations
end

class Category < ActiveRecord::Base
  has_many :categorizations
end

E aqui entra realmente a parte importante: você irá usar um relacionamento chamado de has_many through:, que fará uma consulta SQL, unindo os resultados em uma única consulta. No seu modelo Post, adicione mais um relacionamento.

class Post < ActiveRecord::Base
  has_many :categorizations
  has_many :categories, through: :categorizations
end

Faça a mesma coisa no modelo Category.

class Category < ActiveRecord::Base
  has_many :categorizations
  has_many :posts, through: :categorizations
end

Pronto! Seu relacionamento já foi criado. Para testar, faça algo como isto usando o console.

post = Post.first

# get post categories
post.categories.map(&:title).to_sentence

category = Category.first

# get posts by categories
category.posts.map(&:title).to_sentence

Para criar uma nova associação, você precisa fazer isso através do relacionamento categorizations; caso contrário, você receberá um erro dizendo que não possui um campo para o id.

# through post
post.categorizations.create(category: category)

# through category
category.categorizations.create(post: post)

É isso! Se você tem alguma dúvida, envie um e-mail. Se for um assunto que me interessa, ou que interessa a mais pessoas, eu posso escrever algo aqui!