Net-Base Magazine

08.11.2026

FireDAC: Parameterarrays voor IN-clausules – veilige expand-logica, limieten per DB en debugging van de uiteindelijke SQL

IN (:ids) lijkt comfortabel, maar faalt bij grote lijsten door DB-limits en mythes rond debugging. Deze praktijkgids toont veilige Expand- en Chunking-logica in FireDAC, typische grenzen en een duidelijk trace-opzet met FDMonitor.

08.11.2026

Van magazinethema naar projectpraktijk

Relevante dienst- en technische pagina's bij het artikel

Video-Botschaft

FireDAC: Parameterarrays voor IN-clausules – veilige expand-logica, limieten per DB en debugging van de uiteindelijke SQL

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.

De fout doet zich zelden voor bij de eerste test. Hij treedt ’s nachts in batchprocessen op, of wanneer een beheerder in het Backoffice „zomaar” een grotere selectie markeert. In de log staat dan iets als „too many SQL variables”, ORA‑01795 of een SQL Server‑fout die weinig met de eigenlijke use case te maken heeft. Wie op dat punt nog vertrouwt op het comfortabele patroon WHERE id IN (:ids), merkt snel: het is geen gemakzuchtige feature, maar een struikelpunt.

Daarom gaat het bij BDE-vervanging met native Anbindung: Parameter-Arrays für IN-Clauses: niet om een trukendoos om willekeurig lange lijsten „in één parameter” te proppen, maar om een robuuste expand- en chunking-logica die DB‑limieten respecteert en zich netjes laat debuggen.

Het dilemma daarachter is reëel en doet zich in bijna elk systeem voor:

  • Maximale Sicherheit und Wartbarkeit: waarden worden gebonden (geen SQL‑injectie), plannen kunnen worden hergebruikt, logging blijft beheersbaar.
  • Maximale Robustheit bei großen Listen: er ontstaan geen harde DB‑grenzen, geen „alleen bij Kunde X”‑fouten, reproduceerbare debugging.

Beide doelen zijn te bereiken – maar alleen als je de mechaniek duidelijk scheidt: parameters zijn waarden, Macros/Substitution zijn SQL‑tekst. En: grote lijsten hebben Guardrails nodig.

FireDAC: Parameterarrays für IN-Clauses in der Praxis

BDE-Ablosung mit nativer Anbindung onderscheidt bewust tussen Parametern (gebondene Werte) und Macros/Substitution (Tekstfragmenten, die voor het Prepare in den SQL‑Text eingesetzt werden). Das Preprocessing kann den Command‑Text transformieren, Macros expandieren und die endgültige Statement‑Struktur erzeugen – aber die Wertebindung blijft davon getrennt.[Quelle]

Dat klinkt als formaliteit, maar is een veiligheids‑ en operatiepunt: een Parameter vertegenwoordigt in SQL typisch één waarde. Als je een lijst als tekst in de haakjes „insmokkelt”, kom je snel uit bij stringconcatenatie of macromisbruik. Beiden maken van een veilige query een query die je constant tegen SQL‑injectie, speciale tekens en typeconversies moet verdedigen – en die bovendien de plan‑caching van de database verzwakt.

De leidraad is daarom: of je genereert een IN‑lijst uit meerdere Platzhaltern en bindt elke waarde als parameter, of je verandert van techniek en geeft de database een waardenset als „tabel” (temp‑tabel, collection/array‑type, Table‑Valued Parameter). FireDAC selbst nimmt dir diese Architekturentscheidung nicht ab.

Afwegingskaart: drie wegen naar de IN‑lijst – Nutzen, Aufwand, Risiken

Voordat je over implementatiedetails gaat discussiëren, is een duidelijke blik op de opties zinvol. Het gaat niet om ‚goed versus fout‘, maar om de vraag welk risico je waar wilt dragen: in de Delphi-Code of in het databasebeheer.

Optie 1: Expand naar veel parameters (IN (:p0,:p1,…))

Voordeel: blijft binnen parameterbinding, werkt met FireDAC over verschillende backends, geen extra DB-objecten.
Inspanning: matig (stringopbouw + parameternamen + bindings).
Risico’s/Beperkingen: harde limieten (aantal parameters, IN-expressies), statement-varianten exploderen bij sterk wisselende lijstgrootte.
Geschikt voor: filterlijsten tot ‚enkele honderden‘, retrofit in bestaande bedrijfssoftware, cross-DB.

Optie 2: Chunking (meerdere IN-blokken per OR, netjes geklammerd)

Voordeel: respecteert limieten, blijft cross-DB, kan zeer grote lijsten opvangen zonder DB-specifieke features.
Inspanning: hoger (haakjeslogica, blokvorming, parametermanagement, tests).
Risico’s/Beperkingen: lange WHERE-clausules; OR-ketens kunnen optimizer/plannen beïnvloeden; debugging moet context leveren (blokgrootte/aantallen).
Geschikt voor: Oracle/SQL Server/SQLite in één codebasis, wanneer grote lijsten sporadisch voorkomen.

Optie 3: Waarden als „tabel“ doorgeven (temp-tabel / TVP / Collection)

Voordeel: SQL blijft kort, planstabiliteit vaak beter, zeer grote hoeveelheden zijn hanteerbaar.
Inspanning: DB-specifiek; operatie/deploy (schema, rechten, cleanup/transacties) wordt deel van de oplossing.
Risico’s/Beperkingen: meer bewegende delen (migraties, monitoring, permissies).
Geschikt voor: regelmatig grote hoeveelheden (duizenden+), batchprocessing, wanneer het backend vaststaat en de operatie dit kan dragen.

Harde limieten per database: de werkelijke drijfveren voor Expand-Logik

De limieten zijn de reden waarom „loopt lokaal“ in productie niet genoeg is. Beslissend is niet je Delphi-Code, maar wat het backend aan statementvorm en aantal parameters accepteert.

Database Relevant limiet Typisch foutbeeld Praktische consequentie
Oracle Max. 1000 expressies in een IN-lijst ORA-01795 Chunking of alternatieve techniek (Join/Collection) nodig zodra lijsten echt groot worden
SQL Server Max. 2100 parameters per statement/batch Fout bij te veel parameters Reserve voor extra parameters inplannen; vanaf de drempel chunking of TVP evalueren
SQLite Max. host-parameters (historisch vaak 999, afhankelijk van versie/build) „too many SQL variables“ Chunking vroeg inschakelen; limiet in productie documenteren, omdat het per distributie varieert
PostgreSQL Aantal parameters is beperkt (protocol-/implementatie-afhankelijk) Fouten bij extreme aantallen parameters Bovengrens definiëren; bij zeer grote aantallen waardetabellen-strategie overwegen

Für Oracle ist die 1000er-Grenze sauber dokumentiert: In der IN-Condition sind bis zu 1000 Expressions zulässig.[Bron] Wichtig ist die Folgerung: Das Limit gilt als Strukturgrenze der SQL-Bedingung, nicht als „Literal-Problem“. AskTOM ordnet ORA‑01795 entsprechend als harte IN-List-Grenze ein und nennt Splitten/Verknüpfen als typischen Workaround – alternativ eben ein Join gegen eine Wertemenge.[Bron]

SQLite ist tückisch, weil du nicht gegen „IN-Expressions“, sondern gegen die Anzahl der Bind-Variablen läufst. Das Limit ist als SQLITE_MAX_VARIABLE_NUMBER dokumentiert und kann je nach Version/Build deutlich variieren. Konsequenz: Wer SQLite nur „am Rand“ nutzt (Tests, Tools, Offline-Clients), braucht trotzdem eine Expand-Logik, die nicht plötzlich auf 999 Parameter knallt.[Bron]

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

Wenn du Expand/Chunking baust, dann nicht als „Stringbastelei“, sondern als kleine Infrastruktur-Komponente. Sie sollte vier Dinge zuverlässig tun:

  • Nur Platzhalter erzeugen: Werte werden ausschließlich über FireDAC-Parameter gebunden.
  • Leere Liste explizit behandeln: definierter Pfad, keine SQL-Syntaxfehler, keine stillen Semantikänderungen.
  • Limits und Reserve berücksichtigen: pro DB ein Grenzwert, plus Puffer für weitere Parameter im Statement.
  • Debug-Kontext liefern: Anzahl Werte, Blockgröße, Anzahl Blöcke, optional Fingerprint – statt „alles in Klartext“.

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

„Keine IDs“ passiert ständig: Rechtefilter, Suchfilter, gelöschte Datensätze, leere Selektion. Und genau hier werden viele Implementierungen unsauber, weil sie versuchen, „IN ()“ irgendwie zu retten.

Pragmatische, gut testbare Optionen:

  • Kein DB-Call: wenn dein Use Case ein Ergebnisset liefern soll, gib direkt leer zurück (besonders sinnvoll in Services und APIs).
  • Always-false-Bedingung: wenn du aus Architekturgründen das Statement ausführen musst, ersetze die IN-Passage durch eine sicher falsche Bedingung (z. B. 1=0), statt ein „IN (NULL)“ zu erfinden.

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

Chunking ist nicht nur „für Oracle“. Es ist deine Versicherung gegen zwei typische Realitäten: Zusatzparameter (tenant, Status, Zeitraum, Berechtigungen) und unvorhersehbare Listengrößen.

Ein paar Leitplanken, die in Reviews auffallen sollten:

  • Blockgröße nie am Maximum: Wenn SQL Server 2100 Parameter zulässt, ist eine Blockgröße von 2090 keine gute Idee, weil das Statement selten nur aus der IN-Liste besteht.
  • OR-Blöcke müssen geklammert sein: Sobald ein weiteres AND dazukommt, ändert sich ohne Klammern die Logik.
  • Deterministische parameternamen: Prefix + index (z. B. :ids_0001) maakt Traces, Repros en diff-analyses duidelijk eenvoudiger.

Voorbeeld (geconstrueerd): Wenn ein Batch-Job plötzlich „kundenspezifisch“ scheitert

Debugging van de uiteindelijke SQL: Waarom de wens begrijpelijk is — maar zelden het juiste oplevert

Veel teams zoeken naar „de uiteindelijke SQL“, dus een string waarin alle parameterwaarden „ingevoegd“ zijn. Voor gebonden parameters is dat vaak een schijnvereiste: de database ontvangt statement en waarden gescheiden. Dat is de normale situatie voor veilige uitvoering en plan-reuse. Een enkele, canonieke „uitvoerings-SQL“ bestaat daarom vaak niet in de zin zoals men die kent van handmatig samengestelde SQL.

In FireDAC loopt de juiste debugroute via FDMonitor. Daar zie je Prepare/Execute, de statement-tekst, de parameterwaarden (met types) en de volgorde van de acties. Dat komt dichter bij wat er werkelijk in het backend gebeurt dan elke zelfgemaakte stringreconstructie.[Quelle]

Wat je in de trace gericht moet analyseren

  1. Structuur van de WHERE-clausule: Zijn OR-blokken tussen haakjes gezet voordat er bijkomende AND-filters komen?
  2. Aantal parameters: Hoeveel parameters zijn het werkelijk – inclusief tenant/status/periode? Dat bepaalt de grenzen van SQL Server en SQLite.
  3. Typebinding: Worden numerieke IDs ook numeriek gebonden? Strings versus getallen is geen cosmetische kwestie, maar kan het gebruik van indexen en de keuze van het plan beïnvloeden.
  4. Statement-varianten: Elke andere hoeveelheid placeholders is een andere statement-tekst. Bij wisselende lijsten genereer je daarmee meer prepare-varianten; chunking met een vaste blokgrootte kan de variatie verminderen.

Logging: SQL + context in plaats van SQL + 2.400 waarden

In productie-logs wil je zelden elke afzonderlijke waarde zien. Je wilt diagnosemogelijkheden bij aanvaardbare loggrootte en zonder onnodige data-expositie. Typische, nuttige velden zijn:

  • Aantal waarden (Count)
  • Blokgrootte en aantal blokken
  • Fingerprint van de genormaliseerde lijst (bijv. hash), om herhalingen te herkennen zonder inhoud uit te schrijven
  • Ingekorte weergave (bijv. eerste/laatste 5 waarden), wanneer dat privacyrechtelijk en vakspecifiek verantwoord is

Parameter-Arrays in FireDAC: de term die vaak de verkeerde richting op leidt

FireDAC documenteert „Parameter-Arrays“ vooral in de context van Array-DML (Batched Execution): veel rijen worden in één statement uitgevoerd door parameterwaarden als arrays mee te geven. Dat is een prestatiekenmerk voor INSERT/UPDATE/DELETE – maar het lost niet automatisch het probleem „IN-lijst als één parameter“ op. Het zijn twee verschillende use cases die taalkundig vergelijkbaar klinken, maar operationeel anders werken.[Quelle]

Praktische consequentie voor teamcommunicatie: Als iemand „Parameter-Arrays für IN“ zegt, is het de moeite waard om na te vragen: bedoel je Array-DML, of bedoel je Expand/Chunking voor WHERE IN? Deze duidelijkheid voorkomt dat er uiteindelijk toch weer waarden per tekstsubstitutie in de SQL terechtkomen.

Review-Checkliste: typische Fallstricke, die später teuer werden

1) „Alles als String“ ist bequem, aber kann Indizes aushebeln

Als de kolom numeriek is, moeten de gebonden parameters numeriek zijn. Anders kunnen impliciete conversies optreden. Die zijn moeilijk te zien, maar duur: ze kunnen ertoe leiden dat indexen niet zoals verwacht worden gebruikt of dat plannen bij belasting omslaan.

2) Duplikate und ungültige Werte treiben dich unnötig Richtung Limit

Deduplicatie verlaagt het aantal parameters zonder functioneel nadeel. Evenzo het vroegtijdig verwijderen van lege strings of duidelijk ongeldige IDs. Dit is geen optimalisatie „op goed geluk“, maar vermindert direct de kans dat limieten worden overschreden.

3) Klammerung ist Semantik, kein Stil

Een verkeerd gehaakt OR-blok levert foutieve gegevens op – vaak zonder foutmelding. Dat is het ongunstigste foutbeeld: stil (zonder foutmelding), moeilijk reproduceerbaar en inhoudelijk risicovol. Als Chunking wordt toegepast, moet de haakjesindeling expliciet in tests worden gecontroleerd (niet alleen „het draait“).

4) Freies Expandieren erzeugt viele Statement-Varianten

Als de lijstgrootte sterk varieert, varieert ook het aantal plaatsaanduiders en daarmee de tekst van het statement. Dat verhoogt het aantal prepare-varianten en kan zich in monitoring tonen als „veel Parse/Prepare“. Chunking met een vaste blokgrootte (behalve het laatste blok) vermindert de variatie, maar elimineert die niet volledig. Als dat echt problemen geeft, is „waarden als tabel“ meestal de volgende stap.

Umsetzungsfahrplan: so wird aus einem Randfall ein Standardbaustein

  1. Eingang normalisieren: trimmen, dedupliceren, ongeldige waarden wegwerpen, optioneel sorteren (voor een stabiele Fingerprint).
  2. Backend-Profil definieren: limiet per DB vastleggen (IN-expressies of parameterlimiet) en een Reserve voor extra parameters inplannen.
  3. Strategie wählen: kleine lijsten → Expand; onduidelijke of grotere lijsten → Chunking; zeer grote en frequente lijsten → waarden-als-tabel-aanpak evalueren.
  4. SQL erzeugen: alleen plaatsaanduiders; OR-blokken tussen haakjes zetten; extra AND-filters duidelijk buiten de OR-groep houden.
  5. Parameter binden: types passend zetten; NULL-waarden bewust behandelen (NULL in IN is meestal zinloos en verwart debugging).
  6. Diagnose einbauen: Count/Chunk/Fingerprint in het log; FDMonitor-Trace als „diepere debug-modus“ in het runbook documenteren.
  7. Grenztests: 0, 1, Limit-1, Limit, Limit+1 (steeds plus aanvullende parameters), zodat het gedrag bij wijzigingen stabiel blijft.

Wann sich der Mehraufwand wirklich lohnt (und wann nicht)

Niet elke toepassing heeft de volledige gereedschapskist nodig. De extra inspanning betaalt zich met name uit wanneer minstens één van de volgende punten van toepassing is:

  • Lijsten komen voort uit gebruikersselectie of machtigingsscopes (grootte moeilijk voorspelbaar).
  • Batchprocessen draaien onbeheerd (fouten moeten snel te diagnosticeren zijn).
  • Meerdere databases worden ondersteund (Oracle/SQL Server/SQLite-mix, bijvoorbeeld voor Tools/Tests).
  • De betreffende tabel is groot en performancekritisch (typebinding en planstabiliteit tellen mee).

Als je daarentegen een duidelijk afgebakend Backend hebt en de Use Case garandeert kleine lijsten (bijv. UI-filter met maximaal 50 IDs), dan kan een eenvoudige Expand-Lösung volstaan – zolang je het Null-Fall en een grenstest niet vergeet. Dit is geen ‚overarchitectuur‘, maar bescherming tegen het eerste echte Betriebsrandfall.

Schlusspunkt: Stabilität entsteht nicht durch Tricks, sondern durch Grenzen und Beobachtbarkeit

FireDAC maakt het juiste gemakkelijk: Parameter binden, Macros gescheiden behandelen, Statements netjes voorbereiden. Het probleem ontstaat pas daar waar IN-lijsten ongecontroleerd groeien. Wie Expand/Chunking als gestandaardiseerde bouwsteen implementeert, limieten per database respecteert, lege lijsten als normaal pad behandelt en FDMonitor als debug-waarheid accepteert, haalt de schrik uit het onderwerp. De code betaalt zich uit wanneer je niet langer wilt raden waarom een feature „nur bei großen Daten“ faalt – en wanneer je in de operatie binnen minuten in plaats van uren de oorzaak wilt vinden.

Quellen und weiterfuehrende Informationen

Die fachlichen Kernaussagen wurden anhand der folgenden externen Quellen redaktionell eingeordnet.

  1. Preprocessing Command Text (FireDAC) – RAD Studio (docwiki.embarcadero.com)
    FireDAC scheidt Parameterbindung von Macros/Substitution und preprocesset den Command-Text vor dem Prepare; Werte gehören in Parameter, SQL-Fragmente in Macros.
  2. IN Condition (docs.oracle.com)
    Oracle staat maximaal 1000 uitdrukkingen toe in een IN-lijst, daarom is Chunking of een alternatieve techniek bij grote lijsten noodzakelijk.
  3. Limit and conversion very long IN list : WHERE x IN ( ,,, …) – Ask TOM (asktom.oracle.com)
    ORA-01795 wordt gezien als limiet van de IN-lijst (max. 1000); typische workarounds zijn opsplitsen en verbinden of alternatieven zoals een join tegen waardesets.
  4. Implementation Limits For SQLite (www.sqlite.org)
    SQLite beperkt het aantal host-parameters (SQLITE_MAX_VARIABLE_NUMBER), wat uitgeklapte IN-lijsten direct beperkt.
  5. FDMonitor – RAD Studio (docwiki.embarcadero.com)
    FDMonitor ist het centrale FireDAC-gereedschap om Statements, parameterwaarden, typen en uitvoeringsstappen navolgbaar te tracen.
  6. Array DML (FireDAC) – RAD Studio (docwiki.embarcadero.com)
    FireDAC-parameterarrays worden primair voor Array-DML/batched execution gedocumenteerd en zijn niet automatisch een oplossing voor het binden van IN-lijsten.

Voor dit onderwerp zijn ook FireDAC-IN-clause en Delphi-parameterexpansie belangrijk. Het artikel plaatst deze aspecten begrijpelijk in context en toont waar het in de dagelijkse praktijk om gaat.

Project of moderniseringsproject met Net-Base bespreken.

volgende stap

Wanneer het onderwerp een concreet project wordt, moeten architectuur, bestaande omgeving en exploitatie vroegtijdig samen worden bekeken.

We ondersteunen niet alleen bij individuele vragen, maar ook wanneer uit broncodefragmenten, legacy-onderwerpen of portalideeën een robuust bedrijfsproject moet ontstaan.

  • Huidige situatie, doelbeeld en technische risico's worden gezamenlijk beoordeeld.
  • REST, toegang tot gegevens, portalen en rollout worden niet naar latere fasen verschoven.
  • U ziet vroeg welke weg economisch en operationeel levensvatbaar is.

Bericht delen

Dit bericht direct delen

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

E-mail

Instagram opent in een nieuw tabblad. Link en korte tekst worden van tevoren naar het klembord gekopieerd.

Reactie schrijven

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