【完全解説】Laravel whereHasの使い方とパフォーマンス最適化テクニック2024

SHARE

目次

目次へ

Laravel whereHasとは？基礎から理解する

whereHasメソッドの基本的な構文と動作原理

whereHasメソッドは、Laravelのエロクアントで提供される強力なクエリビルダメソッドです。このメソッドを使用することで、リレーション先のテーブルの条件に基づいてメインのテーブルのレコードをフィルタリングすることができます。

基本的な構文は以下のようになります：

// 基本的な使用方法
$posts = Post::whereHas('comments', function($query) {
    $query->where('is_approved', true);
})->get();

// 上記のSQLはおおよそ以下のようになります
// SELECT * FROM posts 
// WHERE EXISTS (
//     SELECT * FROM comments 
//     WHERE posts.id = comments.post_id 
//     AND comments.is_approved = true
// )

whereHasの内部では、EXISTSサブクエリが生成され、指定された条件に一致するリレーションレコードが存在するかどうかをチェックします。

whereHasが解決する典型的な課題

whereHasメソッドは、以下のような一般的な開発上の課題を効率的に解決します：

  1. 関連データに基づくフィルタリング
// 特定のタグが付いた記事のみを取得
$posts = Post::whereHas('tags', function($query) {
    $query->where('name', 'Laravel');
})->get();

// 承認済みのコメントがある記事のみを取得
$posts = Post::whereHas('comments', function($query) {
    $query->where('status', 'approved');
})->get();
  1. 複数の条件による絞り込み
// アクティブなユーザーが書いた記事で、かつ承認済みコメントがあるものを取得
$posts = Post::whereHas('user', function($query) {
    $query->where('status', 'active');
})->whereHas('comments', function($query) {
    $query->where('is_approved', true);
})->get();

orWhereHasとの違いと使い分け

whereHasとorWhereHasは、条件の組み合わせ方が異なります：

  1. whereHasの場合（AND条件）
// LaravelタグとPHPタグの両方を持つ記事を取得
$posts = Post::whereHas('tags', function($query) {
    $query->where('name', 'Laravel');
})->whereHas('tags', function($query) {
    $query->where('name', 'PHP');
})->get();
  1. orWhereHasの場合（OR条件）
// LaravelタグまたはPHPタグを持つ記事を取得
$posts = Post::whereHas('tags', function($query) {
    $query->where('name', 'Laravel');
})->orWhereHas('tags', function($query) {
    $query->where('name', 'PHP');
})->get();

使い分けのポイント：

メソッド使用ケース特徴
whereHas複数の条件を全て満たす必要がある場合より厳密な検索が可能
orWhereHasいずれかの条件を満たせばよい場合より広い検索結果が得られる

whereHasとorWhereHasを適切に組み合わせることで、複雑な検索条件を表現することができます。以下は実践的な例です：

// LaravelタグがあるOR（PHPタグかつ承認済みコメントがある）記事を取得
$posts = Post::whereHas('tags', function($query) {
    $query->where('name', 'Laravel');
})->orWhere(function($query) {
    $query->whereHas('tags', function($q) {
        $q->where('name', 'PHP');
    })->whereHas('comments', function($q) {
        $q->where('is_approved', true);
    });
})->get();

この基本的な理解を踏まえた上で、より実践的な使用方法や最適化テクニックを習得することで、効率的なクエリの実装が可能になります。

whereHasの実践的な使用方法

1対多のリレーションでの活用例

1対多のリレーションは、whereHasが最も頻繁に使用されるシチュエーションの一つです。以下に実践的な例を示します：

// モデル定義
class User extends Model
{
    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}

class Post extends Model
{
    public function comments()
    {
        return $this->hasMany(Comment::class);
    }
}

// 実践的な使用例
// 1. 投稿数が5つ以上のアクティブなユーザーを取得
$users = User::whereHas('posts', function($query) {
    $query->where('status', 'published');
}, '>=', 5)->get();

// 2. 過去30日以内にコメントがついた投稿を持つユーザーを取得
$users = User::whereHas('posts', function($query) {
    $query->whereHas('comments', function($q) {
        $q->where('created_at', '>=', now()->subDays(30));
    });
})->get();

多対多のリレーションでの活用例

多対多のリレーションでは、中間テーブルの条件も含めた複雑なクエリが可能です：

// モデル定義
class Post extends Model
{
    public function tags()
    {
        return $this->belongsToMany(Tag::class)
            ->withTimestamps()
            ->withPivot('added_by');
    }
}

// 実践的な使用例
// 1. 特定の管理者が追加したタグを持つ投稿を取得
$posts = Post::whereHas('tags', function($query) {
    $query->wherePivot('added_by', 1); // admin_id = 1
})->get();

// 2. 複数の必須タグを持つ投稿を取得
$posts = Post::whereHas('tags', function($query) {
    $query->where('name', 'Laravel');
})->whereHas('tags', function($query) {
    $query->where('name', 'Performance');
})->get();

// 3. タグ付けされた日時に基づくフィルタリング
$posts = Post::whereHas('tags', function($query) {
    $query->wherePivot('created_at', '>=', now()->subDays(7));
})->get();

ネストされたリレーションでの使用方法

複数階層のリレーションを扱う場合、whereHasを入れ子にして使用できます：

// モデル定義
class Department extends Model
{
    public function teams()
    {
        return $this->hasMany(Team::class);
    }
}

class Team extends Model
{
    public function projects()
    {
        return $this->hasMany(Project::class);
    }
}

class Project extends Model
{
    public function tasks()
    {
        return $this->hasMany(Task::class);
    }
}

// 実践的な使用例
// 1. 高優先度のタスクがある進行中のプロジェクトを持つチームがある部門を取得
$departments = Department::whereHas('teams', function($query) {
    $query->whereHas('projects', function($q) {
        $q->where('status', 'in_progress')
          ->whereHas('tasks', function($q) {
              $q->where('priority', 'high');
          });
    });
})->get();

// 2. より読みやすい形に分割した例
$departments = Department::whereHas('teams', function($query) {
    $query->whereHas('projects', function($q) {
        $q->where('status', 'in_progress');

        // タスクに関する条件を別のwhere句として追加
        $q->whereHas('tasks', function($taskQuery) {
            $taskQuery->where('priority', 'high')
                     ->where('status', '!=', 'completed');
        });
    });
})
->with(['teams.projects' => function($query) {
    // Eagerローディングの条件を追加
    $query->where('status', 'in_progress');
}])
->get();

実装のポイント：

シナリオ推奨アプローチ注意点
1対多シンプルな条件から始めるN+1問題に注意
多対多中間テーブルの条件も考慮インデックスの設計が重要
ネスト条件を分割して可読性を確保パフォーマンスに注意

これらの実装パターンを理解することで、複雑なデータ構造においても効率的なクエリを作成することができます。また、必要に応じてwithメソッドを組み合わせることで、パフォーマンスを最適化することも重要です。

whereHasを使用した実装パターン集

特定の条件を満たす関連レコードの絞り込み

実践的なシナリオでは、複数の条件を組み合わせた複雑なフィルタリングが必要になります。以下に主要なパターンを示します：

// 基本的なパターン：条件の組み合わせ
class Order extends Model
{
    public function items()
    {
        return $this->hasMany(OrderItem::class);
    }

    public function customer()
    {
        return $this->belongsTo(Customer::class);
    }
}

// 1. 高額商品を含む注文の検索
$orders = Order::whereHas('items', function($query) {
    $query->where('price', '>=', 10000);
})->get();

// 2. 複数の商品カテゴリーを含む注文
$orders = Order::whereHas('items', function($query) {
    $query->whereIn('category', ['electronics', 'accessories']);
})->get();

// 3. VIP顧客の大口注文
$orders = Order::whereHas('customer', function($query) {
    $query->where('status', 'vip');
})->whereHas('items', function($query) {
    $query->having(DB::raw('SUM(quantity * price)'), '>=', 100000);
})->get();

関連レコードの数に基づくフィルタリング

レコード数に基づくフィルタリングは、ビジネスロジックの実装でよく使用されるパターンです：

class Product extends Model
{
    public function reviews()
    {
        return $this->hasMany(Review::class);
    }

    public function orderItems()
    {
        return $this->hasMany(OrderItem::class);
    }
}

// 1. 評価数による商品フィルタリング
$popularProducts = Product::whereHas('reviews', function($query) {
    $query->where('rating', '>=', 4);
}, '>=', 10)->get();

// 2. 複合条件での注文数フィルタリング
$products = Product::where(function($query) {
    // 直近30日の注文数が20以上
    $query->whereHas('orderItems', function($q) {
        $q->where('created_at', '>=', now()->subDays(30));
    }, '>=', 20)
    // かつ 評価が4以上の商品
    ->whereHas('reviews', function($q) {
        $q->where('rating', '>=', 4);
    });
})->get();

// 3. 在庫切れリスク商品の検出
$products = Product::whereHas('orderItems', function($query) {
    $query->select(DB::raw('COUNT(*)'))
          ->where('created_at', '>=', now()->subDays(7))
          ->havingRaw('COUNT(*) >= ?', [10]);
})->where('stock', '<=', 20)->get();

複雑な条件を組み合わせた検索の実装

より複雑なビジネスロジックを実装する場合の例を示します：

class Course extends Model
{
    public function students()
    {
        return $this->belongsToMany(Student::class);
    }

    public function assignments()
    {
        return $this->hasMany(Assignment::class);
    }

    public function lessons()
    {
        return $this->hasMany(Lesson::class);
    }
}

// 1. 高度な条件を持つスコープの作成
class Course extends Model
{
    // アクティブな受講生がいるコースのスコープ
    public function scopeWithActiveStudents($query)
    {
        return $query->whereHas('students', function($q) {
            $q->where('status', 'active')
              ->where('last_login_at', '>=', now()->subDays(30));
        });
    }

    // 進捗率の高いコースのスコープ
    public function scopeHighProgress($query, $progressRate = 80)
    {
        return $query->whereHas('students', function($q) use ($progressRate) {
            $q->where('progress', '>=', $progressRate);
        }, '>=', 5);
    }
}

// 2. 複数の条件を組み合わせた高度な検索
$courses = Course::withActiveStudents()
    ->where(function($query) {
        $query->whereHas('assignments', function($q) {
            $q->where('due_date', '>=', now())
              ->where('due_date', '<=', now()->addDays(7));
        })->orWhereHas('lessons', function($q) {
            $q->where('start_date', '>=', now())
              ->where('start_date', '<=', now()->addDays(7));
        });
    })
    ->whereHas('students', function($query) {
        $query->where('progress', '>=', 50);
    }, '>=', 3)
    ->get();

// 3. 動的なフィルター条件の構築
class CourseController extends Controller
{
    public function index(Request $request)
    {
        $query = Course::query();

        // 動的なフィルター条件の追加
        if ($request->has('min_students')) {
            $query->whereHas('students', function($q) {}, '>=', 
                $request->input('min_students'));
        }

        if ($request->has('assignment_type')) {
            $query->whereHas('assignments', function($q) use ($request) {
                $q->where('type', $request->input('assignment_type'));
            });
        }

        if ($request->has('progress_rate')) {
            $query->whereHas('students', function($q) use ($request) {
                $q->where('progress', '>=', 
                    $request->input('progress_rate'));
            });
        }

        return $query->get();
    }
}

実装パターンのベストプラクティス：

パターン使用シーンメリット
スコープ定義頻繁に使用する条件コードの再利用性が向上
動的フィルターAPI実装柔軟な検索条件の構築が可能
複合条件複雑なビジネスロジック保守性の高いコード構造

これらのパターンを適切に組み合わせることで、保守性が高く、パフォーマンスも考慮した実装が可能になります。また、ビジネスロジックの変更にも柔軟に対応できる構造を実現できます。

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

N+1問題の回避とeagerロードの適切な使用

whereHasを使用する際、最も注意すべき点はN+1問題の回避です。以下に、問題の特定と解決方法を示します：

// N+1問題が発生するコード
$posts = Post::whereHas('comments', function($query) {
    $query->where('is_approved', true);
})->get();

foreach ($posts as $post) {
    // 各投稿に対して追加のクエリが実行される
    echo $post->comments->count() . " comments\n";
}

// 最適化されたコード
$posts = Post::whereHas('comments', function($query) {
    $query->where('is_approved', true);
})
->with(['comments' => function($query) {
    $query->where('is_approved', true);
}])
->get();

// クエリログの確認方法
\DB::enableQueryLog();
// クエリ実行
$posts = Post::whereHas('comments')->with('comments')->get();
// ログの表示
dd(\DB::getQueryLog());

Eagerローディングのベストプラクティス：

シナリオ推奨アプローチ注意点
単一のリレーションwith() を使用クエリ条件の一致を確認
複数のリレーションwith(['relation1', 'relation2'])メモリ使用量に注意
条件付きロードwhen() と組み合わせる不要なロードを避ける

インデックス設計のベストプラクティス

whereHasのパフォーマンスを最適化するには、適切なインデックス設計が不可欠です：

// マイグレーションでのインデックス設定例
class CreateCommentsTable extends Migration
{
    public function up()
    {
        Schema::create('comments', function (Blueprint $table) {
            $table->id();
            $table->foreignId('post_id')->constrained();
            $table->boolean('is_approved')->default(false);
            $table->timestamps();

            // 複合インデックスの作成
            $table->index(['post_id', 'is_approved']);
        });
    }
}

// クエリパフォーマンスの分析
$explain = DB::select('EXPLAIN SELECT * FROM posts WHERE EXISTS (
    SELECT * FROM comments 
    WHERE posts.id = comments.post_id 
    AND comments.is_approved = true
)');

インデックス設計のポイント：

  1. 外部キーのインデックス
// 基本的な外部キーインデックス
$table->foreign('user_id')->references('id')->on('users')->index();

// 複合インデックスが必要な場合
$table->index(['user_id', 'status']);
  1. 検索条件のインデックス
// 頻繁に使用される検索条件のインデックス
$table->index(['status', 'created_at']);

// 部分インデックスの活用（PostgreSQLの場合）
// migration内で実行
DB::statement('CREATE INDEX comments_approved_idx ON comments (post_id) WHERE is_approved = true');

クエリのキャッシュ戦略

whereHasを使用したクエリのキャッシュ戦略を実装します：

class PostRepository
{
    // キャッシュを活用したクエリの実装
    public function getApprovedCommentPosts($minutes = 60)
    {
        $cacheKey = 'posts_with_approved_comments';

        return Cache::remember($cacheKey, now()->addMinutes($minutes), function() {
            return Post::whereHas('comments', function($query) {
                $query->where('is_approved', true);
            })
            ->with(['comments' => function($query) {
                $query->where('is_approved', true);
            }])
            ->get();
        });
    }

    // タグ付きキャッシュの実装
    public function getPostsByTag($tagName, $minutes = 30)
    {
        $cacheKey = "posts_with_tag_{$tagName}";

        return Cache::tags(['posts', 'tags'])->remember($cacheKey, 
            now()->addMinutes($minutes), function() use ($tagName) {
                return Post::whereHas('tags', function($query) use ($tagName) {
                    $query->where('name', $tagName);
                })->with('tags')->get();
        });
    }

    // キャッシュの自動更新
    public function updatePost($post)
    {
        DB::transaction(function() use ($post) {
            $post->save();
            Cache::tags(['posts'])->flush();
        });
    }
}

// 使用例
class PostController extends Controller
{
    protected $repository;

    public function __construct(PostRepository $repository)
    {
        $this->repository = $repository;
    }

    public function index($tagName = null)
    {
        if ($tagName) {
            return $this->repository->getPostsByTag($tagName);
        }
        return $this->repository->getApprovedCommentPosts();
    }
}

パフォーマンス最適化のチェックリスト：

  1. クエリの監視
  • クエリログの定期的な確認
  • 実行時間の計測
  • メモリ使用量のモニタリング
  1. インデックス管理
  • 定期的なインデックス使用状況の確認
  • 不要なインデックスの削除
  • インデックスの再構築
  1. キャッシュ戦略
  • キャッシュ有効期限の適切な設定
  • キャッシュタグの効果的な使用
  • キャッシュクリア条件の明確化

これらの最適化テクニックを適切に組み合わせることで、whereHasを使用したクエリのパフォーマンスを大幅に改善できます。特に大規模なアプリケーションでは、これらの最適化が重要になります。

whereHasの実践的なユースケース

Eコマースでの商品検索機能の実装

Eコマースサイトでの商品検索は、複数の条件を組み合わせた複雑なクエリが必要になります：

class Product extends Model
{
    public function categories()
    {
        return $this->belongsToMany(Category::class);
    }

    public function variants()
    {
        return $this->hasMany(ProductVariant::class);
    }

    public function reviews()
    {
        return $this->hasMany(Review::class);
    }

    // 在庫のある商品のスコープ
    public function scopeInStock($query)
    {
        return $query->whereHas('variants', function($q) {
            $q->where('stock', '>', 0);
        });
    }

    // 評価の高い商品のスコープ
    public function scopeHighlyRated($query, $minRating = 4)
    {
        return $query->whereHas('reviews', function($q) use ($minRating) {
            $q->having(DB::raw('AVG(rating)'), '>=', $minRating);
        });
    }
}

class ProductController extends Controller
{
    public function search(Request $request)
    {
        $query = Product::query();

        // カテゴリーによるフィルタリング
        if ($request->has('category')) {
            $query->whereHas('categories', function($q) use ($request) {
                $q->where('slug', $request->category);
            });
        }

        // 価格帯によるフィルタリング
        if ($request->has('price_range')) {
            $query->whereHas('variants', function($q) use ($request) {
                [$min, $max] = explode('-', $request->price_range);
                $q->whereBetween('price', [$min, $max]);
            });
        }

        // 在庫状況でのフィルタリング
        if ($request->has('in_stock')) {
            $query->inStock();
        }

        // 評価によるフィルタリング
        if ($request->has('min_rating')) {
            $query->highlyRated($request->min_rating);
        }

        return $query->with(['categories', 'variants', 'reviews'])
                    ->paginate(20);
    }
}

ブログシステムでのタグ付き記事検索

ブログシステムでは、タグやカテゴリーを使った記事の検索が一般的です：

class Post extends Model
{
    public function tags()
    {
        return $this->belongsToMany(Tag::class);
    }

    public function author()
    {
        return $this->belongsTo(User::class, 'user_id');
    }

    public function comments()
    {
        return $this->hasMany(Comment::class);
    }

    // 人気記事のスコープ
    public function scopePopular($query)
    {
        return $query->whereHas('comments', function($q) {
            $q->where('created_at', '>=', now()->subDays(30));
        }, '>=', 5);
    }
}

class BlogController extends Controller
{
    public function index(Request $request)
    {
        $query = Post::query()->with(['tags', 'author', 'comments']);

        // 複数タグでの検索
        if ($request->has('tags')) {
            $tagSlugs = explode(',', $request->tags);
            foreach ($tagSlugs as $slug) {
                $query->whereHas('tags', function($q) use ($slug) {
                    $q->where('slug', $slug);
                });
            }
        }

        // 特定の著者の人気記事
        if ($request->has('author')) {
            $query->whereHas('author', function($q) use ($request) {
                $q->where('username', $request->author);
            })->popular();
        }

        return $query->latest()->paginate(15);
    }
}

ソーシャルメディアでのユーザー関連検索

ソーシャルメディアプラットフォームでの複雑な検索機能の実装：

class User extends Model
{
    public function followers()
    {
        return $this->belongsToMany(User::class, 'followers', 'followed_id', 'follower_id');
    }

    public function following()
    {
        return $this->belongsToMany(User::class, 'followers', 'follower_id', 'followed_id');
    }

    public function posts()
    {
        return $this->hasMany(Post::class);
    }

    public function interests()
    {
        return $this->belongsToMany(Interest::class);
    }
}

class UserSearchService
{
    public function findPotentialConnections(User $user)
    {
        // 共通の興味を持つフォロワーのフォロワーを検索
        return User::whereHas('interests', function($query) use ($user) {
            $query->whereIn('id', $user->interests->pluck('id'));
        })
        ->whereHas('followers', function($query) use ($user) {
            $query->whereIn('follower_id', $user->followers->pluck('id'));
        })
        ->where('id', '!=', $user->id)
        ->whereDoesntHave('followers', function($query) use ($user) {
            $query->where('follower_id', $user->id);
        })
        ->withCount(['followers', 'following', 'posts'])
        ->having('followers_count', '>=', 5)
        ->get();
    }

    public function findActiveUsersInNetwork(User $user)
    {
        $thirtyDaysAgo = now()->subDays(30);

        return User::whereHas('following', function($query) use ($user) {
            $query->where('followed_id', $user->id);
        })
        ->whereHas('posts', function($query) use ($thirtyDaysAgo) {
            $query->where('created_at', '>=', $thirtyDaysAgo);
        }, '>=', 5)
        ->withCount(['posts' => function($query) use ($thirtyDaysAgo) {
            $query->where('created_at', '>=', $thirtyDaysAgo);
        }])
        ->orderBy('posts_count', 'desc')
        ->get();
    }
}

実装のポイント：

ユースケース重要な考慮点最適化アプローチ
Eコマース検索条件の柔軟性スコープの活用とキャッシュ戦略
ブログコンテンツの関連性タグベースの検索最適化
SNSユーザー関係の複雑性インデックス設計と条件の分割

これらの実装例は、whereHasを使用した実践的なアプリケーション開発の基礎となります。特に、複雑なビジネスロジックを効率的に実装する際の参考になります。

whereHasのデバッグとトラブルシューティング

一般的なエラーパターンと解決方法

whereHasを使用する際によく遭遇するエラーとその解決方法を説明します：

  1. リレーション名の誤り
// エラーが発生するコード
$posts = Post::whereHas('comment', function($query) { // 'comments'が正しい
    $query->where('is_approved', true);
})->get();

// エラーメッセージ
// Illuminate\Database\Eloquent\RelationNotFoundException: Call to undefined relationship [comment] on model [App\Models\Post].

// 解決方法
class Post extends Model
{
    // リレーション名を正しく定義
    public function comments() // 複数形が正しい
    {
        return $this->hasMany(Comment::class);
    }
}
  1. クロージャ内でのスコープ問題
// エラーが発生するコード
$status = 'approved';
$posts = Post::whereHas('comments', function($query) {
    $query->where('status', $status); // $statusが未定義
})->get();

// 解決方法
$status = 'approved';
$posts = Post::whereHas('comments', function($query) use ($status) {
    $query->where('status', $status);
})->get();
  1. N+1問題の検出と解決
// 問題のあるコード
\DB::enableQueryLog();

$posts = Post::whereHas('comments')->get();
foreach ($posts as $post) {
    echo $post->comments->count();
}

// クエリログの確認
dd(\DB::getQueryLog()); // 多数のクエリが実行されている

// 解決方法
$posts = Post::whereHas('comments')
    ->with('comments')
    ->get();

クエリログを使用したパフォーマンス分析

クエリのパフォーマンスを分析し、最適化する方法：

class QueryDebugService
{
    public function analyzeQuery($callback)
    {
        // クエリログの有効化
        \DB::enableQueryLog();

        // メモリ使用量の記録開始
        $initialMemory = memory_get_usage();

        // 実行時間の計測開始
        $startTime = microtime(true);

        // クエリの実行
        $result = $callback();

        // 実行時間の計測終了
        $endTime = microtime(true);

        // メモリ使用量の計算
        $memoryUsed = memory_get_usage() - $initialMemory;

        // クエリログの取得
        $queryLog = \DB::getQueryLog();

        // 分析結果の出力
        return [
            'execution_time' => ($endTime - $startTime) * 1000 . 'ms',
            'memory_used' => $this->formatBytes($memoryUsed),
            'query_count' => count($queryLog),
            'queries' => collect($queryLog)->map(function($query) {
                return [
                    'sql' => $query['query'],
                    'bindings' => $query['bindings'],
                    'time' => $query['time'] . 'ms'
                ];
            })
        ];
    }

    private function formatBytes($bytes)
    {
        $units = ['B', 'KB', 'MB', 'GB'];
        $bytes = max($bytes, 0);
        $pow = floor(($bytes ? log($bytes) : 0) / log(1024));
        $pow = min($pow, count($units) - 1);

        return round($bytes / (1024 ** $pow), 2) . ' ' . $units[$pow];
    }
}

// 使用例
class PostController extends Controller
{
    protected $debugService;

    public function __construct(QueryDebugService $debugService)
    {
        $this->debugService = $debugService;
    }

    public function index()
    {
        $analysis = $this->debugService->analyzeQuery(function() {
            return Post::whereHas('comments', function($query) {
                $query->where('is_approved', true);
            })->with('comments')->get();
        });

        dd($analysis);
    }
}

テスト時の効果的なモック方法

whereHasを使用するコードのテスト方法：

class PostTest extends TestCase
{
    use RefreshDatabase;

    /** @test */
    public function it_can_get_posts_with_approved_comments()
    {
        // テストデータの準備
        $postWithApprovedComments = Post::factory()->create();
        $postWithoutApprovedComments = Post::factory()->create();

        Comment::factory()
            ->count(3)
            ->for($postWithApprovedComments)
            ->create(['is_approved' => true]);

        Comment::factory()
            ->count(2)
            ->for($postWithoutApprovedComments)
            ->create(['is_approved' => false]);

        // whereHasを使用したクエリのテスト
        $posts = Post::whereHas('comments', function($query) {
            $query->where('is_approved', true);
        })->get();

        $this->assertCount(1, $posts);
        $this->assertTrue($posts->contains($postWithApprovedComments));
        $this->assertFalse($posts->contains($postWithoutApprovedComments));
    }

    /** @test */
    public function it_can_get_posts_with_multiple_conditions()
    {
        // 複雑な条件のテスト
        $post = Post::factory()->create();
        $user = User::factory()->create(['is_admin' => true]);

        Comment::factory()
            ->count(5)
            ->for($post)
            ->for($user)
            ->create(['is_approved' => true]);

        $posts = Post::whereHas('comments', function($query) {
            $query->where('is_approved', true);
        }, '>=', 5)
        ->whereHas('comments.user', function($query) {
            $query->where('is_admin', true);
        })
        ->get();

        $this->assertCount(1, $posts);
        $this->assertTrue($posts->contains($post));
    }
}

デバッグとテストのベストプラクティス：

カテゴリ推奨アプローチ注意点
エラー検出クエリログの活用本番環境での無効化
パフォーマンス段階的な計測メモリ使用量の監視
テストファクトリの活用データ準備の自動化

これらのデバッグとテスト手法を活用することで、whereHasを使用したコードの信頼性と保守性を高めることができます。特に、複雑なクエリの動作確認や性能最適化の際に役立ちます。

前の記事

【保存版】Laravel入門 2024年決定版 –…

次の記事

Laravel WebSocketの実装完全ガイド：5つの実装…