轨道4关系has_many和belongs_to

Question

I have the following database schema for 3 models.

Item

  id:integer
  name:string
  order:integer (sort order)
  description:text
  price:decimal

ItemAddon

  id:integer
  name:string
  price:decimal

ItemAvailableAddon

  id:integer
  item_id:integer
  item_addon_id:integer

• An item is generic item for sale
• An add-on is an extra that can appear for 1 or more items, but it isn't directly tied to an item; instead it is tied though ItemAvailableAddon
• Item Available Addon ties together items and add ons.

Are these the correct relationships?

• ItemAvailableAddon belongs_to item
• ItemAvailableAddon belongs_to item_addon
• Item has_many item_available_addon
• ItemAddon has_many item_available_addon

The part hat is confusing me is the many_many relationships

Answer 1

It really looks like "has many through" .

An Item :

has_many :item_available_addons
has_many :item_addons, through: :item_available_addons

An ItemAddon :

has_many :item_available_addons
has_many :items, through: :item_available_addons

An ItemAvailableAddon :

belongs_to :item
belongs_to :item_addon

I'm getting a bit confused by similarly-looking model names, but the structure should be this or similar.

Still, consider using has_and_belongs_to_many if an "availability fact" is just a link and requires no extra data (such as, type of relation of an addon to an item: like, say, if this sort of addon is required or optional). Otherwise, you're good to go with this.

has_and_belongs_to_many

Works simpler and is not so customizable. But setting it up can be easier since it doesn't require maintaining an extra model. An extra table is still required though. You will not need an ItemAvailableAddon model for this at all. So:

An Item

has_and_belongs_to_many :item_addons

An ItemAddon

has_and_belongs_to_many :items

And now for the tricky part. The join table. Don't hurry to migrate just yet, read the whole answer first:

rails g migration CreateItemAddonsItems item:references item_addon:references

That will get you a bare-bones migration you need to edit as specified here :

class CreateItemAddonsItems < ActiveRecord::Migration
  def change
    create_table :item_addons_items, id: false do |t|
      t.references :item
      t.references :item_addon
    end
  end
end

Notes:

• I don't quite get the logic behind how Rails determines the default join table name (they say it's lexical order, but...), but experimenting always works: after specifying an association don't make any migrations: fire up a Rails console and try to use that association (something plain and simple like Item.first.item_addons ): that will tell you what table does not exist: create it. That's how I determined the migration name.
• You can specify the name of a join table manually, if the trial&error described above seems awkward. You don't have to stick to Rails' guessing.
• The link says to use t.integer :<model>_id , but it's the same as t.references :<model> , it's a convention. I prefer using the latter, since it's more semantic (it is an integer, but it serves as a reference: not every integer is a reference).
• id: false in table creation. It's important.
• I've seen people adding null: false after each field. I doubt this should have any effect if association is used correctly. Because otherwise anything can happen.
• There isn't ItemAddonItem model or anything similar. It's what has_and_belongs_to_many is all about. A plain join table with no other purpose but maintaining an association.

That's all. Migrate and you should be all set. Just one thing: things would look a lot simpler if ItemAddon were just Addon . It's associated anyway.