Net-Base Magazine

08.11.2026

FireDAC : tableaux de paramètres pour clauses IN — logique d'expansion robuste, limites par base de données et débogage de la requête SQL finale

IN (:ids) paraît pratique, mais échoue sur de longues listes en raison des limites DB et des mythes liés au débogage. Ce guide pratique expose une logique sûre d'expansion et de chunking dans FireDAC, les limites typiques et un paramétrage de traçage propre avec FDMonitor.

08.11.2026

Du thème du magazine à la pratique des projets

Pages de services et techniques pertinentes pour l'article

Video-Botschaft

FireDAC : tableaux de paramètres pour clauses IN — logique d'expansion robuste, limites par base de données et débogage de la requête SQL finale

Warum IN (:ids) mit FireDAC im Betrieb an DB-Limits scheitert, wie Expand/Chunking robust hilft und wie man die finale SQL sauber traced.

Video mit KI erstellt

Transkript anzeigen

Hallo zusammen. IN (:ids) wirkt wie Komfort.

In der Praxis ist es oft ein Stolperdraht. Der Beitrag heißt: FireDAC: Parameter-Arrays für IN-Clauses – sichere Expand-Logik, Limits pro DB und Debugging der finalen SQL.

Der Fehler kommt selten im ersten Test. Er kommt nachts im Batch oder wenn jemand im Backoffice 1.400 Datensätze markiert.

Dann melden Datenbanken Grenzen wie ORA‑01795, „too many SQL variables“ oder ein Parameter-Limit. Wichtig ist die klare Trennung: Parameter sind gebundene Werte, keine Textliste.

Eine robuste Lösung expandiert sauber auf mehrere Platzhalter, arbeitet bei großen Listen mit Chunking in Blöcken und behandelt „Liste leer“ bewusst. Und fürs Debugging: nicht raten, sondern die finale SQL per Trace nachvollziehen, zum Beispiel mit FDMonitor.

Wenn Sie dazu Rückfragen haben, sprechen wir gern kurz über Ihren konkreten Fall.

L’erreur n’apparaît que rarement au premier test. Elle survient la nuit dans le batch, ou lorsqu’un administrateur dans le backoffice « se contente de » sélectionner une plage plus large. Dans le log, on trouve alors quelque chose comme « too many SQL variables », ORA‑01795 ou une erreur SQL‑Server qui n’a que peu de rapport avec le cas d’utilisation réel. Celui qui, à ce stade, mise encore sur le schéma pratique WHERE id IN (:ids) voit vite : ce n’est pas une fonctionnalité de confort, mais un véritable piège.

C’est précisément ce dont il s’agit dans BDE-remplacement avec intégration native : tableaux de paramètres pour les clauses IN : il ne s’agit pas d’une boîte à astuces pour entasser des listes arbitrairement longues « dans un paramètre », mais d’une logique robuste d’expansion et de découpage (chunking) qui respecte les limites de la base de données et qui se laisse déboguer proprement.

Le conflit d’objectifs est réel et se répète dans presque tous les systèmes :

  • Sécurité maximale et maintenabilité : les valeurs sont liées (pas d’injection SQL), les plans peuvent être réutilisés, la journalisation reste contrôlable.
  • Robustesse maximale pour les grandes listes : pas de dépassement des limites imposées par la base de données, pas d’erreurs « seulement chez le client X », débogage reproductible.

On peut atteindre les deux — mais seulement si l’on sépare clairement la mécanique : les paramètres sont des valeurs, les Macros/Substitution sont du texte SQL. Et : les grandes listes ont besoin de garde‑fous.

FireDAC : Tableaux de paramètres pour les clauses IN dans la pratique

BDE-Ablosung mit nativer Anbindung distingue délibérément entre paramètres (valeurs liées) et Macros/Substitution (fragments de texte insérés dans le texte SQL avant le prepare). Le prétraitement peut transformer le texte de commande, développer les macros et produire la structure finale de la requête – mais la liaison des valeurs reste séparée.[Quelle]

Cela peut sembler du formalisme, mais c’est un point de sécurité et d’exploitation : un paramètre représente en SQL typiquement une valeur. Si vous injectez une liste comme texte dans les parenthèses, vous tombez très rapidement dans la concaténation de chaînes ou l’abus de macros. Les deux transforment une requête sûre en une requête que vous devez défendre en permanence contre les injections SQL, les caractères spéciaux et les conversions de type — et qui, accessoirement, affaiblit le plan‑caching de la base de données.

La règle robuste est donc la suivante : soit vous générez une liste IN à partir de plusieurs paramètres de substitution et liez chaque valeur comme paramètre, soit vous changez de technique et fournissez à la base de données un ensemble de valeurs sous forme de « table » (table temporaire, type Collection/Array, Table‑Valued Parameter). FireDAC lui‑même ne vous décharge pas de cette décision d’architecture.

Carte d’arbitrage : trois approches pour la liste IN – utilité, effort, risques

Avant de discuter des détails d’implémentation, il vaut la peine d’avoir un regard clair sur les options. Il ne s’agit pas de « correct vs. incorrect », mais de la question de savoir quel risque vous voulez assumer et où : dans le Delphi-code ou dans l’exploitation de la base de données.

Approche 1 : Expansion en de nombreux paramètres (IN (:p0,:p1,…))

Avantages : reste dans le cadre de la liaison des paramètres, fonctionne avec FireDAC à travers les backends, pas d’objets DB supplémentaires.
Effort : modéré (construction de chaînes + noms de paramètres + liaisons).
Risques/limites : limites strictes (nombre de paramètres, expressions IN), les variantes d’instruction explosent si la taille de la liste varie fortement.
Pertinent pour : listes de filtres jusqu’à « quelques centaines », retrofit dans un logiciel métier existant, cross-DB.

Approche 2 : Chunking (plusieurs blocs IN reliés par OR, correctement parenthésés)

Avantages : respecte les limites, reste cross-DB, peut absorber des listes très longues sans fonctionnalités spécifiques à la DB.
Effort : plus élevé (logique de parenthèses, formation des blocs, gestion des paramètres, tests).
Risques/limites : clauses WHERE longues ; des enchaînements d’OR peuvent affecter l’optimizer/les plans ; le débogage doit fournir le contexte (taille des blocs/comptes).
Pertinent pour : Oracle/SQL Server/SQLite dans une base de code commune, si de grandes listes surviennent de manière sporadique.

Approche 3 : transmettre les valeurs comme « table » (Temp-Tabelle / TVP / Collection)

Avantages : le SQL reste court, la stabilité des plans est souvent meilleure, de très grands volumes sont gérables.
Effort : spécifique à la DB ; l’exploitation/déploiement (schéma, droits, nettoyage/transactions) devient partie de la solution.
Risques/limites : plus de composants mobiles (migrations, monitoring, autorisations).
Pertinent pour : volumes importants réguliers (milliers+), traitement par lots, lorsque le backend est fixé et que l’exploitation peut l’assumer.

Limites strictes par base de données : les vrais moteurs de la logique d’expansion

Les limites sont la raison pour laquelle « ça marche en local » n’est pas suffisant en production. Ce n’est pas votre code Delphi qui est décisif, mais ce que le backend accepte en termes de forme d’instruction et de nombre de paramètres.

Base de données Limite pertinente Erreur typique Conséquence pratique
Oracle Max. 1000 expressions dans une liste IN ORA-01795 Chunking ou technique alternative (Join/Collection) nécessaire dès que les listes deviennent « vraiment » grandes
SQL Server Max. 2100 paramètres par Statement/Batch Erreur en cas de trop grand nombre de paramètres Prévoir une réserve pour paramètres supplémentaires ; au-delà d’un seuil, évaluer le chunking ou les TVP
SQLite Nombre max. de paramètres hôtes (par défaut historiquement souvent 999, dépendant de la version/build) « too many SQL variables » Activer le chunking tôt ; documenter la limite en exploitation car elle varie selon la distribution
PostgreSQL Le nombre de paramètres est limité (lié au protocole/à l’implémentation) Erreur pour des quantités extrêmes de paramètres Définir une limite supérieure ; pour des volumes très importants, envisager une stratégie de tables de valeurs

Pour Oracle, la limite des 1000 est clairement documentée : dans la clause IN, jusqu’à 1000 expressions sont autorisées.[Quelle] Important : la conséquence est la suivante : la limite doit être considérée comme une contrainte de structure de la condition SQL, et non comme un « problème de littéral ». AskTOM classe ORA‑01795 en conséquence comme une limite stricte des listes IN et cite le fractionnement/le regroupement comme contournement typique — ou alternativement un JOIN contre un ensemble de valeurs.[Quelle]

SQLite est sournois, car la limitation ne porte pas sur les « IN-expressions », mais sur le nombre de variables de liaison. La limite est documentée sous le nom SQLITE_MAX_VARIABLE_NUMBER et peut varier sensiblement selon la version/build. Conséquence : même si vous n’utilisez SQLite qu’à la marge (tests, outils, clients hors ligne), il faut quand même une logique d’expansion qui n’explose pas subitement à 999 paramètres.[Quelle]

Sichere Expand-Logik: was sie leisten muss (und was nicht)

Si vous implémentez Expand/Chunking, ne le faites pas par « bricolage de chaînes », mais comme un petit composant d’infrastructure. Il doit accomplir quatre choses de manière fiable :

  • Générer uniquement des paramètres : les valeurs doivent être liées exclusivement via des paramètres FireDAC.
  • Traiter explicitement la liste vide : chemin défini, pas d’erreurs de syntaxe SQL, pas de changements silencieux de sémantique.
  • Prendre en compte les limites et la marge : par SGBD une valeur limite, plus une réserve pour d’autres paramètres dans la requête.
  • Fournir un contexte de débogage : nombre de valeurs, taille des blocs, nombre de blocs, empreinte optionnelle — plutôt que « tout en clair ».

Leere Listen: der Null-Fall ist der häufigste Produktions-Fall

« Aucune ID » arrive constamment : filtres de droits, filtres de recherche, enregistrements supprimés, sélection vide. Et c’est précisément là que beaucoup d’implémentations deviennent bancales, parce qu’elles tentent de « sauver » un IN () d’une manière ou d’une autre.

Options pragmatiques et faciles à tester :

  • Pas d’appel à la DB : si votre cas d’utilisation doit renvoyer un ensemble de résultats, renvoyez directement vide (particulièrement pertinent pour les services et les API).
  • Condition toujours fausse : si, pour des raisons d’architecture, vous devez exécuter la requête, remplacez la portion IN par une condition manifestement fausse (p. ex. 1=0) plutôt que d’inventer un « IN (NULL) ».

Chunking: warum „Reserve“ mehr zählt als das dokumentierte Limit

Le chunking n’est pas seulement « pour Oracle ». C’est votre assurance contre deux réalités typiques : paramètres additionnels (mandant, statut, période, permissions) et tailles de liste imprévisibles.

Quelques garde-fous qui devraient ressortir lors des revues :

  • Taille des blocs : jamais au maximum : si SQL Server autorise 2100 paramètres, une taille de bloc de 2090 n’est pas une bonne idée, car la requête ne se compose rarement uniquement de la liste IN.
  • Les blocs OR doivent être parenthésés : dès qu’un autre AND intervient, la logique change sans parenthèses.
  • Noms de paramètres déterministes : préfixe + index (p. ex. :ids_0001) facilite nettement les traces, les reproductions et les analyses de différences.

Exemple (construit) : quand un job batch échoue soudainement de façon « spécifique au client »

Débogage du SQL final : pourquoi cette demande est compréhensible — mais rarement la bonne approche

Beaucoup d’équipes recherchent « le SQL final », c’est‑à‑dire une chaîne où toutes les valeurs de paramètres sont « insérées ». Pour les paramètres liés, il s’agit souvent d’une fausse exigence : la base de données reçoit l’instruction et les valeurs séparément. C’est le fonctionnement normal pour une exécution sûre et le réemploi des plans. Il n’existe donc souvent pas de « SQL d’exécution » unique et canonique au sens où l’on entendrait une requête écrite à la main.

Dans FireDAC, la voie de débogage correcte passe par FDMonitor. Là, vous voyez Prepare/Execute, le texte de l’instruction, les valeurs des paramètres (avec leurs types) et la séquence des actions. C’est plus proche de ce qui se passe réellement dans le backend que toute reconstruction de chaîne bricolée.[Source]

Ce que vous devriez analyser spécifiquement dans le trace

  1. Structure de la clause WHERE : les blocs OR sont‑ils parenthésés avant l’ajout d’autres filtres AND ?
  2. Nombre de paramètres : combien de paramètres y a‑t‑il réellement — y compris mandant/statut/période ? Cela détermine les limites de SQL Server et de SQLite.
  3. Liaison de type : les IDs numériques sont‑elles liées en tant que numériques ? Chaînes vs nombres n’est pas un sujet cosmétique ; cela peut affecter l’utilisation des index et le choix du plan.
  4. Variantes d’instruction : un nombre différent de placeholders correspond à un autre texte d’instruction. Avec des listes de taille variable, vous générez ainsi plus de variantes de Prepare ; le découpage en blocs de taille fixe peut réduire la variance.

Logging : SQL + contexte plutôt que SQL + 2 400 valeurs

Dans les logs de production, vous ne souhaitez généralement pas voir chaque valeur individuelle. Vous recherchez un diagnostic avec une taille de log raisonnable et sans exposition de données inutile. Les champs typiques utiles sont :

  • Nombre de valeurs (Count)
  • Taille de bloc et nombre de blocs
  • Empreinte de la liste normalisée (p. ex. hash), pour détecter des répétitions sans écrire les contenus
  • Aperçu tronqué (p. ex. 5 premières/5 dernières valeurs), si cela est conforme à la protection des données et pertinent d’un point de vue métier

Tableaux de paramètres dans FireDAC : le terme qui induit souvent en erreur

FireDAC documente les « Parameter-Arrays », principalement dans le contexte de Array-DML (Batched Execution) : plusieurs enregistrements sont exécutés dans une seule instruction en passant les valeurs des paramètres sous forme de tableaux. Il s’agit d’une fonctionnalité de performance pour INSERT/UPDATE/DELETE – mais cela ne résout pas automatiquement le problème de « liste IN comme un seul paramètre ». Ce sont deux cas d’usage différents, qui se ressemblent lexicalement mais fonctionnent différemment sur le plan opérationnel.[Quelle]

Conséquence pratique pour la communication en équipe : si quelqu’un parle de « Parameter-Arrays pour IN », il vaut la peine de clarifier : veux-tu dire Array-DML, ou parles-tu d’Expand/Chunking pour WHERE IN ? Cette précision évite que des valeurs finissent par être injectées par substitution textuelle dans le SQL.

Checklist de revue : pièges typiques qui coûtent cher plus tard

1) « Tout en string » est confortable, mais peut neutraliser les index

Si la colonne est numérique, les paramètres liés doivent être numériques. Sinon des conversions implicites peuvent se produire. Elles sont difficiles à détecter, mais coûteuses : elles peuvent empêcher l’utilisation attendue des index ou faire basculer les plans sous charge.

2) Doublons et valeurs non valides vous poussent inutilement vers la limite

La déduplication réduit le nombre de paramètres sans inconvénient fonctionnel. De même, l’élimination précoce des chaînes vides ou des IDs manifestement invalides. Ce n’est pas une optimisation « au cas où », mais réduit directement le risque d’atteindre des limites.

3) Le parenthésage est de la sémantique, pas du style

Un bloc OR mal parenthésé renvoie des données incorrectes – souvent sans message d’erreur. C’est l’erreur la plus problématique : silencieuse, difficile à reproduire, potentiellement critique sur le plan métier. Si on utilise le chunking, le parenthésage doit être vérifié explicitement dans les tests (pas seulement « ça passe »).

4) L’expansion libre génère de nombreuses variantes d’instruction

Si la taille des listes varie fortement, le nombre de placeholders varie et donc le texte de l’instruction aussi. Cela augmente les variantes de préparation et peut apparaître dans le monitoring comme beaucoup de Parse/Prepare. Le chunking avec une taille de bloc fixe (sauf pour le dernier bloc) réduit cette variété, mais ne l’élimine pas complètement. Si cela pose vraiment problème, l’approche « valeurs en table » est généralement l’étape suivante.

Plan de mise en œuvre : comment un cas marginal devient un composant standard

  1. Normaliser l’entrée : supprimer les espaces en tête/queue, dédupliquer, rejeter les valeurs invalides, trier en option (pour une empreinte stable).
  2. Définir le profil backend : fixer la limite par DB (expressions IN ou limite de paramètres) et prévoir une réserve pour des paramètres additionnels.
  3. Choisir la stratégie : petites listes → Expand ; listes indéterminées ou plus grandes → Chunking ; listes très volumineuses et fréquentes → évaluer l’approche table-de-valeurs.
  4. Générer le SQL : n’utiliser que des placeholders ; parenthéser les blocs OR ; maintenir clairement les filtres AND supplémentaires en dehors du groupe OR.
  5. Lier les paramètres : définir des types appropriés ; traiter les valeurs NULL de manière explicite (NULL dans IN est le plus souvent inefficace et complique le debug).
  6. Ajouter de la diagnostic : logger Count/Chunk/Fingerprint ; documenter FDMonitor-Trace comme « mode debug approfondi » dans le runbook.
  7. Tests aux limites : 0, 1, Limit-1, Limit, Limit+1 (chaque cas plus paramètres additionnels), afin d’assurer un comportement stable lors d’évolutions.

Quand l’effort supplémentaire en vaut vraiment la peine (et quand non)

Toutes les applications n’ont pas besoin du jeu complet d’outils. Le surcoût est justifié surtout si au moins un des points suivants s’applique :

  • Les listes proviennent d’une sélection utilisateur ou de scopes d’autorisations (taille difficile à prévoir).
  • Des processus batch s’exécutent sans supervision (les erreurs doivent être diagnostiquées rapidement).
  • Plusieurs bases de données sont prises en charge (Oracle/SQL Server/SQLite-Mix, p. ex. pour des outils/tests).
  • La table concernée est volumineuse et critique pour la performance (liaison des types et stabilité des plans sont déterminantes).

Si, en revanche, tu disposes d’un backend clairement délimité et que le cas d’utilisation garantit des listes de petite taille (p. ex. filtres UI avec au maximum 50 IDs), une solution Expand simple peut suffire — à condition de ne pas oublier le cas de liste vide et un test de frontière. Ce n’est pas une « Überarchitektur », mais une protection contre le premier vrai cas limite en production.

Point final : la stabilité ne naît pas d’astuces, mais de limites et d’observabilité

FireDAC facilite la bonne pratique : lier les paramètres, traiter séparément les macros, préparer proprement les statements. Le problème n’apparaît que lorsque les listes IN croissent de manière incontrôlée. Qui construit Expand/Chunking comme composant standardisé, respecte les limits par base de données, traite les listes vides comme un chemin normal et accepte FDMonitor comme vérité de débogage, retire à ce sujet son caractère anxiogène. Le code en vaut la peine lorsque tu ne veux plus t’interroger sur pourquoi une fonctionnalité « ne tient que sur de grands volumes » s’effondre — et lorsque tu veux, en exploitation, trouver la cause en minutes plutôt qu’en heures.

Sources et informations complémentaires

Les principaux points techniques ont été mis en perspective à partir des sources externes suivantes.

  1. Preprocessing Command Text (FireDAC) – RAD Studio (docwiki.embarcadero.com)
    FireDAC sépare la liaison des paramètres des macros/substitutions et prétraite le Command-Text avant le Prepare ; les valeurs appartiennent aux paramètres, les fragments SQL aux macros.
  2. IN Condition (docs.oracle.com)
    Oracle autorise au maximum 1000 expressions dans une liste IN, d’où la nécessité du chunking ou d’une technique alternative pour les listes volumineuses.
  3. Limit and conversion very long IN list : WHERE x IN ( ,,, …) – Ask TOM (asktom.oracle.com)
    ORA-01795 est identifié comme la limite de la liste IN (max. 1000) ; les contournements typiques sont la division et la recomposition, ou des alternatives telles que le JOIN contre un ensemble de valeurs.
  4. Implementation Limits For SQLite (www.sqlite.org)
    SQLite limite le nombre de paramètres hôtes (SQLITE_MAX_VARIABLE_NUMBER), ce qui restreint directement les listes IN étendues.
  • FDMonitor – RAD Studio (docwiki.embarcadero.com)
    FDMonitor est l’outil central FireDAC pour tracer de manière reproductible les instructions SQL, les valeurs de paramètres, les types et les étapes d’exécution.
  • Array DML (FireDAC) – RAD Studio (docwiki.embarcadero.com)
    Les tableaux de paramètres FireDAC sont principalement documentés pour Array-DML/exécution par lots et ne constituent pas automatiquement une solution pour la liaison de listes IN.
  • Pour ce sujet, la clause IN FireDAC et l’expansion des paramètres Delphi sont également importantes. L’article remet ces aspects en perspective de manière claire et montre ce qui compte dans la pratique.

    Discuter d’un projet ou d’une modernisation avec Net-Base.

    Étape suivante

    Lorsque le sujet devient un projet réel, l'architecture, l'existant et l'exploitation doivent être examinés ensemble dès le départ.

    Nous n'intervenons pas seulement sur des questions ponctuelles, mais aussi lorsque des fragments de code source, des problématiques liées aux systèmes legacy ou des concepts de portail doivent se transformer en un projet d'entreprise robuste.

    • L'état des lieux, l'état cible et les risques techniques sont évalués conjointement.
    • REST, l’accès aux données, les portails et le déploiement ne sont pas reportés à des phases ultérieures.
    • Vous identifiez tôt quelle voie est viable économiquement et opérationnellement.

    Partager l'article

    Partager directement cette publication

    LinkedIn, X, Facebook, WhatsApp und E-Mail sind sofort verfügbar. für Instagram bereiten wir Link und Kurztext direkt vor.

    Courriel

    Instagram s'ouvre dans un nouvel onglet. Le lien et le court texte sont préalablement copiés dans le presse-papiers.

    Écrire un commentaire

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert