Association in rails

http://jy
aasa.comCopyright 2016. Jyaasa Technologies.
Association in
rails

Copyright 2016. Jyaasa Technologies.
http://jy
aasa.com
Associate Software Engineer at
Jyaasa Technologies
Hello !
I am Sarbada Nanda Jaiswal

http://jy
aasa.com
What is the
association?

http://jy
aasa.com
In Rails, an association is a connection between two
Active Record models.

http://jy
aasa.com
Why associations?

http://jy
aasa.com
Because they make common operations simpler and
easier in your code.
For example: Includes a model for authors and a
model for books. Each author can have many books.
The model declarations would look like:

http://jy
aasa.com
Without associations With Active Record associations
class Author < ApplicationRecord
end
class Book < ApplicationRecord
end
class Author < ApplicationRecord
has_many :books, dependent: :destroy
end
class Book < ApplicationRecord
belongs_to :author
end
@book = Book.create(published_at: Time.now,
author_id: @author.id)
@book = @author.books.create(published_at:
Time.now)
@books = Book.where(author_id: @author.id)
@books.each do |book|
book.destroy
end
@author.destroy
@author.destroy

http://jy
aasa.com
The Types of Associations
Rails supports six types of associations:
● belongs_to
● has_one
● has_many
● has_many :through
● has_one :through
● has_and_belongs_to_many

http://jy
aasa.com
The belongs_to Association
A one-to-one connection with another model.
Each instance of the declaring model "belongs to" one instance of
the other model.
For example, if your application includes authors and books, and
each book can be assigned to exactly one author then how would
be declared the book model?

http://jy
aasa.com

http://jy
aasa.com
class CreateBooks < ActiveRecord::Migration[5.0]
def change
create_table :authors do |t|
t.string :name
t.timestamps
end
create_table :books do |t|
t.belongs_to :author, index: true
t.datetime :published_at
t.timestamps
end
end
end
The corresponding migration might look like this:

http://jy
aasa.com
The has_one Association
Each instance of a model contains or possesses one
instance of another model.
For example, if each supplier in your application has only one
account. How would be declared the supplier model?

http://jy
aasa.com
class CreateSuppliers <
ActiveRecord::Migration[5.0]
def change
create_table :suppliers do |t|
t.string :name
t.timestamps
end
create_table :accounts do |t|
t.belongs_to :supplier, index: true
t.string :account_number
t.timestamps
end
end
end

http://jy
aasa.com
Depending on the use case, you might also need to create a unique index
and/or a foreign key constraint on the supplier column for the accounts table.
In this case, the column definition might look like this:
t.belongs_to :supplier, index: true, unique: true, foreign_key: true
# ...
end

http://jy
aasa.com
The has_many Association
A one-to-many connection with another model.
This association on the "other side" of a belongs_to association.
Each instance of the model has zero or more instances of another
model.
The name of the other model is pluralized when declaring a has_many
association.
For example, in an application containing authors and books. How
would be the author model declared?

http://jy
aasa.com
class CreateAuthors < ActiveRecord::Migration[5.0]
def change
create_table :authors do |t|
t.string :name
t.timestamps
end
create_table :books do |t|
t.belongs_to :author, index: true
t.datetime :published_at
t.timestamps
end
end
end

http://jy
aasa.com
The has_many :through Association
A many-to-many connection with another model.
The declaring model can be matched with zero or more instances of another
model by proceeding through a third model.
For example, consider a medical practice where patients make appointments to
see physicians. How should be relevant association declared?

http://jy
aasa.com
class CreateAppointments < ActiveRecord::Migration[5.0]
def change
create_table :physicians do |t|
t.string :name
t.timestamps
end
create_table :patients do |t|
t.string :name
t.timestamps
end
create_table :appointments do |t|
t.belongs_to :physician, index: true
t.belongs_to :patient, index: true
t.datetime :appointment_date
t.timestamps
end
end
end

http://jy
aasa.com
physician.patients = patients
Automatic deletion of join models is direct, no destroy callbacks are
triggered.

http://jy
aasa.com
The has_many :through association is also useful for setting up "shortcuts"
through nested has_many associations. For example, if a document has many
sections, and a section has many paragraphs, you may sometimes want to get
a simple collection of all paragraphs in the document. You could set that up this
way:
class Document < ApplicationRecord
has_many :sections
has_many :paragraphs, through: :sections
end
class Section < ApplicationRecord
belongs_to :document
has_many :paragraphs
end
class Paragraph < ApplicationRecord
belongs_to :section
end
@document.paragraphs

http://jy
aasa.com
The has_one :through Association
The declaring model can be matched with one instance of another model by
proceeding through a third model.
For example, if each supplier has one account, and each account is
associated with one account history. How should be the supplier model
could look like?

http://jy
aasa.com
class CreateAccountHistories < ActiveRecord::Migration[5.0]
def change
t.string :name
t.timestamps
end
t.belongs_to :supplier, index: true
t.timestamps
end
create_table :account_histories do |t|
t.belongs_to :account, index: true
t.integer :credit_rating
t.timestamps
end
end
end

http://jy
aasa.com
The has_and_belongs_to_many Association
A direct many-to-many connection with another model.
For example, if your application includes assemblies and parts, with each
assembly having many parts and each part appearing in many assemblies,
you could declare the models this way:

http://jy
aasa.com
class CreateAssembliesAndParts < ActiveRecord::Migration[5.0]
def change
create_table :assemblies do |t|
t.string :name
t.timestamps
end
create_table :parts do |t|
t.string :part_number
t.timestamps
end
create_table :assemblies_parts, id: false do |t|
t.belongs_to :assembly, index: true
t.belongs_to :part, index: true
end
end
end

http://jy
aasa.com
Choosing Between belongs_to and has_one
If you want to set up a one-to-one relationship between two models, you'll
need to add belongs_to one, and has_one to the other. How do you know
which is which?
The distinction is in where you place the foreign key (it goes on the table
for the class declaring the belongs_to association), but you should give
some thought to the actual meaning of the data as well. The has_one
relationship says that one of something is yours - that is, that something
points back to you. For example, it makes more sense to say that a
supplier owns an account than that an account owns a supplier. This
suggests that the correct relationships are like this:

http://jy
aasa.com
class Supplier < ApplicationRecord
has_one :account
end
class Account < ApplicationRecord
belongs_to :supplier
end
class CreateSuppliers < ActiveRecord::Migration[5.0]
def change
t.string :name
t.timestamps
end
t.integer :supplier_id
t.timestamps
end
add_index :accounts, :supplier_id
end
end
Using t.integer :supplier_id
makes the foreign key naming
obvious and explicit. In current
versions of Rails, you can
abstract away this
implementation detail by using
t.references :supplier instead.

http://jy
aasa.com
Choosing Between has_many :through and has_and_belongs_to_many
Rails offers two different ways to declare a many-to-many relationship between
models. The simpler way is to use has_and_belongs_to_many, which allows
you to make the association directly:
class Assembly < ApplicationRecord
has_and_belongs_to_many :parts
end
class Part < ApplicationRecord
has_and_belongs_to_many :assemblies
end

http://jy
aasa.com
The second way to declare a many-to-many relationship is to use
has_many :through. This makes the association indirectly, through a join
model:
class Assembly < ApplicationRecord
has_many :manifests
has_many :parts, through: :manifests
end
class Manifest < ApplicationRecord
belongs_to :assembly
belongs_to :part
end
class Part < ApplicationRecord
has_many :manifests
has_many :assemblies, through: :manifests
end

http://jy
aasa.com
The simplest rule of thumb is that you should set up a has_many
:through relationship if you need to work with the relationship model as
an independent entity. If you don't need to do anything with the
relationship model, it may be simpler to set up a
has_and_belongs_to_many relationship (though you'll need to
remember to create the joining table in the database).
You should use has_many :through if you need validations, callbacks
or extra attributes on the join model.

http://jy
aasa.com
Polymorphic Associations
A slightly more advanced twist on associations is the polymorphic
association. With polymorphic associations, a model can belong to more
than one other model, on a single association. For example, you might
have a picture model that belongs to either an employee model or a
product model. Here's how this could be declared:
class Picture < ApplicationRecord
belongs_to :imageable, polymorphic: true
end
class Employee < ApplicationRecord
has_many :pictures, as: :imageable
end
class Product < ApplicationRecord
has_many :pictures, as: :imageable
end

http://jy
aasa.com
You can think of a polymorphic belongs_to declaration as setting up an interface
that any other model can use. From an instance of the Employee model, you can
retrieve a collection of pictures: @employee.pictures.
Similarly, you can retrieve @product.pictures.
If you have an instance of the Picture model, you can get to its parent via
@picture.imageable. To make this work, you need to declare both a foreign key
column and a type column in the model that declares the polymorphic interface:
class CreatePictures < ActiveRecord::Migration[5.0]
def change
create_table :pictures do |t|
t.string :name
t.integer :imageable_id
t.string :imageable_type
t.timestamps
end
add_index :pictures, [:imageable_type,
:imageable_id]
end
end

http://jy
aasa.com
This migration can be simplified by using the t.references form:
class CreatePictures < ActiveRecord::Migration[5.0]
def change
create_table :pictures do |t|
t.string :name
t.references :imageable, polymorphic: true, index: true
t.timestamps
end
end
end

http://jy
aasa.com
Self Joins
In designing a data model, you will sometimes find a model that should have
a relation to itself. For example, you may want to store all employees in a
single database model, but be able to trace relationships such as between
manager and subordinates. This situation can be modeled with self-joining
associations:
class Employee < ApplicationRecord
has_many :subordinates, class_name: "Employee",
foreign_key: "manager_id"
belongs_to :manager, class_name: "Employee"
end

http://jy
aasa.com
With this setup, you can retrieve @employee.subordinates and
@employee.manager.
In your migrations/schema, you will add a references column to the model
itself.
class CreateEmployees < ActiveRecord::Migration[5.0]
def change
create_table :employees do |t|
t.references :manager, index: true
t.timestamps
end
end
end

http://jy
aasa.com
References
http://guides.rubyonrails.org/association_basics.html

Copyright 2015. Jyaasa Technologies.Copyright 2016. Jyaasa Technologies.
http://jyaasa.com

Association in rails

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Association in rails (20)

More from Jyaasa Technologies (20)

Recently uploaded (20)

Association in rails