Eloquent ORM is Laravel’s built-in object-relational mapper that simplifies database interactions using PHP classes and objects. 1. It maps database tables to models, enabling expressive syntax for queries. 2. Models correspond to tables by pluralizing the model name, but custom table names and primary keys can be defined. 3. Querying data is fluent and intuitive with methods like where(), orderBy(), find(), first(), pluck(), and aggregates. 4. Eloquent supports relationships including belongsTo(), hasMany(), belongsToMany(), and indirect ones like hasOneThrough. 5. Basic operations like create, update, and delete are streamlined with mass assignment protection via $fillable or $guarded. Overall, Eloquent enhances readability, maintainability, and scalability by abstracting SQL into clean, object-oriented interactions.

Eloquent ORM is Laravel's built-in object-relational mapper, and it makes working with databases in PHP much smoother. Instead of writing raw SQL queries, you use PHP classes and objects to interact with your database tables. Each database table has a corresponding "Model" that lets you query and manipulate the data using expressive, easy-to-read syntax.

Here’s how it works in practice:

Defining Models

In Eloquent, each model corresponds to a database table. By default, Eloquent assumes the table name is the plural form of the model name. For example, a User model will look for a users table.

You can create a model using Artisan:

php artisan make:model Post

Once created, you can start querying the database like this:

$posts = Post::all(); // gets all records from the posts table

If your table doesn’t follow the plural convention or has a different name, you can specify it directly in the model:

protected $table = 'my_posts';

Also, if your primary key isn’t called id, you can change it:

protected $primaryKey = 'post_id';

This flexibility helps when dealing with legacy databases or custom setups.

Querying Data

Eloquent gives you a fluent way to build queries without writing SQL manually. You can filter, sort, and retrieve data easily.

For example:

$publishedPosts = Post::where('status', 'published')->orderBy('created_at', 'desc')->get();

This reads like plain English: get all published posts sorted by creation date.
Common methods include:

• find($id) – find a record by primary key
• first() – get the first matching record
• pluck('title') – extract a single column
• count(), sum(), etc. – aggregate functions

Behind the scenes, Eloquent uses Laravel’s Query Builder, so you have access to all its powerful features while still working within an object-oriented structure.

Relationships Between Models

One of Eloquent’s biggest strengths is handling relationships between tables. Common relationships like one-to-one, one-to-many, and many-to-many are all supported out of the box.

Let’s say each post belongs to a user:

public function user()
{
    return $this->belongsTo(User::class);
}

Now you can do something like:

$post = Post::find(1);
echo $post->user->name;

Eloquent automatically loads the related user based on the foreign key (by default, user_id).
Other common relationship types:

• hasMany() – for one-to-many (e.g., a user has many posts)
• belongsToMany() – for many-to-many (you’ll need a pivot table)
• hasOneThrough, hasManyThrough – indirect relationships

These help keep your code clean and organized, especially as your app grows.

Basic Operations – Create, Update, Delete

Eloquent also simplifies inserting, updating, and deleting records.
To create a new record:

$post = new Post();
$post->title = 'My First Post';
$post->save();

Or even shorter:

Post::create(['title' => 'Another Post']);

To update:

$post = Post::find(1);
$post->title = 'Updated Title';
$post->save();

And to delete:

$post = Post::find(1);
$post->delete();

Mass assignment protection is important here. If you want to use create(), make sure to define which fields are fillable in your model:

protected $fillable = ['title', 'content'];

Alternatively, you can use $guarded to block certain fields instead.

That’s the core of what Eloquent does — it turns database operations into intuitive, object-based interactions. It’s not just about reducing SQL usage; it’s about making your code more readable, maintainable, and scalable. Once you get used to working with models and relationships, going back to raw queries feels unnecessarily clunky.

It might take a bit of time to get comfortable with all the methods and conventions, but once you do, building complex logic becomes much smoother.

Basically, that’s what Eloquent ORM is in Laravel — a powerful yet simple tool for managing database interactions in a clean, PHP-friendly way.

The above is the detailed content of What is the Eloquent ORM in Laravel?. For more information, please follow other related articles on the PHP Chinese website!