Understanding Active Record Associations

# belongs_to

# app/models/book.rb
class Book < ApplicationRecord
  belongs_to :author

  # must be singular
  # Sets up a 1:1 connection with another model - Author in this case
  # Books associated to author via `author_id` on books table
end

# has_many

# app/models/author.rb
class Author < ApplicationRecord
  has_many :books

  # naming is plural
  # indicates a one-to-many association
  # an author can have many books in this example
  # books associated via `author_id`
end

# has_one

class Supplier < ApplicationRecord
  has_one :account

  # only contains one instance of another model
  # Supplier will only ever have a single account in this example
  # Account associate via `supplier_id`
end

# has_many :through

# sets up a many-to-many association using another model

# app/models/physician.rb
class Physician < ApplicationRecord
  has_many :appointments
  has_many :patients, through: :appointments
end

# app/models/appoinment.rb
# the appointments table would have both a `physician_id` and `patient_id` column
class Appointment < ApplicationRecord
  belongs_to :physician
  belongs_to :patient
end

# app/models/patient.rb
class Patient < ApplicationRecord
  has_many :appointments
  has_many :physicians, through: :appointments
end

# has one through

# sets up a one-to-one connection with another model but can proceed through a third model

# app/models/supplier.rb

class Supplier < ApplicationRecord
  has_one :account
  has_one :account_history, through: :account
end

# app/models/account.rb

# suppliers reference `supplier_id`
class Account < ApplicationRecord
  belongs_to :supplier
  has_one :account_history
end

# app/models/account_history.rb

# account_histores referenced by `account_id`
class AccountHistory < ApplicationRecord
  belongs_to :account
end

# Has and Belongs to many (has_and_belongs_to_many - HABTM)

# A direct many-to-many connection with another model without a third intervening model. You'll need to create a simple join table to use this type of association. It's limiting in terms of advanced querying so use with caution.

# The naming convention of the join table would take the name of both models and become plural so

# assemblies_parts is the new table name which contains an `assembly_id` and `part_id` only.

# app/models/assembly.rb
class Assembly < ApplicationRecord
  has_and_belongs_to_many :parts
end

# app/models/part.rb
class Part < ApplicationRecord
  has_and_belongs_to_many :assemblies
end

# polymorphic
# With polymorphic associations, a model can belong to more than one other model, on a single association.

# app/models/picture.rb
# pictures table has both `imageable_id`, and `imageable_type`
class Picture < ApplicationRecord
  belongs_to :imageable, polymorphic: true
end

# app/models/employee.rb
class Employee < ApplicationRecord
  has_many :pictures, as: :imageable
end

# app/models/product.rb
class Product < ApplicationRecord
  has_many :pictures, as: :imageable
end