Corrigez les requêtes Prisma lentes grâce à l’exécution SQL directe

Vous aimez le DX de Prisma mais avez besoin d’un overhead de lecture plus faible sur les formes de requête prises en charge ? Le JSON de benchmark actuel montre des accélérations moyennes sur Prisma v6, v7 et v8 pour les lectures PostgreSQL et SQLite prises en charge ; les résultats varient selon la forme de requête.

Accélérer Prisma maintenant

  • Lectures prises en charge plus rapides
  • Aucun changement de requête
  • JSON de benchmark actuel
  • PostgreSQL & SQLite
Votre appel Prismauser.findMany
const users = await prisma.user.findMany({
  where: { status: 'ACTIVE' },
  include: { posts: true },
})
SQL exécuté par prisma-sql
SELECT user_t.id, user_t.email, user_t.status,  COALESCE((    SELECT COALESCE(json_agg(json_build_object(      'id', posts_0.id,      'title', posts_0.title,      'authorId', posts_0."authorId"    )), '[]'::json)    FROM "public"."Post" posts_0    WHERE posts_0."authorId" = user_t.id  ), '[]'::json) AS postsFROM "public"."User" user_tWHERE user_t.status = $1
params ["ACTIVE"]1 instruction
Sortie de createToSQL pour un schéma à deux modèles, retours à la ligne ajoutés.
Couverture Prisma
v6–v8
Matrice de benchmarks PostgreSQL et SQLite
Changements de requête
0
Conservez vos appels Prisma existants
Fichiers de benchmark
6
Prisma v6/v7/v8 × PG/SQLite
Sécurité des types
100%
Même API Prisma

Pourquoi Prisma est-il lent ?

Comprendre l’évolution de Prisma et ses caractéristiques de performance aide à expliquer pourquoi cette extension existe.

Le parcours de Prisma : le DX d’abord, la performance compte à l’échelle

💡 Pourquoi cette extension existe

Prisma a fait les bons choix architecturaux pour ses objectifs : sécurité des types, expérience développeur et comportement multi-bases. Mais ces choix créent un overhead perceptible à l’échelle. Cette extension ne remplace pas Prisma — elle optimise les lectures pour les équipes qui veulent le DX de Prisma plus une exécution plus rapide là où ça compte.

  1. 🎯 2019 : La naissance de Prisma moderne

    Prisma 2 a été lancé en 2019, changeant le paysage des ORM TypeScript avec un accès base de données typé et des types générés depuis votre schéma. Prisma a introduit une architecture basée sur un engine pour traduire les requêtes, les valider et fournir des garanties fortes, difficiles à atteindre avec les ORM JavaScript traditionnels.

  2. ⚡ 2020–2022 : Croissance rapide et expansion des fonctionnalités

    Prisma a ajouté des fonctionnalités puissantes comme les écritures imbriquées, les transactions et le middleware. Le périmètre fonctionnel s’est élargi, mais chaque requête payait toujours un coût architectural : les requêtes sont représentées, validées, exécutées, puis les résultats sont mis en forme pour correspondre à l’API Prisma.

  3. 📊 2023 : L’overhead devient visible à l’échelle

    À mesure que davantage d’équipes ont déployé Prisma sur des workloads à fort trafic, l’overhead fixe par requête est devenu mesurable. C’est le plus visible sur les endpoints dominés par la lecture, l’analytics, les agrégations et les gros jeux de résultats. Cet overhead n’est pas un bug ; c’est le coût des garanties et du comportement d’API de Prisma.

  4. 🚀 2024–2025 : Le travail performance de Prisma continue

    Prisma a livré des mises à jour majeures axées sur la performance et des changements d’engine. Même avec des améliorations, il subsiste un coût inévitable pour parser, valider, planifier et mettre en forme les résultats, comparé à l’exécution directe de SQL brut.

  5. 🎯 2026 : Sortie de l’extension prisma-sql

    Cette extension se concentre sur les performances en lecture. Elle contourne le chemin d’exécution de lecture de Prisma pour findMany, findFirst, findUnique, count, aggregate et groupBy, tout en conservant Prisma pour les écritures, les migrations, la gestion du schéma et la génération de types. Validez la compatibilité avec votre version de Prisma avant déploiement.

Couche de traduction des requêtes

Prisma traduit les entrées de vos requêtes en SQL spécifique à la base de données. Cela permet un comportement multi-bases et la sémantique de l’API Prisma, mais ajoute du temps de traitement avant que la base ne voie le SQL.

Validation et garanties de type

Prisma valide les requêtes contre le schéma et applique des garanties au niveau de l’API. Ces garde-fous évitent certaines classes de bugs, mais ajoutent aussi de l’overhead à chaque requête.

Mise en forme des résultats

Les résultats sont mis en forme pour correspondre au comportement de l’API Prisma. C’est excellent pour le DX et la cohérence, mais cela ajoute de la latence, surtout avec de gros jeux de résultats et des includes complexes.

Cette extension complète Prisma en offrant un chemin plus rapide pour les requêtes de lecture prises en charge. Vous gardez Prisma pour le schéma, les migrations, les écritures et les types générés, tandis que le SQL généré prend en charge certaines lectures critiques via des clients natifs de la base de données.

À quelle vitesse ? Benchmarks réels

Comparaison des derniers JSON de benchmark entre Prisma v6, v7, v8, Drizzle ORM et prisma-sql

PostgreSQL

95 cas de requête par run
  • Prisma v6 (6.19.3)1.56× vs Drizzle
    1.99×

    Prisma v6 (6.19.3) : accélération moyenne de 1.99× par rapport à Prisma

    95 cas de requête mesurés, moyenne vs Prisma30 sept. 2026
  • Prisma v7 (7.10.0)1.51× vs Drizzle
    1.47×

    Prisma v7 (7.10.0) : accélération moyenne de 1.47× par rapport à Prisma

    95 cas de requête mesurés, moyenne vs Prisma30 sept. 2026
  • Prisma v8 (8.1.0-dev.1)1.63× vs Drizzle
    1.54×

    Prisma v8 (8.1.0-dev.1) : accélération moyenne de 1.54× par rapport à Prisma

    95 cas de requête mesurés, moyenne vs Prisma30 sept. 2026

SQLite

84 cas de requête par run
  • Prisma v6 (6.19.3)1.79× vs Drizzle
    4.80×

    Prisma v6 (6.19.3) : accélération moyenne de 4.80× par rapport à Prisma

    84 cas de requête mesurés, moyenne vs Prisma30 sept. 2026
  • Prisma v7 (7.10.0)1.84× vs Drizzle
    2.29×

    Prisma v7 (7.10.0) : accélération moyenne de 2.29× par rapport à Prisma

    84 cas de requête mesurés, moyenne vs Prisma30 sept. 2026
  • Prisma v8 (8.1.0-dev.1)1.63× vs Drizzle
    2.10×

    Prisma v8 (8.1.0-dev.1) : accélération moyenne de 2.10× par rapport à Prisma

    84 cas de requête mesurés, moyenne vs Prisma30 sept. 2026

Généré au build à partir des derniers fichiers benchmark-results/*-latest.json. Les barres partagent une même échelle pour les deux bases de données ; l’ambre marque le meilleur run par base. Les résultats varient selon la forme de requête.Tableau par requêteVoir les données complètes du benchmark

Résultats détaillés des benchmarks

Comparaison statistique avec le test t de Welch et un seuil de significativité pratique de 1 ms

Ces résultats reflètent le mode runtime, où les requêtes sont converties en SQL à chaque appel. En mode prérendu, le SQL est généré au build — le runtime exécute des requêtes paramétrées brutes sans aucun coût de conversion.

PostgreSQLPrisma v6 (6.19.3)

Moyenne 1.99x vs PrismaMoyenne 1.56x vs Drizzle35/95 gains significatifs60 dans le seuil de bruit
30 sept. 2026
TestPrismaprisma-sqlDrizzleAccélérationSig.CV%n
findMany basic0.529ms±0.0640.231ms±0.2340.271ms~1.00x≈198.0%50
findMany where =0.501ms±0.00690.208ms±0.00940.347ms~1.00x≈15.6%50
findMany where >=16.51ms±0.2675.67ms±0.3387.43ms2.91x1.31x D***21.0%50
findMany where IN0.657ms±0.1420.292ms±0.0170.492ms~1.00x≈20.3%50
findMany where null0.280ms±0.0200.167ms±0.0120.177ms~1.00x≈25.7%50
findMany ILIKE0.297ms±0.00970.168ms±0.00890.278ms~1.00x≈18.6%50
findMany AND2.72ms±0.1611.11ms±0.1111.45ms2.45x1.31x D***31.5%50
findMany OR13.98ms±0.2864.69ms±0.2215.88ms2.98x1.25x D***17.0%50
findMany NOT0.639ms±0.0130.274ms±0.00910.478ms~1.00x≈12.2%50
findMany orderBy4.50ms±0.2191.48ms±0.0751.76ms3.03x1.18x D***18.5%50
findMany pagination0.342ms±0.0320.171ms±0.0260.295ms~1.00x≈43.2%50
findMany select0.294ms±0.00940.181ms±0.00720.176ms~1.00x≈14.0%50
findMany relation some1.69ms±0.0980.999ms±0.064—~1.00x≈22.1%50
findMany relation every2.17ms±0.0961.47ms±0.078—~1.00x≈18.9%50
findMany relation none26.02ms±0.51710.06ms±0.511—2.59x***18.0%50
findMany nested relation1.76ms±0.0761.24ms±0.060—~1.00x≈18.0%50
findMany complex2.94ms±0.1091.46ms±0.0681.73ms2.01x1.18x D***17.2%50
findFirst0.378ms±0.0320.175ms±0.0140.350ms~1.00x≈28.0%50
findFirst skip0.328ms±0.1070.147ms±0.00640.301ms~1.00x≈15.2%50
findUnique id0.232ms±0.00970.102ms±0.00550.207ms~1.00x≈18.6%50
findUnique email0.210ms±0.00720.090ms±0.00440.179ms~1.00x≈17.1%50
count0.109ms±0.00330.063ms±0.00300.064ms~1.00x≈16.2%50
count where0.469ms±0.0150.247ms±0.0160.287ms~1.00x≈22.2%50
aggregate count0.215ms±0.00780.155ms±0.0042—~1.00x≈9.2%50
aggregate sum/avg0.305ms±0.0140.261ms±0.0053—~1.00x≈7.1%50
aggregate where0.446ms±0.01000.239ms±0.0058—~1.00x≈8.7%50
aggregate min/max0.305ms±0.0150.268ms±0.010—~1.00x≈13.2%50
aggregate complete0.381ms±0.00610.292ms±0.0072—~1.00x≈8.8%50
groupBy0.419ms±0.0240.344ms±0.013—~1.00x≈12.8%50
groupBy count0.422ms±0.01000.358ms±0.0050—~1.00x≈4.8%50
groupBy multi0.544ms±0.0130.442ms±0.052—~1.00x≈38.9%50
groupBy having0.505ms±0.0110.375ms±0.0086—~1.00x≈8.2%50
groupBy + where0.550ms±0.0110.294ms±0.0064—~1.00x≈7.8%50
_count via include0.679ms±0.0130.511ms±0.013—~1.00x≈8.9%50
_count via include + relations1.55ms±0.0370.666ms±0.017—~1.00x≈9.3%50
groupBy aggregates0.557ms±0.00970.465ms±0.0091—~1.00x≈6.9%50
groupBy min/max0.531ms±0.00800.441ms±0.0053—~1.00x≈4.2%50
include list + nested to-one1.46ms±0.0290.337ms±0.032—4.32x***30.2%50
include list + nullable to-one2.59ms±0.0811.65ms±0.056—~1.00x≈11.9%50
include posts4.25ms±0.2162.35ms±0.1205.77ms1.81x2.45x D***18.9%50
include profile0.635ms±0.8710.540ms±0.2410.648ms~1.00x≈104.7%50
include 3 levels4.48ms±0.1484.03ms±0.1474.58ms~1.00x≈13.6%50
include 4 levels5.61ms±0.1823.39ms±0.1324.65ms1.65x1.37x D***13.9%50
include + where4.04ms±0.1762.88ms±0.3995.51ms~1.00x≈46.7%50
include + select nested2.52ms±0.1391.96ms±0.1854.42ms~1.00x≈31.8%50
findMany startsWith0.270ms±0.0280.140ms±0.0140.314ms~1.00x≈35.4%50
findMany endsWith0.563ms±0.0150.216ms±0.00690.369ms~1.00x≈11.1%50
findMany NOT contains0.627ms±0.0220.250ms±0.1040.447ms~1.00x≈121.8%50
findMany LIKE0.245ms±0.00940.111ms±0.00690.250ms~1.00x≈21.9%50
findMany <25.55ms±0.3987.55ms±0.29210.60ms3.39x1.40x D***13.4%50
findMany <=26.43ms±0.3717.78ms±0.22010.97ms3.40x1.41x D***10.2%50
findMany >15.55ms±0.5995.21ms±0.3566.78ms2.99x1.30x D***24.2%50
findMany NOT IN0.644ms±0.0130.282ms±0.0110.487ms~1.00x≈13.4%50
findMany isNot null0.642ms±0.0140.336ms±0.0170.362ms~1.00x≈18.6%50
orderBy multi-field4.99ms±0.1901.55ms±0.0761.88ms3.22x1.21x D***17.0%50
orderBy relation to-one4.10ms±0.1353.08ms±0.090—1.33x***10.2%50
orderBy relation + scalar5.02ms±0.2583.63ms±0.205—1.39x***20.0%50
orderBy nullable relation4.08ms±0.3002.94ms±0.181—1.39x***21.1%50
orderBy deep relation5.43ms±0.1864.04ms±0.174—1.34x***14.9%50
orderBy deep relation + scalar6.34ms±0.1354.62ms±0.100—1.37x***7.8%50
distinct status8.84ms±0.3761.56ms±0.181—5.66x***36.9%50
distinct multi12.04ms±0.1712.50ms±0.073—4.81x***10.3%50
cursor composite tuple1.61ms±0.0251.13ms±0.017—~1.00x≈5.3%50
cursor composite desc1.75ms±0.0371.31ms±0.021—~1.00x≈5.8%50
cursor prefix of orderBy2.70ms±0.1881.66ms±0.082—1.63x***18.1%50
select + include1.60ms±0.1010.309ms±0.0210.568ms5.16x1.84x D***24.6%50
_count relation1.74ms±0.3411.67ms±0.781—~1.00x≈123.8%50
_count multi-relation0.257ms±0.0290.218ms±0.045—~1.00x≈62.4%50
_count inside include2.32ms±0.1261.55ms±0.124—~1.00x≈32.0%50
_count inside nested select4.64ms±0.2023.69ms±0.266—~1.00x≈24.3%50
_count deep include5.49ms±0.2473.98ms±0.158—1.38x***14.1%50
ILIKE special chars0.425ms±0.0330.193ms±0.022—~1.00x≈36.5%50
LIKE case sensitive0.263ms±0.0100.110ms±0.0078—~1.00x≈24.0%50
findMany Date range0.424ms±0.0120.190ms±0.0120.321ms~1.00x≈21.1%50
count Date range1.14ms±0.0470.925ms±0.0520.995ms~1.00x≈19.8%50
findMany Date gte0.403ms±0.0250.178ms±0.00580.303ms~1.00x≈11.6%50
depth-1 low-fan0.566ms±0.0210.447ms±0.102—~1.00x≈73.7%50
depth-1 mid-fan4.21ms±0.1102.34ms±0.178—1.80x***26.3%50
depth-1 high-fan4.16ms±0.1222.25ms±0.130—1.85x***20.4%50
depth-1 wide3.11ms±0.1141.78ms±0.166—1.75x***31.3%50
depth-1 unbound39.65ms±3.789.43ms±0.884—4.21x***29.1%50
depth-24.78ms±0.1533.54ms±0.187—1.35x***18.6%50
depth-2 paginated Project→tasks3.16ms±0.1492.68ms±0.161—~1.00x≈20.6%50
depth-2 high-fan3.84ms±0.1852.86ms±0.229—~1.00x≈28.7%50
depth-2 wide4.90ms±0.1763.08ms±0.176—1.59x***20.6%50
depth-2 unbound65.60ms±1.5217.60ms±0.479—3.73x***4.4%10
depth-3 unbound15.32ms±0.2818.38ms±0.354—1.83x***15.8%50
depth-3 paginated2.44ms±0.1562.34ms±0.253—~1.00x≈32.7%50
depth-4 unbound9.96ms±0.2686.14ms±0.266—1.62x***15.7%50
depth-4 paginated3.42ms±0.1612.42ms±0.175—~1.00x≈23.6%50
findFirst depth-22.91ms±0.1142.30ms±0.173—~1.00x≈25.9%50
findUnique depth-2 Project→tasks→comment3.27ms±0.1132.16ms±0.173—1.52x***27.5%50
complex nested select4.51ms±0.4283.01ms±0.777—~1.00x≈65.7%50
ultra deep query15.94ms±0.5465.83ms±0.361—2.73x***22.0%50
transaction: (3 operations)3.00ms±0.2751.41ms±0.246—2.14x***53.2%50
*** p < 0.001** p < 0.01*  p < 0.05ns non significatif≈ dans le seuil de bruit de 1 ms± IC à 95 %CV% > 15% = forte variance
Mode runtime mesuré. Le mode prérendu évite entièrement la conversion requête-vers-SQL au runtime — attendez-vous à une latence plus faible que celle affichée ici, en particulier pour les requêtes complexes où le coût de conversion est proportionnellement plus élevé.

Méthodologie

  • –Pour reproduire : npm run bench (BENCHMARK_JSON_OUTPUT=1 écrit le JSON). Les résultats sont enregistrés dans benchmark-results/summary-.json ; v--latest.json alimente cette page.
  • –Chaque requête s’exécute sur la même base de données pour tous les clients : Prisma, prisma-sql, Drizzle. La taille d’échantillon par test figure dans la colonne n.
  • –Rapporté pour chaque côté : mean, median, stdDev, p95, p99, CV%. La significativité repose sur le test t de Welch avec un seuil pratique de 1 ms ; les barres d’erreur sont des IC à 95 %.
  • –Mode runtime mesuré : le SQL est converti à chaque appel. Les requêtes prérendues (@optimize) évitent entièrement la conversion et sont plus rapides que ce qui est affiché.
  • –Le matériel et les versions varient d’un run à l’autre - chaque fichier JSON porte son propre horodatage. Comparez des runs effectués sur la même machine.

Ce qui s’exécute plus vite, et ce qui reste dans Prisma

Chaque fonctionnalité de Prisma Client que nous avons vérifiée, sur PostgreSQL et SQLite. Les écritures restent dans Prisma ; les lectures sont compilées en SQL lorsque la forme est prise en charge.

PostgreSQL
SQLite
Méthodes de modèleOptions de requêteFiltresTriAgrégatsAPI clientTypes de résultat

25 des 73 fonctionnalités vérifiées sont entièrement accélérées sur PostgreSQL. 19 peuvent renvoyer un résultat différent de Prisma ; la carte complète les liste une par une avec la raison.

Nombre de fonctionnalités par statut
StatutPostgreSQLSQLite
Accéléré2521
Partiel66
Repli sur Prisma97
Exécuté par Prisma77
Peut différer1917
Non disponible24
prisma-sql uniquement52
Absent de Prisma06
Non vérifié03
Ouvrir la carte de parité complète
ValidéComment garantissons-nous la correction ?Les requêtes prises en charge sont validées contre Prisma sur PostgreSQL et SQLite, avec des rapports de benchmark couvrant Prisma v6, v7, v8, Drizzle et le SQL généré.Voir la méthodologie de test

Comment elle optimise Prisma

Contournez le chemin d’exécution de lecture de Prisma tout en conservant l’API et les types Prisma

  1. Intercepter les requêtes Prisma

    L’extension intercepte les opérations de lecture (findMany, findFirst, findUnique, count, aggregate, groupBy) avant leur exécution

    generated/sql, extrait
    query: {
      $allModels: {
        async $allOperations({ model, operation, args, query }) {
          if (!ACCELERATED_METHODS.has(operation)) {
            return query(args)
          }
          return executeAccelerated(model, operation, args, query)
        },
      },
    }
  2. Générer du SQL optimisé

    Convertir les requêtes Prisma en SQL rapide et paramétré avec des JOIN optimisés

    SQL pour PostgreSQL
    SELECT user_t.id, user_t.email, user_t.status,
      COALESCE((
        SELECT COALESCE(json_agg(json_build_object(
          'id', posts_0.id,
          'title', posts_0.title,
          'authorId', posts_0."authorId"
        )), '[]'::json)
        FROM "public"."Post" posts_0
        WHERE posts_0."authorId" = user_t.id
      ), '[]'::json) AS posts
    FROM "public"."User" user_t
    WHERE user_t.status = $1
    
    -- params ["ACTIVE"]
  3. Exécuter directement

    Exécuter les requêtes via postgres.js ou better-sqlite3 en contournant l’overhead de lecture de Prisma

    generated/sql, extrait
    if (DIALECT === 'postgres') {
      await client.unsafe(sql, normalizedParams).forEach((row) => {
        results.push(row)
      })
      return results
    }
    
    const stmt = getOrPrepareStatement(client, sql)
    return stmt.all(...normalizedParams)
  4. Renvoyer des résultats compatibles

    Les résultats correspondent au format attendu par Prisma. Types, IntelliSense et code de requête existant restent inchangés

    users.ts
    const users = await prisma.user.findMany({
      where: { status: 'ACTIVE' },
      include: { posts: true },
    })
    
    users[0].email
    users[0].posts[0].title
    
    // Mêmes types inférés que Prisma Client.
    // Les valeurs Decimal, BigInt et DateTime peuvent
    // différer ; la carte de parité liste chaque cas.
Sécurité vérifiéeComment prévenons-nous l’injection SQL ?Validation multi-couches avec liaison de paramètres, vérifications de champs basées sur le schéma et la suite de tests de sécurité actuelleVoir les détails sécurité

Pourquoi choisir cette extension Prisma ?

Obtenez la vitesse d’exécution du SQL brut en lecture tout en conservant l’expérience développeur de Prisma

Accélération Prisma instantanée
Une configuration unique accélère les lectures Prisma. Pas de refactor, pas de migration, pas d’arrêt.
Conservez vos types Prisma
Support TypeScript complet. Inférence de types, autocomplétion et sécurité à la compilation préservées tout en accélérant les lectures.
Solution testée en production
Les tests de parité actuels valident les lectures prises en charge sur les versions récentes de Prisma. Utilisez-la pour des applications en production après avoir vérifié la compatibilité avec votre version de Prisma et votre workload.
Support multi-bases
Optimisez les lectures Prisma sur PostgreSQL (dont Neon, Supabase) et SQLite.
Option précompilée
Un générateur optionnel crée le SQL au build, réduisant l’overhead à quelques microsecondes pour vos requêtes les plus chaudes.
Prête pour le serverless (runtimes Node)
Fonctionne dans les runtimes Node serverless. Le support des runtimes Edge dépend des contraintes du runtime et du driver utilisé.

Au-delà des lectures plus rapides

prisma-sql ajoute des capacités absentes de Prisma Client. Mêmes types, même style de code.

$batch

N requêtes de dashboard, un seul aller-retour

Regroupez des lectures indépendantes en un seul aller-retour PostgreSQL. Résultat objet typé, sans jongler avec Promise.all.

const dash = await prisma.$batch((b) => ({
  users: b.user.count(),
  posts: b.post.findMany({ take: 10 }),
  stats: b.task.aggregate({ _count: true }),
}))

@optimize

Précalculez vos requêtes les plus chaudes

Annotez un modèle dans schema.prisma. À la génération, le SQL exact est figé ; les formes de requête correspondantes au runtime évitent complètement la conversion.

/// @optimize {
///   "method": "findMany",
///   "query": {
///     "where": { "status": "$status" },
///     "take": "$take"
///   }
/// }
model User { ... }

Planificateur de cardinalité

Une stratégie choisie par les données, pas au hasard

Les statistiques de relations collectées pilotent le choix de stratégie entre jointures plates, sous-requêtes corrélées et chargement segmenté par where-in. Les grandes tables enfants ne déclenchent jamais de scans par parent.

prisma-sql-collect-stats \
  --output dist/planner.generated.js \
  --prisma-client dist/client/index.js

Quand la performance Prisma compte le plus

Scénarios courants où cette extension fait une vraie différence

Analytics et reporting

Les agrégations et opérations groupBy Prisma bénéficient fortement de l’exécution SQL directe

  • groupBy 5× plus rapide accélère les rapports
  • Requêtes d’agrégation plus rapides
  • Métriques temps réel avec une latence plus faible

APIs à fort trafic

L’overhead par requête se cumule sous charge, surtout sur les endpoints dominés par la lecture

  • Temps de réponse API plus faibles
  • Plus de requêtes par instance
  • Coûts d’infrastructure réduits

Fonctions serverless

Chaque milliseconde compte en serverless : réduisez la latence de lecture là où c’est critique

  • Meilleurs p95/p99 en lecture
  • Coûts plus bas grâce à des lectures plus rapides
  • Lectures plus rapides sans refactor

Backends mobiles

Les utilisateurs perçoivent la latence : des lectures plus rapides améliorent immédiatement l’UX perçue

  • Chargement du feed plus rapide
  • Pagination plus rapide
  • Interactions plus réactives

Optimisez Prisma en 3 étapes

Accélérez les lectures Prisma en moins de 60 secondes

  1. Installer l’extension Prisma

    Terminal
    # PostgreSQL
    npm install prisma-sql postgres
    
    # SQLite
    npm install prisma-sql better-sqlite3
  2. Ajouter l’extension au Prisma Client

    schema.prisma
    generator client {
      provider = "prisma-client"
    }
    
    generator sql {
      provider = "prisma-sql-generator"
    }
    Terminal
    npx prisma generate
    db.ts
    import { PrismaClient } from '@prisma/client'
    import { speedExtension, type SpeedClient } from './generated/sql'
    import postgres from 'postgres'
    
    const sql = postgres(process.env.DATABASE_URL!)
    const basePrisma = new PrismaClient()
    
    export const prisma = basePrisma.$extends(
      speedExtension({ postgres: sql }),
    ) as SpeedClient<typeof basePrisma>
  3. Utiliser Prisma normalement

    users.ts
    const users = await prisma.user.findMany({
      where: { status: 'ACTIVE' },
      include: { posts: true },
    })

SQLite : passez speedExtension({ sqlite: db }) avec une base de données better-sqlite3.Guide d’installation complet

FAQ performance Prisma

Questions fréquentes sur l’optimisation des lectures Prisma

Pourquoi Prisma a-t-il un overhead ?

Prisma ajoute un overhead car il implémente des garanties d’API comme la validation basée sur le schéma, un comportement de requête cohérent et la mise en forme des résultats. Ces couches offrent une excellente expérience développeur mais coûtent du temps comparé à l’exécution directe de SQL brut.

Comment optimiser des requêtes Prisma ?

Optimisez les workloads Prisma dominés par la lecture en ajoutant cette extension. Elle exécute les opérations de lecture via du SQL direct avec postgres.js ou better-sqlite3 tout en conservant l’API et les types Prisma. Le setup est un petit changement d’initialisation et ne nécessite pas de refactor de vos requêtes existantes.

Prisma est-il plus lent que le SQL brut ?

Pour de nombreux workloads en lecture, oui. Il y a un overhead architectural par rapport à l’exécution de SQL brut. Cette extension vise à conserver le DX de Prisma tout en réduisant la latence de lecture via l’exécution directe de SQL.

Puis-je accélérer Prisma sans modifier mes requêtes existantes ?

Oui. Ajoutez l’extension une fois lors de l’initialisation du Prisma Client et gardez votre code de requêtes Prisma inchangé. Les lectures s’exécutent plus vite, tandis que l’API, les types et le schéma Prisma restent identiques.

Est-ce que ça marche en production ?

Oui, l’extension est conçue pour un usage en production sur les chemins de lecture pris en charge. Vérifiez toujours la compatibilité avec votre version de Prisma et exécutez vos propres tests de régression avant déploiement.

Qu’est-ce qui rend les agrégations Prisma plus lentes ?

Les agrégations et groupBy amplifient souvent l’overhead fixe (traitement des requêtes et mise en forme des résultats) et peuvent impliquer de plus grands jeux de résultats intermédiaires. Cette extension optimise ces lectures en générant du SQL directement, ce qui réduit généralement la latence sur les endpoints riches en agrégations.

Prêt à accélérer Prisma ?

Consultez le tableau de benchmarks actuel pour les lectures PostgreSQL et SQLite prises en charge