---
title: "RailsのAssociation（関連付け）とは？6種類の使い分けと発行SQLを実測で解説【Rails 8.1.4】"
url: "https://www.issoh.co.jp/tech/details/2883/"
published: 2024-07-02
updated: 2026-11-01
categories: ["Ruby on Rails"]
publisher: "株式会社一創"
---

# RailsのAssociation（関連付け）とは？6種類の使い分けと発行SQLを実測で解説【Rails 8.1.4】

RailsのAssociation（アソシエーション、日本語版ガイドでは「関連付け」）は、モデル同士のつながりをクラスに宣言する仕組みです。`has_many :comments` と1行書けば `post.comments` が使えるようになり、`Comment.where(post_id: post.id)` を毎回書かずに済みます。

ただ、宣言は1行でも、裏で発行されるSQLは操作ごとに違います。`delete` がレコードを消さない、`joins` の後でN+1が復活する、`has_one` を差し替えると古い行が宙に浮く。この記事では6種類の関連付けの選び方を整理したうえで、activerecord 8.1.4（2026年9月24日公開）とSQLiteで各操作を実行し、取得したログを基に、SQLの種類・クエリ数・主要な条件を抜粋して載せています。

## まとめ

- 関連付けは `belongs_to`・`has_one`・`has_many`・`has_many :through`・`has_one :through`・`has_and_belongs_to_many` の6種類。外部キーカラムを持つ側に `belongs_to` を書きます。
- `config.load_defaults` が5.0以降なら `belongs_to` は必須で、関連先が無いと「Post must exist」で保存できません。
- dependent 未指定で外部キーがNULL許可の `has_many` では、`post.comments.delete(c)` は外部キーを `NULL` にする `UPDATE` で、行は残ります。消すなら `destroy` です。
- 多対多は `has_many :through` を既定にします。`has_and_belongs_to_many` の結合テーブルに追加属性を持たせる使い方は非推奨です。
- 一覧のN+1は `preload`（2クエリ）か `eager_load`（LEFT OUTER JOINの1クエリ）で消します。`joins` は関連先を読み込まないので、参照すると1件ごとにクエリが出ます。
- 関連の有無で絞るなら `where.associated`・`where.missing`、使われなくなった関連付けの洗い出しには Rails 8.1 の `deprecated: true` が使えます。

## 関連付けの役割とActive Recordが追加するメソッド

関連付けの実体は、モデルクラスへのメソッド定義です。Active Record 自体の仕組みは[Active Record（アクティブレコード）とは？仕組みと発行SQL・N+1・検証の落とし穴を実行して解説](/tech/details/2913/)で扱っているので、ここでは関連付けが何を足すかに絞ります。

### 関連付けを書かない場合との差分

```
# 関連付けなし
comments = Comment.where(post_id: @post.id)

# 関連付けあり
comments = @post.comments
```

差は行数より保守性に出ます。外部キー名を変えたとき、前者は全箇所を探して直しますが、後者はモデルの宣言を1行直せば済みます。テーブル同士のつながりをモデルに集めるための宣言、と捉えると分かりやすいでしょう。

### 宣言1行で追加されるメソッドの一覧

8.1.4で `instance_methods` を調べると、宣言ごとに次のメソッドが追加されていました（自動保存・検証用の内部メソッドは除外）。

- `belongs_to :post` … `post`、`post=`、`build_post`、`create_post`、`create_post!`、`reload_post`、`reset_post`、`post_changed?`、`post_previously_changed?`
- `has_one :profile` … `profile`、`profile=`、`build_profile`、`create_profile`、`create_profile!`、`reload_profile`、`reset_profile`
- `has_many :comments` … `comments`、`comments=`、`comment_ids`、`comment_ids=`

`has_many` のメソッドが4つしかないのは、`build`・`create`・`delete` などが `post.comments` の返すコレクションプロキシ側に生えているからです。`belongs_to` 側の `post_changed?` は、関連先を差し替えたかを保存前に判定できます。

### アソシエーション・リレーション・ActiveRecord::Relationの違い

3語は指す層が違います。リレーショナルモデルのリレーションは、同じ属性構成を持つタプルの集合で、表として表現されます。テーブル間の参照関係そのものを指す用語ではありません。アソシエーションは、モデル同士のつながりをRailsのモデルに宣言したもの。コード中の `ActiveRecord::Relation` は、`where` などで組み立て途中のクエリを表すオブジェクトで、テーブル間の関係とは別物です。`has_many` を書いてもDB側に制約はできません（後述）。

## 6種類の関連付けと外部キーの置き場所

[Rails公式ガイドの「Active Record Associations」](https://guides.rubyonrails.org/association%5Fbasics.html)（日本語版は[railsguides.jpの「Active Record の関連付け」](https://railsguides.jp/association%5Fbasics.html)）は6種類を定義しています。どれを選ぶかは、外部キーをどちらのテーブルに置くかと、相手が何件かでほぼ決まります。

| 宣言                          | 相手の件数 | 外部キーの位置  | 典型例                       |
| --------------------------- | ----- | -------- | ------------------------- |
| belongs\_to                 | 1     | 自分のテーブル  | Comment → Post            |
| has\_one                    | 0または1 | 相手のテーブル  | User → Profile            |
| has\_many                   | 0件以上  | 相手のテーブル  | Post → Comment            |
| has\_many :through          | 0件以上  | 中間テーブル   | Doctor → Patient          |
| has\_one :through           | 0または1 | 中間テーブル経由 | Supplier → AccountHistory |
| has\_and\_belongs\_to\_many | 0件以上  | 結合テーブルのみ | Assembly ⇔ Part           |

外部キーは「相手を1件だけ持つ側」に置きます。コメントは記事1件にぶら下がるので `comments.post_id` を持ち、その側が `belongs_to` です。記事側は件数が決まらないのでカラムを持てず、`has_many` か `has_one` になります。

## belongs\_toの実装：必須チェックと外部キーの指定

`belongs_to :post` と書くと、Active Record は自分のテーブルに `post_id` がある前提で `comment.post` を組み立てます。関連名は単数形です。

### load\_defaults 5.0以降の必須チェックとoptional: true

必須かどうかは `config.active_record.belongs_to_required_by_default` が決め、[Configuring Rails Applications](https://guides.rubyonrails.org/configuring.html#config-active-record-belongs-to-required-by-default)によれば `load_defaults` 5.0以降の既定は `true` です。この設定で `post_id` 無しのコメントを検証すると `valid?` は `false`、エラーは「Post must exist」でした。存在しないID（9999）を入れた場合も、同じエラーで保存できませんでした。

```
class Comment < ApplicationRecord
  # 記事に紐づかない下書きを許すときだけ付ける
  belongs_to :post, optional: true
end
```

`optional: true` はモデルの検証を外すだけです。`rails g model Comment post:references` が作るマイグレーションは `null: false` 付きなので、そのまま `post_id` 無しで保存すると今度はDBが `ActiveRecord::NotNullViolation` を返しました。関連先が後から決まる下書きやインポート待ちのデータでだけ、カラム側の `null: false` も外して使います。「検証エラーが出たから付ける」は、参照先を失った行を増やすだけです。

### class\_name・foreign\_keyを明示する条件

規約から外れるのは、同じテーブルを別の役割で複数回参照する場合と、既存DBのカラム名が規約と違う場合です。

```
class Request < ApplicationRecord
  belongs_to :applicant, class_name: "User"
  belongs_to :approver,  class_name: "User", foreign_key: "approved_by_id"
end
```

`belongs_to :approver` は `approver_id` を探すので、カラムが `approved_by_id` なら `foreign_key` が要ります。`foreign_key` を書くと後述の `inverse_of` の自動検出が止まる点も、ここでセットで覚えておくと事故を防げます。

### DBの外部キー制約との役割分担

`belongs_to` はアプリ側の宣言で、それ自体はDBに `FOREIGN KEY` を作りません。制約はマイグレーションの `foreign_key: true` で張ります。関連付けだけだと、SQLを直接流すバッチや別システムからの書き込みで存在しない `post_id` が入ります。逆に制約だけでは、フォームに分かりやすいエラーを返せません。両方を用意してください。`references` 型のジェネレータが生成するファイルの中身は[Railsジェネレータ（rails generate）の使い方｜生成ファイル一覧と取り消し・カスタム生成](/tech/details/2874/)で確認できます。

## has\_oneの実装と差し替え時に古い行が残る挙動

`has_one` は1対1の「持つ側」に書き、外部キーは相手（例では `profiles.user_id`）にあります。`has_one` の宣言だけではDB上の重複を防げないため、1ユーザー1プロフィールを保証するなら、このカラムに一意インデックスも設定します。`belongs_to` との書き分けは、公式ガイドの「belongs\_to vs has\_one」にある通り、外部キーを持つほうが `belongs_to` です。

見落としやすいのは、既にプロフィールを持つユーザーに `user.profile = Profile.new(...)` で新しい行を代入したときです。8.1.4で実行すると、設定ごとに結果が分かれました。

| Profile側・has\_one側の設定       | 発行SQL                           | 古いプロフィール            |
| --------------------------- | ------------------------------- | ------------------- |
| dependent 無し・belongs\_to 任意 | UPDATE（user\_id を NULL）→ INSERT | user\_id が NULL で残る |
| dependent: :destroy         | SELECT → DELETE → INSERT        | 削除                  |
| dependent 無し・belongs\_to 必須 | 例外で中断                           | そのまま残る              |

3行目では `ActiveRecord::RecordNotSaved`（Failed to remove the existing associated profile. The record failed to save after its foreign key was set to nil.）が上がりました。古い行の外部キーを `nil` にして保存しようとし、Profile 側の必須チェックに落ちたためです。1対1で差し替えが起きるモデルには、`dependent: :destroy` を指定します。削除コールバックを実行しなくてよい場合に限り `:delete` も選べます。古いプロフィールを履歴として残す要件なら、削除せず履歴用の関連を設計してください。

## has\_manyの実装とコレクション操作の発行SQL

`has_many` は宣言より、返ってくるコレクションの操作で詰まります。

### マイグレーションからモデル定義までの手順

```
$ bin/rails g model Comment body:text post:references
$ bin/rails db:migrate

# app/models/post.rb（has_many は手で追記する）
class Post < ApplicationRecord
  has_many :comments, dependent: :destroy
end
```

`post:references` は Comment 側のカラム・インデックス・外部キー制約・`belongs_to` まで用意しますが、Post 側の `has_many` は書きません。

### 追加・削除メソッドごとのSQL（実測）

次の表は直前の実装例と条件が違い、Post 側の `dependent` を未指定、`comments.post_id` をNULL許可にした検証用スキーマでの結果です。保存済みの記事に対して各メソッドを呼び、トランザクションのBEGIN／COMMITを除いた本体のSQLを並べました。

| 呼び出し                   | 発行SQL                  | 結果     |
| ---------------------- | ---------------------- | ------ |
| comments.build(…)      | なし                     | メモリ上だけ |
| comments.create(…)     | INSERT                 | 即保存    |
| comments << 未保存の子      | INSERT                 | 即保存    |
| comments << 他記事の保存済みの子 | UPDATE post\_id        | 付け替え   |
| comments.delete(c)     | UPDATE post\_id = NULL | 行は残る   |
| comments.destroy(c)    | DELETE                 | 削除     |
| comments.clear         | UPDATE（全件 NULL）        | 行は残る   |

事故になりやすいのは `delete` と `clear` です。dependent を指定していない `has_many` では外部キーを `NULL` にするだけで、コメントは孤児として残りました。`post_id` が `null: false` の表では、同じ `delete` が `ActiveRecord::NotNullViolation` で落ちます。`delete` の挙動は dependent の設定で変わるので、消す意図なら設定に左右されない `destroy` を書くほうが読み違えません。

### size・count・lengthで変わるクエリ

件数の取り方でもSQLが変わります。未ロードのコレクションで `size` と `count` は `SELECT COUNT(*)` を1本、`length` は全件を `SELECT` して数えました。ロード済みなら `size` はクエリを出しません。迷ったら `size` を使い、毎回DBに数え直させたいときだけ `count` を書きます。

### dependentの値と親を削除したときのSQL

コメント3件を持つ記事を `destroy` したときの実測です。

| dependent                  | 発行SQL（BEGIN／COMMIT除く）           | 子の結果                |
| -------------------------- | ------------------------------- | ------------------- |
| :destroy                   | SELECT 1本 + DELETE 3本 + 親DELETE | 削除（コールバック実行）        |
| :delete\_all               | DELETE 1本 + 親DELETE             | 削除（コールバック無し）        |
| :nullify                   | UPDATE 1本 + 親DELETE             | post\_id が NULL で残る |
| :restrict\_with\_error     | SELECT 1 → ROLLBACK             | 親も子も残る              |
| :restrict\_with\_exception | SELECT 1 → ROLLBACK             | 例外で親も子も残る           |

`:destroy` は子の件数だけ `DELETE` が増えます。そのかわり子の `before_destroy` や添付ファイルの削除、孫への dependent が動きます。`:delete_all` は1本で済みますが、これらは一切動きません。子がコールバックも孫も持たない明細だと確認できたときだけ `:delete_all` にします。子が数万件あってもコールバックを動かしたいなら、Active Job で後から消す `:destroy_async` があります（ジョブ基盤が要るため今回は実行していません）。ただし公式ガイドは、DBの外部キー制約を張った関連付けでは使わないよう明記しています（制約の動作が親を消すトランザクション内で先に起きるため）。`foreign_key: true` 付きの構成には、そのまま適用できません。`:restrict_with_exception` は「Cannot delete record because of dependent comments」の `ActiveRecord::DeleteRestrictionError` を投げます。画面から呼ぶ削除では `:restrict_with_error` にして `errors` で理由を表示してください。

一覧に「コメントN件」を出すと記事ごとに `COUNT` が飛ぶので、件数を親のカラムに持つ `counter_cache` も検討します。後付け時の初期化とずれの直し方は[counter\_cacheとは？Railsでの実装手順とカウントずれ・後付けの対処](/tech/details/3727/)にまとめています。

## 多対多：has\_many :throughとhas\_and\_belongs\_to\_manyの選び方

医師と患者のように、どちらも相手を複数持つ関係は中間テーブルで表します。`has_many :through` は中間テーブルにもモデルを用意します。

```
class Appointment < ApplicationRecord
  belongs_to :doctor
  belongs_to :patient
end

class Doctor < ApplicationRecord
  has_many :appointments
  has_many :patients, through: :appointments
end
```

`doctor.patients << patient` は `appointments` への `INSERT`、`doctor.patients` は `INNER JOIN "appointments"` の1本でした。`doctor.patients.delete(patient)` が消すのは中間の `appointments` の行だけで、患者のレコードは残ります。予約日時のような属性を中間モデルに持たせ、`doctor.appointments.where(...)` で絞り込めるのが利点です。

### has\_and\_belongs\_to\_manyを選んでよい場合

`has_and_belongs_to_many` はモデルを持たない結合テーブル（`create_join_table :assemblies, :parts` で `assemblies_parts` ができます）だけで多対多を作ります。公式ガイドは結合テーブルに属性・検証・コールバックが要るなら `has_many :through` を使うよう勧め、「The use of extra attributes on the join table in a has\_and\_belongs\_to\_many association is deprecated.」とも書いています。新規設計では `has_many :through` を既定にしてください。「いつ所属したか」「兼務か」を後から持たせたくなった時点で、`has_and_belongs_to_many` から `has_many :through` への移行を検討します。既存の結合テーブルを再利用し、必要な主キー・属性と中間モデルを追加する方法もあります。選んでよいのは、既存のスキーマをそのまま扱う場合と、結合そのものに意味を持たせないと決まっている場合です。

## polymorphicとself joinの参照先設計

### polymorphicによる商品・社員への画像の関連付け

1つのモデルが複数種類の親にぶら下がる場合は、外部キーと型名の2カラムで相手を表す polymorphic を使います。

```
# マイグレーション: t.references :imageable, polymorphic: true
class Picture < ApplicationRecord
  belongs_to :imageable, polymorphic: true
end

class Product < ApplicationRecord
  has_many :pictures, as: :imageable
end
```

保存された行は `imageable_type = "Product"`・`imageable_id = 1` で、`product.pictures` は `WHERE "pictures"."imageable_id" = ? AND "pictures"."imageable_type" = ?` を発行しました。注意点は読み込み方です。`Picture.eager_load(:imageable)` は `ActiveRecord::EagerLoadPolymorphicError`（Cannot eagerly load the polymorphic association :imageable）で失敗し、`preload` は型ごとに別クエリを出して動きました。JOINの相手テーブルが行ごとに違うので、polymorphic は `preload` で読みます。DBの外部キー制約も張れないため、整合性はアプリ側の検証に頼ることになります。

### self joinによる社員・上司の同一テーブル参照

```
class Employee < ApplicationRecord
  has_many :subordinates, class_name: "Employee", foreign_key: "manager_id"
  belongs_to :manager, class_name: "Employee", optional: true
end
```

`boss.subordinates` は `WHERE "employees"."manager_id" = ?` の1本でした。最上位の社員には上司がいないので、`belongs_to` に `optional: true` が必要です。

## inverse\_ofの自動検出が効かない条件

`post.comments.first.post` のように往復したとき、同じオブジェクトが返るかは双方向関連の認識で決まります。標準的な命名なら自動で認識され、実測でも `equal?(post)` は `true` でした。公式ガイドの「Bi-directional Associations」によれば、`:through` と `:foreign_key` を使った関連付けでは自動認識されないことがあり、反対側のスコープも認識を止めます。関連付け自身のスコープは、`config.active_record.automatic_scope_inversing`（`load_defaults` 7.0以降の既定で `true`）なら推論されます。

`foreign_key: "approved_by_id"` の関連付けで確かめた結果です。

| 宣言             | user.approved\_requests.first.approver | 同一オブジェクト |
| -------------- | -------------------------------------- | -------- |
| inverse\_of 無し | users への SELECT が追加で1本                 | false    |
| inverse\_of 有り | 追加クエリなし                                | true     |

```
class Request < ApplicationRecord
  belongs_to :approver, class_name: "User",
             foreign_key: "approved_by_id", inverse_of: :approved_requests
end

class User < ApplicationRecord
  has_many :approved_requests, class_name: "Request",
           foreign_key: "approved_by_id", inverse_of: :approver
end
```

別オブジェクトになると、親で変えた未保存の値が子から見えない、ネストしたフォームの保存で親を参照すると古い値になる、といった形で症状が出ます。`foreign_key` を書いたら `inverse_of` も両側に書く、と決めておけば踏みません。

## N+1クエリを避ける読み込み方

一覧で各レコードの関連先を個別に読み込んでいるなら、まずN+1を疑い、SQLログでクエリ数を確認します。記事3件とコメントを表示するだけで、記事1本＋記事ごとのコメント3本の計4クエリが出ました。件数に比例して増えるので、100件なら101本です。ORM全般の検出方法は[N+1問題とは？発行クエリ数の実測と検出方法・ORM別の対策](/tech/details/4262/)で扱っています。

### preload・includes・eager\_load・joinsの発行SQL

| 書き方                                       | クエリ数   | 発行SQLの形                  |
| ----------------------------------------- | ------ | ------------------------ |
| preload(:comments)                        | 2      | WHERE post\_id IN (…)    |
| includes(:comments)                       | 2      | preload と同じ              |
| includes + where(comments: {…})           | 1      | LEFT OUTER JOIN に切替      |
| includes + where(“comments.approved = 1”) | 失敗     | no such column           |
| 上に references(:comments) を追加              | 1      | LEFT OUTER JOIN          |
| eager\_load(:comments)                    | 1      | LEFT OUTER JOIN          |
| joins + 後で comments を参照                   | 1 + 件数 | INNER JOIN + 1件ごとに COUNT |
| preload + where(comments: {…})            | 失敗     | no such column           |

表示するだけなら `preload` を第一候補にします。単純なクエリ2本で、実行計画も読みやすいからです。関連先の値で絞り込むなら `eager_load` に切り替えます。`includes` は条件の書き方で2本とJOINを行き来し、文字列の条件では `references` を足さないとJOINされずにSQLエラーになりました。意図が決まっているなら `preload` か `eager_load` を直接書くほうが、読み手に挙動が伝わります。

見落としやすい挙動が2つあります。1つは、`includes(:comments).where(comments: { approved: true })` の結果で `post.comments` を呼ぶと、承認済みの1件しか入っていなかったことです。JOINの条件で絞った子がそのまま関連にキャッシュされるので、全件のつもりで件数を表示すると数字が合いません。もう1つは `joins` で、絞り込みには効いても関連先を読み込まないため、その後の `post.comments.size` が1件ごとの `COUNT` に戻りました。`Post.joins(:comments).count` もコメント数ぶん重複して6を返し、記事数の3を得るには `distinct` が必要でした。

### strict\_loadingによる遅延読み込みの例外化

N+1は少量データの開発環境では体感できません。[Active Record クエリインターフェイスのガイド](https://guides.rubyonrails.org/active%5Frecord%5Fquerying.html#strict-loading)が説明する `strict_loading` を使うと、遅延読み込みそのものを例外にできます。

```
Post.strict_loading.first.comments.to_a
# => ActiveRecord::StrictLoadingViolationError:
#    `Post` is marked for strict_loading. The Comment association named `:comments` cannot be lazily loaded.

Post.strict_loading.preload(:comments).first.comments.to_a  # 例外なし

# モデル単位で常に有効にする
class Post < ApplicationRecord
  self.strict_loading_by_default = true
end
```

例外は関連先のレコードをロードした時点で出ます。`to_a` と `first` は例外になり、`comments.size` は `COUNT` が1本出るだけで通りました。`size` だけで動作確認すると、効いていないように見えます。既存アプリでいきなりアプリ全体（`config.active_record.strict_loading_by_default = true`）に掛けると大量に落ちるので、新規モデルと一覧系のクエリから足し、違反をログに流す `action_on_strict_loading_violation = :log` で範囲を測ってから広げてください。

## where.associated・where.missingによる関連の有無での絞り込み

「コメントが1件でも付いた記事」「著者の無い孤児レコード」を取るとき、`joins` や `left_joins` と `IS NULL` を手で組む必要はありません。Rails 6.1で `where.missing`、7.0で `where.associated` が入っています（[activerecord 7.0 の CHANGELOG](https://github.com/rails/rails/blob/7-0-stable/activerecord/CHANGELOG.md)）。

```
Post.where.missing(:comments).pluck(:title)
# SELECT "posts"."title" FROM "posts" LEFT OUTER JOIN "comments"
#   ON "comments"."post_id" = "posts"."id" WHERE "comments"."id" IS NULL

Post.where.associated(:comments).distinct.pluck(:title)
# SELECT DISTINCT "posts"."title" FROM "posts" INNER JOIN "comments"
#   ON "comments"."post_id" = "posts"."id" WHERE "comments"."id" IS NOT NULL
```

`where.associated` は `INNER JOIN` なので、コメントが2件ある記事は2行返ります。記事の一覧として使うなら `distinct` を付けます。`where.missing` は `dependent: :nullify` や `delete` で外部キーが `NULL` になった子の棚卸しにも使えます（`Comment.where.missing(:post)`）。

## 使われなくなった関連付けの棚卸し（Rails 8.1のdeprecatedオプション）

長く動くアプリには、誰も呼んでいない関連付けが残ります。消したくても、どこかのビューやジョブが参照していないか確かめられず放置されがちです。Rails 8.1.0（2025年10月22日）で入った `deprecated: true` は、この確認を実行時に肩代わりします。

```
class Author < ApplicationRecord
  has_many :books, deprecated: true
end
```

[activerecord 8.1 の CHANGELOG](https://github.com/rails/rails/blob/8-1-stable/activerecord/CHANGELOG.md)は「Three reporting modes are supported (:warn, :raise, and :notify), and backtraces can be enabled or disabled. Defaults are :warn mode and disabled backtraces.」と記しています。既定の `:warn` で4通りの参照を試すと、Active Record のロガーに次の警告が出ました。

```
The association Author#books is deprecated, the method books was invoked
The association Author#books is deprecated, referenced in query to preload records
The association Author#books is deprecated, referenced in query to join its table
The association Author#books is deprecated, referenced in query to join its table
```

上から `author.books`、`Author.preload(:books)`、`Author.joins(:books)`、`Author.where.associated(:books)` の順です。クエリ経由の参照も実行時に検出できます。ただし、観測期間中に実行されなかった処理は検出できないため、コード検索と併用してください。警告はロガー経由なので、Rails アプリなら `log/development.log` などに出ます。モードは [config.active\_record.deprecated\_associations\_options](https://guides.rubyonrails.org/configuring.html#config-active-record-deprecated-associations-options) で変え、`{ mode: :raise }` にすると同じ参照で `ActiveRecord::DeprecatedAssociationError` が上がりました。

運用は、本番を `:warn` で監視し、月次・年次ジョブや利用頻度の低い画面もコード検索とテストで確認したうえで削除し、テスト環境は `:raise` にして残った呼び出しをテスト失敗で見つける、という分担が向いています。「とりあえず全部に付ける」使い方は避けてください。警告が日常的に流れると、本当に消したい関連付けの信号が埋もれます。関連付けとスコープでモデルが膨らんだときの分割は[RailsのFat Model対策｜1500行model.rbを分割する4手法と判断基準](/tech/details/12933/)、共通化の判断は[RailsのConcernはアンチパターンか？使い方と判断基準](/tech/details/10329/)が参考になります。

## よくある質問

### モデルに定義済みのアソシエーションを一覧で確認する方法はありますか？

リフレクションAPIを使います。`Post.reflect_on_all_associations` は全関連付けのリフレクションを返し、`.map { |r| [r.macro, r.name] }` で `[[:has_many, :comments]]` のように種類と名前を取れます。`reflect_on_all_associations(:has_many)` と引数を渡せば種類で絞れ、名前だけなら `Post.reflections.keys` が手軽です。

### belongs\_toにthroughオプションは書けますか？

書けません。8.1.4で `belongs_to :supplier, through: :account` と書くと、クラスを読み込んだ時点で「Unknown key: :through」の `ArgumentError` になりました。中間モデル越しに1件の相手を取りたいときは `has_one :supplier, through: :account` を使います。発行されるのは `INNER JOIN "accounts"` の1本です。

### has\_and\_belongs\_to\_manyはもう使わないほうがよいですか？

新規設計では `has_many :through` を選んでください。`has_and_belongs_to_many` は廃止こそされていませんが、結合テーブルに追加の属性を持たせる使い方は公式に非推奨とされ、モデルが無いので検証やコールバックも書けません。既存の結合テーブルをそのまま扱う場合に限って使います。

### belongs\_toにforeign\_keyを指定するのはどんなときですか？

関連名から推測されるカラム名（`belongs_to :approver` なら `approver_id`）と、実際のカラム名が違うときです。指定すると `inverse_of` の自動検出が止まるので、両側に `inverse_of` も書きます。

### アソシエーションを使うと一覧表示が遅くなるのはなぜですか？

関連付け自体ではなく、1件ごとに関連先を読み込むN+1クエリが原因です。表示だけなら `preload`、関連先で絞り込むなら `eager_load` で先に読み込み、再発防止に `strict_loading` を使います。

## 関連記事

- [Active Record（アクティブレコード）とは？仕組みと発行SQL・N+1・検証の落とし穴を実行して解説【Rails 8.1.4】](/tech/details/2913/)
- [counter\_cacheとは？Railsでの実装手順とカウントずれ・後付けの対処](/tech/details/3727/)
- [N+1問題とは？発行クエリ数の実測と検出方法・ORM別の対策](/tech/details/4262/)
- [RailsのFat Model対策｜1500行model.rbを分割する4手法と判断基準](/tech/details/12933/)
- [RailsのConcernはアンチパターンか？使い方と判断基準【Rails 8.1で実測】](/tech/details/10329/)

---

出典: [RailsのAssociation（関連付け）とは？6種類の使い分けと発行SQLを実測で解説【Rails 8.1.4】](<https://www.issoh.co.jp/tech/details/2883/>)（株式会社一創）
