Kansas City on Rails

Many-to-many relationships in Rails can be confusing at first. There are a couple different ways to handle them, depending on what you need. Let’s say you want to organize your mp3 collection. Artists obviously have multiple songs, but songs also have multiple artists.

has_and_belongs_to_many

The simpler way to do this is using HABTM (has_and_belongs_to_many) to define your relationships. Here are the models:

# app/models/song.rb
class Song < ActiveRecord::Base
  has_and_belongs_to_many :artists
end

# app/models/artist.rb
class Artist < ActiveRecord::Base
  has_and_belongs_to_many :songs
end

And here are the migrations:

# db/migrate/create_artists.rb
class CreateArtists < ActiveRecord::Migration
  def self.up
    create_table :artists do |t|
      t.string :name
      t.timestamps
    end
  end

  def self.down
    drop_table :artists
  end
end

# db/migrate/create_songs.rb
class CreateSongs < ActiveRecord::Migration
  def self.up
    create_table :songs do |t|
      t.string :name
      t.timestamps
    end
  end

  def self.down
    drop_table :songs
  end
end

# db/migrate/create_artists_songs.rb
class CreateArtistsSongs < ActiveRecord::Migration
  def self.up
    create_table :artists_songs, :id => false do |t|
      t.integer :artist_id
      t.integer :song_id
    end
  end

  def self.down
    drop_table :artists_songs
  end
end

Notice a couple things about the migrations. First, I had to manually create a join table migration. Its name must be a combination of the two tables being joined, in alphabetical order. This is how Rails is able to figure out the join table’s name automatically. Also notice that I had to specify :id => false in the join table definition. Primary keys in join tables cause big problems.

Now, if I have an object song that is an instance of the Song class, I can say song.artists and get a list of the artists associated with this song. I can do the same for artists. Yay!

has_many :through

What if we wanted to track what instrument the artist played on a given song? This doesn’t go in the artists table, because it’s different for every song. It doesn’t go in the songs table either, because each artist probably played something different. It needs to go in the join table, but there’s a problem. There’s no way in your Rails code to access the information stored in the join table itself.

What we really have here is more than just a join table – it’s another model all its own. Let’s call it a contribution. Each artist’s contribution to a song is unique. I might play nose flute in a rendition of Herbie Hancock’s Watermelon Man, but I play the slide whistle when recreating the theme song from the Krusty the Klown show.

Recreating the models from scratch looks like this:

# app/models/artist.rb
class Artist  < ActiveRecord::Base
  has_many :contributions
  has_many :songs, :through => :contributions
end

# app/models/contribution.rb
class Contribution < ActiveRecord::Base
  belongs_to :artist
  belongs_to :song
end

# app/models/song.rb
class Song < ActiveRecord::Base
  has_many :contributions
  has_many :artists, :through => :contributions
end

The migrations look like this:

# db/migrate/create_artists.rb
class CreateArtists < ActiveRecord::Migration
  def self.up
    create_table :artists do |t|
      t.string :name
      t.timestamps
    end
  end

  def self.down
    drop_table :artists
  end
end

# db/migrate/create_contributions.rb
class CreateContributions < ActiveRecord::Migration
  def self.up
    create_table :contributions do |t|
      t.references :artist
      t.references :song
      t.string :instrument
      t.timestamps
    end
  end

  def self.down
    drop_table :contributions
  end
end

# db/migrate/create_songs.rb
class CreateSongs < ActiveRecord::Migration
  def self.up
    create_table :songs do |t|
      t.string :name
      t.timestamps
    end
  end

  def self.down
    drop_table :songs
  end
end

I didn’t have to manually create the join table this time. I created the three models calling script/generate, and the tables were created automatically. Now, with an object artist that is an instance of the Artist class, I can get a list of contributions with artist.contributions. I can get a list of songs just as easily with artist.songs, and Rails will find them through the contributions table. If I want the instrument the artist used on the first song, I can say artist.songs[0].contribution.instrument, and so on.

Deciding Which to Use

If two models have a many-to-many relationship and you need to track info about the relationship itself, use has_many :through. In fact, sometimes it’s wise to do this anyway, if you anticipate needing that later. HABTM should only be used when the relationship itself will never need to track data of its own.

Tags: developers, habtm, has_and_belongs_to_many, has_many, has_many :through, Rails, Ruby, ruby on rails

This entry was posted on January 16, 2010 at 12:10 pm and is filed under Rails. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.