модуль ActiveRecord::Associations::ClassMethods

Ассоциации представляют собой набор макро-подобных методов класса для связывания объектов через внешние ключи. Они выражают такие отношения, как «Проект имеет одного руководителя проекта» или «Проект принадлежит портфолио». Каждый макрос добавляет ряд методов в класс, которые специализируются в зависимости от символа коллекции или ассоциации и хэша опций. Он работает практически так же, как собственные attr* методы Ruby.

class Project < ActiveRecord::Base
  belongs_to              :portfolio
  has_one                 :project_manager
  has_many                :milestones
  has_and_belongs_to_many :categories
end

Класс проекта теперь имеет следующие методы (и больше) для упрощения навигации и манипулирования его отношениями:

• Project#portfolio, Project#portfolio=(portfolio), Project#reload_portfolio

• Project#project_manager, Project#project_manager=(project_manager), Project#reload_project_manager

• Project#milestones.empty?, Project#milestones.size, Project#milestones, Project#milestones<<(milestone), Project#milestones.delete(milestone), Project#milestones.destroy(milestone), Project#milestones.find(milestone_id), Project#milestones.build, Project#milestones.create

• Project#categories.empty?, Project#categories.size, Project#categories, Project#categories<<(category1), Project#categories.delete(category1), Project#categories.destroy(category1)

Предупреждение

Не создавайте ассоциаций с теми же именами, что и методы экземпляров ActiveRecord::Base. Поскольку ассоциация добавляет метод с таким же именем в свою модель, использование ассоциации с тем же именем, что и предоставленное ActiveRecord::Base, переопределит метод, унаследованный через ActiveRecord::Base, и вызовет ошибки. Например, attributes и connection были бы плохим выбором для имён ассоциаций, поскольку эти имена уже существуют в списке ActiveRecord::Base методов экземпляров.

Автоматически сгенерированные методы

См. также Публичные методы экземпляров ниже для получения дополнительной информации.

Единичные ассоциации (один к одному)

                                  |            |  belongs_to  |
generated methods                 | belongs_to | :polymorphic | has_one
----------------------------------+------------+--------------+---------
other                             |     X      |      X       |    X
other=(other)                     |     X      |      X       |    X
build_other(attributes={})        |     X      |              |    X
create_other(attributes={})       |     X      |              |    X
create_other!(attributes={})      |     X      |              |    X
reload_other                      |     X      |      X       |    X
other_changed?                    |     X      |      X       |
other_previously_changed?         |     X      |      X       |

Коллекционные ассоциации (один ко многим / многие ко многим)

                                  |       |          | has_many
generated methods                 | habtm | has_many | :through
----------------------------------+-------+----------+----------
others                            |   X   |    X     |    X
others=(other,other,...)          |   X   |    X     |    X
other_ids                         |   X   |    X     |    X
other_ids=(id,id,...)             |   X   |    X     |    X
others<<                          |   X   |    X     |    X
others.push                       |   X   |    X     |    X
others.concat                     |   X   |    X     |    X
others.build(attributes={})       |   X   |    X     |    X
others.create(attributes={})      |   X   |    X     |    X
others.create!(attributes={})     |   X   |    X     |    X
others.size                       |   X   |    X     |    X
others.length                     |   X   |    X     |    X
others.count                      |   X   |    X     |    X
others.sum(*args)                 |   X   |    X     |    X
others.empty?                     |   X   |    X     |    X
others.clear                      |   X   |    X     |    X
others.delete(other,other,...)    |   X   |    X     |    X
others.delete_all                 |   X   |    X     |    X
others.destroy(other,other,...)   |   X   |    X     |    X
others.destroy_all                |   X   |    X     |    X
others.find(*args)                |   X   |    X     |    X
others.exists?                    |   X   |    X     |    X
others.distinct                   |   X   |    X     |    X
others.reset                      |   X   |    X     |    X
others.reload                     |   X   |    X     |    X

Переопределение сгенерированных методов

Методы ассоциаций генерируются в модуле, включенном в класс модели, что упрощает переопределения. Таким образом, исходный сгенерированный метод можно вызвать с помощью super:

class Car < ActiveRecord::Base
  belongs_to :owner
  belongs_to :old_owner

  def owner=(new_owner)
    self.old_owner = self.owner
    super
  end
end

Модуль методов ассоциаций включается сразу после модуля методов сгенерированных атрибутов, что означает, что ассоциация переопределит методы для атрибута с тем же именем.

Кардинальность и ассоциации

Активные записи ассоциации могут использоваться для описания отношений один-к-одному, один-ко-многим и многие-ко-многим между моделями. Каждая модель использует ассоциацию для описания своей роли в отношении. Ассоциация belongs_to всегда используется в модели, которая имеет внешний ключ.

Один-к-одному

Используйте has_one в базовой, и belongs_to в связанной модели.

class Employee < ActiveRecord::Base
  has_one :office
end
class Office < ActiveRecord::Base
  belongs_to :employee    # foreign key - employee_id
end

Один-ко-многим

Используйте has_many в базовой, и belongs_to в связанной модели.

class Manager < ActiveRecord::Base
  has_many :employees
end
class Employee < ActiveRecord::Base
  belongs_to :manager     # foreign key - manager_id
end

Многие-ко-многим

Существует два способа построения отношения многие-ко-многим.

Первый способ использует ассоциацию has_many с опцией :through и моделью соединения, поэтому есть два этапа ассоциаций.

class Assignment < ActiveRecord::Base
  belongs_to :programmer  # foreign key - programmer_id
  belongs_to :project     # foreign key - project_id
end
class Programmer < ActiveRecord::Base
  has_many :assignments
  has_many :projects, through: :assignments
end
class Project < ActiveRecord::Base
  has_many :assignments
  has_many :programmers, through: :assignments
end

Для второго способа используйте has_and_belongs_to_many в обеих моделях. Это требует таблицы соединения, которая не имеет соответствующей модели или первичного ключа.

class Programmer < ActiveRecord::Base
  has_and_belongs_to_many :projects       # foreign keys in the join table
end
class Project < ActiveRecord::Base
  has_and_belongs_to_many :programmers    # foreign keys in the join table
end

Выбор способа построения отношения многие-ко-многим не всегда прост. Если вам нужно работать с моделью отношения как со своей сущностью, используйте has_many :through. Используйте has_and_belongs_to_many при работе со схемами устаревшего типа или когда вы никогда не работаете напрямую с самим отношением.

Это ассоциация belongs_to или has_one?

Оба выражают отношение 1-к-1. Разница в основном в том, где разместить внешний ключ, который находится в таблице для класса, объявляющего отношение belongs_to.

class User < ActiveRecord::Base
  # I reference an account.
  belongs_to :account
end

class Account < ActiveRecord::Base
  # One user references me.
  has_one :user
end

Таблицы для этих классов могут выглядеть следующим образом:

CREATE TABLE users (
  id bigint NOT NULL auto_increment,
  account_id bigint default NULL,
  name varchar default NULL,
  PRIMARY KEY  (id)
)

CREATE TABLE accounts (
  id bigint NOT NULL auto_increment,
  name varchar default NULL,
  PRIMARY KEY  (id)
)

Несохраненные объекты и ассоциации

Вы можете манипулировать объектами и ассоциациями до их сохранения в базе данных, но есть некоторые особенности поведения, о которых вам следует знать, в основном связанные с сохранением связанных объектов.

Вы можете установить опцию :autosave для has_one, belongs_to, has_many или has_and_belongs_to_many ассоциации. Установка её в значение true всегда сохранит члены, а установка в значение false никогда не сохранит члены. Дополнительные сведения об опции :autosave доступны по адресу AutosaveAssociation.

Ассоциации один-к-одному

• Присвоение объекта ассоциации has_one автоматически сохраняет этот объект и заменяемый объект (если таковой есть), чтобы обновить их внешние ключи — за исключением случая, когда родительский объект не сохранён (new_record? == true).

• Если одно из этих сохранений завершается ошибкой (потому что один из объектов недействителен), генерируется исключение ActiveRecord::RecordNotSaved, и назначение отменяется.

• Если вы хотите назначить объект ассоциации has_one без его сохранения, используйте метод #build_association (документированный ниже). Заменяемый объект по-прежнему будет сохранён, чтобы обновить его внешний ключ.

• Назначение объекта ассоциации belongs_to не сохраняет объект, поскольку поле внешнего ключа принадлежит родителю. Он также не сохраняет родителя.

Коллекции

• Добавление объекта в коллекцию (has_many или has_and_belongs_to_many) автоматически сохраняет этот объект, за исключением случая, когда родительский объект (владелец коллекции) ещё не сохранён в базе данных.

• Если сохранение любого из добавляемых в коллекцию объектов (через push или аналогично) завершается ошибкой, то push возвращает false.

• Если сохранение завершается ошибкой при замене коллекции (через association=), генерируется исключение ActiveRecord::RecordNotSaved, и назначение отменяется.

• Вы можете добавить объект в коллекцию без автоматического сохранения, используя метод collection.build (документированный ниже).

• Все несохраненные (new_record? == true) члены коллекции автоматически сохраняются при сохранении родителя.

Настройка запроса

Ассоциации создаются из объектов Relation, и вы можете использовать синтаксис Relation, чтобы их настроить. Например, для добавления условия:

class Blog < ActiveRecord::Base
  has_many :published_posts, -> { where(published: true) }, class_name: 'Post'
end

Внутри блока -> { ... } вы можете использовать все обычные методы Relation.

Доступ к объекту владельца

Иногда полезно иметь доступ к объекту владельца при построении запроса. Владелец передается как параметр в блок. Например, следующая ассоциация найдет все события, которые происходят в день рождения пользователя:

class User < ActiveRecord::Base
  has_many :birthday_events, ->(user) { where(starts_on: user.birthday) }, class_name: 'Event'
end

Примечание: Объединение, жадное и предварительное загрузка этих ассоциаций невозможны. Эти операции происходят до создания экземпляра, и область действия будет вызвана с аргументом nil.

Обработчики событий ассоциации

Аналогично обычным обработчикам событий, которые привязываются к жизненному циклу объекта Active Record, вы также можете определить обработчики событий, которые вызываются при добавлении или удалении объекта из коллекции ассоциации.

class Firm < ActiveRecord::Base
  has_many :clients,
           dependent: :destroy,
           after_add: :congratulate_client,
           after_remove: :log_after_remove

  def congratulate_client(record)
    # ...
  end

  def log_after_remove(record)
    # ...
  end

Можно объединять обработчики событий, передавая их как массив. Пример:

class Firm < ActiveRecord::Base
  has_many :clients,
           dependent: :destroy,
           after_add: [:congratulate_client, -> (firm, record) { firm.log << "after_adding#{record.id}" }],
           after_remove: :log_after_remove
end

Возможные обработчики событий: before_add, after_add, before_remove и after_remove.

Если какой-либо из обработчиков событий before_add вызывает исключение, объект не будет добавлен в коллекцию.

Аналогично, если какой-либо из обработчиков событий before_remove вызывает исключение, объект не будет удален из коллекции.

Примечание: Чтобы вызвать обработчики удаления, необходимо использовать методы destroy / destroy_all. Например:

* <tt>firm.clients.destroy(client)</tt>
* <tt>firm.clients.destroy(*clients)</tt>
* <tt>firm.clients.destroy_all</tt>

Методы delete / delete_all подобного типа не вызывают обработчиков удаления:

* <tt>firm.clients.delete(client)</tt>
* <tt>firm.clients.delete(*clients)</tt>
* <tt>firm.clients.delete_all</tt>

Расширения ассоциаций

Объекты-прокси, которые управляют доступом к ассоциациям, можно расширить с помощью анонимных модулей. Это особенно полезно для добавления новых методов поиска, создания и других методов типа фабрики, которые используются только в рамках этой ассоциации.

class Account < ActiveRecord::Base
  has_many :people do
    def find_or_create_by_name(name)
      first_name, last_name = name.split(" ", 2)
      find_or_create_by(first_name: first_name, last_name: last_name)
    end
  end
end

person = Account.first.people.find_or_create_by_name("David Heinemeier Hansson")
person.first_name # => "David"
person.last_name  # => "Heinemeier Hansson"

Если вам нужно использовать одинаковые расширения для многих ассоциаций, вы можете использовать именованный модуль расширений.

module FindOrCreateByNameExtension
  def find_or_create_by_name(name)
    first_name, last_name = name.split(" ", 2)
    find_or_create_by(first_name: first_name, last_name: last_name)
  end
end

class Account < ActiveRecord::Base
  has_many :people, -> { extending FindOrCreateByNameExtension }
end

class Company < ActiveRecord::Base
  has_many :people, -> { extending FindOrCreateByNameExtension }
end

Некоторые расширения могут работать только при наличии знаний о внутренней работе ассоциации. Расширения могут получить доступ к соответствующему состоянию, используя следующие методы (где items - имя ассоциации):

• record.association(:items).owner - Возвращает объект, частью которого является ассоциация.

• record.association(:items).reflection - Возвращает объект рефлексии, описывающий ассоциацию.

• record.association(:items).target - Возвращает связанный объект для belongs_to и has_one или коллекцию связанных объектов для has_many и has_and_belongs_to_many.

Однако, внутри собственного кода расширения у вас не будет доступа к record как указано выше. В этом случае вы можете получить доступ к proxy_association. Например, record.association(:items) и record.items.proxy_association вернут один и тот же объект, что позволит вам делать вызовы, такие как proxy_association.owner внутри расширений ассоциаций.

Модели объединения ассоциаций

Ассоциации Has Many могут быть сконфигурированы с опцией :through для использования явной модели объединения для извлечения данных. Это работает аналогично ассоциации has_and_belongs_to_many. Преимущество состоит в том, что вы можете добавлять валидации, колбэки и дополнительные атрибуты к модели объединения. Рассмотрим следующую схему:

class Author < ActiveRecord::Base
  has_many :authorships
  has_many :books, through: :authorships
end

class Authorship < ActiveRecord::Base
  belongs_to :author
  belongs_to :book
end

@author = Author.first
@author.authorships.collect { |a| a.book } # selects all books that the author's authorships belong to
@author.books                              # selects all books by using the Authorship join model

Вы также можете пройти через ассоциацию has_many в модели объединения:

class Firm < ActiveRecord::Base
  has_many   :clients
  has_many   :invoices, through: :clients
end

class Client < ActiveRecord::Base
  belongs_to :firm
  has_many   :invoices
end

class Invoice < ActiveRecord::Base
  belongs_to :client
end

@firm = Firm.first
@firm.clients.flat_map { |c| c.invoices } # select all invoices for all clients of the firm
@firm.invoices                            # selects all invoices by going through the Client join model

Аналогично, вы можете пройти через ассоциацию has_one в модели объединения:

class Group < ActiveRecord::Base
  has_many   :users
  has_many   :avatars, through: :users
end

class User < ActiveRecord::Base
  belongs_to :group
  has_one    :avatar
end

class Avatar < ActiveRecord::Base
  belongs_to :user
end

@group = Group.first
@group.users.collect { |u| u.avatar }.compact # select all avatars for all users in the group
@group.avatars                                # selects all avatars by going through the User join model.

Важное замечание при прохождении через ассоциации has_one или has_many в модели объединения заключается в том, что эти ассоциации являются только для чтения. Например, следующее не будет работать после предыдущего примера:

@group.avatars << Avatar.new   # this would work if User belonged_to Avatar rather than the other way around
@group.avatars.delete(@group.avatars.last)  # so would this

Установка обратных ссылок

Если вы используете belongs_to в модели объединения, рекомендуется установить опцию :inverse_of для belongs_to, что означает правильную работу следующего примера (где tags — ассоциация has_many :through):

@post = Post.first
@tag = @post.tags.build name: "ruby"
@tag.save

Последняя строка должна сохранить запись через (запись Tagging). Это будет работать только если :inverse_of установлена:

class Tagging < ActiveRecord::Base
  belongs_to :post
  belongs_to :tag, inverse_of: :taggings
end

Если вы не установите запись :inverse_of, ассоциация сделает всё возможное, чтобы сопоставить себя с правильной обратной ссылкой. Автоматическое определение обратной ссылки работает только для ассоциаций has_many, has_one и belongs_to.

Опции :foreign_key и :through для ассоциаций также помешают автоматически найти обратную ссылку, как и пользовательские области в некоторых случаях. Дополнительные сведения см. в руководстве по ассоциациям Active Record .

Автоматическое определение обратной ссылки использует эвристику, основанную на имени класса, поэтому оно может не работать для всех ассоциаций, особенно для тех, у которых нестандартные имена.

Вы можете отключить автоматическое определение обратных ссылок, установив опцию :inverse_of в false, как показано ниже:

class Tagging < ActiveRecord::Base
  belongs_to :tag, inverse_of: false
end

Вложенные ассоциации

Вы можете указать любую ассоциацию с опцией :through, включая ассоциацию, у которой есть сама опция :through. Например:

class Author < ActiveRecord::Base
  has_many :posts
  has_many :comments, through: :posts
  has_many :commenters, through: :comments
end

class Post < ActiveRecord::Base
  has_many :comments
end

class Comment < ActiveRecord::Base
  belongs_to :commenter
end

@author = Author.first
@author.commenters # => People who commented on posts written by the author

Эквивалентный способ настройки этой ассоциации:

class Author < ActiveRecord::Base
  has_many :posts
  has_many :commenters, through: :posts
end

class Post < ActiveRecord::Base
  has_many :comments
  has_many :commenters, through: :comments
end

class Comment < ActiveRecord::Base
  belongs_to :commenter
end

При использовании вложенной ассоциации вы не сможете изменить ассоциацию, потому что нет достаточной информации для определения того, какое изменение нужно сделать. Например, если вы попытаетесь добавить Commenter в приведённом выше примере, не будет способа определить, как настроить промежуточные объекты Post и Comment.

Полиморфные ассоциации

Полиморфные ассоциации моделей не ограничены типами моделей, с которыми они могут быть связаны. Вместо этого они определяют интерфейс, которому должна соответствовать ассоциация has_many.

class Asset < ActiveRecord::Base
  belongs_to :attachable, polymorphic: true
end

class Post < ActiveRecord::Base
  has_many :assets, as: :attachable         # The :as option specifies the polymorphic interface to use.
end

@asset.attachable = @post

Это работает с использованием столбца типа в дополнение к внешнему ключу для указания связанной записи. В примере с активами вам потребуется столбец с целочисленным типом attachable_id и строковым столбцом attachable_type.

Использование полиморфных ассоциаций в сочетании с наследованием одной таблицы (STI) немного сложно. Для корректной работы ассоциаций убедитесь, что вы сохраняете базу модели для моделей STI в столбце типа полиморфной ассоциации. Чтобы продолжить пример с активами, предположим, что гостевые записи и пользовательские записи используют таблицу записей для STI. В этом случае в таблице записей должен быть столбец type.

Примечание: метод attachable_type= вызывается при назначении attachable. class_name объекта attachable передаётся как String.

class Asset < ActiveRecord::Base
  belongs_to :attachable, polymorphic: true

  def attachable_type=(class_name)
     super(class_name.constantize.base_class.to_s)
  end
end

class Post < ActiveRecord::Base
  # because we store "Post" in attachable_type now dependent: :destroy will work
  has_many :assets, as: :attachable, dependent: :destroy
end

class GuestPost < Post
end

class MemberPost < Post
end

Кэширование

Все методы основаны на простом принципе кэширования, которое сохранит результат последнего запроса, если специально не указано иное. Кэш даже совместно используется между методами, чтобы сделать использование макро-добавляемых методов ещё более дешёвым, не беспокоясь слишком сильно о производительности с первого раза.

project.milestones             # fetches milestones from the database
project.milestones.size        # uses the milestone cache
project.milestones.empty?      # uses the milestone cache
project.milestones.reload.size # fetches milestones from the database
project.milestones             # uses the milestone cache

Жадное загрузка ассоциаций

Жадная загрузка — способ поиска объектов определённого класса и нескольких именованных ассоциаций. Это один из самых простых способов предотвратить проблему N+1, в которой извлечение 100 записей, каждая из которых должна отображать автора, вызывает 101 запрос к базе данных. Благодаря жадной загрузке количество запросов будет уменьшено с 101 до 2.

class Post < ActiveRecord::Base
  belongs_to :author
  has_many   :comments
end

Рассмотрим следующий цикл, используя вышеупомянутый класс:

Post.all.each do |post|
  puts "Post:            " + post.title
  puts "Written by:      " + post.author.name
  puts "Last comment on: " + post.comments.first.created_on
end

Для итерации по этим ста записям мы сгенерируем 201 запрос к базе данных. Давайте сначала оптимизируем его для извлечения автора:

Post.includes(:author).each do |post|

Это ссылается на имя ассоциации belongs_to, которая также использовала символ :author. После загрузки записей find соберет author_id из каждой записи и загрузит все ссылающиеся авторов одним запросом. Это сократит количество запросов с 201 до 102.

Мы можем улучшить ситуацию ещё больше, указав обе ассоциации в методе поиска:

Post.includes(:author, :comments).each do |post|

Это загрузит все комментарии одним запросом. Это уменьшит общее количество запросов до 3. В общем случае количество запросов будет равно 1 плюс количество именованных ассоциаций (если некоторые из ассоциаций являются полиморфными belongs_to — см. ниже).

Для включения глубокой иерархии ассоциаций используйте хэш:

Post.includes(:author, { comments: { author: :gravatar } }).each do |post|

Приведённый выше код загрузит все комментарии и всех связанных с ними авторов и аватары. Вы можете комбинировать любые сочетания символов, массивов и хэшей для извлечения необходимых вам ассоциаций.

Вся эта мощь не должна вводить вас в заблуждение, что вы можете извлечь огромные объёмы данных без штрафа за производительность просто потому, что вы уменьшили количество запросов. Базе данных всё равно нужно отправлять все данные в Active Record, и их всё равно нужно обработать. Поэтому это не панацея от проблем с производительностью, но это отличный способ сократить количество запросов в такой ситуации, как описанная выше.

Поскольку загружается только одна таблица за раз, условия или упорядочивания не могут ссылаться на таблицы, кроме основной. В этом случае Active Record возвращается к ранее использовавшейся стратегии на основе LEFT OUTER JOIN. Например:

Post.includes([:author, :comments]).where(['comments.approved = ?', true])

Это приведёт к одному SQL-запросу со соединениями в духе: LEFT OUTER JOIN comments ON comments.post_id = posts.id и LEFT OUTER JOIN authors ON authors.id = posts.author_id. Обратите внимание, что использование таких условий может иметь непредвиденные последствия. В приведённом выше примере записи, у которых нет одобренных комментариев, вообще не возвращаются, так как условия применяются к SQL-запросу в целом, а не только к ассоциации.

Для разбора ссылок на столбцы для этого отката, например, order: "author.name DESC" будет работать, но order: "name DESC" нет.

Если вы хотите загрузить все записи (включая записи без одобренных комментариев), напишите свой собственный LEFT OUTER JOIN запрос, используя ON:

Post.joins("LEFT OUTER JOIN comments ON comments.post_id = posts.id AND comments.approved = '1'")

В этом случае обычно более естественно включить ассоциацию, имеющую определённые условия:

class Post < ActiveRecord::Base
  has_many :approved_comments, -> { where(approved: true) }, class_name: 'Comment'
end

Post.includes(:approved_comments)

Это загрузит записи и жадно загрузит ассоциацию approved_comments, содержащую только те комментарии, которые были одобрены.

Если вы жадно загружаете ассоциацию со заданной опцией :limit, она будет проигнорирована, и будут возвращены все связанные объекты:

class Picture < ActiveRecord::Base
  has_many :most_recent_comments, -> { order('id DESC').limit(10) }, class_name: 'Comment'
end

Picture.includes(:most_recent_comments).first.most_recent_comments # => returns all associated comments.

Жадная загрузка поддерживается для полиморфных ассоциаций.

class Address < ActiveRecord::Base
  belongs_to :addressable, polymorphic: true
end

Вызов, который пытается жадно загрузить модель адреса

Address.includes(:addressable)

Это выполнит один запрос для загрузки адресов и загрузит addressable одним запросом на тип addressable. Например, если все addressable — это либо тип Person, либо тип Company, то всего будет выполнено 3 запроса. Список типов addressable для загрузки определяется на основе загруженных адресов. Это не поддерживается, если Active Record должен вернуться к предыдущей реализации жадной загрузки, и вызовет ActiveRecord::EagerLoadPolymorphicError. Причина в том, что тип родительской модели — это значение столбца, поэтому соответствующее имя таблицы не может быть включено в FROM/JOIN клаузы этого запроса.

Псевдонимы таблиц

Active Record использует псевдонимы таблиц в случае, если таблица упоминается несколько раз в соединении. Если таблица упоминается только один раз, используется стандартное имя таблицы. Во второй раз таблица алиасится как #{reflection_name}_#{parent_table_name}. Индексы добавляются для любых последующих упоминаний имени таблицы.

Post.joins(:comments)
# => SELECT ... FROM posts INNER JOIN comments ON ...
Post.joins(:special_comments) # STI
# => SELECT ... FROM posts INNER JOIN comments ON ... AND comments.type = 'SpecialComment'
Post.joins(:comments, :special_comments) # special_comments is the reflection name, posts is the parent table name
# => SELECT ... FROM posts INNER JOIN comments ON ... INNER JOIN comments special_comments_posts

Пример древовидной структуры:

TreeMixin.joins(:children)
# => SELECT ... FROM mixins INNER JOIN mixins childrens_mixins ...
TreeMixin.joins(children: :parent)
# => SELECT ... FROM mixins INNER JOIN mixins childrens_mixins ...
                            INNER JOIN parents_mixins ...
TreeMixin.joins(children: {parent: :children})
# => SELECT ... FROM mixins INNER JOIN mixins childrens_mixins ...
                            INNER JOIN parents_mixins ...
                            INNER JOIN mixins childrens_mixins_2

Таблицы Has and Belongs to Many используют ту же идею, но добавляют суффикс _join:

Post.joins(:categories)
# => SELECT ... FROM posts INNER JOIN categories_posts ... INNER JOIN categories ...
Post.joins(categories: :posts)
# => SELECT ... FROM posts INNER JOIN categories_posts ... INNER JOIN categories ...
                           INNER JOIN categories_posts posts_categories_join INNER JOIN posts posts_categories
Post.joins(categories: {posts: :categories})
# => SELECT ... FROM posts INNER JOIN categories_posts ... INNER JOIN categories ...
                           INNER JOIN categories_posts posts_categories_join INNER JOIN posts posts_categories
                           INNER JOIN categories_posts categories_posts_join INNER JOIN categories categories_posts_2

Если вы хотите указать собственные пользовательские соединения с помощью метода ActiveRecord::QueryMethods#joins, эти имена таблиц будут иметь приоритет над жадными ассоциациями:

Post.joins(:comments).joins("inner join comments ...")
# => SELECT ... FROM posts INNER JOIN comments_posts ON ... INNER JOIN comments ...
Post.joins(:comments, :special_comments).joins("inner join comments ...")
# => SELECT ... FROM posts INNER JOIN comments comments_posts ON ...
                           INNER JOIN comments special_comments_posts ...
                           INNER JOIN comments ...

Псевдонимы таблиц автоматически усекаются в соответствии с максимальной длиной идентификаторов таблиц в соответствии со спецификой базы данных.

Модули

По умолчанию ассоциации будут искать объекты в текущем объеме модуля. Рассмотрим:

module MyApplication
  module Business
    class Firm < ActiveRecord::Base
      has_many :clients
    end

    class Client < ActiveRecord::Base; end
  end
end

Когда Firm#clients вызывается, он, в свою очередь, вызовет MyApplication::Business::Client.find_all_by_firm_id(firm.id). Если вы хотите ассоциировать с классом в другом объеме модуля, это можно сделать, указав полное имя класса.

module MyApplication
  module Business
    class Firm < ActiveRecord::Base; end
  end

  module Billing
    class Account < ActiveRecord::Base
      belongs_to :firm, class_name: "MyApplication::Business::Firm"
    end
  end
end

Взаимные ассоциации

Когда вы указываете ассоциацию, обычно существует ассоциация на связанной модели, которая определяет ту же связь в обратном направлении. Например, с помощью следующих моделей:

class Dungeon < ActiveRecord::Base
  has_many :traps
  has_one :evil_wizard
end

class Trap < ActiveRecord::Base
  belongs_to :dungeon
end

class EvilWizard < ActiveRecord::Base
  belongs_to :dungeon
end

Ассоциация traps в модели Dungeon и ассоциация dungeon в модели Trap являются обратными друг другу, и обратной ассоциацией dungeon в модели EvilWizard является ассоциация evil_wizard в модели Dungeon (и наоборот). По умолчанию Active Record может угадать обратную ассоциацию на основе имени класса. Результат следующий:

d = Dungeon.first
t = d.traps.first
d.object_id == t.dungeon.object_id # => true

Экземпляры Dungeon d и t.dungeon в приведенном выше примере ссылаются на один и тот же экземпляр в памяти, поскольку ассоциация соответствует имени класса. Результат был бы таким же, если бы мы добавили :inverse_of к нашим определениям моделей:

class Dungeon < ActiveRecord::Base
  has_many :traps, inverse_of: :dungeon
  has_one :evil_wizard, inverse_of: :dungeon
end

class Trap < ActiveRecord::Base
  belongs_to :dungeon, inverse_of: :traps
end

class EvilWizard < ActiveRecord::Base
  belongs_to :dungeon, inverse_of: :evil_wizard
end

Для получения дополнительной информации см. документацию по параметру :inverse_of.

Удаление из ассоциаций

Зависимые ассоциации

has_many, has_one и belongs_to ассоциации поддерживают параметр :dependent. Это позволяет указать, что связанные записи должны быть удалены при удалении владельца.

Например:

class Author
  has_many :posts, dependent: :destroy
end
Author.find(1).destroy # => Will destroy all of the author's posts, too

Параметр :dependent может иметь разные значения, которые определяют, как выполняется удаление. Для получения дополнительной информации см. документацию по этому параметру для разных типов ассоциаций. При отсутствии параметра поведение заключается в том, чтобы не предпринимать никаких действий со связанными записями при уничтожении записи.

Обратите внимание, что :dependent реализовано с помощью системы обратных вызовов Rails, которая работает путем обработки обратных вызовов в определенном порядке. Следовательно, другие объявленные до или после параметра :dependent обратные вызовы могут повлиять на его работу.

Обратите внимание, что параметр :dependent игнорируется для ассоциаций has_one :through.

Удалить или уничтожить?

has_many и has_and_belongs_to_many ассоциации имеют методы destroy, delete, destroy_all и delete_all.

Для has_and_belongs_to_many, delete и destroy одинаковы: они приводят к удалению записей в таблице соединения.

Для has_many, destroy и destroy_all всегда вызывают метод destroy удаляемой(ых) записи(ей), чтобы обработать обратные вызовы. Однако delete и delete_all либо выполняют удаление в соответствии со стратегией, указанной параметром :dependent, или, если параметр :dependent не задан, следует стратегии по умолчанию. Стратегия по умолчанию - ничего не делать (оставить внешние ключи со значениями родительских id), за исключением has_many :through, где стратегия по умолчанию - delete_all (удалить записи соединения без запуска их обратных вызовов).

Также есть метод clear, который такой же, как delete_all, за исключением того, что он возвращает ассоциацию, а не записи, которые были удалены.

Что удаляется?

Здесь есть потенциальная проблема: has_and_belongs_to_many и has_many :through ассоциации содержат записи в таблицах соединения, а также связанные записи. Итак, когда мы вызываем один из этих методов удаления, что именно должно быть удалено?

Ответ заключается в том, что предполагается, что удаление по ассоциации заключается в удалении связи между владельцем и связанным(ыми) объектом(ами), а не обязательно самих связанных объектов. Итак, с has_and_belongs_to_many и has_many :through, записи в таблице соединения будут удалены, но сами связанные записи — нет.

Это имеет смысл, если подумать: если вы вызовете post.tags.delete(Tag.find_by(name: 'food')), вы захотите разорвать связь метки «еда» со статьей, а не удалять саму метку из базы данных.

Однако есть примеры, где эта стратегия не имеет смысла. Например, предположим, что у человека есть много проектов, а каждый проект имеет много задач. Если мы удалили одну из задач человека, мы, вероятно, не захотим удалить проект. В этой ситуации метод удаления фактически не сработает: он может быть использован только в том случае, если ассоциация в модели соединения является belongs_to. В других ситуациях ожидается, что вы будете выполнять операции непосредственно на связанных записях или на ассоциации :through.

В случае обычной has_many нет различия между «связанными записями» и «связью», поэтому есть только один вариант того, что будет удалено.

В случае has_and_belongs_to_many и has_many :through, если вы хотите удалить связанные записи сами, вы всегда можете сделать что-то вроде person.tasks.each(&:destroy).

Безопасность типов с ActiveRecord::AssociationTypeMismatch

Если вы попытаетесь назначить объект ассоциации, которая не соответствует выведенному или указанному :class_name, вы получите ActiveRecord::AssociationTypeMismatch.

Параметры

Все макросы ассоциаций можно специализировать с помощью параметров. Это делает случаи более сложными, чем простые и предсказуемые.