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

Ассоциации — это набор макроподобных методов класса для связывания объектов через внешние ключи. Они выражают отношения, такие как «Проект имеет одного менеджера проекта» или «Проект принадлежит портфелю». Каждый макрос добавляет ряд методов в класс, которые специализируются в зависимости от коллекции или символа ассоциации и хэша опций. Он работает почти так же, как собственные методы 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#portfolio.nil?

• Project#project_manager, Project#project_manager=(project_manager), Project#project_manager.nil?,

• 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

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

                                  |       |          | 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 при работе со схемами legacy или когда вы никогда напрямую не работаете с самим отношением.

Это ассоциация 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 int NOT NULL auto_increment,
  account_id int default NULL,
  name varchar default NULL,
  PRIMARY KEY  (id)
)

CREATE TABLE accounts (
  id int 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 Project
  has_and_belongs_to_many :developers, after_add: :evaluate_velocity

  def evaluate_velocity(developer)
    ...
  end
end

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

class Project
  has_and_belongs_to_many :developers,
                          after_add: [:evaluate_velocity, Proc.new { |p, d| p.shipping_date = Time.now}]
end

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

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

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

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

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

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 внутри расширений ассоциаций.

Ассоциации с присоединяемыми моделями

Ассоциации «многие ко многим» могут быть настроены с опцией :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.

Дополнительные опции для ассоциаций, определённые в константе AssociationReflection::INVALID_AUTOMATIC_INVERSE_OPTIONS, также помешают автоматически находить обратную ссылку ассоциации.

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

Вы можете отключить автоматическое обнаружение обратных ссылок, установив опцию :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. Тип attachable передаётся как строка.

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(true).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)

Это выполнит один запрос для загрузки адресов и загрузит адресные данные с одним запросом на каждый тип адресных данных. Например, если все адресные данные являются либо класса Person, либо Company, тогда всего будет выполнено 3 запроса. Список типов адресных данных для загрузки определяется на основе загруженных адресов. Это не поддерживается, если 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

Таблицы соединения «многие ко многим» используют ту же идею, но добавляют суффикс _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:

• не работает со связями :through.

• не работает со связями :polymorphic.

• обратные связи для связей belongs_to и has_many игнорируются.

Для получения дополнительной информации см. документацию по параметру :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 не задан, следуют по умолчанию. По умолчанию ничего не делается (ключи внешнего ключа остаются со значениями идентификаторов родительских записей), за исключением связей 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.

Параметры

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