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

未保存的对象和关联

您可以在将对象和关联保存到数据库之前对其进行操作，但应该注意一些特殊行为，主要涉及关联对象的保存。

您可以在 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 之类的调用。

关联连接模型

Has Many 关联可以使用 :through 选项进行配置，以使用显式连接模型来检索数据。它的操作方式类似于 has_and_belongs_to_many 关联。优势在于您能够在连接模型上添加验证、回调和额外属性。考虑以下模式

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

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

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

您也可以通过连接模型上的 has_many 关联进行操作

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

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

class Invoice < ActiveRecord::Base
  belongs_to :client
end

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

类似地，您也可以通过连接模型上的 has_one 关联进行操作

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

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

class Avatar < ActiveRecord::Base
  belongs_to :user
end

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

通过连接模型上的 has_one 或 has_many 关联进行操作的一个重要警告是，这些关联是只读的。例如，以下操作在前面的示例之后将不起作用

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

设置逆关系

如果您在连接模型上使用 belongs_to，建议在 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 Associations 指南。

自动猜测反向关联使用基于类名的启发式方法，因此它可能不适用于所有关联，特别是那些具有非标准名称的关联。

您可以通过将 :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) 结合使用有点棘手。为了使关联按预期工作，请确保将 STI 模型的基础模型存储在多态关联的类型列中。继续上面的资产示例，假设存在使用 posts 表进行 STI 的访客帖子和成员帖子。在这种情况下，posts 表中必须有一个 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

要遍历这 100 个帖子，我们将生成 201 个数据库查询。首先，让我们只针对检索作者进行优化

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

这引用了也使用 :author 符号的 belongs_to 关联的名称。加载帖子后，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|

上面的代码将加载所有评论以及所有关联的作者和 gravatar。您可以混合匹配任何符号、数组和哈希的组合来检索要加载的关联。

所有这些功能不应该让你误以为你可以提取大量数据而不会有任何性能损失，仅仅因为你减少了查询次数。数据库仍然需要将所有数据发送到 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 个查询。要加载的可寻址类型列表是根据加载的地址决定的。如果 Active Record 必须回退到以前实现的预加载，则不支持此功能，并将引发 ActiveRecord::EagerLoadPolymorphicError。原因是父模型的类型是列值，因此其相应的表名不能放在该查询的 FROM/JOIN 子句中。

表别名

Active Record 在表在连接中被多次引用时使用表别名。如果表只被引用一次，则使用标准表名。第二次，表被别名为 #{reflection_name}_#{parent_table_name}。索引附加到任何后续使用表名的操作中。

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

充当树示例

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

Has and Belongs to Many 连接表使用相同的思路，但添加了 _join 后缀

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

如果您希望使用 ActiveRecord::QueryMethods#joins 方法指定您自己的自定义连接，这些表名将优先于预加载关联

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

表别名会根据特定数据库自动截断，以符合表标识符的最大长度。

模块

默认情况下，关联将在当前模块范围内查找对象。考虑

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

    class Client < ActiveRecord::Base; end
  end
end

当调用 Firm#clients 时，它将依次调用 MyApplication::Business::Client.find_all_by_firm_id(firm.id)。如果您想与另一个模块范围内的类关联，可以通过指定完整的类名来实现。

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

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

双向关联

当您指定关联时，关联模型上通常会有一个关联，它以相反的方式指定相同的关联。例如，使用以下模型

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

class Trap < ActiveRecord::Base
  belongs_to :dungeon
end

class EvilWizard < ActiveRecord::Base
  belongs_to :dungeon
end

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 Associations 指南。

从关联中删除

依赖关联

has_many、has_one 和 belongs_to 关联支持 :dependent 选项。这允许您指定在删除所有者时应删除关联记录。

例如

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

:dependent 选项可以具有不同的值，这些值指定删除操作的执行方式。有关更多信息，请参阅不同特定关联类型的此选项的文档。如果没有给出选项，则在销毁记录时，行为是不会对关联记录执行任何操作。

请注意，:dependent 是使用 Rails 的回调系统实现的，该系统通过按顺序处理回调来工作。因此，在 :dependent 选项之前或之后声明的其他回调会影响其执行方式。

请注意，:dependent 选项被忽略，因为 has_one :through 关联。

删除或销毁？

has_many 和 has_and_belongs_to_many 关联具有 destroy、delete、destroy_all 和 delete_all 方法。

对于 has_and_belongs_to_many，delete 和 destroy 是相同的：它们会导致连接表中的记录被删除。

对于 has_many，destroy 和 destroy_all 始终会调用要删除的记录的 destroy 方法，以便运行回调。但是 delete 和 delete_all 则会根据 :dependent 选项指定的策略进行删除，或者如果没有给出 :dependent 选项，则会遵循默认策略。默认策略是无操作（保留带有父 ID 的外键），除了 has_many :through，其默认策略是 delete_all（删除连接记录，不运行其回调）。

还存在一个 clear 方法，它与 delete_all 相同，只是它返回关联而不是已删除的记录。

删除什么？

这里存在一个潜在的陷阱：has_and_belongs_to_many 和 has_many :through 关联在联接表中具有记录，以及关联的记录。因此，当我们调用这些删除方法之一时，究竟应该删除什么？

答案是，假设对关联的删除是关于移除所有者和关联对象之间的链接，而不是必需的关联对象本身。因此，对于 has_and_belongs_to_many 和 has_many :through，联接记录将被删除，但关联记录不会被删除。

如果您仔细考虑，这很有道理：如果您要调用 post.tags.delete(Tag.find_by(name: 'food'))，您希望“食物”标签与帖子解除关联，而不是从数据库中删除标签本身。

但是，有些例子表明这种策略没有意义。例如，假设一个人拥有许多项目，每个项目都有许多任务。如果我们删除了一个人的任务，我们可能不希望项目被删除。在这种情况下，delete 方法实际上不起作用：只有当联接模型上的关联是 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