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 關聯可用於描述模型之間的一對一、一對多和多對多關聯性。每個模型會使用關聯來描述其在關聯性中的角色。

一對一

在基礎部分使用 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

多對多

建立多對多關聯性的方法有兩種。

第一種方式是使用帶有 :through 選項和聯結模型的 has_many 關聯，因此會有兩個關聯階段。

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

未儲存的物件和相關性

可以在物件和相關性儲存至資料庫前對其進行操作，但有一些特別的行為您應該知道，主要與關聯物件的儲存有關。

您可以設定 has_one、belongs_to、has_many 或 has_and_belongs_to_many 相關性的 :autosave 選項。將其設為 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 Many 關聯，以便使用明確的加入模型來擷取資料。這與 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，最好是在 belongs_to 中設定 :inverse_of 選項，代表以下範例能正常運作（而其中 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

此方法使用類型欄位搭配外來金鑰來指定關聯記錄。在 Asset 範例中，您需要 attachable_id 整數欄位及 attachable_type 字串欄位。

將多型關聯與單一表格繼承（STI）搭配使用時會稍微 tricky 一些。為了讓關聯如預期運作，請務必在多型關聯的類型欄位中儲存 STI 模型的基礎模型。繼續使用上面的資產範例，假設我們有使用 post 表格 for STI 的客座貼文及會員貼文。在這種情況下，post 表格中必須有一個 type 欄位。

注意：在指派 attachable 時會呼叫 attachable_type= 方法。attachable 的 class_name 會作為 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|

這是指也使用 :author 符號的 belongs_to 關聯關係的名稱。在載入文章後，find 會從每篇文章中收集 author_id，並使用一個查詢載入所有參考到的作者。這樣做會將查詢數量從 201 減少到 102。

我們可透過在 finder 中同時參考兩個關聯關係讓情況更進一步，使用

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

這樣會使用單一查詢載入所有留言。這將總查詢數量減少到 3。通常，查詢數量會等於 1 加上命名的關聯關係數量（除非某些關聯關係是多型 belongs_to - 請參閱下方）。

若要包含多層階的關聯關係，請使用 hash

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

上述程式碼會載入所有留言及其所有相關的作者與大頭貼。您可以混合和搭配任何符號、陣列和 hash 組合，以擷取您想載入的關聯關係。

所有這些功能不應讓您誤以為可以因為減少了查詢數量，而毫不費力地擷取大量資料。資料庫仍需要將所有資料傳送給 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" 則不會。

如果您想要載入所有文章（包括沒有已核准留言的文章），請使用 ON 撰寫自己的 LEFT OUTER JOIN 查詢

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 個查詢。要載入的對應對象類型清單會在載入的地址之後決定。如果 Activa Record 必須降回使用過往的 eager 載入實作，這將不受支援，並且會產生 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 方法來指定您自己的自訂加入，這些表格名稱將優先於 eager 關聯

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

Dungeon 上的 traps 關聯和 Trap 上的 dungeon 關聯是彼此的相反，而 EvilWizard 上的 dungeon 關聯的相反則是 Dungeon 上的 evil_wizard 關聯 (反之亦然)。預設上，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 關聯指南。

從關聯中刪除

依賴關聯

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 方法，以執行 callback。然而，delete 和 delete_all 會根據 :dependent 選項指定的策略執行刪除，或是在沒有提供 :dependent 選項的情況下，遵循預設策略。預設策略是除了 has_many :through 外什麼都不做（讓外來鍵保持設定為父類型的識別碼），delete_all 為 has_many :through 的預設策略（刪除關聯記錄，而不執行它們的 callback）。

還有一個 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'))，你會想要從文章中取消和「food」標籤的連結，而不是從資料庫中移除標籤本身。

不過，在某些案例中，此策略並不明智。例如，假設一個人有很多專案，而且每個專案都有很多任務。如果我們刪除某個人的其中一個任務，我們或許不會想要刪除這個專案。在此情況下，刪除方法根本不起作用：它只能在關聯模型上的關聯是 belongs_to 時使用。在其他情況下，你應該直接對關聯記錄或 :through 關聯執行操作。

對於一般的 has_many，不會區分「關聯記錄」和「連結」，因此只有一個選項可以刪除哪些項目。

對於 has_and_belongs_to_many 和 has_many :through，如果你想自行刪除關聯記錄，永遠可以執行類似 person.tasks.each(&:destroy) 的操作。

具備 ActiveRecord::AssociationTypeMismatch 的類型安全

如果你嘗試將物件指定給與推論或指定的 :class_name 不相符的關聯，會收到 ActiveRecord::AssociationTypeMismatch。

選項

可以使用選項調整所有關聯巨集。這讓比簡單和可預測的案例更加複雜的案例得以實現。

class Post < ActiveRecord::Base
  belongs_to :author
end

post = Post.find(7)
author = Author.find(19)

post.author           # similar to Author.find(post.author_id)
post.author = author  # similar to post.author_id = author.id
post.build_author     # similar to post.author = Author.new
post.create_author    # similar to post.author = Author.new; post.author.save; post.author
post.create_author!   # similar to post.author = Author.new; post.author.save!; post.author
post.reload_author
post.reset_author
post.author_changed?
post.author_previously_changed?

belongs_to :firm, -> { where(id: 2) }
belongs_to :user, -> { joins(:friends) }
belongs_to :level, ->(game) { where("game_level > ?", game.current_level) }

belongs_to :firm, foreign_key: "client_of"
belongs_to :person, primary_key: "name", foreign_key: "person_name"
belongs_to :author, class_name: "Person", foreign_key: "author_id"
belongs_to :valid_coupon, ->(o) { where "discounts > ?", o.payments_count },
                          class_name: "Coupon", foreign_key: "coupon_id"
belongs_to :attachable, polymorphic: true
belongs_to :project, -> { readonly }
belongs_to :post, counter_cache: true
belongs_to :comment, touch: true
belongs_to :company, touch: :employees_last_updated_at
belongs_to :user, optional: true
belongs_to :account, default: -> { company.account }
belongs_to :account, strict_loading: true
belongs_to :note, query_constraints: [:organization_id, :note_id]

# File activerecord/lib/active_record/associations.rb, line 1689
def belongs_to(name, scope = nil, **options)
  reflection = Builder::BelongsTo.build(self, name, scope, options)
  Reflection.add_reflection self, name, reflection
end

class CreateDevelopersProjectsJoinTable < ActiveRecord::Migration[8.0]
  def change
    create_join_table :developers, :projects
  end
end

class Developer < ActiveRecord::Base
  has_and_belongs_to_many :projects
end

developer = Developer.find(11)
project   = Project.find(9)

developer.projects
developer.projects << project
developer.projects.delete(project)
developer.projects.destroy(project)
developer.projects = [project]
developer.project_ids
developer.project_ids = [9]
developer.projects.clear
developer.projects.empty?
developer.projects.size
developer.projects.find(9)
developer.projects.exists?(9)
developer.projects.build  # similar to Project.new(developer_id: 11)
developer.projects.create # similar to Project.create(developer_id: 11)
developer.projects.reload

has_and_belongs_to_many :projects, -> { includes(:milestones, :manager) }
has_and_belongs_to_many :categories, ->(post) {
  where("default_category = ?", post.default_category)
}

has_and_belongs_to_many :contractors 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

has_and_belongs_to_many :projects
has_and_belongs_to_many :projects, -> { includes(:milestones, :manager) }
has_and_belongs_to_many :nations, class_name: "Country"
has_and_belongs_to_many :categories, join_table: "prods_cats"
has_and_belongs_to_many :categories, -> { readonly }
has_and_belongs_to_many :categories, strict_loading: true

# File activerecord/lib/active_record/associations.rb, line 1870
        def has_and_belongs_to_many(name, scope = nil, **options, &extension)
          habtm_reflection = ActiveRecord::Reflection::HasAndBelongsToManyReflection.new(name, scope, options, self)

          builder = Builder::HasAndBelongsToMany.new name, self, options

          join_model = builder.through_model

          const_set join_model.name, join_model
          private_constant join_model.name

          middle_reflection = builder.middle_reflection join_model

          Builder::HasMany.define_callbacks self, middle_reflection
          Reflection.add_reflection self, middle_reflection.name, middle_reflection
          middle_reflection.parent_reflection = habtm_reflection

          include Module.new {
            class_eval <<-RUBY, __FILE__, __LINE__ + 1
              def destroy_associations
                association(:#{middle_reflection.name}).delete_all(:delete_all)
                association(:#{name}).reset
                super
              end
            RUBY
          }

          hm_options = {}
          hm_options[:through] = middle_reflection.name
          hm_options[:source] = join_model.right_reflection.name

          [:before_add, :after_add, :before_remove, :after_remove, :autosave, :validate, :join_table, :class_name, :extend, :strict_loading].each do |k|
            hm_options[k] = options[k] if options.key? k
          end

          has_many name, scope, **hm_options, &extension
          _reflections[name].parent_reflection = habtm_reflection
        end

class Firm < ActiveRecord::Base
  has_many :clients
end

firm = Firm.find(2)
client = Client.find(6)

firm.clients                       # similar to Client.where(firm_id: 2)
firm.clients << client
firm.clients.delete(client)
firm.clients.destroy(client)
firm.clients = [client]
firm.client_ids
firm.client_ids = [6]
firm.clients.clear
firm.clients.empty?                # similar to firm.clients.size == 0
firm.clients.size                  # similar to Client.count "firm_id = 2"
firm.clients.find                  # similar to Client.where(firm_id: 2).find(6)
firm.clients.exists?(name: 'ACME') # similar to Client.exists?(name: 'ACME', firm_id: 2)
firm.clients.build                 # similar to Client.new(firm_id: 2)
firm.clients.create                # similar to Client.create(firm_id: 2)
firm.clients.create!               # similar to Client.create!(firm_id: 2)
firm.clients.reload

has_many :comments, -> { where(author_id: 1) }
has_many :employees, -> { joins(:address) }
has_many :posts, ->(blog) { where("max_post_length > ?", blog.max_post_length) }

has_many :employees 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

has_many :comments, -> { order("posted_on") }
has_many :comments, -> { includes(:author) }
has_many :people, -> { where(deleted: false).order("name") }, class_name: "Person"
has_many :tracks, -> { order("position") }, dependent: :destroy
has_many :comments, dependent: :nullify
has_many :tags, as: :taggable
has_many :reports, -> { readonly }
has_many :subscribers, through: :subscriptions, source: :user
has_many :subscribers, through: :subscriptions, disable_joins: true
has_many :comments, strict_loading: true
has_many :comments, query_constraints: [:blog_id, :post_id]
has_many :comments, index_errors: :nested_attributes_order

# File activerecord/lib/active_record/associations.rb, line 1302
def has_many(name, scope = nil, **options, &extension)
  reflection = Builder::HasMany.build(self, name, scope, options, &extension)
  Reflection.add_reflection self, name, reflection
end

class Account < ActiveRecord::Base
  has_one :beneficiary
end

account = Account.find(5)
beneficiary = Beneficiary.find(8)

account.beneficiary               # similar to Beneficiary.find_by(account_id: 5)
account.beneficiary = beneficiary # similar to beneficiary.update(account_id: 5)
account.build_beneficiary         # similar to Beneficiary.new(account_id: 5)
account.create_beneficiary        # similar to Beneficiary.create(account_id: 5)
account.create_beneficiary!       # similar to Beneficiary.create!(account_id: 5)
account.reload_beneficiary
account.reset_beneficiary

has_one :author, -> { where(comment_id: 1) }
has_one :employer, -> { joins(:company) }
has_one :latest_post, ->(blog) { where("created_at > ?", blog.enabled_at) }

has_one :credit_card, dependent: :destroy  # destroys the associated credit card
has_one :credit_card, dependent: :nullify  # updates the associated records foreign
                                              # key value to NULL rather than destroying it
has_one :last_comment, -> { order('posted_on') }, class_name: "Comment"
has_one :project_manager, -> { where(role: 'project_manager') }, class_name: "Person"
has_one :attachment, as: :attachable
has_one :boss, -> { readonly }
has_one :club, through: :membership
has_one :club, through: :membership, disable_joins: true
has_one :primary_address, -> { where(primary: true) }, through: :addressables, source: :addressable
has_one :credit_card, required: true
has_one :credit_card, strict_loading: true
has_one :employment_record_book, query_constraints: [:organization_id, :employee_id]

# File activerecord/lib/active_record/associations.rb, line 1498
def has_one(name, scope = nil, **options)
  reflection = Builder::HasOne.build(self, name, scope, options)
  Reflection.add_reflection self, name, reflection
end