ORM in Laravel: Eloquent Overview

Laravel's ORM (Object-Relational Mapping) is called Eloquent, and it's one of the most powerful and developer-friendly features of the framework. Here's a comprehensive overview:

Basic Concepts

1. Active Record Implementation: Each Eloquent model interacts with a single database table.

2. Conventions:

   • Table names are plural (e.g., User model → users table)

   • Primary key is id

   • Foreign keys are model_id (e.g., user_id)

   • Timestamps use created_at and updated_at columns

Defining Models

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    // Specify table if different from convention
    protected $table = 'my_users';
    
    // Disable timestamps
    public $timestamps = false;
    
    // Define fillable fields for mass assignment
    protected $fillable = ['name', 'email'];
    
    // Or guarded fields (opposite of fillable)
    protected $guarded = ['id', 'password'];
}

CRUD Operations

Create

// Simple create
$user = new User;
$user->name = 'John';
$user->save();

// Mass assignment
$user = User::create(['name' => 'John', 'email' => 'john@example.com']);

Read

// Get all records
$users = User::all();

// Find by ID
$user = User::find(1);

// First match
$user = User::where('active', 1)->first();

// Complex query
$users = User::where('votes', '>', 100)
             ->orderBy('name')
             ->take(10)
             ->get();

Update

$user = User::find(1);
$user->email = 'new@example.com';
$user->save();

// Mass update
User::where('active', 1)->update(['active' => 0]);

Delete

$user = User::find(1);
$user->delete();

// Direct delete
User::destroy(1);
User::destroy([1, 2, 3]);

// Conditional delete
User::where('active', 0)->delete();

Relationships

One-to-One

// User has one Phone
class User extends Model
{
    public function phone()
    {
        return $this->hasOne(Phone::class);
    }
}

// Access
$phone = User::find(1)->phone;

One-to-Many

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

// Access
$comments = Post::find(1)->comments;

Many-to-Many

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

// Access
$roles = User::find(1)->roles;

Advanced Features

1. Accessors & Mutators:

// Accessor
public function getNameAttribute($value)
{
    return ucfirst($value);
}

// Mutator
public function setNameAttribute($value)
{
    $this->attributes['name'] = strtolower($value);
}

2. Scopes:

// Local scope
public function scopePopular($query)
{
    return $query->where('votes', '>', 100);
}

// Usage
$users = User::popular()->get();

3. Eager Loading (N+1 problem solution):

$books = Book::with('author')->get();

4. Soft Deletes:

use Illuminate\Database\Eloquent\SoftDeletes;

class User extends Model
{
    use SoftDeletes;
    
    protected $dates = ['deleted_at'];
}

// Will set deleted_at instead of actually deleting
User::find(1)->delete();

// Include soft deleted models
User::withTrashed()->get();

5. Observers:

class UserObserver
{
    public function created($user)
    {
        // Logic after user is created
    }
}

// Register in a service provider
User::observe(UserObserver::class);

Eloquent provides many more features like model events, serialization, API resources, and more, making it a full-featured ORM solution for Laravel applications.