The N 1 query problem refers to the fact that after obtaining the main record, each record triggers an additional query to obtain the associated data, resulting in a large number of repeated queries. For example, when obtaining 100 users, the orders of each user are queried one by one, and a total of 101 queries are performed. To identify this problem, pay attention to the following three points: 1. Calling relationship methods in the loop; 2. The debugging tool displays a large number of similar queries; 3. The page loading time increases significantly as the number of records increases. Solutions include: 1. Preload with () or withCount() of Eloquent; 2. Use DQL or warehouse methods to explicitly associate data in Doctrine; 3. Develop early enabled debugging tools such as Laravel Telescope, Symfony Profiler to monitor the number of queries, and promptly discover and fix problems.

When you're fetching related data in PHP applications using an ORM like Eloquent or Doctrine, you might run into a common performance issue known as the N 1 query problem.

It happens when your code runs one query to get a list of records (like users), then loops through each record and makes another query to fetch related data (like each user's posts). This leads to many more queries than expected — slowing things down fast.

Let's break it down and talk about how to spot it and what to do about it.

What Exactly Is the N 1 Query Problem?

The name comes from this:

• 1 query to get the main records (eg, all users)
• Then N more queries — one for each of those records — to get related data (eg, each user's orders)

For example, imagine you have 100 users and you loop over them:

 $users = User::all();

foreach ($users as $user) {
    echo $user->orders()->count();
}

Behind the scenes, this will run 1 query to get all users, then 100 more queries — one per user — to count their orders. That's 101 queries total.

Even if each query is fast, doing this at scale kills performance.

How to Spot It in Your Code

Here are some signs you're dealing with N 1:

• You're looping through a collection and calling a relationship inside the loop.
• You're seeing a lot of similar-looking queries in your debug tools (like Laravel Telescope or Symfony Profiler).
• Page load times increase dramatically as the number of records grows.

If you see something like “SELECT * FROM orders WHERE user_id = ?” repeated dozens or hundreds of times on a single page, that's a red flag.

How to Avoid It (In PHP ORMs)

Most modern PHP ORMs come with built-in ways to avoid this problem. Here's how to handle it in common ORMs:

Use Eager Loading (Laravel / Eloquent)

Eloquent provides with() to eager load relationships:

 $users = User::with('orders')->get();

foreach ($users as $user) {
    echo $user->orders->count(); // No extra query here
}

This way, Eloquent loads all users and their related orders in just two queries instead of N 1.

You can even eager load nested relationships:

 User::with('orders.items');

Pro tip: If you only need a count, use withCount() :

 $users = User::withCount('orders')->get();
echo $user->orders_count;

Use JOINs or Fetch Joins in DQL (Doctrine / Symfony)

In Doctrine, you can use DQL to join related entities explicitly:

 $dql = "SELECT u, o FROM App\Entity\User u JOIN u.orders o";
$users = $entityManager->createQuery($dql)->getResult();

Or in repositories:

 $users = $userRepository->findAllWithOrders();

Make sure your repository method uses a proper join so that related data is loaded in one go.

Bonus Tip: Use Debugging Tools Early

Don't wait until performance tanks in production.

Tools like:

• Laravel Telescope
• Symfony Profiler
• Debug Bar
• Clockwork

...can show you exactly how many queries are being run and help catch N 1 issues before they become a real problem.

Also, consider enabling query logging during development so you can see every SQL call made on a page load.

Avoiding the N 1 query problem boils down to thinking ahead about how your ORM loads related data. Most of the time, you don't even need to write raw SQL — just make sure you're using the right methods provided by your ORM.

That's basically it. Not rocket science, but easy to overlook.

The above is the detailed content of What is the N 1 query problem, and how can it be avoided in PHP applications using an ORM?. For more information, please follow other related articles on the PHP Chinese website!