Introduction
Eloquent ORM is Laravel’s powerful and intuitive way to interact with databases. It provides a simple Active Record implementation that makes database operations easy and enjoyable. In this guide, we’ll explore how to use Eloquent ORM to manage your database interactions, handle relationships, and implement advanced techniques to get the most out of your Laravel application.
If you’re new to Laravel, check out our introduction to Laravel before diving into Eloquent ORM.
What is Eloquent ORM?
Eloquent ORM (Object-Relational Mapping) is a feature of Laravel that allows you to interact with your database tables as if they were objects. This means you can perform database queries using a clean, expressive syntax without writing raw SQL.
Basic CRUD Operations with Eloquent
Eloquent makes it simple to perform CRUD (Create, Read, Update, Delete) operations on your database. Let’s start with a basic example using a User model.
Creating Records
To create a new record in the database, you can use the create method or save a new model instance:
use App\Models\User;
// Using the create method
User::create([
'name' => 'John Doe',
'email' => '[email protected]',
'password' => bcrypt('secret'),
]);
// Using a new model instance
$user = new User;
$user->name = 'Jane Doe';
$user->email = '[email protected]';
$user->password = bcrypt('secret');
$user->save();
</code>Note: To use the create method, make sure the fillable property is defined in your model to allow mass assignment:
protected $fillable = ['name', 'email', 'password'];
Reading Records
Eloquent provides several ways to retrieve records from the database:
// Get all users
$users = User::all();
// Get a single user by ID
$user = User::find(1);
// Get the first user that matches certain criteria
$user = User::where('email', '[email protected]')->first();
Updating Records
Updating records is straightforward with Eloquent:
$user = User::find(1);
$user->name = 'John Smith';
$user->save();
You can also use the update method:
User::where('id', 1)->update(['name' => 'John Smith']);
Deleting Records
To delete a record, simply use the delete method:
$user = User::find(1);
$user->delete();
Or, delete records directly with a query:
User::destroy(1);
Eloquent Relationships
One of Eloquent’s most powerful features is its ability to define relationships between models. This allows you to easily retrieve related data without complex queries.
One-to-One Relationship
A one-to-one relationship is used when a model has exactly one related model. For example, a User might have one Profile:
// User model
public function profile()
{
return $this->hasOne(Profile::class);
}
// Profile model
public function user()
{
return $this->belongsTo(User::class);
}
You can then access the related profile like this:
$user = User::find(1);
$profile = $user->profile;
One-to-Many Relationship
A one-to-many relationship is used when a model can have multiple related models. For example, a Post might have many Comments:
// Post model
public function comments()
{
return $this->hasMany(Comment::class);
}
// Comment model
public function post()
{
return $this->belongsTo(Post::class);
}
To retrieve a post’s comments:
$post = Post::find(1);
$comments = $post->comments;
Many-to-Many Relationship
A many-to-many relationship is used when a model can belong to many other models and vice versa. For example, a User might belong to many Roles, and a Role might belong to many Users:
// User model
public function roles()
{
return $this->belongsToMany(Role::class);
}
// Role model
public function users()
{
return $this->belongsToMany(User::class);
}
To retrieve a user’s roles:
$user = User::find(1);
$roles = $user->roles;
Advanced Eloquent Techniques
Eloquent offers several advanced techniques to enhance your database interactions.
Query Scopes
Query scopes allow you to define reusable query logic in your model. There are two types of scopes: local and global.
Local Scopes:
public function scopeActive($query)
{
return $query->where('active', 1);
}
You can use this scope in your queries:
$users = User::active()->get();
Global Scopes:
Global scopes apply to all queries for a model:
protected static function boot()
{
parent::boot();
static::addGlobalScope('active', function (Builder $builder) {
$builder->where('active', 1);
});
}
Eager Loading
Eager loading is a way to load related models along with the main model to prevent the “N+1” problem:
$users = User::with('profile')->get();
This loads the users and their associated profiles in a single query, improving performance.
Accessors and Mutators
Accessors and mutators allow you to format attributes before they are saved to or retrieved from the database:
Accessor:
public function getFullNameAttribute()
{
return "{$this->first_name} {$this->last_name}";
}
Usage
$user = User::find(1);
echo $user->full_name;
Mutator:
public function setPasswordAttribute($value)
{
$this->attributes['password'] = bcrypt($value);
}
The password will be automatically hashed when setting it.
Best Practices for Eloquent ORM
- Use Query Scopes: Simplify your code by using local and global scopes for common queries.
- Eager Load Relationships: Avoid performance issues by eager loading related models when necessary.
- Keep Logic in Models: Leverage Eloquent’s features like accessors, mutators, and relationships to keep your logic within models.
- Use Mass Assignment Carefully: Always define the
$fillableproperty to protect your models from mass assignment vulnerabilities.
Conclusion
Mastering Eloquent ORM is crucial for efficient database management in Laravel. By understanding basic CRUD operations, relationships, and advanced techniques, you can write clean, maintainable, and efficient code. Eloquent’s expressive syntax and powerful features make it a joy to work with, allowing you to focus on building great applications.
Want to learn more? Explore our next article on Laravel migrations to see how you can manage your database schema with ease.