რა არის N+1 პრობლემა GraphQL-ში და როგორ აგვარებს მას DataLoader?

Question

IT Interview Practice · Accepted Answer

**N+1 პრობლემა** ჩნდება, როცა ველის resolver თითო parent ელემენტზე ერთხელ მუშაობს და ყოველი გაშვება საკუთარ database query-ს უშვებს. N პოსტის სიის, შემდეგ კი თითოეული პოსტის ავტორის მოტანა იწვევს **1 query-ს პოსტებისთვის + N query-ს ავტორებისთვის** — N+1 მიმოცვლა, რომელიც დატვირთვის ქვეშ წარმადობას თელავს.

## რატომ ხდება ეს

resolver-ები მუშაობს თითო ველზე, თითო ელემენტზე. `Post.author` სიის ყოველი პოსტისთვის ცალკე სრულდება და არცერთმა არ იცის დანარჩენების შესახებ, ამიტომ თითოეული საკუთარ `findById`-ს აკეთებს.

```js
// BAD: one DB call per post -> N+1
const resolvers = {
  Post: {
    author: (post, _a, ctx) => ctx.db.users.findById(post.authorId),
  },
};
```

## DataLoader: batch + cache

**DataLoader** გადადებს ცალკეულ `.load(id)` გამოძახებებს, რომლებიც ერთსა და იმავე tick-ში კეთდება, შემდეგ კი შეგროვებულ გასაღებებს ერთ **batch ფუნქციას** გადასცემს, რომელიც ყველას ერთ query-ში მოიტანს. ის ასევე **caching-ს** აკეთებს გასაღების მიხედვით request-ის ფარგლებში, ამიტომ განმეორებადი id-ები უფასოა.

```js
import DataLoader from "dataloader";

// create ONE loader per request (put it on context so caching is request-scoped)
const userLoader = new DataLoader(async (ids) => {
  // ids arrives as [1, 2, 3, ...] -> a single batched query
  const users = await db.users.findByIds(ids);
  // MUST return values in the SAME ORDER as ids
  return ids.map((id) => users.find((u) => u.id === id));
});

const resolvers = {
  Post: {
    author: (post, _a, ctx) => ctx.userLoader.load(post.authorId), // batched
  },
};
// Now N author resolvers collapse into 1 query: total 2 queries, not N+1.
```

ორი წესი: შექმენი loader-ები **თითო request-ზე** (და არა გლობალურად — თორემ მომხმარებლებს შორის მოძველებული მონაცემი გაჟონავს) და batch ფუნქციამ შედეგები **ზუსტად გასაღებების თანმიმდევრობით** უნდა დააბრუნოს.

## რატომ არის ეს მნიშვნელოვანი

N+1 არის GraphQL-ის ყველაზე გავრცელებული წარმადობის ხაფანგი და თითქმის გარანტირებული ინტერვიუს კითხვა. ის, რომ DataLoader-ს მიმართავ — და იცი, *რატომ* უნდა იყოს ის request-scoped და თანმიმდევრობის შემნახველი — რეალურ production გამოცდილებაზე მიანიშნებს.

რატომ ხდება ეს

DataLoader: batch + cache

რატომ არის ეს მნიშვნელოვანი

დაკავშირებული კითხვები