GraphQL లో N+1 problem అంటే ఏమిటి మరియు DataLoader దాన్ని ఎలా పరిష్కరిస్తుంది?

Question

IT Interview Practice · Accepted Answer

**N+1 problem** అనేది ఒక field resolver ప్రతి parent item కు ఒకసారి నడిచి, ప్రతి నడక తన సొంత database query ను జారీ చేసినప్పుడు జరుగుతుంది. N posts యొక్క list ను fetch చేసి, ఆపై ప్రతి post యొక్క author ను fetch చేయడం **posts కోసం 1 query + authors కోసం N queries** ను fire చేస్తుంది — ఇవి load కింద performance ను దెబ్బతీసే N+1 round trips.

## ఇది ఎందుకు జరుగుతుంది

Resolvers per field, per item గా నడుస్తాయి. `Post.author` list లోని ప్రతి post కు విడిగా execute అవుతుంది, మరియు వాటిలో ఏదీ ఇతరుల గురించి తెలియదు, కాబట్టి ప్రతి ఒక్కటి తన సొంత `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** ఒకే tick లో చేసిన వ్యక్తిగత `.load(id)` calls ను వాయిదా వేస్తుంది, ఆపై సేకరించిన keys ను వాటన్నింటినీ ఒకే query లో fetch చేసే ఒక **batch function** కు అందిస్తుంది. ఇది request లోపల key ద్వారా **cache** కూడా చేస్తుంది, కాబట్టి పునరావృత ids ఉచితం.

```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.
```

రెండు నియమాలు: loaders ను **per request** గా సృష్టించండి (globally కాదు — మీరు users మధ్య stale data ను leak చేస్తారు), మరియు batch function ఫలితాలను **ఖచ్చితమైన key order లో** తిరిగి ఇవ్వాలి.

## ఇది ఎందుకు ముఖ్యం

N+1 అనేది అత్యంత సాధారణ GraphQL performance trap మరియు దాదాపు హామీ ఇవ్వబడిన interview ప్రశ్న. మీరు DataLoader ను ఉపయోగిస్తారని — మరియు అది ఎందుకు request-scoped మరియు order-preserving గా ఉండాలో *ఎందుకు* తెలుసని — చూపడం నిజమైన production అనుభవాన్ని సూచిస్తుంది.

ఇది ఎందుకు జరుగుతుంది

DataLoader: batch + cache

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు