Laravel多模型多表搜索实现求助：单模型搜索作用域已正常运行

Got it, let's tackle how to expand your single-model search scope to work across multiple related tables in Laravel. Your existing scope works great for one model, but we can refactor it to be reusable and support cross-model searches cleanly.

Step 1: Create a Reusable Searchable Trait #

Instead of duplicating code across models, build a trait that any searchable model can use. This keeps your code DRY and easy to maintain.

namespace App\Traits;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\DB;

trait Searchable
{
    /**
     * Scope a query to search across the model and specified associations.
     *
     * @param Builder $query
     * @param string $search
     * @param array $searchableAssociations [association_name => [field1, field2]]
     * @return Builder
     */
    public function scopeSearch(Builder $query, string $search, array $searchableAssociations = []): Builder
    {
        // Group base model search conditions to avoid logic conflicts
        $query->where(function (Builder $q) use ($search) {
            foreach ($this->getSearchableFields() as $field) {
                $q->orWhere($field, 'LIKE', "%{$search}%");
            }
        });

        // Add search across specified associated models
        foreach ($searchableAssociations as $association => $fields) {
            $query->orWhereHas($association, function (Builder $q) use ($search, $fields) {
                // Group association search conditions too
                $q->where(function (Builder $subQ) use ($search, $fields) {
                    foreach ($fields as $field) {
                        $subQ->orWhere($field, 'LIKE', "%{$search}%");
                    }
                });
            });
        }

        return $query;
    }

    /**
     * Define default searchable fields for the model (override in individual models if needed)
     *
     * @return array
     */
    protected function getSearchableFields(): array
    {
        // Default fields matching your original scope
        return ['title', 'sub_body', 'body'];
    }
}

Step 2: Use the Trait in Your Models #

Add the trait to any model that needs search functionality. For example, in your main model (e.g., Post):

namespace App\Models;

use App\Traits\Searchable;
use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    use Searchable;

    // Your model relationships, fillables, etc.
    public function translations()
    {
        return $this->hasMany(PostTranslation::class);
    }

    // Optional: Override searchable fields if this model has unique columns
    // protected function getSearchableFields(): array
    // {
    //     return ['title', 'sub_body', 'body', 'slug'];
    // }
}

If you have another associated model (like Comment) that needs search, just add the trait to it too and override getSearchableFields as needed.

Step 3: Perform Cross-Model Searches #

Now you can search your base model plus any associated tables by passing the association names and their fields to the search scope:

// Search Post model + its translations (value field) + comments (content field)
$results = Post::search('your-search-keyword', [
    'translations' => ['value'],
    'comments' => ['content']
])->paginate(10);

Bonus: Search Across Independent Models #

If you need to search across completely separate models (not just associated ones), you can combine results using collections or database unions:

Option 1: Collection Merge (Simple) #

$posts = Post::search('term')->get();
$comments = Comment::search('term')->get();

// Combine and sort results by creation date
$combinedResults = $posts->merge($comments)->sortByDesc('created_at');

Option 2: Database Union (More Efficient for Large Datasets) #

// Select consistent columns across models for union
$postQuery = Post::search('term')
    ->select('id', 'title', 'created_at', DB::raw('"post" as model_type'));

$commentQuery = Comment::search('term')
    ->select('id', 'content as title', 'created_at', DB::raw('"comment" as model_type'));

$combinedResults = $postQuery->union($commentQuery)->get();

Key Notes #

• Logical Grouping: We use nested where() closures to group search conditions, preventing unexpected behavior when combining with other query constraints.
• Flexibility: The trait lets each model define its own searchable fields, so you don't have to one-size-fits-all everything.
• Performance: For large datasets, consider adding full-text indexes to your searchable columns instead of using LIKE queries for faster results.

内容的提问来源于stack exchange，提问作者Ali Özen