Ассоциации Active Record

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

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

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

project = Project.first
project.portfolio
project.portfolio = Portfolio.first
project.reload_portfolio

project.project_manager
project.project_manager = ProjectManager.first
project.reload_project_manager

project.milestones.empty?
project.milestones.size
project.milestones
project.milestones << Milestone.first
project.milestones.delete(Milestone.first)
project.milestones.destroy(Milestone.first)
project.milestones.find(Milestone.first.id)
project.milestones.build
project.milestones.create

project.categories.empty?
project.categories.size
project.categories
project.categories << Category.first
project.categories.delete(category1)
project.categories.destroy(category1)

Предостережение

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

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

См. также «Методы экземпляра публичного использования» ниже (из belongs_to) для получения более подробной информации.

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

                                  |            |  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

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

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

Ассоциации Active Record могут использоваться для описания отношений один-к-одному, один-ко-многим и много-ко-многим между моделями. Каждая модель использует ассоциацию для описания своей роли в отношении. Ассоциация 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

Примечание: Объединение или жадное загрузка таких ассоциаций невозможны, поскольку эти операции происходят до создания экземпляра. Такие ассоциации могут быть предварительно загружены, но это выполнит N+1 запросов, так как для каждой записи будет другой диапазон (аналогично предварительной загрузке полиморфных диапазонов).

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

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

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

  def congratulate_client(client)
    # ...
  end

  def log_after_remove(client)
    # ...
  end
end

Callbacks могут быть определены тремя способами:

1. Символ, который ссылается на метод, определённый в классе с связанной коллекцией. Например, after_add: :congratulate_client вызывает Firm#congratulate_client(client).

2. Вызываемый объект со схемой, принимающей как запись с связанной коллекцией, так и запись, добавляемую или удаляемую. Например, after_add: ->(firm, client) { ... }.

3. Объект, который отвечает на имя обработчика событий. Например, передача after_add: CallbackObject.new вызывает CallbackObject#after_add(firm, client).

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

class CallbackObject
  def after_add(firm, client)
    firm.log << "after_adding #{client.id}"
  end
end

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

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

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

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

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

• firm.clients.destroy(client)

• firm.clients.destroy(*clients)

• firm.clients.destroy_all

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

• firm.clients.delete(client)

• firm.clients.delete(*clients)

• firm.clients.delete_all

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

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

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.

Параметры :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. Тип 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

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

Address.includes(:addressable)

Это выполнит один запрос для загрузки адресов и загрузит адресабельныe элементы с одним запросом на каждый тип адресабельного элемента. Например, если все адресабельные элементы относятся к классу 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 и руководство по ассоциациям Active Record Active Record Associations guide.

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

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

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.

Параметры

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