GraphQL-இல் N+1 problem என்றால் என்ன, DataLoader அதை எவ்வாறு தீர்க்கிறது?

Question

IT Interview Practice · Accepted Answer

ஒரு field resolver ஒவ்வொரு parent item-க்கும் ஒரு முறை இயங்கி, ஒவ்வொரு இயக்கமும் தனது சொந்த database query-ஐ வெளியிடும்போது **N+1 problem** ஏற்படுகிறது. N post-களின் ஒரு list-ஐயும், பிறகு ஒவ்வொரு post-இன் author-ஐயும் fetch செய்வது **post-களுக்கு 1 query + author-களுக்கு N query**-ஐ fire செய்கிறது — N+1 round trip-கள், சுமையின் கீழ் performance-ஐ நசுக்குகின்றன.

## அது ஏன் நடக்கிறது

Resolver-கள் ஒவ்வொரு field-க்கும், ஒவ்வொரு item-க்கும் இயங்குகின்றன. `Post.author`, list-இல் உள்ள ஒவ்வொரு post-க்கும் தனித்தனியாக இயங்குகிறது, மேலும் அவற்றில் எதுவும் மற்றவற்றைப் பற்றி அறியாது, எனவே ஒவ்வொன்றும் தனது சொந்த `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)` அழைப்புகளைத் தள்ளிவைத்து, பிறகு சேகரிக்கப்பட்ட key-களை ஒரு **batch function**-க்கு ஒப்படைக்கிறது, அது அவை அனைத்தையும் ஒரே query-இல் fetch செய்கிறது. மேலும் அது request-இனுள் key மூலம் **cache** செய்கிறது, எனவே திரும்பத் திரும்ப வரும் 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-க்கும்** உருவாக்குங்கள் (globally அல்ல — நீங்கள் user-களுக்கு இடையே stale data-வைக் கசியவிடுவீர்கள்), மேலும் batch function முடிவுகளை **சரியான key வரிசையில்** திருப்பி அனுப்ப வேண்டும்.

## இது ஏன் முக்கியம்

N+1 என்பது மிகவும் பொதுவான ஒற்றை GraphQL performance பொறி மற்றும் கிட்டத்தட்ட உறுதியான ஒரு interview கேள்வி. நீங்கள் DataLoader-ஐ நோக்கிச் செல்வதைக் காட்டுவது — மேலும் அது ஏன் request-scoped மற்றும் order-preserving ஆக இருக்க வேண்டும் என்பதை அறிவது — உண்மையான production அனுபவத்தைக் குறிக்கிறது.

அது ஏன் நடக்கிறது

DataLoader: batch + cache

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்