ActiveRecordマスターへの道：初級から上級までの書き方を網羅！

イントロダクション

ActiveRecordは、RubyのウェブアプリケーションフレームワークであるRuby on Railsの重要なコンポーネントです。オブジェクトリレーショナルマッピング（ORM）の機能を提供し、データベースとのやり取りを抽象化することで、開発者はSQLを直接書くことなく、Rubyのオブジェクトを通してデータベースを操作できます。

ActiveRecordを使うメリット

データベースとのやり取りが簡単になる
SQLを直接書く必要がなく、生産性が向上する
データベースに依存しないコードを書くことができる
リレーションシップを定義することで、関連するデータを簡単に取得できる
バリデーションやコールバックなどの機能により、データの整合性を保つことができる

本記事の目的と対象読者

この記事は、ActiveRecordの基本的な使い方から、高度なテクニックまでを網羅的に説明することを目的としています。サンプルアプリケーションを通して、実際の開発現場で役立つノウハウを提供します。

対象読者は、以下のような方々です：

Ruby on Railsを学び始めた初心者
ActiveRecordの基本は理解しているが、より深い知識を求めている中級者
ActiveRecordのベストプラクティスを学びたい上級者

初心者の方は、ActiveRecordの基本的な概念や使い方を学ぶことができます。中級者の方は、より効率的で可読性の高いコードを書くためのテクニックを身につけられるでしょう。上級者の方は、パフォーマンス最適化やテスト駆動開発などの高度なトピックについて学ぶことができます。

この記事を通して、読者の皆さんがActiveRecordのマスターになるための道を歩み始められることを願っています。それでは、さっそくサンプルアプリケーションを紹介しながら、ActiveRecordの世界に飛び込んでいきましょう！

サンプルアプリケーションの紹介

この記事では、ブログアプリケーションを例に、ActiveRecordの様々な機能を説明していきます。このアプリケーションには、以下のようなモデルが含まれています：

Userモデル：ブログの著者を表す
Postモデル：ブログ記事を表す
Commentモデル：ブログ記事に対するコメントを表す
Categoryモデル：ブログ記事のカテゴリを表す
Tagモデル：ブログ記事のタグを表す

モデル間のリレーションシップ

これらのモデル間には、以下のようなリレーションシップが存在します：

UserとPostは1対多の関係です。1人のユーザーが複数の記事を持つことができます。
PostとCommentは1対多の関係です。1つの記事に複数のコメントが付くことができます。
PostとCategoryは多対多の関係です。1つの記事が複数のカテゴリに属することができ、1つのカテゴリに複数の記事が属することができます。
PostとTagは多対多の関係です。1つの記事に複数のタグを付けることができ、1つのタグが複数の記事に付くことができます。

これらのリレーションシップを正しく定義することで、ActiveRecordの強力な機能を活用できます。次の章から、実際にコードを書きながら、ActiveRecordの使い方を学んでいきましょう。

基本的なActiveRecordの使い方

この章では、ActiveRecordの基本的な使い方について説明します。モデルの定義、レコードの作成・読み取り・更新・削除（CRUD操作）、バリデーション、コールバックなどを取り上げます。

モデルの定義

モデルを定義することは、ActiveRecordを使う上で欠かせません。モデルは、データベースのテーブルとRubyのオブジェクトをマッピングするための仕組みです。以下は、Userモデルの例です：

class User < ApplicationRecord
  has_many :posts
  has_many :comments
end

この例では、UserモデルがApplicationRecordを継承しています。ApplicationRecordは、Rails 5以降で導入された新しい基底クラスで、従来のActiveRecord::Baseの代わりに使われます。

また、has_manyメソッドを使って、UserとPost、UserとCommentの1対多の関係を定義しています。

レコードの作成、読み取り、更新、削除（CRUD操作）

ActiveRecordを使うと、レコードの作成、読み取り、更新、削除が簡単に行えます。

レコードの作成

createメソッドを使ってレコードを作成できます。

user = User.create(name: "John Doe", email: "john@example.com", password: "password")

また、newメソッドとsaveメソッドを組み合わせることもできます。

user = User.new
user.name = "John Doe"
user.email = "john@example.com"
user.password = "password"
user.save

レコードの読み取り

findメソッドを使ってレコードを読み取ることができます。

user = User.find(1)

このコードは、idが1のユーザーレコードを取得します。

レコードの更新

updateメソッドを使ってレコードを更新できます。

user = User.find(1)
user.update(email: "johndoe@example.com")

レコードの削除

destroyメソッドを使ってレコードを削除できます。

user = User.find(1)
user.destroy

バリデーションの追加

バリデーションを追加することで、データの整合性を保つことができます。以下は、Userモデルにバリデーションを追加する例です：

class User < ApplicationRecord
  has_many :posts
  has_many :comments

  validates :name, presence: true
  validates :email, presence: true, uniqueness: true
  validates :password, presence: true, length: { minimum: 6 }
end

この例では、name、email、passwordの存在チェック、emailの一意性チェック、passwordの最小文字数チェックを行っています。

コールバックの使用

コールバックを使うと、モデルのライフサイクルの特定の時点で処理を実行できます。以下は、Userモデルにコールバックを追加する例です：

class User < ApplicationRecord
  has_many :posts
  has_many :comments

  validates :name, presence: true
  validates :email, presence: true, uniqueness: true
  validates :password, presence: true, length: { minimum: 6 }

  before_save :encrypt_password

  private

  def encrypt_password
    self.password = BCrypt::Password.create(password)
  end
end

この例では、before_saveコールバックを使って、ユーザーのパスワードを保存前に暗号化しています。

フローチャートを使ったCRUD操作の流れの説明

以下は、ActiveRecordを使ったCRUD操作の流れをフローチャートで示したものです：

このフローチャートは、アプリケーションがActiveRecordを使ってレコードを操作する一連の流れを示しています。バリデーションが成功すればレコードが保存され、失敗すればエラーメッセージが表示されます。

以上が、ActiveRecordの基本的な使い方の概要です。次の章では、リレーションシップの定義について詳しく説明します。

リレーションシップの定義

ActiveRecordの強力な機能の1つが、リレーションシップを定義できることです。リレーションシップを使うと、モデル間の関連を簡単に表現でき、関連するデータを効率的に取得できます。

1対多のリレーションシップ

1対多のリレーションシップは、一方のモデルが他方のモデルの複数のインスタンスを持つ関係です。例えば、UserとPostの関係は1対多です。1人のユーザーが複数の記事を持つことができます。

以下は、UserとPostの1対多の関係を定義する例です：

class User < ApplicationRecord
  has_many :posts
end

class Post < ApplicationRecord
  belongs_to :user
end

has_manyメソッドを使って、Userが複数のPostを持つことを示しています。一方、belongs_toメソッドを使って、Postが1人のUserに属することを示しています。

多対多のリレーションシップ

多対多のリレーションシップは、両方のモデルが互いに複数のインスタンスを持つ関係です。例えば、PostとCategoryの関係は多対多です。1つの記事が複数のカテゴリに属することができ、1つのカテゴリに複数の記事が属することができます。

多対多の関係を定義するには、has_many :throughを使います。以下は、PostとCategoryの多対多の関係を定義する例です：

class Post < ApplicationRecord
  has_many :post_categories
  has_many :categories, through: :post_categories
end

class Category < ApplicationRecord
  has_many :post_categories
  has_many :posts, through: :post_categories
end

class PostCategory < ApplicationRecord
  belongs_to :post
  belongs_to :category
end

この例では、PostCategoryというモデルを介して、PostとCategoryの多対多の関係を実現しています。PostとCategoryはそれぞれhas_many :post_categoriesを持ち、throughオプションを使って、PostCategoryを経由して互いを参照しています。

リレーションシップのオプション

リレーションシップを定義する際、様々なオプションを指定できます。よく使われるオプションには以下のようなものがあります：

dependent：関連するレコードの削除方法を指定します。:destroyを指定すると、関連するレコードも一緒に削除されます。:delete_allを指定すると、関連するレコードはデータベースから直接削除されます。
foreign_key：外部キーの名前を指定します。デフォルトでは、関連するモデル名の単数形に_idを付けたものが使われます。
primary_key：関連先のモデルの主キーを指定します。デフォルトではidが使われます。
counter_cache：関連するレコードの数をキャッシュするためのカウンターキャッシュを有効にします。

以下は、UserとPostの1対多の関係にオプションを指定する例です：

class User < ApplicationRecord
  has_many :posts, dependent: :destroy
end

class Post < ApplicationRecord
  belongs_to :user, counter_cache: true
end

この例では、Userが削除されると、関連するPostも一緒に削除されます。また、Postが作成または削除されると、Userのposts_countというカラムが自動的に更新されます。

サンプルアプリケーションでのリレーションシップの実装

サンプルのブログアプリケーションでは、以下のようにリレーションシップを定義しています：

class User < ApplicationRecord
  has_many :posts, dependent: :destroy
  has_many :comments, dependent: :destroy
end

class Post < ApplicationRecord
  belongs_to :user
  has_many :comments, dependent: :destroy
  has_many :post_categories, dependent: :destroy
  has_many :categories, through: :post_categories
  has_many :post_tags, dependent: :destroy
  has_many :tags, through: :post_tags
end

class Comment < ApplicationRecord
  belongs_to :user
  belongs_to :post
end

class Category < ApplicationRecord
  has_many :post_categories, dependent: :destroy
  has_many :posts, through: :post_categories
end

class Tag < ApplicationRecord
  has_many :post_tags, dependent: :destroy
  has_many :posts, through: :post_tags
end

class PostCategory < ApplicationRecord
  belongs_to :post
  belongs_to :category
end

class PostTag < ApplicationRecord
  belongs_to :post
  belongs_to :tag
end

これらのリレーションシップを定義することで、モデル間の関連を簡単に扱えるようになります。例えば、Userモデルのpostsメソッドを呼び出すことで、そのユーザーが投稿した記事の一覧を取得できます。

次の章では、スコープとクラスメソッドについて説明します。

スコープとクラスメソッド

スコープとクラスメソッドは、ActiveRecordのモデルに関連する汎用的なクエリやビジネスロジックを定義するために使われます。スコープは、特定の条件に合うレコードのセットを返すメソッドで、チェーンして使うことができます。クラスメソッドは、モデルに関連する汎用的な処理を実装するために使われます。

スコープの定義と使用

スコープを定義するには、scopeメソッドを使います。以下は、Postモデルにpublishedスコープを定義する例です：

class Post < ApplicationRecord
  scope :published, -> { where(published: true) }
end

この例では、publishedスコープは、publishedカラムがtrueのレコードを返します。

スコープを使うには、モデルクラスからスコープ名を呼び出します。以下は、publishedスコープを使って公開済みの記事を取得する例です：

published_posts = Post.published

スコープはチェーンして使うことができます。以下は、publishedスコープとorderメソッドを組み合わせて、公開済みの記事を作成日時の降順で取得する例です：

latest_published_posts = Post.published.order(created_at: :desc)

クラスメソッドの定義と使用

クラスメソッドを定義するには、selfキーワードを使います。以下は、Postモデルにlatestクラスメソッドを定義する例です：

class Post < ApplicationRecord
  def self.latest(limit = 10)
    order(created_at: :desc).limit(limit)
  end
end

この例では、latestクラスメソッドは、作成日時の降順で指定された数（デフォルトは10）の記事を返します。

クラスメソッドを使うには、モデルクラスからクラスメソッド名を呼び出します。以下は、latestクラスメソッドを使って最新の5件の記事を取得する例です：

latest_posts = Post.latest(5)

スコープとクラスメソッドの組み合わせ

スコープとクラスメソッドを組み合わせることで、より柔軟で強力なクエリを実現できます。以下は、publishedスコープとlatestクラスメソッドを組み合わせて、公開済みの最新記事を取得する例です：

latest_published_posts = Post.published.latest

サンプルアプリケーションでのスコープとクラスメソッドの活用

サンプルのブログアプリケーションでは、以下のようにスコープとクラスメソッドを定義しています：

class Post < ApplicationRecord
  scope :published, -> { where(published: true) }
  scope :draft, -> { where(published: false) }
  scope :recent, -> { order(created_at: :desc) }

  def self.search(query)
    where("title LIKE ? OR content LIKE ?", "%#{query}%", "%#{query}%")
  end
end

この例では、publishedスコープは公開済みの記事を、draftスコープは下書き状態の記事を返します。recentスコープは、作成日時の降順で記事を返します。

また、searchクラスメソッドは、タイトルまたは本文に指定されたキーワードを含む記事を返します。

これらのスコープとクラスメソッドを使って、以下のようなクエリを実行できます：

# 公開済みの記事を取得
published_posts = Post.published

# 下書き状態の記事を取得
draft_posts = Post.draft

# 最新の5件の公開済み記事を取得
latest_published_posts = Post.published.recent.limit(5)

# "Rails"というキーワードを含む記事を検索
rails_posts = Post.search("Rails")

スコープとクラスメソッドを活用することで、よりクリーンで読みやすいコードを書くことができます。また、複雑なクエリを簡単に再利用できるようになります。

次の章では、高度なクエリの実行について説明します。

高度なクエリの実行

ActiveRecordには、高度なクエリを実行するための様々なメソッドが用意されています。これらのメソッドを使いこなすことで、効率的でパフォーマンスの高いクエリを書くことができます。

`where`を使用した条件指定

whereメソッドは、与えられた条件に一致するレコードを返します。以下は、Postモデルでwhereメソッドを使う例です：

# タイトルに"Rails"を含む記事を取得
rails_posts = Post.where("title LIKE ?", "%Rails%")

# 特定のユーザーが投稿した記事を取得
user_posts = Post.where(user_id: user.id)

# 複数の条件を指定して記事を取得
rails_posts_by_user = Post.where("title LIKE ?", "%Rails%").where(user_id: user.id)

`order`と`reorder`を使用した並べ替え

orderメソッドは、指定されたカラムで結果を並べ替えます。reorderメソッドは、既存の並べ替えを上書きします。以下は、Postモデルでorderとreorderメソッドを使う例です：

# 作成日時の降順で記事を取得
latest_posts = Post.order(created_at: :desc)

# タイトルのアルファベット順で記事を取得
alphabetical_posts = Post.order(:title)

# 作成日時の降順で並べ替えた後、タイトルのアルファベット順で並べ替え
posts_by_title = Post.order(created_at: :desc).reorder(:title)

`limit`と`offset`を使用したページネーション

limitメソッドは、取得するレコードの数を制限します。offsetメソッドは、指定した数のレコードをスキップします。これらのメソッドを組み合わせて、ページネーションを実装できます。以下は、Postモデルでlimitとoffsetメソッドを使う例です：

# 最初の10件の記事を取得
first_page_posts = Post.limit(10)

# 11件目から20件目の記事を取得
second_page_posts = Post.limit(10).offset(10)

`group`と`having`を使用したグループ化と集計

groupメソッドは、指定したカラムでレコードをグループ化します。havingメソッドは、グループ化された結果に条件を指定します。以下は、Postモデルでgroupとhavingメソッドを使う例です：

# カテゴリごとの記事数を取得
category_post_counts = Post.group(:category_id).count

# 記事数が5以上のカテゴリを取得
popular_categories = Category.joins(:posts).group("categories.id").having("COUNT(posts.id) >= ?", 5)

`distinct`を使用した重複レコードの除外

distinctメソッドは、重複するレコードを除外します。以下は、Postモデルでdistinctメソッドを使う例です：

# 重複するタイトルの記事を除外
unique_titled_posts = Post.select(:title).distinct

`from`を使用したテーブル名の指定

fromメソッドは、クエリの対象となるテーブルを明示的に指定する場合に使います。以下は、fromメソッドを使ってpostsテーブルからレコードを取得する例です：

Post.select('posts.id, posts.title').from('posts')

通常、fromメソッドを明示的に使う必要はありませんが、複雑なクエリを書く際に便利な場合があります。

`joins`と`left_outer_joins`を使用した結合

joinsメソッドは、内部結合を使ってテーブルを結合します。以下は、joinsメソッドを使ってpostsテーブルとusersテーブルを結合する例です：

Post.joins(:user)

これは、以下のSQLクエリと同等です：

SELECT "posts".* FROM "posts" INNER JOIN "users" ON "posts"."user_id" = "users"."id"

left_outer_joinsメソッドは、左外部結合を使ってテーブルを結合します。以下は、left_outer_joinsメソッドを使ってpostsテーブルとusersテーブルを結合する例です：

Post.left_outer_joins(:user)

これは、以下のSQLクエリと同等です：

SELECT "posts".* FROM "posts" LEFT OUTER JOIN "users" ON "posts"."user_id" = "users"."id"

内部結合と左外部結合の違いは、結合条件に一致しないレコードの扱いです。内部結合では、結合条件に一致しないレコードは結果に含まれませんが、左外部結合では、左側のテーブルのレコードは常に結果に含まれます。

`includes`と`preload`を使用したEager Loading

includesメソッドとpreloadメソッドは、Eager Loadingを実現するためのメソッドです。Eager Loadingは、関連するレコードを事前にロードすることで、N+1クエリ問題を防ぐことができます。

includesメソッドは、クエリの結果を使って関連するレコードをロードします。以下は、includesメソッドを使ってpostsテーブルとusersテーブルをEager Loadingする例です：

Post.includes(:user)

これは、以下のようなSQLクエリを実行します：

SELECT "posts".* FROM "posts"
SELECT "users".* FROM "users" WHERE "users"."id" IN (...)

preloadメソッドは、別々のクエリを使って関連するレコードをロードします。以下は、preloadメソッドを使ってpostsテーブルとusersテーブルをEager Loadingする例です：

Post.preload(:user)

これは、以下のようなSQLクエリを実行します：

SELECT "posts".* FROM "posts"
SELECT "users".* FROM "users" WHERE "users"."id" IN (...)

includesとpreloadの主な違いは、クエリの実行方法です。includesは結果を使って関連するレコードをロードするため、複雑なクエリではpreloadよりも効率的な場合があります。一方、preloadは別々のクエリを使ってロードするため、シンプルなクエリではincludesよりも高速な場合があります。

`eager_load`を使用した事前ロード

eager_loadメソッドは、SQLのLEFT OUTER JOINを使って関連するレコードを事前にロードします。以下は、eager_loadメソッドを使ってpostsテーブルとusersテーブルを事前ロードする例です：

Post.eager_load(:user)

これは、以下のSQLクエリと同等です：

SELECT "posts"."id" AS t0_r0, "posts"."title" AS t0_r1, ..., "users"."id" AS t1_r0, "users"."name" AS t1_r1, ... FROM "posts" LEFT OUTER JOIN "users" ON "users"."id" = "posts"."user_id"

eager_loadは、単一のクエリですべてのレコードを取得するため、大量のデータを扱う場合はメモリ消費量が大きくなる可能性があります。

`references`を使用した関連テーブルの参照

referencesメソッドは、クエリ内で関連テーブルを参照する場合に使います。以下は、referencesメソッドを使ってusersテーブルを参照する例です：

Post.includes(:user).where('users.name = ?', 'Alice').references(:user)

referencesメソッドを使わない場合、usersテーブルが実際にはクエリに含まれないため、エラーが発生します。

`none`を使用した空のリレーションの取得

noneメソッドは、空のリレーションを返します。以下は、noneメソッドを使って空のリレーションを取得する例です：

Post.none

これは、以下のSQLクエリと同等です：

SELECT "posts".* FROM "posts" WHERE (1 = 0)

noneメソッドは、条件によって結果が存在しない場合に使うと便利です。

`readonly`を使用した読み取り専用モードの設定

readonlyメソッドは、クエリの結果を読み取り専用モードに設定します。以下は、readonlyメソッドを使ってクエリの結果を読み取り専用にする例です：

Post.readonly.first

読み取り専用モードに設定されたオブジェクトは、変更を保存できません。

`select`を使用した取得カラムの制限

selectメソッドは、クエリの結果に含めるカラムを指定します。以下は、selectメソッドを使ってidとtitleカラムのみを取得する例です：

Post.select(:id, :title)

これは、以下のSQLクエリと同等です：

SELECT "posts"."id", "posts"."title" FROM "posts"

selectメソッドを使うことで、不要なカラムを取得しないようにできます。

`reselect`と`regroup`を使用したクエリの変更

reselectメソッドは、SELECT句を上書きします。以下は、reselectメソッドを使ってSELECT句を変更する例です：

Post.select(:title).reselect(:id)

これは、以下のSQLクエリと同等です：

SELECT "posts"."id" FROM "posts"

regroupメソッドは、GROUP BY句を上書きします。以下は、regroupメソッドを使ってGROUP BY句を変更する例です：

Post.group(:title).regroup(:id)

これは、以下のSQLクエリと同等です：

SELECT "posts".* FROM "posts" GROUP BY "posts"."id"

`annotate`を使用したクエリの注釈付け

annotateメソッドは、クエリにコメントを追加します。以下は、annotateメソッドを使ってクエリにコメントを追加する例です：

Post.annotate('this is a comment').to_sql

これは、以下のSQLクエリと同等です：

SELECT "posts".* FROM "posts" /* this is a comment */

annotateメソッドは、クエリのデバッグに役立ちます。

`optimizer_hints`を使用したクエリ最適化のヒント

optimizer_hintsメソッドは、クエリオプティマイザにヒントを渡します。以下は、optimizer_hintsメソッドを使ってMySQLのMAX_EXECUTION_TIMEヒントを渡す例です：

Post.optimizer_hints("MAX_EXECUTION_TIME(5000)")

これは、以下のSQLクエリと同等です：

SELECT /*+ MAX_EXECUTION_TIME(5000) */ "posts".* FROM "posts"

optimizer_hintsメソッドは、特定のデータベースでのみ使用できます。

`lock`を使用したレコードのロック

lockメソッドは、レコードをロックします。以下は、lockメソッドを使って排他的ロックを取得する例です：

Post.lock.first

これは、以下のSQLクエリと同等です：

SELECT "posts".* FROM "posts" LIMIT 1 FOR UPDATE

ロックを使うことで、レコードの同時更新を防ぐことができます。

`extract_associated`を使用した関連レコードの抽出

extract_associatedメソッドは、関連するレコードを抽出します。以下は、extract_associatedメソッドを使ってpostsの関連するusersを抽出する例です：

posts = Post.limit(10).to_a
users = Post.extract_associated(:user, posts)

これは、以下のSQLクエリと同等です：

SELECT "posts".* FROM "posts" LIMIT 10
SELECT "users".* FROM "users" WHERE "users"."id" IN (...)

extract_associatedメソッドは、事前にロードされていない関連レコードを効率的に取得するのに役立ちます。

以上が、ActiveRecordの高度なクエリメソッドの一覧です。これらのメソッドを適切に使い分けることで、ほとんどのクエリを効率的に実行できます。ただし、これらのメソッドの中にはデータベース固有のものもあるため、使用する際は注意が必要です。

ActiveRecordの高度なクエリメソッドを理解することで、アプリケーションのパフォーマンスを大幅に向上させることができます。適切なメソッドを選択し、効率的なクエリを書くことを心がけましょう。

サンプルアプリケーションでの高度なクエリの実装

サンプルのブログアプリケーションでは、以下のような高度なクエリを使っています：

# ユーザーごとの記事数を取得
user_post_counts = Post.group(:user_id).count

# 特定のタグを持つ記事を取得
tagged_posts = Post.joins(:tags).where(tags: { name: "Ruby" })

# 特定のユーザーがコメントした記事を取得
commented_posts_by_user = Post.joins(:comments).where(comments: { user_id: user.id }).distinct

# 最新の5件のコメントとそれに関連する記事とユーザーを取得
latest_comments_with_posts_and_users = Comment.order(created_at: :desc).limit(5).includes(:post, :user)

これらのクエリは、アプリケーションのパフォーマンスを向上させるために重要です。例えば、includesメソッドを使ってコメントに関連する記事とユーザーを事前にロードすることで、N+1クエリ問題を防ぐことができます。

次の章では、ActiveRecordとデータベースの相互作用について説明します。

ActiveRecordとデータベースの相互作用

ActiveRecordは、オブジェクト指向のRubyコードとリレーショナルデータベースの間の橋渡しをします。ActiveRecordのメソッドを呼び出すと、それに対応するSQLクエリがデータベースに送信されます。ここでは、ActiveRecordがSQLクエリに変換する仕組みと、ActiveRecordとデータベースの相互作用について説明します。

ActiveRecordがSQLクエリに変換する仕組み

ActiveRecordは、メソッドチェーンを使って複雑なクエリを構築できます。これらのメソッドは、最終的にSQLクエリに変換されます。以下は、ActiveRecordのメソッドチェーンとそれに対応するSQLクエリの例です：

# ActiveRecord
Post.where(published: true).order(created_at: :desc).limit(10)

# SQL
SELECT "posts".* FROM "posts" WHERE "posts"."published" = 1 ORDER BY "posts"."created_at" DESC LIMIT 10

ActiveRecordは、メソッドチェーンを内部的にARel（ActiveRecord Query Interface）と呼ばれるオブジェクトに変換します。ARelは、抽象的なクエリ表現を提供し、実際のSQLクエリへの変換を担当します。これにより、ActiveRecordはデータベースに依存しないクエリを構築できます。

シーケンス図を使ったActiveRecordとデータベースの相互作用の説明

以下は、ActiveRecordとデータベースの相互作用をシーケンス図で表したものです：

アプリケーションがActiveRecordのメソッドチェーンを呼び出します。
ActiveRecordは、メソッドチェーンをARelオブジェクトに変換します。
ActiveRecordは、ARelオブジェクトをSQLクエリに変換します。
ActiveRecordは、SQLクエリをデータベースに送信します。
データベースは、クエリ結果をActiveRecordに返却します。
ActiveRecordは、クエリ結果をActiveRecordオブジェクトに変換します。
ActiveRecordは、ActiveRecordオブジェクトをアプリケーションに返却します。

このように、ActiveRecordはアプリケーションとデータベースの間の通信を抽象化し、オブジェクト指向のインターフェースを提供します。開発者は、SQLを直接書く代わりに、Rubyのコードを書くことでデータベースを操作できます。

ActiveRecordのパフォーマンス最適化

ActiveRecordを使う上で、パフォーマンスの最適化は重要なトピックです。ここでは、N+1問題の解決、Eager Loadingの活用、カウンターキャッシュの使用、クエリのキャッシュなど、パフォーマンスを向上させるテクニックを紹介します。

N+1問題の解決

N+1問題は、関連するレコードを取得する際に発生する非効率なクエリのことを指します。以下は、N+1問題が発生する例です：

posts = Post.limit(10)

posts.each do |post|
  puts post.user.name
end

この例では、10件の記事を取得した後、各記事に対してユーザー名を表示しています。しかし、このコードでは、10件の記事を取得するクエリに加えて、各記事のユーザーを取得するためのクエリが10回発行されます（合計11回のクエリ）。

N+1問題を解決するには、includesメソッドを使ってリレーションを事前にロードします。以下は、includesメソッドを使った例です：

posts = Post.includes(:user).limit(10)

posts.each do |post|
  puts post.user.name
end

この例では、includesメソッドを使って記事に関連するユーザーを事前にロードしています。これにより、11回のクエリが2回に減ります（10件の記事を取得するクエリと、関連するユーザーを取得するクエリ）。

Eager Loadingの活用

Eager Loadingは、関連するレコードを事前にロードすることで、N+1問題を防ぐテクニックです。ActiveRecordでは、includes、preload、eager_loadの3つのメソッドを使ってEager Loadingを実現できます。

includes：SQLのLEFT OUTER JOINを使ってリレーションを読み込みます。
preload：別々のクエリを使ってリレーションを読み込みます。
eager_load：SQLのINNER JOINを使ってリレーションを読み込みます。

これらのメソッドを適切に使い分けることで、パフォーマンスを向上させることができます。

カウンターキャッシュの使用

カウンターキャッシュは、関連するレコードの数をキャッシュすることで、COUNT クエリを減らすテクニックです。以下は、Postモデルにcomments_countカラムを追加し、カウンターキャッシュを使う例です：

class Post < ApplicationRecord
  has_many :comments, counter_cache: true
end

class Comment < ApplicationRecord
  belongs_to :post
end

この例では、Postモデルのcomments_countカラムに、関連するコメントの数がキャッシュされます。これにより、post.comments.countを呼び出す代わりに、post.comments_countを使ってコメント数を取得できます。

クエリのキャッシュ

ActiveRecordは、同じクエリを繰り返し実行する場合、クエリ結果をキャッシュすることでパフォーマンスを向上させます。以下は、クエリキャッシュを有効にする例です：

ActiveRecord::Base.connection.cache do
  post = Post.find(1)
  post.title # クエリが発行される
  post.title # キャッシュからデータが取得される
end

この例では、ActiveRecord::Base.connection.cacheブロック内で同じクエリが2回実行されています。2回目のクエリは、キャッシュからデータを取得するため、データベースへのアクセスが発生しません。

サンプルアプリケーションでのパフォーマンス最適化

サンプルのブログアプリケーションでは、以下のようなパフォーマンス最適化を行っています：

includesメソッドを使ってN+1問題を解決
カウンターキャッシュを使ってCOUNTクエリを減らす
クエリキャッシュを有効にしてクエリ結果を再利用

# N+1問題の解決
posts = Post.includes(:user, :comments).limit(10)

# カウンターキャッシュの使用
class Post < ApplicationRecord
  has_many :comments, counter_cache: true
end

# クエリキャッシュの有効化
ActiveRecord::Base.connection.cache do
  # 複雑なクエリを実行
end

これらの最適化により、アプリケーションのパフォーマンスが大幅に向上します。特に、大規模なデータセットを扱う場合や、高トラフィックなアプリケーションでは、これらのテクニックが重要になります。

次の章では、ActiveRecordのカスタマイズについて説明します。

ActiveRecordのカスタマイズ

ActiveRecordは、柔軟にカスタマイズできるように設計されています。ここでは、カスタムバリデーションの作成、カスタムクエリメソッドの定義、シリアライズの活用、単一テーブル継承（STI）の使用など、ActiveRecordをカスタマイズするテクニックを紹介します。

カスタムバリデーションの作成

ActiveRecordには、validatesメソッドを使って組み込みのバリデーションを設定できます。しかし、アプリケーションの要件によっては、カスタムバリデーションが必要になることがあります。以下は、Postモデルにカスタムバリデーションを追加する例です：

class Post < ApplicationRecord
  validate :title_must_be_capitalized

  private

  def title_must_be_capitalized
    if title.present? && title != title.capitalize
      errors.add(:title, "must be capitalized")
    end
  end
end

この例では、title_must_be_capitalizedというカスタムバリデーションを定義しています。このバリデーションは、タイトルが存在する場合、最初の文字が大文字であることを確認します。

カスタムクエリメソッドの定義

ActiveRecordのクエリメソッドを拡張するために、カスタムクエリメソッドを定義できます。以下は、Postモデルにカスタムクエリメソッドを追加する例です：

class Post < ApplicationRecord
  def self.search(query)
    where("title LIKE ? OR content LIKE ?", "%#{query}%", "%#{query}%")
  end
end

この例では、searchというカスタムクエリメソッドを定義しています。このメソッドは、タイトルまたは本文に指定されたキーワードを含む記事を検索します。

シリアライズの活用

ActiveRecordのシリアライズ機能を使うと、オブジェクトをJSONやXMLなどのフォーマットに変換できます。以下は、Postモデルにシリアライズを追加する例です：

class Post < ApplicationRecord
  serialize :metadata, JSON
end

この例では、metadataカラムをJSONフォーマットでシリアライズしています。これにより、metadataカラムに任意のJSONデータを保存できます。

単一テーブル継承（STI）の使用

単一テーブル継承（STI）は、複数のモデルを1つのデータベーステーブルで表現するテクニックです。以下は、Postモデルを継承してNewsPostモデルとBlogPostモデルを作成する例です：

class Post < ApplicationRecord
  # 共通の属性とメソッド
end

class NewsPost < Post
  # NewsPost固有の属性とメソッド
end

class BlogPost < Post
  # BlogPost固有の属性とメソッド
end

この例では、Postモデルを継承してNewsPostモデルとBlogPostモデルを作成しています。これらのモデルは、postsテーブルを共有しますが、typeカラムを使ってモデルを区別します。

サンプルアプリケーションでのActiveRecordのカスタマイズ

サンプルのブログアプリケーションでは、以下のようなActiveRecordのカスタマイズを行っています：

class Post < ApplicationRecord
  # カスタムバリデーション
  validate :title_must_be_unique_within_user

  # カスタムクエリメソッド
  def self.recent_posts_by_user(user)
    where(user: user).order(created_at: :desc).limit(5)
  end

  # シリアライズ
  serialize :metadata, JSON

  private

  def title_must_be_unique_within_user
    if user.posts.where(title: title).where.not(id: id).exists?
      errors.add(:title, "must be unique within user's posts")
    end
  end
end

# STIを使ったモデルの定義
class NewsPost < Post
  # NewsPost固有の属性とメソッド
end

class BlogPost < Post
  # BlogPost固有の属性とメソッド
end

この例では、以下のようなカスタマイズを行っています：

title_must_be_unique_within_userというカスタムバリデーションを定義し、同じユーザーの記事内でタイトルが一意であることを確認しています。
recent_posts_by_userというカスタムクエリメソッドを定義し、特定のユーザーの最新の5件の記事を取得しています。
metadataカラムをJSONでシリアライズしています。
STIを使ってNewsPostモデルとBlogPostモデルを定義しています。

これらのカスタマイズにより、アプリケーションの要件に合わせてActiveRecordの動作を拡張できます。

ActiveRecordのテスト

ActiveRecordモデルをテストすることは、アプリケーションの品質を維持するために重要です。RSpecやMinitest、FactoryBotなどのツールを使って、ActiveRecordモデルのテストを効果的に行うことができます。ここでは、モデルのテスト、リレーションシップのテスト、バリデーションとコールバックのテスト、テストデータの作成とセットアップなど、ActiveRecordのテストについて説明します。

モデルのテスト

モデルのテストでは、モデルの属性やメソッドが期待通りに動作することを確認します。以下は、Postモデルの属性をテストする例です（RSpecを使用）：

RSpec.describe Post, type: :model do
  describe "attributes" do
    let(:post) { Post.new(title: "Test Title", content: "Test Content") }

    it "has a title" do
      expect(post.title).to eq("Test Title")
    end

    it "has a content" do
      expect(post.content).to eq("Test Content")
    end
  end
end

この例では、Postモデルのtitle属性とcontent属性が期待通りの値を持つことをテストしています。

リレーションシップのテスト

リレーションシップのテストでは、モデル間の関連が正しく設定されていることを確認します。以下は、UserモデルとPostモデルの1対多の関係をテストする例です（RSpecを使用）：

RSpec.describe User, type: :model do
  describe "associations" do
    it { should have_many(:posts) }
  end
end

RSpec.describe Post, type: :model do
  describe "associations" do
    it { should belong_to(:user) }
  end
end

この例では、Userモデルが多数のPostを持ち、Postモデルが1人のUserに属することをテストしています。

バリデーションとコールバックのテスト

バリデーションとコールバックのテストでは、モデルのバリデーションとコールバックが正しく動作することを確認します。以下は、Postモデルのバリデーションとコールバックをテストする例です（RSpecを使用）：

RSpec.describe Post, type: :model do
  describe "validations" do
    it { should validate_presence_of(:title) }
    it { should validate_presence_of(:content) }
  end

  describe "callbacks" do
    let(:post) { build(:post, title: "initial title") }

    it "sets slug before validation" do
      post.valid?
      expect(post.slug).to eq("initial-title")
    end
  end
end

この例では、Postモデルのtitle属性とcontent属性の存在チェックをテストしています。また、valid?メソッドが呼び出される前に、slug属性が正しく設定されることをテストしています。

テストデータの作成とセットアップ

テストデータの作成とセットアップは、テストの効率を上げるために重要です。FactoryBotを使うと、テストデータの作成とセットアップを簡単に行うことができます。以下は、FactoryBotを使ってUserモデルとPostモデルのテストデータを作成する例です：

FactoryBot.define do
  factory :user do
    sequence(:email) { |n| "user#{n}@example.com" }
    password { "password" }
  end

  factory :post do
    title { "Test Title" }
    content { "Test Content" }
    association :user
  end
end

この例では、UserモデルとPostモデルのファクトリを定義しています。sequenceメソッドを使って一意のメールアドレスを生成し、associationメソッドを使って関連するモデルを設定しています。

サンプルアプリケーションでのテストの実装

サンプルのブログアプリケーションでは、以下のようなテストを実装しています：

RSpec.describe Post, type: :model do
  describe "validations" do
    it { should validate_presence_of(:title) }
    it { should validate_presence_of(:content) }
    it { should validate_uniqueness_of(:title).scoped_to(:user_id) }
  end

  describe "associations" do
    it { should belong_to(:user) }
    it { should have_many(:comments).dependent(:destroy) }
    it { should have_many(:categories).through(:post_categories) }
    it { should have_many(:tags).through(:post_tags) }
  end

  describe "scopes" do
    let!(:published_post) { create(:post, published: true) }
    let!(:unpublished_post) { create(:post, published: false) }

    describe ".published" do
      it "returns published posts" do
        expect(Post.published).to eq([published_post])
      end
    end

    describe ".unpublished" do
      it "returns unpublished posts" do
        expect(Post.unpublished).to eq([unpublished_post])
      end
    end
  end
end

この例では、以下のようなテストを行っています：

Postモデルのtitle属性とcontent属性の存在チェック、およびtitle属性のユーザー内での一意性チェックをテストしています。
PostモデルとUser、Comment、Category、Tagモデルとの関連をテストしています。
publishedスコープとunpublishedスコープが期待通りに動作することをテストしています。

これらのテストにより、アプリケーションの品質を維持し、リグレッションを防ぐことができます。

ActiveRecordのベストプラクティス

ActiveRecordを効果的に使うには、ベストプラクティスに従うことが重要です。ここでは、コードの可読性と保守性、適切なインデックスの設定、トランザクションの使用、セキュリティに関する考慮事項など、ActiveRecordのベストプラクティスについて説明します。

コードの可読性と保守性

コードの可読性と保守性を高めるために、以下のようなベストプラクティスに従います：

モデルの責任を明確にし、単一責任の原則（SRP）に従う
適切な命名規則を使用する（モデル名は単数形、テーブル名は複数形など）
スコープやクラスメソッドを使ってクエリをカプセル化する
コールバックを最小限に抑え、複雑なビジネスロジックはモデルの外に移動する
バリデーションとコールバックの違いを理解し、適切に使い分ける

適切なインデックスの設定

データベースのパフォーマンスを向上させるために、適切なインデックスを設定することが重要です。以下のようなケースでは、インデックスの設定を検討します：

頻繁に検索される列
結合に使用される外部キー
ソートに使用される列
一意性制約が必要な列

トランザクションの使用

トランザクションを使うことで、一連のデータベース操作の整合性を保つことができます。以下のようなケースでは、トランザクションの使用を検討します：

複数のレコードを更新する場合
複数のモデルを操作する場合
外部システムとのインテグレーションが必要な場合

ActiveRecordでは、transactionメソッドを使ってトランザクションを定義できます：

Post.transaction do
  post = Post.create(title: "New Post", content: "Post Content")
  post.comments.create(content: "First Comment")
end

セキュリティに関する考慮事項

ActiveRecordを使う際は、以下のようなセキュリティ上の考慮事項に注意します：

SQLインジェクションを防ぐために、プレースホルダを使ってクエリを構築する
ストロングパラメータを使って、許可されたパラメータのみを受け入れる
機密情報を平文で保存しない
必要に応じて、データベースレベルでの制約を設定する

サンプルアプリケーションでのベストプラクティスの実践

サンプルのブログアプリケーションでは、以下のようなベストプラクティスを実践しています：

class Post < ApplicationRecord
  # 適切な関連の定義
  belongs_to :user
  has_many :comments, dependent: :destroy
  has_many :categories, through: :post_categories
  has_many :tags, through: :post_tags

  # バリデーションの設定
  validates :title, presence: true, uniqueness: { scope: :user_id }
  validates :content, presence: true

  # スコープの定義
  scope :published, -> { where(published: true) }
  scope :unpublished, -> { where(published: false) }

  # クラスメソッドの定義
  def self.search(query)
    where("title LIKE ? OR content LIKE ?", "%#{query}%", "%#{query}%")
  end

  # コールバックの最小化
  before_validation :set_slug

  private

  def set_slug
    self.slug = title.parameterize
  end
end

# トランザクションの使用例
def create_post_with_comment(post_params, comment_params)
  Post.transaction do
    post = Post.create(post_params)
    post.comments.create(comment_params)
  end
end

# ストロングパラメータの使用例
def post_params
  params.require(:post).permit(:title, :content, :published)
end

この例では、以下のようなベストプラクティスを実践しています：

belongs_toやhas_manyを使って適切な関連を定義しています。
validatesメソッドを使ってバリデーションを設定しています。
scopeメソッドを使ってクエリをカプセル化しています。
before_validationコールバックを使ってスラッグを設定していますが、コールバックの使用は最小限に抑えています。
transactionメソッドを使って、関連するレコードを一括で作成しています。
params.requireとparams.permitを使って、許可されたパラメータのみを受け入れています。

これらのベストプラクティスに従うことで、コードの品質と保守性を高め、セキュアなアプリケーションを構築することができます。

発展的なトピック

ActiveRecordは、単独でも非常に強力なツールですが、他のツールやテクニックと組み合わせることで、さらに高度なアプリケーションを構築できます。ここでは、ActiveRecordとNoSQLデータベースの連携、ActiveRecordとバックグラウンドジョブの併用、ActiveRecordとキャッシュストアの連携など、発展的なトピックについて説明します。

ActiveRecordとNoSQLデータベースの連携

ActiveRecordは、リレーショナルデータベースとの連携に特化していますが、NoSQLデータベースと連携することもできます。例えば、MongoDBを使う場合、mongoidというGemを使ってActiveRecordライクなインターフェースを実現できます。

class User
  include Mongoid::Document
  field :name, type: String
  field :email, type: String
  has_many :posts
end

class Post
  include Mongoid::Document
  field :title, type: String
  field :content, type: String
  belongs_to :user
end

この例では、mongoidを使ってUserモデルとPostモデルを定義しています。リレーショナルデータベースを使う場合と同様に、has_manyやbelongs_toを使って関連を定義できます。

ActiveRecordとバックグラウンドジョブの併用

ActiveRecordを使う際、時間のかかる処理をバックグラウンドジョブとして実行することで、アプリケーションのレスポンス性能を向上させることができます。例えば、ActiveJobを使って、メール送信処理をバックグラウンドで実行できます。

class UserMailer < ApplicationMailer
  def welcome_email(user)
    @user = user
    mail(to: @user.email, subject: "Welcome to Our Blog!")
  end
end

class SendWelcomeEmailJob < ApplicationJob
  def perform(user)
    UserMailer.welcome_email(user).deliver_now
  end
end

# ユーザー作成後にジョブをキュー
class UsersController < ApplicationController
  def create
    @user = User.new(user_params)

    if @user.save
      SendWelcomeEmailJob.perform_later(@user)
      redirect_to @user, notice: "User was successfully created."
    else
      render :new
    end
  end
end

この例では、UserMailerでウェルカムメールを定義し、SendWelcomeEmailJobでメール送信処理をバックグラウンドジョブとして実行しています。UsersControllerのcreateアクション内で、ユーザー作成後にSendWelcomeEmailJobをキューに登録しています。

ActiveRecordとキャッシュストアの連携

ActiveRecordと連携してキャッシュストアを使うことで、アプリケーションのパフォーマンスを向上させることができます。例えば、Redisをキャッシュストアとして使う場合、redis-railsというGemを使ってRailsのキャッシュ機能と統合できます。

# config/environments/production.rb
config.cache_store = :redis_store, {
  host: ENV['REDIS_HOST'],
  port: ENV['REDIS_PORT'],
  db: ENV['REDIS_DB'],
  namespace: 'cache'
}

class PostsController < ApplicationController
  def show
    @post = Post.find(params[:id])
    @comment = @post.comments.build

    @comments = Rails.cache.fetch("post_#{@post.id}_comments", expires_in: 1.hour) do
      @post.comments.includes(:user).order(created_at: :desc)
    end
  end
end

この例では、config/environments/production.rbでRedisをキャッシュストアとして設定しています。PostsControllerのshowアクション内で、Rails.cache.fetchを使ってコメントのキャッシュを読み書きしています。キャッシュキーにはpost_#{@post.id}_commentsを使い、1時間のキャッシュ有効期間を設定しています。

これらの発展的なトピックを理解し、適切に活用することで、より高度で効率的なアプリケーションを構築できます。

まとめ

この記事では、ActiveRecordの基本から応用まで、幅広いトピックを扱ってきました。ActiveRecordは、Rubyでウェブアプリケーションを構築する上で欠かせないツールであり、その使い方を習得することは非常に重要です。

ActiveRecordマスターへのロードマップ

ActiveRecordのマスターを目指すには、以下のようなステップを踏むことが有効です：

ActiveRecordの基本的な使い方（モデルの定義、CRUD操作、バリデーション、コールバックなど）を理解する。
リレーションシップやスコープ、クラスメソッドなどの中級レベルのトピックを学ぶ。
パフォーマンス最適化やセキュリティ、テストなど、実践的なスキルを身につける。
発展的なトピックに挑戦し、ActiveRecordと他のツールやテクニックを組み合わせる方法を学ぶ。
実際のプロジェクトでActiveRecordを使い、経験を積む。

継続的な学習の重要性

技術は常に進化しており、ActiveRecordも例外ではありません。新しいバージョンがリリースされるたびに、新機能や改良が加えられます。継続的に学習し、最新の情報を追うことが重要です。

また、ActiveRecordだけでなく、データベースやSQLの知識を深めることも大切です。ActiveRecordは多くの面倒な作業を抽象化してくれますが、根底にあるデータベースの仕組みを理解することで、より効果的にActiveRecordを使いこなせるようになります。

参考資料と次のステップ

公式ドキュメント: Active Record Basics
書籍: 「Railsガイド」、「パーフェクトRuby on Rails」
オンラインコース: 「Ruby on Rails チュートリアル」、「マスターRails」

この記事を通して、ActiveRecordの基礎から応用まで、体系的に学ぶことができたはずです。今後は、実際のプロジェクトでActiveRecordを使ってみることをおすすめします。実践を通して、ActiveRecordの理解を深めていきましょう。

ActiveRecordマスターへの道：初級から上級までの書き方を網羅！

イントロダクション

ActiveRecordを使うメリット

本記事の目的と対象読者

サンプルアプリケーションの紹介

モデル間のリレーションシップ

基本的なActiveRecordの使い方

モデルの定義

レコードの作成、読み取り、更新、削除（CRUD操作）

レコードの作成

レコードの読み取り

レコードの更新

レコードの削除

バリデーションの追加

コールバックの使用

フローチャートを使ったCRUD操作の流れの説明

リレーションシップの定義

1対多のリレーションシップ

多対多のリレーションシップ

リレーションシップのオプション

サンプルアプリケーションでのリレーションシップの実装

スコープとクラスメソッド

スコープの定義と使用

クラスメソッドの定義と使用

スコープとクラスメソッドの組み合わせ

サンプルアプリケーションでのスコープとクラスメソッドの活用

高度なクエリの実行

whereを使用した条件指定

orderとreorderを使用した並べ替え

limitとoffsetを使用したページネーション

groupとhavingを使用したグループ化と集計

distinctを使用した重複レコードの除外

fromを使用したテーブル名の指定

joinsとleft_outer_joinsを使用した結合

includesとpreloadを使用したEager Loading

eager_loadを使用した事前ロード

referencesを使用した関連テーブルの参照

noneを使用した空のリレーションの取得

readonlyを使用した読み取り専用モードの設定

selectを使用した取得カラムの制限

reselectとregroupを使用したクエリの変更

annotateを使用したクエリの注釈付け

optimizer_hintsを使用したクエリ最適化のヒント

lockを使用したレコードのロック

extract_associatedを使用した関連レコードの抽出

サンプルアプリケーションでの高度なクエリの実装

ActiveRecordとデータベースの相互作用

ActiveRecordがSQLクエリに変換する仕組み

シーケンス図を使ったActiveRecordとデータベースの相互作用の説明

ActiveRecordのパフォーマンス最適化

N+1問題の解決

Eager Loadingの活用

カウンターキャッシュの使用

クエリのキャッシュ

サンプルアプリケーションでのパフォーマンス最適化

ActiveRecordのカスタマイズ

カスタムバリデーションの作成

カスタムクエリメソッドの定義

シリアライズの活用

単一テーブル継承（STI）の使用

サンプルアプリケーションでのActiveRecordのカスタマイズ

ActiveRecordのテスト

モデルのテスト

リレーションシップのテスト

バリデーションとコールバックのテスト

テストデータの作成とセットアップ

サンプルアプリケーションでのテストの実装

ActiveRecordのベストプラクティス

コードの可読性と保守性

適切なインデックスの設定

トランザクションの使用

セキュリティに関する考慮事項

サンプルアプリケーションでのベストプラクティスの実践

発展的なトピック

ActiveRecordとNoSQLデータベースの連携

ActiveRecordとバックグラウンドジョブの併用

ActiveRecordとキャッシュストアの連携

まとめ

ActiveRecordマスターへのロードマップ

継続的な学習の重要性

`where`を使用した条件指定

`order`と`reorder`を使用した並べ替え

`limit`と`offset`を使用したページネーション

`group`と`having`を使用したグループ化と集計

`distinct`を使用した重複レコードの除外

`from`を使用したテーブル名の指定

`joins`と`left_outer_joins`を使用した結合

`includes`と`preload`を使用したEager Loading

`eager_load`を使用した事前ロード

`references`を使用した関連テーブルの参照

`none`を使用した空のリレーションの取得

`readonly`を使用した読み取り専用モードの設定

`select`を使用した取得カラムの制限

`reselect`と`regroup`を使用したクエリの変更

`annotate`を使用したクエリの注釈付け

`optimizer_hints`を使用したクエリ最適化のヒント

`lock`を使用したレコードのロック

`extract_associated`を使用した関連レコードの抽出