Logo run_as_root - Magento B2B Agentur Würzburg
PERFORMANCE

N+1-Queries auf Magento-2-Produktseiten: getUsedProducts im Visier

Ein Configurable mit 50 Varianten kann locker 150 zusätzliche Queries pro Seitenaufruf verursachen. So stopfst du N+1-Bugs in Magento 2 mit Batch-Loading an der Wurzel.


On this page

    Die PDP lädt zäh. Nicht dramatisch langsam, nur unangenehm zäh, genau die Art von Zähigkeit, die die ersten Performance-Runden übersteht, weil sie auf einer normalen Produktseite kaum auffällt und erst zum Thema wird, wenn jemand ein Configurable mit vielen Optionen profiled.

    Du öffnest den New-Relic-Trace. Die Render-Spanne liegt bei 1,8 Sekunden, der Großteil davon MySQL. Du gehst tiefer und findest 178 einzelne Queries auf dieser einen PDP, 156 davon fast identisch: SELECT * FROM cataloginventory_stock_item WHERE product_id = ?, jedes Mal mit einer anderen ID. Achtundvierzig dieser Child-IDs gehören zu den Varianten des Configurables, der Rest kommt von woanders. Willkommen bei N+1 auf einer Magento-2-Produktseite.

    TL;DR

    • Ein Configurable mit 50 Kindern, über getUsedProducts() geladen, kostet dich im Standard-Rendering-Pfad plus ein paar üblichen Plugins grob drei zusätzliche Queries pro Child: ein Stock-Lookup, ein bis zwei Attribut-Lookups. Macht 150+ zusätzliche Queries pro PDP.
    • So wird es typischerweise schlimmer: getUsedProducts() wird mehr als einmal pro Request aufgerufen, Plugins auf Configurable::getUsedProducts iterieren die Kinder nochmal durch, und Feed-Exporte rufen $productRepository->getById($id) in einer Schleife.
    • Der Fix sieht praktisch immer gleich aus: IDs vorab sammeln, alles in einer Collection mit addFieldToFilter('entity_id', ['in' => $ids]) laden, joinAttribute für die Attribute nutzen, die du wirklich brauchst, und Stock im Bulk über StockItemRepository::getItems($productIds) holen.
    • N+1 ist einer der am einfachsten zu findenden Bugs. Er wird trotzdem ständig ausgeliefert. Wenn du noch nie danach geschaut hast, hast du ihn.

    Was N+1 in Magento bedeutet

    Das Muster ist älter als Magento selbst. Du lädst eine Liste von N Dingen in einer Query, dann holst du dir zu jedem Eintrag ein zugehöriges Ding, einzeln, in einer Schleife. Am Ende stehst du bei 1 + N Queries, obwohl zwei gereicht hätten.

    Magento bietet zwei APIs zum Datenladen, und beide können in diese Falle laufen. Collections setzen eine einzige SQL-Query für einen ganzen Batch an Zeilen ab. Repositories sind für „gib mir das eine Ding mit dieser ID" gebaut. Die Repository-API ist bequem und liest sich am Call-Site angenehm, in einer Schleife aufgerufen wird sie aber zur Katastrophe. Jedes $this->productRepository->getById($id) ist ein Product-Load, ein EAV-Attribut-Join und ein Haufen Decorator-Overhead, und du zahlst das komplett N-mal.

    Die Kurzfassung: Collections sind dein Freund, und sobald du eine Schleife über IDs siehst, die eine „ById"-, „bySku"- oder „ByCode"-Methode aufruft, geh erstmal davon aus, dass du einen Bug vor dir hast, bis du das Gegenteil bewiesen hast.

    Der Hauptverdächtige: getUsedProducts() wird mehrfach aufgerufen

    Configurables in Magento haben einen Helper: Magento\ConfigurableProduct\Model\Product\Type\Configurable::getUsedProducts(). Er lädt die Kinder als Collection und cacht sie für den Rest des Requests auf der Configurable-Instanz. Soweit unproblematisch. Die Probleme fangen an, wenn irgendetwas dieses Caching aushebelt.

    Der häufigste Grund: Plugins. Zwei, drei Module hängen sich jeweils mit einem eigenen Plugin an getUsedProducts, jedes ruft die Original-Methode, um an die Kinder zu kommen, jedes macht „irgendwas" mit dem Ergebnis, und jeder dieser Aufrufe landet auf einer frischen Instanz, die den Cache nicht teilt. Am Ende wird getUsedProducts drei- oder viermal pro Request auf demselben Configurable aufgerufen, und jeder Aufruf fährt die Query plus den ganzen Per-Child-Kram erneut.

    Eine einfache Diagnose: Häng ein error_log mit debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2) in ein Plugin auf Magento\ConfigurableProduct\Model\Product\Type\Configurable::getUsedProducts. Lade eine PDP. Zähl die Aufrufe. Einer pro Request ist gesund, alles darüber ist das Erste, was du fixen solltest, weil sich alles Nachgelagerte darauf multipliziert.

    ⚠️
    Auch öffentliche Marketplace-Module machen das. OX_DisplayOutOfStock zum Beispiel liefert ein Plugin auf Configurable::getUsedProducts, das das Original aufruft, die Kinder noch mal durchiteriert, um die nicht lieferbaren rauszufiltern, und dabei pro Child einen eigenen Stock-Lookup fährt. Auf einer PDP mit 50 Kindern hast du damit, plus dem Vanilla-Magento-Rendering, das ebenfalls iteriert, zwei komplette Durchläufe, bevor dein eigener Code die Liste überhaupt anfasst.

    Die zweite Ebene: Stock-Lookups pro Child

    Für jedes Child, das der Rendering-Pfad durchgeht, muss Magento 2 wissen, ob es gerade lieferbar ist. Die bequeme API dafür ist $this->_stockRegistry->getStockItem($childId). In einem foreach über 50 Kinder aufgerufen, sind das 50 einzelne cataloginventory_stock_item-Queries, eine pro Child.

    Der Fix ist StockItemRepository::getItems($productIds). Die Methode nimmt ein Array von Product-IDs entgegen und liefert alle Stock-Items in einer einzigen Query zurück. Dieselben Daten, ein Roundtrip statt N.

    1// der Bug
    2foreach ($configurable->getUsedProducts() as $child) {
    3 $stock = $this->stockRegistry->getStockItem($child->getId());
    4 if (!$stock->getIsInStock()) {
    5 continue;
    6 }
    7 // ...
    8}
    9 
    10// der Fix
    11$childIds = array_map(fn($c) => (int) $c->getId(), $configurable->getUsedProducts());
    12$stockItems = $this->stockItemRepository->getItems($childIds);
    13$stockByProduct = [];
    14foreach ($stockItems as $item) {
    15 $stockByProduct[$item->getProductId()] = $item;
    16}
    17 
    18foreach ($configurable->getUsedProducts() as $child) {
    19 $stock = $stockByProduct[$child->getId()] ?? null;
    20 if ($stock === null || !$stock->getIsInStock()) {
    21 continue;
    22 }
    23 // ...
    24}

    Gleiche Business-Logik, gleiche Ausgabe, eine Query statt fünfzig.

    Die dritte Ebene: Attribut-Lookups pro Child

    Der letzte übliche N+1 auf diesem Pfad: $child->getResource()->getAttribute('color'), aufgerufen in derselben Schleife. Ist das Attribut noch nicht auf dem Child geladen, geht jeder Aufruf zurück zu eav_attribute, um die Metadaten zu lesen, und manchmal zusätzlich zu catalog_product_entity_varchar (oder welche Backend-Tabelle das Attribut eben nutzt), um den Wert zu holen. Einzeln ist das billig. Bei 50 Kindern mit zwei Attributen pro Child sind das 100 zusätzliche Queries, mit denen niemand gerechnet hat.

    Der Fix: die Attribute schon beim Laden der Collection mit anfordern. Zwei Varianten, je nachdem, wie du an die Kinder kommst:

    1// wenn du den Load selbst steuerst, addAttributeToSelect auf der Collection nutzen
    2$collection = $this->childCollectionFactory->create()
    3 ->addAttributeToSelect(['color', 'size', 'manufacturer'])
    4 ->addFieldToFilter('entity_id', ['in' => $childIds]);
    5 
    6// liest du aus getUsedProducts und kannst den Load nicht anfassen,
    7// hol die Attribute in einem Rutsch auf die bereits geladenen Objekte
    8$this->productRepository->getList(
    9 $this->searchCriteriaBuilder
    10 ->addFilter('entity_id', $childIds, 'in')
    11 ->create()
    12);

    addAttributeToSelect hängt das Attribut an das zugrunde liegende Select der Collection an, die Kinder kommen mit dem Attribut bereits geladen zurück, und der In-Loop-Aufruf von getResource()->getAttribute() wird zum No-op.

    Die Feed-Export-Variante

    Gleiches Muster, anderer Schauplatz. Statt einer PDP, die ein Configurable rendert, hast du einen Feed-Export-Cronjob, der einen Google-Merchant-Center-Feed mit 10.000 Produkten baut. Die Controller- oder Cron-Klasse macht grob das hier:

    1foreach ($productIds as $id) {
    2 $product = $this->productRepository->getById($id);
    3 $parentId = $this->configurableType->getParentIdsByChild($id)[0] ?? null;
    4 $parent = $parentId !== null ? $this->productRepository->getById($parentId) : null;
    5 // Feed-Zeile bauen
    6}

    Zehntausend Durchläufe, pro Durchlauf drei productRepository->getById-Aufrufe plus eine getParentIdsByChild-Query. Macht dreißigtausend einzelne Product-Loads. Der Cron, der eigentlich in fünf Minuten durch sein sollte, läuft eine Stunde. Schlimmer: Jeder Load bringt seine eigenen EAV-Attribut-Joins mit, und die Query-Zahl explodiert in den sechsstelligen Bereich.

    Der Fix ist, die Produkte batchweise über eine Collection zu laden statt einzeln:

    1$batchSize = 500;
    2foreach (array_chunk($productIds, $batchSize) as $batch) {
    3 $collection = $this->productCollectionFactory->create()
    4 ->addAttributeToSelect($feedAttributes) // die 5-10, die du wirklich brauchst
    5 ->addFieldToFilter('entity_id', ['in' => $batch]);
    6 
    7 $stockItems = $this->stockItemRepository->getItems($batch);
    8 
    9 foreach ($collection as $product) {
    10 // Feed-Zeile bauen, Stock aus $stockItems[$product->getId()] lesen
    11 }
    12}

    Batching ist dabei kein nice-to-have. Ein einzelnes addFieldToFilter('entity_id', ['in' => $zehntausendIds]) erzeugt eine SQL-IN (...)-Klausel, die die meisten MySQL-Server zwar schlucken, an der sich manche aber verschlucken. 500 auf einmal ist die langweilige, sichere Größe.

    Der Fix: eine Query pro N Dinge, nicht N Queries pro Ding

    Jeder N+1-Fix in Magento folgt derselben Choreografie aus drei Schritten.

    1. Sammle die IDs, die du brauchst, bevor die Schleife läuft. Meistens liegen sie schon auf dem Parent-Objekt oder im initialen Query-Ergebnis.
    2. Lade alles in ein bis zwei Queries per Collection oder bulk-fähiger Repository-Methode. Indexiere das Ergebnis vorab nach ID in einem schlichten PHP-Array.
    3. Lass die Schleife über die ursprüngliche Liste laufen und lies die vorgeladenen Daten aus dem Array, statt die Per-Item-API aufzurufen.

    Fast jeder Bulk-Performance-Fix in Magento 2 läuft auf genau diese Form hinaus. Feed-Exports, Report-Builder, PDP-Rendering-Pfade und im Grunde jeder heiße Code-Pfad, der eine Liste von Kindern mit Per-Child-Lookups durchläuft. Der Fix ist immer derselbe: den Lookup aus der Schleife rausziehen.

    Vorher und nachher, mit Belegen

    Zurück zu unserem Configurable mit 50 Kindern.

    Vorher: 1 Query zum Laden des Configurables, 1 für getUsedProducts (mal so oft, wie die Plugins es erneut aufrufen, sagen wir drei), 50 Stock-Queries, 100 Attribut-Queries (zwei pro Child), plus weitere 25 Queries für Dinge wie URL-Rewrites, Kategoriezugehörigkeit und Bildergalerien. Macht in Summe rund 180 Queries und etwa 1,5 Sekunden PDP-TTFB, der Großteil davon MySQL-Roundtrips.

    Nachher: 1 Query für das Configurable, 1 für die Children-Collection mit den benötigten Attributen direkt gejoint, 1 für Bulk-Stock über getItems, plus die verbleibenden Overhead-Queries. Macht rund 30 Queries und unter 400 ms MySQL-Zeit.

    Die Zahlen sind kein Skalpell, sondern eine Hausnummer. Wo genau du landest, hängt von der Modullast des Shops, der Größe des Attribut-Sets und den Marketplace-Erweiterungen mit eigenen Plugins auf dem Configurable-Type ab. Die Größenordnung stimmt aber zuverlässig. Wer auf einer stark frequentierten PDP mit vielen Varianten alle drei N+1-Ebenen fixt, bewegt die TTFB um rund eine Sekunde, und das merken echte Kund:innen.

    Weiterführende Artikel

    • Varnish-Hit-Rate unter 30 % auf Magento 2 diagnostizieren. Die meisten Shops stoßen auf N+1, weil die PDP sich zäh anfühlt. Der erste Reflex ist fast immer die Cache-Seite zu prüfen, und die hat oft ihre eigenen, unabhängigen Baustellen. Mach diesen Check zuerst, dann weißt du, ob du einen Cache-Miss oder einen echten PHP-Bottleneck vor dir hast.

    Die N+1-Checkliste

    1. Baseline-Query-Count auf einem bekannt schlechten Pfad

      New Relic, Tideways oder bin/magento dev:profiler:enable, dann den Request beobachten. Eine PDP mit 40+ Kindern, die mehr als 50 SQL-Queries absetzt, ist so gut wie sicher N+1-verseucht. Notier dir die Zahl.

    2. Nach getById und getBySku in Schleifen greppen

      grep -rn --include='*.php' -E '(productRepository|categoryRepository|stockRegistry)->\w+ById' app/code/. Jeder Treffer innerhalb eines foreach- oder for-Blocks ist ein Kandidat. Anschauen, bestätigen.

    3. Jedes Plugin auf Configurable::getUsedProducts prüfen

      grep -rn --include='*.xml' 'getUsedProducts' app/code/ vendor/. Mehr als ein Plugin von mehr als einem Vendor ist ein starkes Indiz dafür, dass die Methode mehrfach pro Request läuft und sich alles Nachgelagerte darauf multipliziert.

    4. Per-Child-Stock-Lookups auf getItems umstellen

      Jedes foreach mit $stockRegistry->getStockItem($id) darin durch einen einzigen StockItemRepository::getItems($ids)-Aufruf vor der Schleife ersetzen, Ergebnis vorab nach Product-ID indexieren.

    5. Per-Child-Attribut-Lookups auf den Collection-Load verlagern

      addAttributeToSelect auf der Collection, die die Kinder liefert. Kommen die Kinder aus getUsedProducts und du kannst den Load nicht anfassen, hol die Daten über einen searchCriteria-Aufruf statt per Child-Resource-Reads nach.

    6. Feed-Exporte und Reports batchen

      Niemals getById über mehr als eine Handvoll IDs in einer Schleife aufrufen. array_chunk in 500er-Batches, jeden Batch als Collection mit nur den Attributen laden, die der Feed braucht, Bulk-Stock pro Batch vorladen.

    7. Nach jedem Fix neu profilen

      Gleicher Trace, gleicher Pfad. Der Query-Count sollte auf dem PDP-Pfad um Faktor fünf bis zehn fallen, auf Feed-Export-Pfaden um Faktor hundert oder mehr. Die TTFB sollte ungefähr um die vorherige MySQL-Zeit sinken.

    8. Einen CI-Guard einbauen

      Eine statische Analyseregel oder ein einfacher Test, der den Query-Log für einen PDP-Request dumpt und fehlschlägt, sobald der Count einen sinnvollen Schwellwert überschreitet (40 für eine Configurable-PDP ist großzügig bemessen). Günstige Versicherung gegen das nächste Plugin, das den Bug wieder reinbringt.

    N+1 ist selten das Einzige, was deinen Shop ausbremst

    Wir führen fokussierte Magento-2-Performance-Audits durch. Du bekommst eine Query-Count-Baseline, die konkrete Liste der Übeltäter pro Pfad und einen fertigen Batch-Loading-Refactor-Plan. Zwei bis drei Tage, direkt am Code.

    Performance-Audit buchen

    Related articles

    01
    Security

    Cloudflare-WAF bei Magento 2: Warum "Protected" nicht gleich sicher heißt

    Ein grünes Cloudflare-Dashboard schützt deinen Magento-2-Shop nicht automatisch. Der Neun-Punkte-Check zu OWASP-Regeln, UA-Bypässen, Admin-Pfaden und TLS.

    von david-lambauer
    Apr 21, 2026
    02
    Security

    Subdomain-Takeover bei Magento: wenn vergessene CNAMEs zur Sicherheitslücke werden

    Nach dem Hosting-Wechsel weg von Hypernode oder Hipex bleiben CNAME-Einträge in deiner DNS-Zone liegen. Wie daraus ein Subdomain-Takeover wird und wie du deine Zone selbst prüfst.

    von david-lambauer
    Apr 21, 2026
    03
    Performance

    Magento 2: Niedrige Varnish-Hit-Rate diagnostizieren und fixen

    Hit-Rate unter 30 %? So findest du den PHP-Code, die Cookies und die Fehlkonfiguration, die Magento am Full Page Cache vorbeischleusen, Schritt für Schritt.

    von david-lambauer
    Apr 21, 2026