The main difference between Eloquent ORM and Query Builder in Laravel is the operation method and applicable scenarios. 1. Eloquent is based on the model and provides object-oriented data interaction methods, suitable for processing model logic and relationships; Query Builder directly operates database tables, suitable for quickly obtaining or manipulating data. 2. Query Builder has higher performance because it does not instantiate complete model objects and is suitable for large data volumes or complex connections; Eloquent is suitable for scenarios where model functions are required. 3. Eloquent supports defining and using model relationships (such as hasMany, belongsTo) and provides lazy loading functions; Query Builder needs to manually manage connections and related data. 4. Query Builder is more flexible for complex SQL queries; Eloquent is suitable for standard CRUD operations and structured model systems.

Eloquent ORM and Query Builder in Laravel serve similar purposes—interacting with your database—but they do it in different ways, and choosing between them depends on what you need to accomplish.

What's the Main Difference?

Eloquent is an Object-Relational Mapper (ORM) . That means it maps your database tables to PHP classes, and rows to instances of those classes. It gives you a more expressive, object-oriented way to work with data.

The Query Builder, on the other hand, provides a fluent interface for creating and running database queries without needing to write raw SQL. It works directly with the database tables, not models.

So if you want to work with model objects and relationships, use Eloquent. If you just need to fetch or manipulate data quickly and efficiently, especially when performance matters or joins get complex, go with Query Builder.

1. Working with Models vs. Raw Tables

Eloquent ORM revolves around models. You define a User model, and from there you can access properties like $user->name , or call methods like User::find(1) .

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

This makes it ideal for situations where you want to encapsulate logic inside a model, like formatting attributes or defining relationships.

Query Builder doesn't care about models. It works directly with tables:

 $user = DB::table('users')->where('id', 1)->first();
echo $user->name;

It returns plain stdClass objects, which are fine if you don't need any model-specific behavior.

Use Eloquent when you want to work with rich model objects and relationships.
Use Query Builder when you just need data and want to avoid overhead.

2. Performance Considerations

Eloquent has some overhead because it builds full model instances. For simple queries or large datasets, that might be unnecessary.

The Query Builder tends to be faster because it doesn't instantiate full model objects. It's also better suited for heavy joins or custom SQL constructs.

For example, this query using Eloquent might load extra data:

 $orders = Order::with('user')->get();

But if all you need is a list of order IDs and user emails, using Query Builder would be more efficient:

 $results = DB::table('orders')
    ->join('users', 'orders.user_id', '=', 'users.id')
    ->select('orders.id', 'users.email')
    ->get();

If performance matters or you're selecting specific fields, Query Builder may be better.
If you need full model functionality, stick with Eloquent.

3. Relationships and Lazy Loading

One of Eloquent's biggest strengths is how it handles relationships . You can define a hasMany() or belongsTo() relationship once in your model and then easily access related data:

 class User extends Model {
    public function posts() {
        return $this->hasMany(Post::class);
    }
}

$user = User::find(1);
foreach ($user->posts as $post) {
    echo $post->title;
}

The Query Builder doesn't support relationships natively. You'd have to manually join tables and manage the data yourself.

Lazy loading is another Eloquent feature: it only loads related data when you actually access it. But be careful—it can cause N 1 query issues if used incorrectly.

Use Eloquent when dealing with related data.
Use Query Builder when you're handling joins manually or avoiding eager/lazy loading pitfalls.

4. Flexibility and Custom Queries

Sometimes you need to write complex queries or subqueries that are hard to express using Eloquent's syntax. In those cases, Query Builder offers more flexibility.

For example, building a union or a nested where clause is often easier with Query Builder:

 $users = DB::table('users')
    ->where('votes', '>', 100)
    ->orWhere(function ($query) {
        $query->where('name', 'John')
              ->where('votes', '>', 50);
    })
    ->get();

While Eloquent can handle many advanced scenarios, sometimes the Query Builder feels cleaner and more direct.

Use Query Builder for complex or highly customized SQL.
Use Eloquent for standard CRUD operations and when working within a structured model system.

That's basically it. Both tools are powerful in their own right, and knowing when to use each will make your Laravel code cleaner and more efficient.

The above is the detailed content of Difference between Eloquent ORM and the Query Builder in Laravel.. For more information, please follow other related articles on the PHP Chinese website!