【Laravel入門】データベース検索機能を実装する完全ガイド2024 〜初心者でもわかる7つの実装手法

Laravelで作る検索機能の基礎知識
- Laravelの検索機能に必要な主要要素
- 検索機能実装前に押さえておくべき設計のポイント
シンプルな検索機能の手順実装
高度な検索機能の実装テクニック
検索機能のパフォーマンス最適化
実践的な検索機能の実装例
検索機能のテストと保守
Laravel の検索機能を強化する外部パッケージ

目次へ

Laravelで作る検索機能の基礎知識

Laravelでデータベース検索機能を実装する際に、まずは基本的な要素と設計のポイントを押さえておくことが重要です。この章では、検索機能の実装に必要な基礎知識を解説していきます。

Laravelの検索機能に必要な主要要素

Laravel で検索機能を実装する際には、以下の主要な要素が必要となります：

モデル（Model）

Eloquent ORM を使用したデータベースとのやり取り
検索用のスコープ（scope）メソッドの定義
リレーションシップの設定

コントローラ（Controller）

検索リクエストの受け取りと処理
検索条件の構築
検索結果の返却

ビュー（View）

検索フォームの表示
検索結果の表示
ページネーションの実装

ルート（Route）

検索用のエンドポイント定義
検索フォームと結果表示のルーティング

検索機能実装前に押さえておくべき設計のポイント

効率的で保守性の高い検索機能を実装するために、以下の設計ポイントを押さえておく必要があります：

検索パラメータの設計

クエリパラメータの命名規則の統一
バリデーションルールの設定
デフォルト値の適切な設定

パフォーマンスへの配慮

インデックスの適切な設定
N+1問題の回避
キャッシュ戦略の検討

セキュリティ対策

SQLインジェクション対策
XSS対策
CSRF対策

保守性と拡張性

責務の分離（SRP原則の遵守）
共通処理の抽出
テストの容易性

ユーザビリティ

検索条件の保持
検索履歴の管理
エラー処理とフィードバック

これらの要素と設計ポイントを理解した上で実装を進めることで、より堅牢で使いやすい検索機能を作ることができます。次章では、これらの知識を基に、実際のコードを使って基本的な検索機能の実装方法を解説していきます。

シンプルな検索機能の手順実装

実際にLaravelで基本的な検索機能を実装していく手順を、具体的なコード例を交えて解説します。ここでは商品検索を例に、名前による検索機能を実装していきます。

Eloquentを使った基本的な検索クエリの書き方

まず、商品（Product）モデルを作成し、基本的な検索機能を実装します。

// app/Models/Product.php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    protected $fillable = [
        'name',
        'description',
        'price',
        'category_id'
    ];

    // 検索用のスコープを定義
    public function scopeSearch($query, $keyword)
    {
        // キーワードが空の場合は全件取得
        if (empty($keyword)) {
            return $query;
        }

        // 名前で部分一致検索
        return $query->where('name', 'like', "%{$keyword}%");
    }
}

検索フォームの作成とルーティングの設定方法

検索フォームの作成とルーティングの設定を行います。

// routes/web.php
Route::get('/products', [ProductController::class, 'index'])->name('products.index');

<!-- resources/views/products/index.blade.php -->
<form action="{{ route('products.index') }}" method="GET" class="mb-4">
    <div class="flex items-center">
        <input
            type="text"
            name="keyword"
            value="{{ request('keyword') }}"
            class="border-gray-300 rounded-md shadow-sm"
            placeholder="商品名を入力"
        >
        <button type="submit" class="ml-2 px-4 py-2 bg-blue-500 text-white rounded-md">
            検索
        </button>
    </div>
</form>

検索結果の表示方法とページネーションの実現

コントローラーで検索処理を実装し、結果を表示します。

// app/Http/Controllers/ProductController.php
namespace App\Http\Controllers;

use App\Models\Product;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    public function index(Request $request)
    {
        // 検索キーワードを取得
        $keyword = $request->input('keyword');

        // クエリの実行とページネーション
        $products = Product::search($keyword)
            ->orderBy('created_at', 'desc')
            ->paginate(10);

        // ビューに変数を渡して表示
        return view('products.index', [
            'products' => $products,
            'keyword' => $keyword,
        ]);
    }
}

検索結果の表示部分を実装します：

<!-- resources/views/products/index.blade.php -->
<div class="mt-4">
    @if($products->isEmpty())
        <p>検索結果が見つかりませんでした。</p>
    @else
        <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
            @foreach($products as $product)
                <div class="border rounded-lg p-4">
                    <h3 class="text-lg font-semibold">{{ $product->name }}</h3>
                    <p class="text-gray-600">{{ $product->description }}</p>
                    <p class="text-blue-600 font-bold">¥{{ number_format($product->price) }}</p>
                </div>
            @endforeach
        </div>

        <!-- ページネーションリンクの表示 -->
        <div class="mt-4">
            {{ $products->withQueryString()->links() }}
        </div>
    @endif
</div>

このコードによって実現される機能：

基本的な検索機能

商品名による部分一致検索
検索キーワードが空の場合は全件表示
検索条件の保持

ユーザビリティの向上

検索フォームの入力値保持
検索結果が0件の場合のメッセージ表示
レスポンシブなグリッドレイアウト

ページネーション機能

10件ごとのページ分割
検索条件を保持したままのページ遷移
ページネーションリンクの表示

以上の実装により、基本的な検索機能を持つ商品一覧ページが完成します。次章では、この基本実装をベースに、より高度な検索機能の実装方法について解説していきます。

高度な検索機能の実装テクニック

基本的な検索機能を拡張して、より高度な検索機能を実装する方法を解説します。ここでは、複数条件の組み合わせ、あいまい検索、そしてクエリスコープを活用した実装テクニックを紹介します。

複数の条件を組み合わせた検索機能の作り方

複数の検索条件を組み合わせる実装例を示します：

// app/Models/Product.php
class Product extends Model
{
    public function scopeAdvancedSearch($query, array $conditions)
    {
        return $query->when($conditions['keyword'] ?? null, function ($query, $keyword) {
            $query->where(function ($query) use ($keyword) {
                $query->where('name', 'like', "%{$keyword}%")
                      ->orWhere('description', 'like', "%{$keyword}%");
            });
        })
        ->when($conditions['category_id'] ?? null, function ($query, $categoryId) {
            $query->where('category_id', $categoryId);
        })
        ->when($conditions['price_min'] ?? null, function ($query, $minPrice) {
            $query->where('price', '>=', $minPrice);
        })
        ->when($conditions['price_max'] ?? null, function ($query, $maxPrice) {
            $query->where('price', '<=', $maxPrice);
        })
        ->when($conditions['in_stock'] ?? null, function ($query) {
            $query->where('stock', '>', 0);
        });
    }
}

コントローラーでの実装：

// app/Http/Controllers/ProductController.php
public function search(Request $request)
{
    $conditions = $request->validate([
        'keyword' => 'nullable|string|max:100',
        'category_id' => 'nullable|exists:categories,id',
        'price_min' => 'nullable|numeric|min:0',
        'price_max' => 'nullable|numeric|gt:price_min',
        'in_stock' => 'nullable|boolean'
    ]);

    $products = Product::advancedSearch($conditions)
        ->with('category')  // Eager Loading
        ->orderBy('created_at', 'desc')
        ->paginate(15);

    return view('products.search', compact('products', 'conditions'));
}

部分一致検索とあいまい検索の実装方法

より柔軟な検索を実現するための実装例を示します：

// app/Models/Product.php
class Product extends Model
{
    public function scopeFuzzySearch($query, $keyword)
    {
        // キーワードを分割して配列化
        $keywords = preg_split('/[\s　]+/u', $keyword, -1, PREG_SPLIT_NO_EMPTY);

        return $query->where(function ($query) use ($keywords) {
            foreach ($keywords as $keyword) {
                $query->where(function ($query) use ($keyword) {
                    // 名前、説明文、商品コードで検索
                    $query->where('name', 'like', "%{$keyword}%")
                          ->orWhere('description', 'like', "%{$keyword}%")
                          ->orWhere('product_code', 'like', "%{$keyword}%");
                });
            }
        });
    }
}

スコープを活用した検索の最適化手法

検索機能を効率的に実装・管理するためのスコープパターンを紹介します：

// app/Models/Product.php
class Product extends Model
{
    // 価格帯による検索
    public function scopePriceRange($query, $min, $max)
    {
        return $query->when($min, fn($q) => $q->where('price', '>=', $min))
                    ->when($max, fn($q) => $q->where('price', '<=', $max));
    }

    // カテゴリーによる検索
    public function scopeInCategories($query, $categoryIds)
    {
        return $query->whereIn('category_id', (array)$categoryIds);
    }

    // 在庫状況による検索
    public function scopeStockStatus($query, $status)
    {
        return match ($status) {
            'in_stock' => $query->where('stock', '>', 0),
            'out_of_stock' => $query->where('stock', '<=', 0),
            'low_stock' => $query->where('stock', '>', 0)
                                ->where('stock', '<=', 5),
            default => $query
        };
    }

    // 検索条件の組み合わせ例
    public function scopeFilterByConditions($query, array $conditions)
    {
        return $query->when($conditions['keyword'] ?? null, 
                          fn($q, $keyword) => $q->fuzzySearch($keyword))
                    ->when($conditions['price'] ?? null, 
                          fn($q) => $q->priceRange(
                              $conditions['price']['min'] ?? null,
                              $conditions['price']['max'] ?? null
                          ))
                    ->when($conditions['categories'] ?? null,
                          fn($q) => $q->inCategories($conditions['categories']))
                    ->when($conditions['stock_status'] ?? null,
                          fn($q) => $q->stockStatus($conditions['stock_status']));
    }
}

このように実装することで得られる利点：

保守性の向上

検索ロジックがモデルに集約される
スコープの組み合わせによる柔軟な検索条件の構築
コードの再利用性の向上

可読性の向上

検索条件ごとにスコープが分離される
意図が明確な命名による理解のしやすさ
チェーンメソッドによる直感的な使用方法

拡張性の確保

新しい検索条件の追加が容易
既存の検索条件の修正が局所的
テストが書きやすい構造

次章では、これらの高度な検索機能を実装する際の性能最適化について解説していきます。

検索機能のパフォーマンス最適化

検索機能の実装後、ユーザー数や検索対象のデータ量が増加すると、パフォーマンスの問題が顕在化してきます。ここでは、Laravel検索機能のパフォーマンスを最適化するための具体的な手法を解説します。

インデックスを活用した検索速度の向上方法

データベースのインデックスを適切に設定することで、検索のパフォーマンスを大きく改善できます。

// database/migrations/2024_02_19_create_products_table.php
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('products', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->text('description');
            $table->decimal('price', 10, 2);
            $table->integer('category_id');
            $table->integer('stock');
            $table->timestamps();

            // 単一カラムインデックス
            $table->index('name');
            $table->index('category_id');
            $table->index('price');

            // 複合インデックス
            $table->index(['category_id', 'price']);
        });
    }
};

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

頻繁に検索される列にインデックスを作成

   // 既存テーブルへのインデックス追加
   public function up()
   {
       Schema::table('products', function (Blueprint $table) {
           // 検索頻度の高い列にインデックスを追加
           $table->index(['name', 'category_id', 'price']);
       });
   }

不要なインデックスの削除

   public function down()
   {
       Schema::table('products', function (Blueprint $table) {
           $table->dropIndex(['name', 'category_id', 'price']);
       });
   }

N+1 問題を解決する EagerLoading の実装

N+1問題は検索機能のパフォーマンスを著しく低下させる主要な原因の一つです。

// app/Http/Controllers/ProductController.php
class ProductController extends Controller
{
    public function index(Request $request)
    {
        // 悪い例（N+1問題発生）
        $products = Product::search($request->keyword)->paginate(10);

        // 良い例（Eager Loadingで解決）
        $products = Product::search($request->keyword)
            ->with(['category', 'brand', 'reviews'])  // リレーション先を事前読み込み
            ->paginate(10);

        return view('products.index', compact('products'));
    }

    // 条件付きEager Loading
    public function advancedSearch(Request $request)
    {
        $products = Product::query()
            ->with(['category', 'brand'])
            ->when($request->include_reviews, function ($query) {
                $query->with(['reviews' => function ($query) {
                    $query->latest()->limit(5);
                }]);
            })
            ->search($request->keyword)
            ->paginate(15);
    }
}

キャッシュを使った検索結果の最適化テクニック

頻繁に実行される検索や、計算コストの高い検索結果をキャッシュすることで、パフォーマンスを向上させることができます。

// app/Http/Controllers/ProductController.php
use Illuminate\Support\Facades\Cache;

class ProductController extends Controller
{
    public function search(Request $request)
    {
        // キャッシュキーの生成
        $cacheKey = 'search_' . md5(json_encode($request->all()));

        // キャッシュから結果を取得、なければDBから取得してキャッシュ
        $products = Cache::remember($cacheKey, now()->addMinutes(30), function () use ($request) {
            return Product::search($request->keyword)
                ->with(['category', 'brand'])
                ->paginate(15);
        });

        return view('products.search', compact('products'));
    }

    // より高度なキャッシュ戦略の実装例
    public function advancedCacheSearch(Request $request)
    {
        $cacheKey = $this->generateCacheKey($request);
        $cacheTags = ['products', 'search'];

        if (Cache::tags($cacheTags)->has($cacheKey)) {
            $results = Cache::tags($cacheTags)->get($cacheKey);
            $this->incrementSearchCount($cacheKey);
            return $results;
        }

        $results = $this->performSearch($request);

        // 検索結果をキャッシュ（人気の検索はより長く保持）
        $ttl = $this->determineCacheTTL($cacheKey);
        Cache::tags($cacheTags)->put($cacheKey, $results, $ttl);

        return $results;
    }

    private function generateCacheKey(Request $request): string
    {
        return sprintf(
            'search_%s_%s_%s',
            $request->input('keyword', ''),
            $request->input('category', ''),
            $request->input('sort', 'default')
        );
    }

    private function determineCacheTTL(string $cacheKey): int
    {
        $searchCount = Cache::get("search_count_{$cacheKey}", 0);

        // 検索頻度に応じてキャッシュ時間を調整
        return match (true) {
            $searchCount > 100 => 60,  // 1時間
            $searchCount > 50  => 30,  // 30分
            default           => 15    // 15分
        };
    }
}

パフォーマンス最適化のベストプラクティス：

クエリの最適化

必要なカラムのみを選択
適切なインデックスの使用
結合条件の最適化

キャッシュ戦略

適切なキャッシュキーの設計
キャッシュの有効期限の設定
キャッシュの無効化タイミング

監視とチューニング

クエリログの分析
パフォーマンスのモニタリング
ボトルネックの特定と解消

次章では、これらの最適化テクニックを活用した実践的な検索機能の実装例を紹介していきます。

実践的な検索機能の実装例

ここでは、実際のプロジェクトでよく求められる高度な検索機能の実装例を紹介します。Ajax検索によるリアルタイム検索、検索履歴機能、そして検索結果のソート機能について、具体的な実装方法を解説します。

Ajax検索の実装方法とライブ検索の作り方

ユーザーの入力に応じてリアルタイムに検索結果を表示する実装例を示します：

// routes/web.php
Route::get('/products/search', [ProductController::class, 'ajaxSearch'])
    ->name('products.ajax-search');

// app/Http/Controllers/ProductController.php
public function ajaxSearch(Request $request)
{
    $products = Product::query()
        ->when($request->keyword, function ($query, $keyword) {
            $query->where('name', 'like', "%{$keyword}%");
        })
        ->with('category')
        ->take(5)
        ->get();

    return response()->json([
        'products' => $products
    ]);
}

フロントエンド実装（Bladeビュー）：

<!-- resources/views/products/search.blade.php -->
<div x-data="liveSearch()">
    <div class="relative">
        <input
            type="text"
            x-model="keyword"
            x-on:input.debounce.300ms="search()"
            class="w-full px-4 py-2 border rounded-lg"
            placeholder="商品名を入力"
        >

        <!-- 検索結果の表示領域 -->
        <div
            x-show="results.length > 0"
            class="absolute z-10 w-full mt-1 bg-white border rounded-lg shadow-lg"
        >
            <template x-for="product in results" :key="product.id">
                <div class="p-2 hover:bg-gray-100 cursor-pointer">
                    <div x-text="product.name" class="font-medium"></div>
                    <div x-text="product.price" class="text-sm text-gray-600"></div>
                </div>
            </template>
        </div>
    </div>
</div>

<script>
function liveSearch() {
    return {
        keyword: '',
        results: [],

        async search() {
            if (this.keyword.length < 2) {
                this.results = [];
                return;
            }

            try {
                const response = await fetch(`/products/search?keyword=${this.keyword}`);
                const data = await response.json();
                this.results = data.products;
            } catch (error) {
                console.error('検索エラー:', error);
                this.results = [];
            }
        }
    }
}
</script>

検索履歴機能の追加手順

ユーザーの検索履歴を保存・表示する機能の実装例：

// database/migrations/2024_02_19_create_search_histories_table.php
public function up()
{
    Schema::create('search_histories', function (Blueprint $table) {
        $table->id();
        $table->foreignId('user_id')->constrained();
        $table->string('keyword');
        $table->json('filters')->nullable();
        $table->integer('result_count');
        $table->timestamps();

        $table->index(['user_id', 'created_at']);
    });
}

// app/Models/SearchHistory.php
class SearchHistory extends Model
{
    protected $fillable = ['user_id', 'keyword', 'filters', 'result_count'];
    protected $casts = ['filters' => 'array'];

    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

// app/Http/Controllers/ProductController.php
public function search(Request $request)
{
    $products = Product::search($request->keyword)
        ->with('category')
        ->paginate(15);

    // 検索履歴の保存
    if ($request->user()) {
        SearchHistory::create([
            'user_id' => $request->user()->id,
            'keyword' => $request->keyword,
            'filters' => $request->only(['category', 'price_range']),
            'result_count' => $products->total()
        ]);
    }

    // 最近の検索履歴を取得
    $recentSearches = [];
    if ($request->user()) {
        $recentSearches = SearchHistory::where('user_id', $request->user()->id)
            ->latest()
            ->take(5)
            ->get();
    }

    return view('products.search', compact('products', 'recentSearches'));
}

検索結果のソート機能の実装方法

複数の条件でソート可能な検索結果の実装例：

// app/Http/Controllers/ProductController.php
public function search(Request $request)
{
    $sortField = $request->input('sort', 'created_at');
    $sortDirection = $request->input('direction', 'desc');

    // 許可されたソートフィールドの定義
    $allowedSortFields = [
        'name' => 'name',
        'price' => 'price',
        'popularity' => 'view_count',
        'newest' => 'created_at'
    ];

    // クエリの構築
    $products = Product::search($request->keyword)
        ->when($sortField, function ($query) use ($sortField, $sortDirection, $allowedSortFields) {
            if (isset($allowedSortFields[$sortField])) {
                $query->orderBy($allowedSortFields[$sortField], $sortDirection);
            }
        })
        ->paginate(15)
        ->appends($request->query());

    return view('products.search', [
        'products' => $products,
        'sortField' => $sortField,
        'sortDirection' => $sortDirection
    ]);
}

ソート機能のフロントエンド実装：

<!-- resources/views/products/search.blade.php -->
<div class="flex items-center justify-between mb-4">
    <h2>検索結果: {{ $products->total() }}件</h2>

    <div class="flex items-center space-x-2">
        <span class="text-gray-600">並び替え:</span>
        <select
            x-data
            x-on:change="window.location = new URL($event.target.value, window.location.href)"
            class="border rounded-md px-2 py-1"
        >
            <option value="{{ route('products.search', array_merge(request()->query(), ['sort' => 'newest'])) }}"
                    {{ request('sort') === 'newest' ? 'selected' : '' }}>
                新着順
            </option>
            <option value="{{ route('products.search', array_merge(request()->query(), ['sort' => 'price', 'direction' => 'asc'])) }}"
                    {{ request('sort') === 'price' && request('direction') === 'asc' ? 'selected' : '' }}>
                価格が安い順
            </option>
            <option value="{{ route('products.search', array_merge(request()->query(), ['sort' => 'price', 'direction' => 'desc'])) }}"
                    {{ request('sort') === 'price' && request('direction') === 'desc' ? 'selected' : '' }}>
                価格が高い順
            </option>
            <option value="{{ route('products.search', array_merge(request()->query(), ['sort' => 'popularity'])) }}"
                    {{ request('sort') === 'popularity' ? 'selected' : '' }}>
                人気順
            </option>
        </select>
    </div>
</div>

これらの実装によって得られる利点：

ユーザビリティの向上

リアルタイムな検索結果表示
検索履歴からの素早い再検索
柔軟なソート機能

パフォーマンスの最適化

必要な情報のみを非同期で取得
検索履歴のインデックス最適化
効率的なソートの実装

保守性の確保

責務の明確な分離
再利用可能なコンポーネント
拡張性の高い設計

次章では、これらの機能を含む検索システムのテストと保守について解説していきます。

検索機能のテストと保守

検索機能の信頼性を確保し、長期的な保守性を高めるためには、適切なテストの実装と保守性を考慮したコード設計が不可欠です。ここでは、PHPUnitを使用したテスト方法や一般的なバグへの対処法、そして将来の機能拡張に備えたコード設計について解説します。

PHPUnitを使った検索機能のテスト方法

検索機能の各コンポーネントに対するテストの実装例を示します：

// tests/Feature/ProductSearchTest.php
namespace Tests\Feature;

use Tests\TestCase;
use App\Models\Product;
use App\Models\Category;
use Illuminate\Foundation\Testing\RefreshDatabase;

class ProductSearchTest extends TestCase
{
    use RefreshDatabase;

    protected function setUp(): void
    {
        parent::setUp();

        // テストデータの準備
        Category::factory()->create(['name' => 'Electronics']);
        Product::factory()->count(20)->create();
        Product::factory()->create([
            'name' => 'Test Product',
            'price' => 1000,
            'category_id' => 1
        ]);
    }

    /** @test */
    public function it_can_search_products_by_keyword()
    {
        $response = $this->get('/products/search?keyword=Test');

        $response->assertStatus(200)
                ->assertSee('Test Product')
                ->assertViewHas('products');
    }

    /** @test */
    public function it_returns_empty_results_for_non_matching_keyword()
    {
        $response = $this->get('/products/search?keyword=NonExistent');

        $response->assertStatus(200)
                ->assertDontSee('Test Product')
                ->assertViewHas('products', function($products) {
                    return $products->isEmpty();
                });
    }

    /** @test */
    public function it_can_filter_products_by_price_range()
    {
        $response = $this->get('/products/search?price_min=500&price_max=1500');

        $response->assertStatus(200)
                ->assertSee('Test Product')
                ->assertViewHas('products', function($products) {
                    return $products->every(function($product) {
                        return $product->price >= 500 && $product->price <= 1500;
                    });
                });
    }

    /** @test */
    public function it_handles_invalid_search_parameters_gracefully()
    {
        $response = $this->get('/products/search?price_min=invalid');

        $response->assertStatus(302)
                ->assertSessionHasErrors('price_min');
    }
}

// tests/Unit/ProductTest.php
namespace Tests\Unit;

use Tests\TestCase;
use App\Models\Product;
use Illuminate\Foundation\Testing\RefreshDatabase;

class ProductTest extends TestCase
{
    use RefreshDatabase;

    /** @test */
    public function it_can_scope_search_by_name()
    {
        Product::factory()->create(['name' => 'Test Product']);
        Product::factory()->create(['name' => 'Another Product']);

        $results = Product::search('Test')->get();

        $this->assertCount(1, $results);
        $this->assertEquals('Test Product', $results->first()->name);
    }

    /** @test */
    public function it_can_combine_multiple_search_conditions()
    {
        Product::factory()->create([
            'name' => 'Test Product',
            'price' => 1000,
            'category_id' => 1
        ]);

        $conditions = [
            'keyword' => 'Test',
            'price_min' => 500,
            'category_id' => 1
        ];

        $results = Product::advancedSearch($conditions)->get();

        $this->assertCount(1, $results);
        $this->assertEquals('Test Product', $results->first()->name);
    }
}

一般的なバグと対処法

検索機能で発生しやすい問題とその解決方法を解説します：

SQLインジェクション対策

// 悪い例（SQLインジェクションの危険あり）
$query->whereRaw("name LIKE '%$keyword%'");

// 良い例（パラメータバインディングを使用）
$query->where('name', 'like', "%{$keyword}%");

// より安全な実装
$query->where('name', 'like', '%' . str_replace(['%', '_'], ['\%', '\_'], $keyword) . '%');

N+1問題の回避

// 問題のある実装
$products = Product::search($keyword)->get();
foreach ($products as $product) {
    echo $product->category->name; // N+1問題発生
}

// 改善された実装
$products = Product::search($keyword)
    ->with('category')  // Eager Loading
    ->get();

メモリ使用量の最適化

// メモリを大量に使用する実装
$products = Product::all()->filter(function($product) use ($keyword) {
    return str_contains($product->name, $keyword);
});

// 最適化された実装
$products = Product::query()
    ->where('name', 'like', "%{$keyword}%")
    ->cursor()  // メモリ効率の良いイテレーション
    ->filter(function($product) {
        return $product->isAvailable();
    });

将来の機能拡張に備えたコード設計のポイント

保守性と拡張性を考慮したコード設計の例を示します：

検索条件のカプセル化

// app/SearchFilters/ProductSearchFilter.php
class ProductSearchFilter
{
    protected $query;
    protected $filters;

    public function __construct($query, array $filters)
    {
        $this->query = $query;
        $this->filters = $filters;
    }

    public function apply()
    {
        foreach ($this->filters as $filter => $value) {
            if (method_exists($this, $filter)) {
                $this->$filter($value);
            }
        }
        return $this->query;
    }

    protected function keyword($value)
    {
        return $this->query->where('name', 'like', "%{$value}%");
    }

    protected function priceRange($value)
    {
        return $this->query->whereBetween('price', [$value['min'], $value['max']]);
    }
}

検索結果の変換処理の分離

// app/Transformers/ProductTransformer.php
class ProductTransformer
{
    public function transform(Product $product)
    {
        return [
            'id' => $product->id,
            'name' => $product->name,
            'price' => $this->formatPrice($product->price),
            'category' => $product->category?->name,
            'availability' => $this->getAvailabilityStatus($product)
        ];
    }

    protected function formatPrice($price)
    {
        return number_format($price) . '円';
    }

    protected function getAvailabilityStatus(Product $product)
    {
        return $product->stock > 0 ? '在庫あり' : '在庫なし';
    }
}

検索ログの実装

// app/Observers/SearchLogObserver.php
class SearchLogObserver
{
    public function created(SearchHistory $searchHistory)
    {
        Log::channel('search')->info('Search performed', [
            'user_id' => $searchHistory->user_id,
            'keyword' => $searchHistory->keyword,
            'filters' => $searchHistory->filters,
            'results' => $searchHistory->result_count
        ]);
    }
}