$users = User::where('active', 1)->get();

Then business requirements kick in. Suddenly you need users who are active, have made purchases in the last 30 days, belong to specific roles, and haven't been flagged by the admin team. Before you know it, you're looking at this nightmare:

```php
$users = User::where('active', 1)
    ->where('created_at', '>=', now()->subDays(30))
    ->whereHas('orders', function($q) {
        $q->where('status', 'completed')
          ->where('created_at', '>=', now()->subDays(30));
    })
    ->whereIn('role_id', [1, 2, 3])
    ->whereDoesntHave('flags', function($q) {
        $q->where('type', 'admin_review');
    })
    ->with(['profile', 'orders' => function($q) {
        $q->where('status', 'completed');
    }])
    ->get();

This works, but good luck maintaining it six months from now!

Method Chaining: Your First Line of Defense

Laravel's fluent interface is your friend. Instead of cramming everything into one massive query, break it down into logical chunks using method chaining.

Here's how to make that monster query more readable:

$query = User::query();

// Base filters
$query->where('active', 1)
      ->where('created_at', '>=', now()->subDays(30));

// Relationship filters
$query->whereHas('orders', function($q) {
    $q->where('status', 'completed')
      ->where('created_at', '>=', now()->subDays(30));
});

// Role filtering
$query->whereIn('role_id', [1, 2, 3]);

// Exclusion filters
$query->whereDoesntHave('flags', function($q) {
    $q->where('type', 'admin_review');
});

// Eager loading
$query->with(['profile', 'orders' => function($q) {
    $q->where('status', 'completed');
}]);

$users = $query->get();

Much better! Each section has a clear purpose, and you can easily comment or modify individual parts.

Query Scopes: Reusable Query Logic

When you find yourself writing the same conditions repeatedly, extract them into query scopes:

// In your User model
public function scopeActive($query)
{
    return $query->where('active', 1);
}

public function scopeRecentlyActive($query, $days = 30)
{
    return $query->where('created_at', '>=', now()->subDays($days));
}

public function scopeWithCompletedOrders($query, $days = 30)
{
    return $query->whereHas('orders', function($q) use ($days) {
        $q->where('status', 'completed')
          ->where('created_at', '>=', now()->subDays($days));
    });
}

public function scopeByRoles($query, array $roleIds)
{
    return $query->whereIn('role_id', $roleIds);
}

Now your complex query becomes:

$users = User::active()
    ->recentlyActive(30)
    ->withCompletedOrders(30)
    ->byRoles([1, 2, 3])
    ->with(['profile', 'orders'])
    ->get();

That's readable code that tells a story!

The Specification Pattern for Complex Business Logic

When your queries involve complex business rules that change frequently, the Specification Pattern can save your sanity. Create separate classes for each business rule:

class ActiveUserSpecification
{
    public function apply($query)
    {
        return $query->where('active', 1);
    }
}

class RecentPurchaseSpecification
{
    private $days;
    
    public function __construct($days = 30)
    {
        $this->days = $days;
    }
    
    public function apply($query)
    {
        return $query->whereHas('orders', function($q) {
            $q->where('status', 'completed')
              ->where('created_at', '>=', now()->subDays($this->days));
        });
    }
}

Then compose your query using these specifications:

$specifications = [
    new ActiveUserSpecification(),
    new RecentPurchaseSpecification(30),
    new RoleFilterSpecification([1, 2, 3]),
];

$query = User::query();

foreach ($specifications as $spec) {
    $spec->apply($query);
}

$users = $query->get();

The beauty? Each specification is testable independently, and adding new business rules doesn't require touching existing code.

Handling Complex Relationships with whereHas()

Relationship queries can get messy fast. The key is using whereHas() effectively while maintaining readability:

// Instead of this complex join mess
$users = DB::table('users')
    ->join('orders', 'users.id', '=', 'orders.user_id')
    ->join('order_items', 'orders.id', '=', 'order_items.order_id')
    ->join('products', 'order_items.product_id', '=', 'products.id')
    ->where('users.active', 1)
    ->where('products.category', 'electronics')
    ->where('orders.total', '>', 100)
    ->select('users.*')
    ->distinct()
    ->get();

// Write this readable version
$users = User::active()
    ->whereHas('orders', function($query) {
        $query->where('total', '>', 100)
              ->whereHas('items', function($itemQuery) {
                  $itemQuery->whereHas('product', function($productQuery) {
                      $productQuery->where('category', 'electronics');
                  });
              });
    })
    ->get();

The second version tells you exactly what business logic you're implementing.

Query Builder for Raw Performance

Sometimes Eloquent isn't enough, and you need the raw power of the Query Builder. But that doesn't mean abandoning readability:

$orders = DB::table('orders')
    ->select([
        'orders.id',
        'orders.total',
        'users.name as customer_name',
        DB::raw('COUNT(order_items.id) as item_count'),
        DB::raw('SUM(order_items.quantity * order_items.price) as calculated_total')
    ])
    ->join('users', 'orders.user_id', '=', 'users.id')
    ->leftJoin('order_items', 'orders.id', '=', 'order_items.order_id')
    ->where('orders.status', 'completed')
    ->where('orders.created_at', '>=', now()->subDays(30))
    ->groupBy(['orders.id', 'orders.total', 'users.name'])
    ->having('calculated_total', '>', 50)
    ->orderBy('calculated_total', 'desc')
    ->get();

Break complex Query Builder calls into sections with comments:

$query = DB::table('orders');

// Select calculated fields
$query->select([
    'orders.id',
    'orders.total',
    'users.name as customer_name',
    DB::raw('COUNT(order_items.id) as item_count'),
    DB::raw('SUM(order_items.quantity * order_items.price) as calculated_total')
]);

// Join related tables
$query->join('users', 'orders.user_id', '=', 'users.id')
      ->leftJoin('order_items', 'orders.id', '=', 'order_items.order_id');

// Apply business filters
$query->where('orders.status', 'completed')
      ->where('orders.created_at', '>=', now()->subDays(30));

// Group and filter aggregated results
$query->groupBy(['orders.id', 'orders.total', 'users.name'])
      ->having('calculated_total', '>', 50)
      ->orderBy('calculated_total', 'desc');

return $query->get();

Database Views for Ultimate Complexity

When your queries become too complex even with these techniques, consider pushing the complexity into the database itself using views:

CREATE VIEW high_value_customers AS
SELECT 
    u.id,
    u.name,
    u.email,
    COUNT(o.id) as total_orders,
    SUM(o.total) as lifetime_value,
    AVG(o.total) as average_order_value,
    MAX(o.created_at) as last_order_date
FROM users u
LEFT JOIN orders o ON u.id = o.user_id AND o.status = 'completed'
WHERE u.active = 1
GROUP BY u.id, u.name, u.email
HAVING lifetime_value > 1000 OR total_orders > 10;

Then query the view with simple, readable Laravel code:

$highValueCustomers = DB::table('high_value_customers')
    ->where('last_order_date', '>=', now()->subDays(90))
    ->orderBy('lifetime_value', 'desc')
    ->get();

Performance Tips That Don't Sacrifice Readability

1. Use eager loading consistently: Always load relationships you'll use to avoid N+1 queries.
2. Index your query paths: Make sure your database has indexes for the columns you're filtering on.
3. Use chunk() for large datasets:

User::active()
    ->withCompletedOrders()
    ->chunk(1000, function($users) {
        foreach ($users as $user) {
            // Process each user
        }
    });

4. Consider query caching for expensive operations:

$expensiveData = Cache::remember('complex_user_stats', 3600, function() {
    return User::complexBusinessLogic()->get();
});

Testing Your Complex Queries

Readable queries are testable queries. Write tests for your query scopes and specifications:

public function test_active_users_scope()
{
    User::factory()->create(['active' => 1]);
    User::factory()->create(['active' => 0]);
    
    $activeUsers = User::active()->get();
    
    $this->assertCount(1, $activeUsers);
    $this->assertTrue($activeUsers->first()->active);
}