How does Eloquent ORM work in Laravel?

Eloquent ORM (Object-Relational Mapping) is Laravel's built-in ORM that provides an elegant and straightforward way to interact with a database. It helps developers work with databases in a more intuitive, object-oriented manner without writing raw SQL queries.

Here’s how Eloquent ORM works:

1. Model Representation of Database Tables

Each table in your database is represented by a corresponding "Model" in Laravel. For example, if you have a users table in your database, you'd typically create a User model:

class User extends Model {
    // Model methods and properties go here
}

Eloquent will automatically assume that the corresponding table for the User model is users, following Laravel's naming convention (plural form of the model name).

2. Query Builder and ORM Operations

Eloquent models allow you to interact with your database using common object-oriented operations:

• Retrieving Data: You can retrieve records from a table using methods like all(), find(), or where():

  $users = User::all(); // Retrieves all users
  $user = User::find(1); // Retrieves a user by primary key
  $activeUsers = User::where('status', 'active')->get(); // Retrieves users with active status
  

• Inserting Data: Inserting new records into the database is simple:

  $user = new User();
  $user->name = 'John Doe';
  $user->email = 'john@example.com';
  $user->save();
  

• Updating Data: You can update existing records using the model instance:

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

• Deleting Data: Similarly, you can delete a record by calling delete() on a model instance:

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

3. Relationships Between Models

Eloquent makes it easy to define relationships between different models (e.g., one-to-many, many-to-many, one-to-one).

• One-to-Many Relationship:

  class Post extends Model {
      public function comments() {
          return $this->hasMany(Comment::class);
      }
  }
  
  class Comment extends Model {
      public function post() {
          return $this->belongsTo(Post::class);
      }
  }
  

• Many-to-Many Relationship:

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

These relationships allow you to easily access related data:

$post = Post::find(1);
$comments = $post->comments; // Fetches all comments related to the post

4. Eager Loading

Eloquent supports eager loading to optimize queries and avoid the N+1 query problem. You can retrieve related data efficiently:

$posts = Post::with('comments')->get();

5. Mass Assignment

Eloquent also allows you to insert or update multiple fields at once using mass assignment:

User::create([
    'name' => 'Jane Doe',
    'email' => 'jane@example.com'
]);

For mass assignment, you'll need to define which attributes are fillable in the model:

class User extends Model {
    protected $fillable = ['name', 'email'];
}

6. Soft Deletes

Eloquent supports soft deletes, meaning records are not permanently deleted but instead marked as deleted. This is useful for preserving records.

use Illuminate\Database\Eloquent\SoftDeletes;

class User extends Model {
    use SoftDeletes;
}

7. Accessors & Mutators

You can define custom methods to format or manipulate data when accessing or saving it to the database:

• Accessors modify the data when retrieving it from the database.
• Mutators modify the data before saving it to the database.

Example of an accessor:

public function getFullNameAttribute() {
    return "{$this->first_name} {$this->last_name}";
}

Summary

Eloquent ORM in Laravel abstracts away most of the database interactions into a simple, object-oriented syntax, letting developers work with PHP objects rather than writing complex SQL queries. It supports all standard database operations, relationships between models, and more advanced features like soft deletes, eager loading, and mass assignment, making it powerful and easy to use.