0Pricing
FastAPI Backend Development Bootcamp · Ders

DataLoaders ile N+1 Sorgularını Çözme

Çözümleyicilerdeki N+1 sorgu patlamalarını ortadan kaldırmak için veritabanı aramalarını dataloader'larla toplu hâle getirin ve önbelleğe alın.

DataLoaders ile N+1 Sorgularını Çözme, CoddyKit'te ücretsiz bir FastAPI Backend Development Bootcamp dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, FastAPI Backend Development Bootcamp öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. FastAPI Backend Development Bootcamp kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

The N+1 Problem in GraphQL

GraphQL lets clients ask for nested data in a single request, like a list of posts and each post's author. The danger is hidden in the resolvers.

Suppose you fetch 100 posts with 1 query, then resolve each post's author by running one query per post. That is 1 + 100 = 101 queries — the classic N+1 problem.

  • 1 query to load the list (the 1)
  • N queries, one per item, to load a related field (the N)

At scale this destroys latency and hammers the database. DataLoaders are the standard fix.

Seeing N+1 in a Strawberry Resolver

Here is a naive Strawberry resolver that triggers N+1. Each author resolver issues its own database call.

If a query returns 50 posts, this author resolver fires 50 separate SELECT statements. The list query plus those 50 lookups is the N+1 explosion.

import strawberry

@strawberry.type
class Author:
    id: int
    name: str

@strawberry.type
class Post:
    id: int
    title: str
    author_id: int

    @strawberry.field
    async def author(self) -> Author:
        # BAD: one DB round-trip per post -> N+1
        row = await db.fetch_one(
            "SELECT id, name FROM authors WHERE id = :id",
            {"id": self.author_id},
        )
        return Author(id=row["id"], name=row["name"])

The Core Idea: Batch and Cache

A DataLoader solves N+1 with two techniques:

  • Batching: instead of resolving each author_id immediately, the loader collects all the keys requested during one tick of the event loop and resolves them together in a single batched query (e.g. WHERE id = ANY(...)).
  • Caching: within a single request, the same key is only fetched once. Asking for author 7 ten times yields one lookup.

The result: 1 query for the posts + 1 batched query for all authors = 2 queries instead of 101.

How Batching Works on the Event Loop

Strawberry's DataLoader relies on the asyncio event loop. When several resolvers call loader.load(key), the loader does not run immediately. It records each key and returns a pending awaitable.

On the next tick, the loader takes every queued key, calls your batch function once with the full list of keys, and then resolves each individual awaitable with its matching result.

This is why DataLoaders only work in async code: the deferral mechanism depends on the loop scheduling the batch dispatch after the current synchronous work finishes.

Writing the Batch Load Function

The heart of a DataLoader is the batch function. It receives a list of keys and must return a list of results in the exact same order as the keys.

Two non-negotiable rules:

  • The returned list length must equal the keys length.
  • Result at index i must correspond to keys[i]. Missing rows should map to None (or an Exception), never be dropped.

Below we map rows by id, then re-emit them in key order.

from typing import List, Optional

async def load_authors(keys: List[int]) -> List[Optional[Author]]:
    rows = await db.fetch_all(
        "SELECT id, name FROM authors WHERE id = ANY(:ids)",
        {"ids": keys},
    )
    by_id = {row["id"]: Author(id=row["id"], name=row["name"]) for row in rows}
    # Preserve order; None for missing keys
    return [by_id.get(key) for key in keys]

Order Alignment Demonstrated

The order-preservation contract is the most common source of DataLoader bugs. Here is a standalone simulation: rows arrive in arbitrary order from the database, but we must return them aligned to the requested keys.

Run this to see how a lookup dict plus a key-ordered comprehension guarantees correct alignment even when the DB returns rows out of order or omits a missing key.

def batch_load(keys, rows):
    by_id = {row["id"]: row["name"] for row in rows}
    return [by_id.get(k) for k in keys]

keys = [3, 1, 7, 4]
# DB returns rows shuffled and is missing id=7
rows = [
    {"id": 1, "name": "Ada"},
    {"id": 4, "name": "Linus"},
    {"id": 3, "name": "Grace"},
]

result = batch_load(keys, rows)
print(result)  # ['Grace', 'Ada', None, 'Linus']
assert len(result) == len(keys)
for key, name in zip(keys, result):
    print(f"key={key} -> {name}")

Creating a DataLoader in Strawberry

Strawberry ships a DataLoader class. You construct it with your batch function. Calling .load(key) returns an awaitable that resolves after batching.

Critically, a DataLoader instance holds a per-instance cache. You must create a fresh loader per request so stale data and cross-user leakage never happen. We will wire that up next via context.

from strawberry.dataloader import DataLoader

# batch function from the previous scene
author_loader = DataLoader(load_fn=load_authors)

# Inside a resolver you would now write:
#   author = await author_loader.load(self.author_id)
# Many concurrent .load() calls collapse into ONE call to load_authors.

Per-Request Loaders via GraphQL Context

The clean place to store request-scoped loaders is the GraphQL context. With FastAPI + Strawberry you override get_context to build fresh loaders on every request.

This guarantees the batch window and the cache are isolated to one request — exactly the lifetime you want.

from strawberry.fastapi import GraphQLRouter
from strawberry.dataloader import DataLoader

async def get_context() -> dict:
    return {
        "author_loader": DataLoader(load_fn=load_authors),
        # one loader per relation, all rebuilt per request
    }

graphql_app = GraphQLRouter(schema, context_getter=get_context)
# app.include_router(graphql_app, prefix="/graphql")

Using the Loader Inside a Resolver

Now the author resolver reads the loader from info.context and calls .load(). Strawberry injects info when you declare it as a parameter.

Even though this resolver runs once per post, all those .load() calls are batched into a single SELECT ... WHERE id = ANY(...) — N+1 is gone.

import strawberry
from strawberry.types import Info

@strawberry.type
class Post:
    id: int
    title: str
    author_id: int

    @strawberry.field
    async def author(self, info: Info) -> Author:
        loader = info.context["author_loader"]
        return await loader.load(self.author_id)

Caching Wins and Their Limits

Within one request the loader caches by key, so repeated load(7) calls hit the DB once. This is great for fan-out queries where the same author appears across many posts.

Watch the trade-offs:

  • The cache is per request by design — never share a loader across requests or you serve stale data.
  • If a record changes mid-request and you re-read it, you get the cached copy. Call loader.clear(key) after a mutation to invalidate.
  • The cache key is the raw key value, so keep keys hashable and consistent (e.g. always int, not sometimes str).

Loading Collections and Tuple Keys

DataLoaders are not only for one-to-one lookups. For one-to-many (a post's comments), the batch function returns a list per key. Group the rows by foreign key, then emit one list per requested key (empty list if none).

For composite lookups, use a hashable tuple as the key, e.g. (post_id, locale). Just keep the type stable so caching stays correct.

from collections import defaultdict

async def load_comments(post_ids):
    rows = await db.fetch_all(
        "SELECT id, post_id, body FROM comments WHERE post_id = ANY(:ids)",
        {"ids": post_ids},
    )
    grouped = defaultdict(list)
    for row in rows:
        grouped[row["post_id"]].append(row)
    # one list per key, in key order
    return [grouped.get(pid, []) for pid in post_ids]

Quick Check: DataLoader Lifetime

A teammate creates a single module-level DataLoader and reuses it for the whole app to "save memory." Why is this the wrong choice for a multi-user FastAPI GraphQL service?

Recap: DataLoaders Defeat N+1

You learned how to eliminate N+1 query explosions in Strawberry + FastAPI resolvers:

  • N+1 happens when a nested resolver issues one query per parent item.
  • A DataLoader fixes it by batching all keys from one event-loop tick into a single query and caching repeated keys within the request.
  • The batch function must return results aligned to the input keys, same length, same order, with None or empty lists for misses.
  • Build loaders per request in get_context and read them from info.context inside resolvers.
  • Use lists-per-key for one-to-many relations and hashable tuple keys for composite lookups; call clear() after mutations.

With this pattern, deeply nested GraphQL queries stay fast and your database stays calm.

Sıkça Sorulan Sorular

“DataLoaders ile N+1 Sorgularını Çözme” dersi ücretsiz mi?

Evet — “DataLoaders ile N+1 Sorgularını Çözme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve FastAPI Backend Development Bootcamp kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. FastAPI Backend Development Bootcamp kursu toplamda 4 dersten oluşur.

“DataLoaders ile N+1 Sorgularını Çözme” dersinde ne öğreneceğim?

Çözümleyicilerdeki N+1 sorgu patlamalarını ortadan kaldırmak için veritabanı aramalarını dataloader'larla toplu hâle getirin ve önbelleğe alın. FastAPI Backend Development Bootcamp ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

FastAPI Backend Development Bootcamp öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te FastAPI Backend Development Bootcamp, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“DataLoaders ile N+1 Sorgularını Çözme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu FastAPI Backend Development Bootcamp dersinde kod yazıp çalıştırabilir miyim?

Evet. Her FastAPI Backend Development Bootcamp dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Türleri, Sorguları ve Mutasyonları Tanımlama
  2. DataLoaders ile N+1 Sorgularını Çözme
  3. Gerçek Zamanlı GraphQL Abonelikleri
  4. Sorgu Maliyeti Analizi ve Derinlik Sınırlama
← FastAPI Backend Development Bootcamp Sayfasına Dön