Laravel Eloquent: Advanced Relationships and Performance Optimization

Mastering Laravel Eloquent: Advanced Relationships and Performance Optimization

Eloquent is Laravel's beautiful ActiveRecord implementation that makes database interactions intuitive and expressive. In this comprehensive guide, we'll explore advanced relationship techniques and performance optimization strategies that will take your Laravel skills to the next level.

Understanding Eloquent Relationships

Eloquent relationships are one of Laravel's most powerful features. They provide an expressive way to work with database relationships while maintaining clean, readable code. Let's dive deep into various relationship types and their practical implementations.

Basic Relationship Types

// One-to-One Relationship
class User extends Model
{
    public function profile()
    {
        return $this->hasOne(Profile::class);
    }
}

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

// Many-to-Many Relationship
class User extends Model
{
    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }
}
    

Advanced Relationship Patterns

Polymorphic Relationships

Polymorphic relationships allow a model to belong to more than one other model on a single association. This is perfect for features like comments, file uploads, or activity feeds:

// Comment model can belong to either Post or Video
class Comment extends Model
{
    public function commentable()
    {
        return $this->morphTo();
    }
}

class Post extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

class Video extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

// Usage examples
$post = Post::find(1);
$comments = $post->comments;

$video = Video::find(1);
$comments = $video->comments;

// Creating polymorphic relations
$post->comments()->create([
    'body' => 'Great post!',
    'created_by' => auth()->id()
]);
    

Has-Many-Through Relationship

This relationship provides a convenient way to access distant relations via an intermediate relation. Perfect for scenarios where you need to access data through multiple tables:

// Country -> User -> Post
class Country extends Model
{
    public function posts()
    {
        return $this->hasManyThrough(Post::class, User::class);
    }
}

// Access all posts from a country
$country = Country::find(1);
$posts = $country->posts;

// With additional conditions
$recentPosts = $country->posts()
    ->where('published_at', '>', now()->subDays(30))
    ->get();
    

Performance Optimization Techniques

Eager Loading for N+1 Problem Prevention

The N+1 query problem is one of the most common performance issues in ORM-based applications. Here's how to identify and fix it:

// ❌ Bad: N+1 queries (executes query for each post)
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->user->name; // Executes a query for each post
    echo $post->category->name; // More queries!
}

// ✅ Good: 2 queries total using eager loading
$posts = Post::with('user', 'category', 'tags')->get();
foreach ($posts as $post) {
    echo $post->user->name; // No additional queries
    echo $post->category->name;
}

// ✅ Even better: Nested eager loading with specific columns
$posts = Post::with([
    'user:id,name,email',
    'category:id,name',
    'tags:id,name',
    'comments.user:id,name'
])->get();

// Conditional eager loading
$posts = Post::with(['comments' => function ($query) {
    $query->where('approved', true);
}])->get();
    

Lazy Eager Loading

When you need to load relationships after the parent model has already been retrieved, lazy eager loading comes to the rescue:

$posts = Post::all();

// Load relationships when needed
if ($someCondition) {
    $posts->load('user', 'comments');
}

// Or load for specific models with conditions
$posts->loadMissing(['user' => function ($query) {
    $query->select('id', 'name', 'avatar');
}]);

// Load counts
$posts->loadCount('comments', 'likes');
    

Advanced Query Optimization

// Use select() to choose specific columns and reduce memory usage
$posts = Post::with(['user:id,name', 'category:id,name'])
    ->select('id', 'title', 'created_by', 'category_id', 'published_at', 'status')
    ->where('status', 'published')
    ->orderBy('published_at', 'desc')
    ->paginate(15);

// Use has() for existence checks (more efficient than whereHas)
$usersWithPosts = User::has('posts')->get();
$usersWithPopularPosts = User::has('posts', '>=', 5)->get();

// Use whereHas for conditional relationships with complex conditions
$popularPosts = Post::whereHas('comments', function($query) {
    $query->where('likes', '>', 10)
        ->where('created_at', '>', now()->subMonth());
})->get();

// Use withCount for relationship counts without loading relationships
$posts = Post::withCount(['comments', 'likes'])
    ->having('comments_count', '>', 5)
    ->orderBy('likes_count', 'desc')
    ->get();

// Chunking for large datasets
Post::where('status', 'published')
    ->chunk(200, function ($posts) {
        foreach ($posts as $post) {
            // Process posts in batches of 200
            $this->processPost($post);
        }
    });

// Cursor for very large datasets (memory efficient)
foreach (Post::where('status', 'published')->cursor() as $post) {
    // Process each post without loading all into memory
    $this->processPost($post);
}
    

Advanced Eloquent Features

Accessors and Mutators

class User extends Model
{
    // Accessor - automatically called when accessing the attribute
    public function getFullNameAttribute()
    {
        return "{$this->first_name} {$this->last_name}";
    }

    // Mutator - automatically called when setting the attribute
    public function setEmailAttribute($value)
    {
        $this->attributes['email'] = strtolower(trim($value));
    }

    // Date mutator
    public function setBirthDateAttribute($value)
    {
        $this->attributes['birth_date'] = Carbon::createFromFormat('d/m/Y', $value);
    }

    // JSON mutator for array fields
    public function setMetadataAttribute($value)
    {
        $this->attributes['metadata'] = json_encode($value);
    }

    public function getMetadataAttribute($value)
    {
        return json_decode($value, true) ?? [];
    }
}

// Usage in controllers and views
$user = User::find(1);
echo $user->full_name; // Automatically uses accessor
$user->email = '  John@Example.COM  '; // Automatically uses mutator
    

Query Scopes

class Post extends Model
{
    // Local scope
    public function scopePublished($query)
    {
        return $query->where('published', true)
                    ->whereNotNull('published_at');
    }

    // Dynamic scope with parameters
    public function scopeCategory($query, $categoryId)
    {
        return $query->where('category_id', $categoryId);
    }

    // Complex scope with multiple conditions
    public function scopePopular($query, $minLikes = 100)
    {
        return $query->where('likes_count', '>=', $minLikes)
                    ->where('views_count', '>=', 1000)
                    ->orderBy('likes_count', 'desc');
    }

    // Global scope - applied to all queries
    protected static function booted()
    {
        static::addGlobalScope('active', function ($query) {
            $query->where('active', true);
        });
    }

    // Local scope with relationships
    public function scopeWithUser($query)
    {
        return $query->with(['user' => function ($query) {
            $query->select('id', 'name', 'avatar');
        }]);
    }
}

// Usage examples
$publishedPosts = Post::published()->get();
$categoryPosts = Post::category(1)->published()->get();
$popularPosts = Post::popular(50)->withUser()->get();

// Remove global scope for specific query
$allPosts = Post::withoutGlobalScope('active')->get();
    

Performance Monitoring and Debugging

Using Laravel Debugbar

Install Laravel Debugbar to monitor query performance and identify bottlenecks:

composer require barryvdh/laravel-debugbar --dev
    

Query Logging and Analysis

// Enable query log
DB::enableQueryLog();

// Run your queries
$posts = Post::with('user', 'category', 'tags')
    ->where('status', 'published')
    ->orderBy('created_at', 'desc')
    ->paginate(20);

// Get query log
$queries = DB::getQueryLog();

// Analyze slow queries
foreach ($queries as $query) {
    if ($query['time'] > 100) { // More than 100ms
        Log::warning('Slow query detected', [
            'query' => $query['query'],
            'bindings' => $query['bindings'],
            'time' => $query['time']
        ]);
    }
}

// Using query events to log all queries
DB::listen(function ($query) {
    if ($query->time > 100) {
        Log::info('Slow Query: ' . $query->sql, [
            'bindings' => $query->bindings,
            'time' => $query->time
        ]);
    }
});
    

Real-World Example: Blog Application

Here's a complete example of optimized queries for a blog application with multiple relationships and performance considerations:

class PostController extends Controller
{
    public function index(Request $request)
    {
        $query = Post::with([
            'user:id,name,avatar',
            'category:id,name,slug',
            'tags:id,name',
            'comments' => function ($query) {
                $query->with('user:id,name')
                    ->where('approved', true)
                    ->orderBy('created_at', 'desc')
                    ->limit(5);
            }
        ])
        ->select('id', 'title', 'excerpt', 'slug', 'created_by', 'category_id', 'published_at', 'views_count')
        ->where('status', 'published')
        ->where('published_at', '<=', now())
        ->orderBy('published_at', 'desc');

        // Search functionality
        if ($request->has('search')) {
            $query->where(function ($q) use ($request) {
                $q->where('title', 'like', '%' . $request->search . '%')
                ->orWhere('excerpt', 'like', '%' . $request->search . '%');
            });
        }

        // Filter by category
        if ($request->has('category')) {
            $query->whereHas('category', function ($q) use ($request) {
                $q->where('slug', $request->category);
            });
        }

        // Filter by tags
        if ($request->has('tags')) {
            $query->whereHas('tags', function ($q) use ($request) {
                $q->whereIn('slug', (array) $request->tags);
            });
        }

        $posts = $query->paginate(12);

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

    public function show(Post $post)
    {
        // Eager load all necessary relationships with specific columns
        $post->load([
            'user:id,name,email,bio,avatar',
            'category:id,name,slug,description',
            'tags:id,name,slug',
            'comments' => function ($query) {
                $query->with(['user:id,name,avatar', 'replies.user:id,name,avatar'])
                    ->where('approved', true)
                    ->orderBy('created_at', 'desc');
            }
        ]);

        // Increment views efficiently
        $post->increment('views_count');

        // Load related posts
        $relatedPosts = Post::where('category_id', $post->category_id)
            ->where('id', '!=', $post->id)
            ->where('status', 'published')
            ->with(['user:id,name', 'category:id,name'])
            ->select('id', 'title', 'slug', 'excerpt', 'created_by', 'category_id', 'published_at')
            ->orderBy('published_at', 'desc')
            ->limit(6)
            ->get();

        return view('posts.show', compact('post', 'relatedPosts'));
    }
}
    

Advanced Relationship Techniques

Polymorphic Many-to-Many Relationships

// Taggable system - tags can be applied to multiple models
class Tag extends Model
{
    public function posts()
    {
        return $this->morphedByMany(Post::class, 'taggable');
    }

    public function videos()
    {
        return $this->morphedByMany(Video::class, 'taggable');
    }
}

class Post extends Model
{
    public function tags()
    {
        return $this->morphToMany(Tag::class, 'taggable');
    }
}

// Usage
$post = Post::find(1);
$post->tags()->attach([1, 2, 3]);

$video = Video::find(1);
$video->tags()->attach([2, 4, 5]);

// Get all posts with a specific tag
$tag = Tag::find(1);
$posts = $tag->posts;
    

Custom Intermediate Table Models

// For many-to-many relationships with additional attributes
class PostTag extends Pivot
{
    protected $table = 'post_tag';

    public function post()
    {
        return $this->belongsTo(Post::class);
    }

    public function tag()
    {
        return $this->belongsTo(Tag::class);
    }
}

class Post extends Model
{
    public function tags()
    {
        return $this->belongsToMany(Tag::class)
                    ->using(PostTag::class)
                    ->withPivot('added_by', 'added_at')
                    ->withTimestamps();
    }
}

// Usage with pivot attributes
$post->tags()->attach($tagId, [
    'added_by' => auth()->id(),
    'added_at' => now()
]);
    

By implementing these advanced Eloquent techniques and performance optimizations, you can significantly improve your Laravel application's database performance while maintaining clean, readable, and maintainable code. Remember that performance optimization is an ongoing process that requires monitoring and continuous improvement.