【第四弾】Laravel入門資料

モデル(Model)とは

モデルとは、データベースのテーブルを操作するためのPHPクラスです。
SQL文を書かずに、PHPのコードでデータベースを操作できます。

まずは手を動かして、モデルを作って使ってみましょう。理屈は後から理解します。

【ステップ1】モデルを作成しよう

モデル作成コマンド

# Productモデルを作成
php artisan make:model Product

これで app/Models/Product.php が作られます。

⭐ 重要: $fillable を設定

app/Models/Product.php を開いて、$fillable を追加します。
これがないと create() でエラーになります。

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    use HasFactory;

    // ⭐ これを追加！
    protected $fillable = [
        'name',
        'description',
        'price',
        'stock',
        'is_published',
        'category_id',
    ];
}

✅ モデルの準備完了！これで Eloquent ORM を使えます。
※ Eloquent ORM については後ほど詳しく説明します。

【ステップ2】Tinkerで実際に操作してみよう

Tinkerは、コマンドラインでPHPコードを実行できるツールです。
実際にデータベースを操作しながら、モデルの使い方を覚えましょう。

Tinker起動

php artisan tinker

終了する時は exit または Ctrl + C

【実践1】データを取得してみる

// 全件取得
>>> $products = App\Models\Product::all();
=> Illuminate\Database\Eloquent\Collection {
     all: [
       App\Models\Product {
         id: 1,
         name: "ノートPC",
         price: 120000,
       },
       App\Models\Product {
         id: 2,
         name: "ワイヤレスマウス",
         price: 3000,
       },
       // ...
     ],
   }

// 件数確認
>>> $products->count();
=> 3

// IDで1件取得
>>> $product = App\Models\Product::find(1);
=> App\Models\Product {
     id: 1,
     name: "ノートPC",
     price: 120000,
     stock: 10,
   }

// 属性にアクセス
>>> $product->name;
=> "ノートPC"

>>> $product->price;
=> 120000

【実践2】条件を指定して取得

// 価格が10000円より高い商品
>>> $products = App\Models\Product::where('price', '>', 10000)->get();
=> Illuminate\Database\Eloquent\Collection {
     all: [
       App\Models\Product {
         id: 1,
         name: "ノートPC",
         price: 120000,
       },
     ],
   }

// 最初の1件だけ
>>> $product = App\Models\Product::where('price', '<', 5000)->first();
=> App\Models\Product {
     id: 2,
     name: "ワイヤレスマウス",
     price: 3000,
   }

// 件数だけ知りたい
>>> App\Models\Product::where('price', '>', 10000)->count();
=> 1

【実践3】データを作成してみる

// 新しい商品を作成
>>> $product = App\Models\Product::create([
...   'name' => 'Bluetoothキーボード',
...   'description' => '打ちやすいキーボード',
...   'price' => 8000,
...   'stock' => 15,
...   'is_published' => true,
...   'category_id' => 1,  // 家電
... ]);
=> App\Models\Product {
     id: 4,
     name: "Bluetoothキーボード",
     price: 8000,
     // ...
   }

// 確認
>>> App\Models\Product::find(4)->name;
=> "Bluetoothキーボード"

【実践4】データを更新してみる

// IDで取得
>>> $product = App\Models\Product::find(4);

// 価格を変更
>>> $product->price = 7500;

// 保存
>>> $product->save();
=> true

// 確認
>>> $product->price;
=> 7500

// 別の方法: update() メソッド
>>> $product->update(['stock' => 20]);
=> true

【実践5】データを削除してみる

// IDで取得
>>> $product = App\Models\Product::find(4);

// 削除
>>> $product->delete();
=> true

// 確認（nullになる）
>>> App\Models\Product::find(4);
=> null

✅ データの取得・作成・更新・削除ができました！

【ステップ3】いま何をしたか理解しよう

ORM（Object-Relational Mapping）とは

さっきやったことが、まさにORMです。

「::」と「->」の使い分け

さっきのTinkerで、2種類の記号を使いました。

終端メソッド - いつSQLが実行される？

さっき where() の後に get() や first() を書きましたね。
実は、get() や first() を呼ぶまでSQLは実行されません。

// ここまではSQL未実行（クエリを組み立てているだけ）
$query = Product::where('price', '>', 10000);

// get() を呼んで初めてSQL実行される
$products = $query->get();  // ← ここで実行

// first() も終端メソッド
$product = $query->first();  // ← ここで実行

// count() も終端メソッド
$count = $query->count();  // ← ここで実行

実務でよく使うメソッド一覧

ここまでで基本的な操作ができるようになりました。
実務でよく使うメソッドを重要度順に紹介します。

いつSQLが実行される？終端メソッドを理解しよう

Eloquent ORMでは、メソッドチェーンで繋いでいる間はSQL文は発行されません。
最後に終端メソッドを呼んで初めて、データベースにSQLが送られます。

// ここまではSQL未発行（クエリを組み立てているだけ）
$query = Product::where('price', '>', 10000)
    ->where('is_published', true)
    ->orderBy('created_at', 'desc');

// この時点ではまだデータベースに問い合わせていない

// get() を呼んで初めてSQL実行される ← 終端メソッド
$products = $query->get();  // SELECT * FROM products WHERE ...

// first() も終端メソッド
$product = $query->first();  // SELECT * FROM products WHERE ... LIMIT 1

主な終端メソッド一覧

よく使う終端メソッドを覚えましょう。

終端メソッドでないもの（チェーンできる）

これらはSQL未実行。さらにメソッドを繋げられます。

// 全部繋げてもSQL未実行
$query = Product::where('price', '>', 10000)
    ->where('is_published', true)
    ->orderBy('created_at', 'desc')
    ->limit(10)
    ->select('name', 'price')
    ->with('category');

// ここまでSQL未実行

// get() で初めてSQL実行
$products = $query->get();  // ← ここで実行される

【Tinkerで確認】実際に試してみよう

Tinkerで、いつSQLが実行されるか確認できます。

php artisan tinker

// クエリログを有効化
>>> DB::enableQueryLog();

// where() や orderBy() を書く（SQL未実行）
>>> $query = App\Models\Product::where('price', '>', 10000)->orderBy('price', 'desc');

// まだログは空
>>> DB::getQueryLog();
=> []  // 空！まだSQL実行されていない

// get() で実行
>>> $products = $query->get();

// ログを確認
>>> DB::getQueryLog();
=> [
     [
       "query" => "select * from `products` where `price` > ? order by `price` desc",
       "bindings" => [10000],
       "time" => 1.23,
     ],
   ]  // ← get() を呼んだ時にSQLが実行された！

【Tinkerで確認】pluck() と バインド値

他の終端メソッドも試してみましょう。

// 特定のカラムだけ取得
>>> App\Models\Product::pluck('name');
=> Illuminate\Support\Collection {
     all: [
       "ノートPC",
       "ワイヤレスマウス",
       "オーガニックコーヒー",
       "Laravel入門書",
     ],
   }

// IDをキーにして名前を取得
>>> App\Models\Product::pluck('name', 'id');
=> Illuminate\Support\Collection {
     all: [
       1 => "ノートPC",
       2 => "ワイヤレスマウス",
       3 => "オーガニックコーヒー",
       4 => "Laravel入門書",
     ],
   }

// クエリを作成（SQL未実行）
>>> $query = App\Models\Product::where('price', '>', 10000);

// SQLの構造を確認（?がある）
>>> $query->toSql();
=> "select * from `products` where `price` > ?"

// バインド値を確認（?に入る実際の値）
>>> $query->getBindings();
=> [
     10000,
   ]

// 問題なければ実行
>>> $products = $query->get();

なぜこの仕組みが便利なのか？

$query = Product::query();

if ($request->has('min_price')) {
    $query->where('price', '>=', $request->min_price);
}

if ($request->has('category_id')) {
    $query->where('category_id', $request->category_id);
}

// 最後に一度だけSQL実行
$products = $query->get();

$query = Product::where('is_published', true);

// 同じクエリで件数を取得
$count = $query->count();  // SQL実行1回目

// 同じクエリでデータ取得
$products = $query->get();  // SQL実行2回目

// 同じクエリで最初の1件
$first = $query->first();  // SQL実行3回目

$query = Product::where('price', '>', 10000);

// SQLを確認できる（まだ実行されていない）
echo $query->toSql();  // select * from `products` where `price` > ?

// バインド値も確認
dd($query->getBindings());  // [10000]

// 問題なければ実行
$products = $query->get();

💡 覚え方: get, first, count, pluck などが終端メソッド。これを呼ぶまでデータは取得されない!

なぜEloquent ORMを使うのか？ - SQL → クエリビルダー → ORMの進化

Laravelでデータベース操作をする方法は、実は3つあります。
それぞれに問題があり、最終的にEloquent ORMが生まれました。

【方法1】生SQL - 最も危険な方法

use Illuminate\Support\Facades\DB;

// 全件取得
$products = DB::select('SELECT * FROM products');

// 条件付き取得
$products = DB::select('SELECT * FROM products WHERE price > ?', [10000]);

// ❌ 危険な書き方（SQLインジェクションの危険性）
$products = DB::select("SELECT * FROM products WHERE name = '$name'");

【方法2】クエリビルダー - まだリスクが残る

use Illuminate\Support\Facades\DB;

// ✅ 安全な書き方
$products = DB::table('products')->where('price', '>', 10000)->get();

// ❌ 危険な書き方（whereRaw を使うとSQLインジェクションのリスク）
$products = DB::table('products')
    ->whereRaw("name = '$name'")  // 危険！
    ->get();

// クエリビルダー: JOINを手動で書く必要がある
$products = DB::table('products')
    ->join('categories', 'products.category_id', '=', 'categories.id')
    ->select('products.*', 'categories.name as category_name')
    ->get();

// 結果は配列（オブジェクトではない）
foreach ($products as $product) {
    echo $product->category_name;  // categoryオブジェクトではなく文字列
}

php artisan tinker

// クエリビルダーでJOIN
>>> $products = DB::table('products')
...     ->join('categories', 'products.category_id', '=', 'categories.id')
...     ->select('products.*', 'categories.name as category_name')
...     ->limit(2)
...     ->get();

=> Illuminate\Support\Collection {
     all: [
       {
         +"id": 1,
         +"name": "ノートPC",
         +"description": "高性能なノートパソコン",
         +"price": 120000,
         +"stock": 10,
         +"is_published": 1,
         +"category_id": 1,
         +"created_at": "2025-10-26 23:30:29",
         +"updated_at": "2025-10-26 23:30:29",
         +"category_name": "家電",  // ← 文字列として追加されただけ
       },
       {
         +"id": 2,
         +"name": "ワイヤレスマウス",
         +"description": "静音設計のマウス",
         +"price": 3000,
         +"stock": 50,
         +"is_published": 1,
         +"category_id": 1,
         +"created_at": "2025-10-26 23:30:29",
         +"updated_at": "2025-10-26 23:30:29",
         +"category_name": "家電",
       },
     ],
   }

// カテゴリー名を取得する場合
>>> $products[0]->category_name;
=> "家電"  // ただの文字列

// カテゴリーオブジェクトは存在しない
>>> $products[0]->category;
=> null  // ❌ リレーションではないので取れない

// Eloquent: リレーションで簡単に取得
$products = Product::with('category')->get();

foreach ($products as $product) {
    echo $product->category->name;  // リレーションで自動取得
}

>>> $products = App\Models\Product::with('category')->limit(2)->get();

=> Illuminate\Database\Eloquent\Collection {
     all: [
       App\Models\Product {
         id: 1,
         name: "ノートPC",
         description: "高性能なノートパソコン",
         price: 120000,
         stock: 10,
         is_published: 1,
         category_id: 1,
         created_at: "2025-10-26 23:30:29",
         updated_at: "2025-10-26 23:30:29",
         category: App\Models\Category {  // ← オブジェクトとして取得！
           id: 1,
           name: "家電",
           created_at: "2025-10-26 23:30:29",
           updated_at: "2025-10-26 23:30:29",
         },
       },
       App\Models\Product {
         id: 2,
         name: "ワイヤレスマウス",
         description: "静音設計のマウス",
         price: 3000,
         stock: 50,
         is_published: 1,
         category_id: 1,
         created_at: "2025-10-26 23:30:29",
         updated_at: "2025-10-26 23:30:29",
         category: App\Models\Category {
           id: 1,
           name: "家電",
           created_at: "2025-10-26 23:30:29",
           updated_at: "2025-10-26 23:30:29",
         },
       },
     ],
   }

// カテゴリー名を取得
>>> $products[0]->category->name;
=> "家電"

// カテゴリーの他の情報も取得可能
>>> $products[0]->category->id;
=> 1

>>> $products[0]->category->created_at;
=> Illuminate\Support\Carbon @1730020229 {
     date: 2025-10-26 23:30:29.0 UTC (+00:00),
   }

// 例: 価格を税込みで表示したい場合

// クエリビルダー: 毎回計算が必要
$products = DB::table('products')->get();
foreach ($products as $product) {
    echo $product->price * 1.1;  // 毎回計算を書く必要がある
}

// Eloquent: モデルにカスタムメソッドを定義すれば再利用できる
// Product.php
public function getPriceWithTax() {
    return $this->price * 1.1;
}

// 使う側
$products = Product::all();
foreach ($products as $product) {
    echo $product->getPriceWithTax();  // スッキリ！明示的！
}

// クエリビルダー: テーブル名が文字列（タイポしても気づかない）
DB::table('producst')->get();  // タイポ！でもエラーにならず実行時に失敗

// Eloquent: クラス名なのでIDEが補完してくれる
Product::all();  // タイポしたら即座にエラーになる

【方法3】Eloquent ORM - 最も安全な方法

use App\Models\Product;

// 全件取得
$products = Product::all();

// 条件付き取得
$products = Product::where('price', '>', 10000)->get();

// ユーザー入力を使っても安全
$products = Product::where('name', $request->name)->get();  // ✅ 自動でエスケープされる

3つの方法の比較

リレーションシップの実践

ここからは、実際にリレーションシップを定義して、Tinkerで動作を確認していきます。
Product（商品）を中心に、Category（カテゴリー）、ProductDetail（商品詳細）、Tag（タグ）との関係を学びます。

【準備】Categoryモデルを作成

categoriesテーブルは既に存在しているため、モデルだけを作成します。

php artisan make:model Category

Categoryモデルを編集

app/Models/Category.php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Category extends Model
{
    use HasFactory;

    // まだ設定していないため、Categoryにもfillableを設定
    protected $fillable = ['name'];
}

📚 リレーションメソッドの種類

Laravelでは、テーブル間の関係を表現するために、いくつかのリレーションメソッドが用意されています。

Product::class
// ↓ 実際にはこの文字列を返す
"App\Models\Product"

1対多（One to Many）リレーションを定義

Product（商品） ← Category（カテゴリー）
1つのカテゴリーは複数の商品を持つ関係です。

Category側（親）にリレーションを追加

app/Models/Category.php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Category extends Model
{
    use HasFactory;

    protected $fillable = ['name'];

    // このカテゴリーに属する商品（複数）
    public function products()
    {
        return $this->hasMany(Product::class);
    }
}

Product側（子）にリレーションを追加

app/Models/Product.php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    use HasFactory;

    protected $fillable = [
        'name',
        'description',
        'price',
        'stock',
        'is_published',
        'category_id',  // 外部キー
    ];

    // この商品が属するカテゴリー（1つ）
    public function category()
    {
        return $this->belongsTo(Category::class);
    }
}

// ✅ 推奨: わかりやすい名前
public function category()  // 単数形（1つのカテゴリー）
{
    return $this->belongsTo(Category::class);
}

public function products()  // 複数形（複数の商品）
{
    return $this->hasMany(Product::class);
}

// ❌ 動くけど推奨しない: 意味不明な名前
public function test123()  // これでも動く
{
    return $this->belongsTo(Category::class);
}

// ✅ こんな名前でもOK（意味があれば）
public function belongsToCategory()  // より明示的
{
    return $this->belongsTo(Category::class);
}

public function allProducts()  // すべての商品
{
    return $this->hasMany(Product::class);
}

// ケース1: category() というメソッド名の場合
public function category()
{
    return $this->belongsTo(Category::class);
}

// 使い方
$product = Product::first();
$product->category;  // ✅ category() で定義したので category でアクセス
$product->test123;   // ❌ エラー: そんなリレーションは存在しない

// ケース2: test123() というメソッド名に変えた場合
public function test123()  // メソッド名を変更
{
    return $this->belongsTo(Category::class);
}

// 使い方
$product = Product::first();
$product->category;  // ❌ エラー: category() メソッドは存在しない
$product->test123;   // ✅ test123() で定義したので test123 でアクセス

// Eager Loadingも同じ
Product::with('category')->get();  // ❌ エラー
Product::with('test123')->get();   // ✅ これなら動く

// ケース3: belongsToCategory() という名前の場合
public function belongsToCategory()
{
    return $this->belongsTo(Category::class);
}

// 使い方
$product = Product::first();
$product->category;            // ❌ エラー
$product->belongsToCategory;   // ✅ このメソッド名でアクセス

// Eager Loading
Product::with('belongsToCategory')->get();  // ✅

Tinkerで動作確認

php artisan tinker

// 既存のカテゴリーを取得（Seederで作成済み）
>>> $category = \App\Models\Category::first();
=> App\Models\Category {
     id: 1,
     name: "家電",
     created_at: "2025-10-27 12:00:00",
     updated_at: "2025-10-27 12:00:00",
   }

// 商品からカテゴリーを取得（これで動くようになった！）
>>> $product = \App\Models\Product::first();
>>> $product->category;
=> App\Models\Category {
     id: 1,
     name: "家電",
     created_at: "2025-10-27 12:00:00",
     updated_at: "2025-10-27 12:00:00",
   }

>>> $product->category->name;
=> "家電"

// カテゴリーから商品を取得
>>> $category->products;
=> Illuminate\Database\Eloquent\Collection {
     all: [
       App\Models\Product {
         id: 1,
         name: "ノートPC",
         // ... 以下省略
       },
       // ... 他の商品
     ],
   }

// withでEager Loading（これでエラーが出なくなった！）
>>> $products = \App\Models\Product::with('category')->get();
=> Illuminate\Database\Eloquent\Collection {
     all: [
       App\Models\Product {
         id: 1,
         name: "ノートPC",
         category: App\Models\Category {
           id: 1,
           name: "家電",
         },
       },
       // ...
     ],
   }

Eager Loading（事前読み込み）とは？ - N+1問題を解決する

Eager Loadingは、リレーションデータを事前にまとめて取得する機能です。
これを使わないと、N+1問題という深刻なパフォーマンス問題が発生します。

php artisan tinker

// まず、DBクエリのログを有効化
>>> \DB::enableQueryLog();

// ❌ withを使わずに商品を全件取得
>>> $products = \App\Models\Product::all();
=> Illuminate\Database\Eloquent\Collection {#...}

// 各商品のカテゴリー名を表示
>>> foreach ($products as $product) {
...     echo $product->name . ' - ' . $product->category->name . "\n";
... }
ノートPC - 家電
ワイヤレスマウス - 家電
コーヒー豆 - 食品
Tシャツ - 衣類
プログラミング入門 - 書籍

// 実行されたSQLを確認
>>> \DB::getQueryLog();
=> [
     [
       "query" => "select * from `products`",  // ← 1回目: 商品を全件取得
     ],
     [
       "query" => "select * from `categories` where `categories`.`id` = ? limit 1",
       "bindings" => [1],  // ← 2回目: category_id=1 のカテゴリーを取得
     ],
     [
       "query" => "select * from `categories` where `categories`.`id` = ? limit 1",
       "bindings" => [1],  // ← 3回目: またcategory_id=1 を取得（無駄！）
     ],
     [
       "query" => "select * from `categories` where `categories`.`id` = ? limit 1",
       "bindings" => [2],  // ← 4回目: category_id=2 のカテゴリーを取得
     ],
     [
       "query" => "select * from `categories` where `categories`.`id` = ? limit 1",
       "bindings" => [3],  // ← 5回目: category_id=3 のカテゴリーを取得
     ],
     [
       "query" => "select * from `categories` where `categories`.`id` = ? limit 1",
       "bindings" => [4],  // ← 6回目: category_id=4 のカテゴリーを取得
     ],
   ]

// 合計: 6回のクエリが実行された！
// 1回（商品） + 5回（各商品ごとにカテゴリー） = 6回

// クエリログをリセット
>>> \DB::flushQueryLog();
>>> \DB::enableQueryLog();

// ✅ withを使って商品とカテゴリーをまとめて取得
>>> $products = \App\Models\Product::with('category')->get();
=> Illuminate\Database\Eloquent\Collection {#...}

// 各商品のカテゴリー名を表示（さっきと同じコード）
>>> foreach ($products as $product) {
...     echo $product->name . ' - ' . $product->category->name . "\n";
... }
ノートPC - 家電
ワイヤレスマウス - 家電
コーヒー豆 - 食品
Tシャツ - 衣類
プログラミング入門 - 書籍

// 実行されたSQLを確認
>>> \DB::getQueryLog();
=> [
     [
       "query" => "select * from `products`",  // ← 1回目: 商品を全件取得
     ],
     [
       "query" => "select * from `categories` where `categories`.`id` in (?, ?, ?, ?)",
       "bindings" => [1, 2, 3, 4],  // ← 2回目: カテゴリーをまとめて取得！
     ],
   ]

// 合計: たった2回のクエリで完了！
// 1回（商品） + 1回（全カテゴリー） = 2回

1対1（One to One）リレーション

Product（商品） - ProductDetail（商品詳細）
1つの商品は1つの詳細情報を持つ関係です。

ProductDetailモデルとマイグレーションを作成

php artisan make:model ProductDetail -m

マイグレーションファイルを編集

public function up(): void
{
    Schema::create('product_details', function (Blueprint $table) {
        $table->id();
        $table->foreignId('product_id')->constrained()->onDelete('cascade');
        $table->text('long_description')->nullable();
        $table->string('manufacturer')->nullable();
        $table->string('warranty_period')->nullable();
        $table->timestamps();
    });
}

ProductDetailモデルを編集

app/Models/ProductDetail.php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class ProductDetail extends Model
{
    use HasFactory;

    protected $fillable = [
        'product_id',
        'long_description',
        'manufacturer',
        'warranty_period',
    ];

    // この詳細情報が属する商品（1つ）
    public function product()
    {
        return $this->belongsTo(Product::class);
    }
}

Productモデルにリレーションを追加

app/Models/Product.php（既存のcategory()の下に追加）

// この商品の詳細情報（1つ）
public function detail()
{
    return $this->hasOne(ProductDetail::class);
}

マイグレーションを実行

php artisan migrate

products テーブル
├─ id: 1
├─ name: ノートパソコン
└─ price: 120000

product_details テーブル
├─ id: 1
├─ product_id: 1  ← 外部キー（Productのidを参照）
├─ long_description: 高性能な...
└─ manufacturer: Dell

class ProductDetail extends Model
{
    // product_id を持っているので belongsTo()
    public function product()
    {
        return $this->belongsTo(Product::class);
    }
}

class Product extends Model
{
    // 外部キーを持たないので hasOne()
    public function detail()
    {
        return $this->hasOne(ProductDetail::class);
    }
}

🎯 Tinkerで試してみよう

実際に1対1リレーションを使って、商品の詳細情報を登録・取得してみます。

1️⃣ Tinkerを起動

php artisan tinker

2️⃣ 商品を1つ取得

>>> $product = \App\Models\Product::first();
=> App\Models\Product {#...
     id: 1,
     name: "ノートパソコン",
     price: 120000,
     category_id: 1,
   }

3️⃣ この商品に詳細情報を作成（hasOneを使う）

>>> $detail = $product->detail()->create([
...     'long_description' => '高性能なCore i7プロセッサーを搭載した15.6インチノートPC。メモリ16GB、SSD512GBで快適な動作を実現。',
...     'manufacturer' => 'Dell',
...     'warranty_period' => '1年間',
... ]);
=> App\Models\ProductDetail {#...
     product_id: 1,
     long_description: "高性能なCore i7プロセッサーを搭載した...",
     manufacturer: "Dell",
     warranty_period: "1年間",
   }

4️⃣ 商品から詳細情報を取得（hasOne - プロパティとしてアクセス）

>>> $product->detail;
=> App\Models\ProductDetail {#...
     id: 1,
     product_id: 1,
     long_description: "高性能なCore i7プロセッサーを搭載した...",
     manufacturer: "Dell",
     warranty_period: "1年間",
   }

// 詳細情報の特定のカラムにアクセス
>>> $product->detail->manufacturer;
=> "Dell"

>>> $product->detail->warranty_period;
=> "1年間"

5️⃣ 逆方向: 詳細情報から商品を取得（belongsTo）

>>> $detail = \App\Models\ProductDetail::first();
=> App\Models\ProductDetail {#...
     id: 1,
     product_id: 1,
     long_description: "高性能なCore i7プロセッサーを搭載した...",
   }

// この詳細情報が属する商品を取得
>>> $detail->product;
=> App\Models\Product {#...
     id: 1,
     name: "ノートパソコン",
     price: 120000,
   }

>>> $detail->product->name;
=> "ノートパソコン"

6️⃣ Eager Loadingで一緒に取得

// ✅ 商品と詳細情報をまとめて取得
>>> $products = \App\Models\Product::with('detail')->get();

>>> foreach ($products as $product) {
...     echo $product->name;
...     if ($product->detail) {
...         echo " - 製造元: " . $product->detail->manufacturer;
...     }
...     echo "\n";
... }
ノートパソコン - 製造元: Dell
スマートフォン
冷蔵庫
...

// ❌ エラーになる可能性
$product->detail->manufacturer;  // detailがnullの場合エラー

// ✅ 安全
if ($product->detail) {
    echo $product->detail->manufacturer;
}

多対多（Many to Many）リレーション

Product（商品） ↔ Tag（タグ）
1つの商品は複数のタグを持ち、1つのタグは複数の商品に紐づく関係です。

products テーブル
├─ id: 1 (ノートパソコン)
├─ id: 2 (スマートフォン)

tags テーブル
├─ id: 1 (人気)
├─ id: 2 (新商品)
├─ id: 3 (セール中)

product_tag テーブル（中間テーブル）
├─ product_id: 1, tag_id: 1  ← ノートパソコンは「人気」
├─ product_id: 1, tag_id: 2  ← ノートパソコンは「新商品」
├─ product_id: 2, tag_id: 1  ← スマートフォンは「人気」
└─ product_id: 2, tag_id: 3  ← スマートフォンは「セール中」

Tagモデルとマイグレーションを作成

php artisan make:model Tag -m

マイグレーションファイルを編集（tagsテーブル）

database/migrations/xxxx_create_tags_table.php

public function up(): void
{
    Schema::create('tags', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->timestamps();
    });
}

中間テーブルのマイグレーションを作成

php artisan make:migration create_product_tag_table

中間テーブルのマイグレーションを編集

database/migrations/xxxx_create_product_tag_table.php

public function up(): void
{
    Schema::create('product_tag', function (Blueprint $table) {
        $table->id();
        $table->foreignId('product_id')->constrained()->onDelete('cascade');
        $table->foreignId('tag_id')->constrained()->onDelete('cascade');
        $table->timestamps();
    });
}

Tagモデルを編集

app/Models/Tag.php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Tag extends Model
{
    use HasFactory;

    protected $fillable = ['name'];

    // このタグが紐づく商品（複数）
    public function products()
    {
        return $this->belongsToMany(Product::class);
    }
}

Productモデルにリレーションを追加

app/Models/Product.php（既存のリレーションの下に追加）

// この商品に紐づくタグ（複数）
public function tags()
{
    return $this->belongsToMany(Tag::class);
}

マイグレーションを実行

php artisan migrate

🎯 Tinkerで試してみよう

実際に多対多リレーションを使って、商品にタグを紐づけてみます。

1️⃣ Tinkerを起動

php artisan tinker

2️⃣ タグを作成

>>> $tag1 = \App\Models\Tag::create(['name' => '人気']);
=> App\Models\Tag {#... id: 1, name: "人気" }

>>> $tag2 = \App\Models\Tag::create(['name' => '新商品']);
=> App\Models\Tag {#... id: 2, name: "新商品" }

>>> $tag3 = \App\Models\Tag::create(['name' => 'セール中']);
=> App\Models\Tag {#... id: 3, name: "セール中" }

3️⃣ 商品を取得

>>> $product = \App\Models\Product::first();
=> App\Models\Product {#... id: 1, name: "ノートパソコン" }

4️⃣ 商品にタグを紐づける（attach）

// 1つずつ紐づける
>>> $product->tags()->attach($tag1->id);
>>> $product->tags()->attach($tag2->id);

// または、配列でまとめて紐づける
>>> $product->tags()->attach([1, 2]);

// タグIDを直接指定してもOK
>>> $product->tags()->attach(3);

5️⃣ 商品に紐づくタグを取得

>>> $product->tags;
=> Illuminate\Database\Eloquent\Collection {#...
     all: [
       App\Models\Tag {#... id: 1, name: "人気" },
       App\Models\Tag {#... id: 2, name: "新商品" },
       App\Models\Tag {#... id: 3, name: "セール中" },
     ],
   }

// タグ名だけ取得
>>> $product->tags->pluck('name');
=> Illuminate\Support\Collection {#...
     all: ["人気", "新商品", "セール中"],
   }

6️⃣ 逆方向: タグに紐づく商品を取得

>>> $tag = \App\Models\Tag::find(1);  // 「人気」タグ
=> App\Models\Tag {#... id: 1, name: "人気" }

>>> $tag->products;
=> Illuminate\Database\Eloquent\Collection {#...
     all: [
       App\Models\Product {#... id: 1, name: "ノートパソコン" },
       App\Models\Product {#... id: 2, name: "スマートフォン" },
     ],
   }

7️⃣ タグの紐づけを解除（detach）

// 特定のタグを解除
>>> $product->tags()->detach(3);  // 「セール中」タグを解除

// 複数のタグを解除
>>> $product->tags()->detach([1, 2]);

// 全てのタグを解除
>>> $product->tags()->detach();

8️⃣ タグを同期（sync）

// 指定したタグIDだけを紐づける（それ以外は削除）
>>> $product->tags()->sync([1, 3]);
// 結果: 「人気」と「セール中」だけが紐づく

// 既存のタグを保持しつつ、新しいタグを追加したい場合
>>> $product->tags()->syncWithoutDetaching([2]);
// 結果: 「人気」「セール中」「新商品」の3つが紐づく

9️⃣ Eager Loadingで一緒に取得

// ✅ 商品とタグをまとめて取得
>>> $products = \App\Models\Product::with('tags')->get();

>>> foreach ($products as $product) {
...     echo $product->name . " のタグ: ";
...     echo $product->tags->pluck('name')->implode(', ');
...     echo "\n";
... }
ノートパソコン のタグ: 人気, 新商品, セール中
スマートフォン のタグ: 人気
冷蔵庫 のタグ:
...

モデルの便利な機能

リレーション以外にも、モデルには便利な機能があります。
「なぜEloquent ORMを使うのか」で触れた「問題3: モデルの機能が使えない」の具体例を見ていきましょう。

カスタムメソッド（ビジネスロジック）

モデルに独自のメソッドを追加して、ビジネスロジックをカプセル化できます。

例1: 高額商品かどうかを判定

// ❌ コントローラーやビューで毎回判定（悪い例）
if ($product->price >= 100000) {
    echo "高額商品";
}

// ✅ モデルにメソッドを定義（良い例）
class Product extends Model
{
    public function isExpensive()
    {
        return $this->price >= 100000;
    }
}

// 使用
if ($product->isExpensive()) {
    echo "高額商品";
}

例2: 在庫があるかチェック

class Product extends Model
{
    public function isInStock()
    {
        return $this->stock > 0;
    }

    public function hasLowStock()
    {
        return $this->stock > 0 && $this->stock <= 5;
    }
}

// 使用
if ($product->isInStock()) {
    echo "購入可能";
}

if ($product->hasLowStock()) {
    echo "残りわずか！";
}

例3: フォーマットされた価格を取得

class Product extends Model
{
    // 定数で税率を管理（マジックナンバーを避ける）
    const TAX_RATE_STANDARD = 0.1;   // 標準税率10%
    const TAX_RATE_REDUCED = 0.08;   // 軽減税率8%

    public function getFormattedPrice()
    {
        return '¥' . number_format($this->price);
    }

    public function getPriceWithTax($taxRate = null)
    {
        // nullの場合は標準税率を使用
        $rate = $taxRate ?? self::TAX_RATE_STANDARD;
        $priceWithTax = $this->price * (1 + $rate);
        return '¥' . number_format($priceWithTax);
    }
}

// 使用
echo $product->getFormattedPrice();                           // ¥120,000
echo $product->getPriceWithTax();                             // ¥132,000（標準税率）
echo $product->getPriceWithTax(Product::TAX_RATE_REDUCED);    // ¥129,600（軽減税率）

例4: 割引価格を計算

class Product extends Model
{
    public function getDiscountedPrice($discountPercent)
    {
        return $this->price * (1 - $discountPercent / 100);
    }

    public function isOnSale()
    {
        // tagsリレーションを使って「セール中」タグがあるかチェック
        return $this->tags->contains('name', 'セール中');
    }
}

// 使用
if ($product->isOnSale()) {
    $salePrice = $product->getDiscountedPrice(20);  // 20%オフ
    echo "セール価格: ¥" . number_format($salePrice);
}

🎯 Tinkerで試してみよう

実際にカスタムメソッドを追加して、Tinkerで動作を確認してみます。

1️⃣ Productモデルにメソッドを追加

app/Models/Product.php

class Product extends Model
{
    // 既存のリレーション...

    // 定数
    const TAX_RATE_STANDARD = 0.1;   // 標準税率10%
    const TAX_RATE_REDUCED = 0.08;   // 軽減税率8%

    // カスタムメソッド
    public function isExpensive()
    {
        return $this->price >= 100000;
    }

    public function isInStock()
    {
        return $this->stock > 0;
    }

    public function getFormattedPrice()
    {
        return '¥' . number_format($this->price);
    }

    public function getPriceWithTax($taxRate = null)
    {
        $rate = $taxRate ?? self::TAX_RATE_STANDARD;
        $priceWithTax = $this->price * (1 + $rate);
        return '¥' . number_format($priceWithTax);
    }
}

2️⃣ Tinkerで試す

php artisan tinker

>>> $product = \App\Models\Product::first();
=> App\Models\Product {#...
     id: 1,
     name: "ノートパソコン",
     price: 120000,
     stock: 5,
   }

// 高額商品かチェック
>>> $product->isExpensive();
=> true

// 在庫チェック
>>> $product->isInStock();
=> true

// フォーマットされた価格
>>> $product->getFormattedPrice();
=> "¥120,000"

// 税込価格（デフォルトで標準税率）
>>> $product->getPriceWithTax();
=> "¥132,000"

// 軽減税率を指定
>>> $product->getPriceWithTax(Product::TAX_RATE_REDUCED);
=> "¥129,600"

// 定数の確認
>>> Product::TAX_RATE_STANDARD;
=> 0.1

>>> Product::TAX_RATE_REDUCED;
=> 0.08

その他のモデル機能（参考）

以下の機能も便利ですが、まずはカスタムメソッドをマスターしましょう。
詳細は公式ドキュメントを参照してください。

protected $casts = [
    'price' => 'integer',        // 文字列 → 数値
    'is_active' => 'boolean',    // "1" → true, "0" → false
    'options' => 'array',        // JSON文字列 → 配列
    'published_at' => 'datetime', // 文字列 → Carbonオブジェクト
];

// getXxxAttribute() という命名規則
public function getFullNameAttribute()
{
    return $this->first_name . ' ' . $this->last_name;
}

// 使用
$user->full_name;  // "太郎 山田"（自動的にメソッドが呼ばれる）

// setXxxAttribute() という命名規則
public function setNameAttribute($value)
{
    $this->attributes['name'] = strtoupper($value);  // 大文字に変換
}

// 使用
$product->name = 'laptop';  // 保存時に自動的に "LAPTOP" になる

まとめ

この章では、Laravelのモデル（Model）とEloquent ORMについて学びました。

重要なポイント

• モデルは app/Models/ に配置
• php artisan make:model で作成
• Eloquent ORMで安全にデータベース操作（SQLインジェクション対策が自動）
• CRUD操作: create(), find(), update(), delete()
• $fillable で一括代入を制御（Mass Assignment対策）
• リレーションで関連データを簡単に取得: $product->category
• 多対多リレーションでは中間テーブル（ピボットテーブル）が必要
• attach(), detach(), sync() で中間テーブルを操作

よく使うEloquentメソッド

リレーションの種類

多対多リレーション操作メソッド

ベストプラクティス

次のステップ

モデルの基本とEloquent ORMの使い方を学びました。
次はDB実践で、実際にCRUDアプリケーションを作成します。