Fra magasinets tema til projektpraksis
Passende service- og tekniske sider til artiklen
Video-Botschaft
FireDAC: Parameter-arrays til IN-klausuler – sikker ekspansionslogik, begrænsninger pr. DB og fejlsøgning af den endelige 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.
Fejlen dukker sjældent op ved første test. Den kommer om natten i batchkørsler, eller når en admin i backoffice „lige“ markerer et større udvalg. I loggen står der så noget i retning af „too many SQL variables“, ORA‑01795 eller en SQL‑Server-fejl, som har lidt med den egentlige Use Case at gøre. Den, der her stadig sætter lid til det bekvemme mønster WHERE id IN (:ids), opdager hurtigt: Det er ikke et komfortfeature, men en snubletråd.
Netop derfor handler det om BDE-udskiftning med native tilslutning: Parameter-arrays for IN-klausuler: ikke om en trickkasse, hvor man presser vilkårligt lange lister „ind i én parameter“, men om en robust expand- og chunking-logik, der respekterer DB-grænser og lader sig debugge rent.
Det bagvedliggende målkonflikt er reel og gentager sig i næsten hvert system:
- Maksimal sikkerhed og vedligeholdelighed: Værdier bindes (ingen SQL-Injection), planer kan genbruges, logging forbliver kontrollerbar.
- Maksimal robusthed ved store lister: ingen hårde DB-grænser bryder, ingen „kun hos kunde X“-fejl, reproducerbar fejlsøgning.
Man kan opnå begge dele – men kun hvis man klart adskiller mekanikken: parametre er værdier, Macros/Substitution er SQL-tekst. Og: Store lister har brug for Guardrails.
FireDAC: Parameter-arrays for IN-klausuler i praksis
BDE-Ablosung mit nativer Anbindung adskiller bevidst mellem parametre (bundne værdier) og Macros/Substitution (tekstfragmenter, som indsættes i SQL-teksten før Prepare). Det Preprocessing kan transformere Command-Text, ekspandere Macros og skabe den endelige statement-struktur – men værdibindingen forbliver adskilt.[Kilde]
Det lyder af formalitet, men det er et sikkerheds- og driftspunkt: Et parameter repræsenterer i SQL typisk én værdi. Hvis du smugler en liste ind i parenteserne som tekst, ender du hurtigt med strengsammenkædning eller misbrug af Macros. Begge dele forvandler en sikker query til en, du konstant må forsvare mod SQL-Injection, specialtegn og typekonverteringer – og som samtidig svækker databaseplan-caching.
Den holdbare linje er derfor: Enten genererer du en IN-liste af flere pladsholdere og binder hver værdi som parameter, eller du skifter teknik og giver databasen en værdimængde som en „tabel“ (temp-tabel, Collection/Array-Typ, Table-Valued Parameter). FireDAC tager ikke denne arkitekturbeslutning for dig.
Afvejning: Tre veje til IN-listen – nytte, indsats, risici
Før man diskuterer implementeringsdetaljer, er det værd at få et klart overblik over mulighederne. Det handler ikke om „rigtigt vs. forkert“, men om spørgsmålet om, hvilket risiko du vil bære hvor: i Delphi-koden eller i databasedriften.
Vej 1: Udvid til mange parametre (IN (:p0,:p1,…))
Fordele: forbliver inden for parameterbinding, fungerer med FireDAC på tværs af backends, ingen ekstra DB-objekter.
Arbejdsindsats: moderat (stringopbygning + parameternavne + bindinger).
Risici/Begrænsninger: hårde grænser (antal parametre, IN-udtryk), statement-varianter eksploderer ved kraftigt varierende listestørrelser.
Plausibelt for: filterlister op til „nogle hundrede“, retrofit i eksisterende forretningssoftware, cross-DB.
Vej 2: Chunking (flere IN-blokke per OR, korrekt afgrænset)
Fordele: respekterer grænser, forbliver cross-DB, kan håndtere meget store lister uden DB-specifikke features.
Arbejdsindsats: højere (parenteslogik, blokopbygning, parameterstyring, tests).
Risici/Begrænsninger: lange WHERE-klausuler; OR-kæder kan påvirke optimizer/planer; debugging skal give kontekst (blokstørrelse/antal).
Plausibelt for: Oracle/SQL Server/SQLite i én kodebase, når store lister optræder sporadisk.
Vej 3: Overfør værdier som „tabel“ (Temp-Tabelle / TVP / Collection)
Fordele: SQL forbliver kort, planstabilitet ofte bedre, meget store mængder er håndterbare.
Arbejdsindsats: DB-specifik; drift/deployment (skema, rettigheder, oprydning/transaktioner) bliver en del af løsningen.
Risici/Begrænsninger: flere bevægelige dele (migrationer, monitoring, rettigheder).
Plausibelt for: regelmæssigt store mængder (tusinder+), batch-processing, når backend er fastlagt, og driften kan bære det.
Hårde grænser pr. database: de reelle drivere for expand-logikken
Grænserne er årsagen til, at „det kører lokalt“ i drift ikke er nok. Det afgørende er ikke din Delphi-kode, men hvad backenden accepterer af statement-form og antal parametre.
| Database | Relevant grænse | Typisk fejlbillede | Praktisk konsekvens |
|---|---|---|---|
| Oracle | Maks. 1000 udtryk i en IN-liste | ORA-01795 | Chunking eller alternativ teknik (Join/Collection) nødvendig, så snart lister bliver „virkelig“ store |
| SQL Server | Maks. 2100 parametre pr. statement/batch | Fejl ved for mange parametre | Planlæg reserve til ekstra parametre; ved tærskelværdien evaluér chunking eller TVP |
| SQLite | Maks. host-parametre (default historisk ofte 999, afhænger af version/build) | „too many SQL variables“ | Aktivér chunking tidligt; dokumentér limitten i drift, da den varierer efter distribution |
| PostgreSQL | Antallet af parametre er begrænset (protokol-/implementationsbetinget) | Fejl ved ekstreme mængder parametre | Definér en øvre grænse; ved meget store mængder overvej en værditabel-strategi |
For Oracle er 1000-grænsen klart dokumenteret: I IN-betingelsen er der op til 1000 udtryk tilladt.[Quelle] Vigtigt er konklusionen: Grænsen gælder som en strukturel grænse for SQL-betingelsen, ikke som et „literal-problem“. AskTOM klassificerer ORA‑01795 tilsvarende som en hård IN-liste-grænse og nævner splitning/sammenkædning som typisk workaround – alternativt et JOIN mod en mængde af værdier.[Quelle]
SQLite er snedig, fordi du ikke støder på en grænse for „IN-udtryk“, men på antallet af bind-variabler. Grænsen er dokumenteret som SQLITE_MAX_VARIABLE_NUMBER og kan variere betydeligt afhængigt af version/build. Konsekvens: Den, der kun bruger SQLite „i periferien“ (tests, værktøjer, offline-klienter), har alligevel brug for en expand-logik, der ikke pludselig rammer 999 parametre.[Quelle]
Sichere Expand-Logik: was sie leisten muss (und was nicht)
Hvis du implementerer Expand/Chunking, så ikke som „string-manipulation“, men som en lille infrastrukturkomponent. Den bør pålideligt udføre fire ting:
- Kun generere pladsholdere: Værdier bindes udelukkende via FireDAC-parametre.
- Håndter tomme lister eksplicit: defineret sti, ingen SQL-syntaksfejl, ingen skjulte semantiske ændringer.
- Tag hensyn til grænser og reserve: per DB en grænseværdi, plus buffer til yderligere parametre i statementet.
- Sørg for debug-kontekst: antal værdier, blokstørrelse, antal blokke, eventuelt Fingerprint – i stedet for „alt i klartekst“.
Leere Listen: der Null-Fall ist der häufigste Produktions-Fall
„Ingen IDs“ sker hele tiden: adgangsfiltre, søgefiltre, slettede poster, tom selektion. Og netop her bliver mange implementeringer upræcise, fordi de forsøger at redde „IN ()“ på en eller anden måde.
Pragmatiske, godt testbare muligheder:
- Ingen DB-kald: hvis dit Use Case skal returnere et resultatsæt, returnér tomt med det samme (især for Services og APIs).
- Always-false-Bedingung: hvis du af arkitekturgrunde skal udføre statementet, erstat IN-delen med en sikkert falsk betingelse (f.eks. 1=0) i stedet for at opfinde „IN (NULL)“.
Chunking: warum „Reserve“ mehr zählt als das dokumentierte Limit
Chunking er ikke kun for Oracle. Det er din forsikring mod to typiske realiteter: ekstra parametre (tenant, status, periode, rettigheder) og uforudsigelige listestørrelser.
Et par retningslinjer, der bør fremhæves i reviews:
- Blokstørrelse aldrig ved maksimum: Hvis SQL Server tillader 2100 parametre, er en blokstørrelse på 2090 ikke en god idé, fordi statementet sjældent kun består af IN-listen.
- OR-blokke skal være omsluttede af parenteser: Så snart et ekstra AND tilføjes, ændres logikken uden parenteser.
- Parameternavne deterministisk: Prefix + index (f.eks. :ids_0001) gør traces, reproduktioner og diff-analyser markant enklere.
Eksempel (konstrueret): Wenn ein Batch-Job plötzlich „kundenspezifisch“ scheitert
Debugging der finalen SQL: Warum der Wunsch verständlich ist – aber selten das Richtige trifft
Mange teams søger efter „den endelige SQL“, altså en streng hvor alle parameterværdier er „indsat“. For bundne parametre er det ofte et falsk krav: databasen får statement og værdier adskilt. Det er normaltilstanden for sikker eksekvering og plan-genbrug. En enkelt, kanonisk „eksekverings-SQL“ eksisterer derfor ofte ikke i den forstand, man kender fra manuelt sammenskrevet SQL.
In FireDAC fører den korrekte debug-vej via FDMonitor. Der kan du se Prepare/Execute, statement-teksten, parameterværdierne (med typer) og rækkefølgen af handlinger. Det er tættere på, hvad der reelt sker i backend’en, end enhver hjemmelavet strengrekonstruktion.[Quelle]
Was du im Trace gezielt auswerten solltest
- Struktur der WHERE-Klausel: Er OR-blokke indrammet med parenteser, inden yderligere AND-filtre følger?
- Parameterzählung: Hvor mange parametre er der reelt – inklusive mandant/status/tidsrum? Det afgør grænser for SQL Server og SQLite.
- Typbindung: Bindes numeriske ID’er også numerisk? Strings vs. tal er ikke et kosmetisk emne; det kan påvirke indeksbrug og valg af plan.
- Statement-Varianten: Enhver anden mængde pladsholdere er en anden statement-tekst. Ved varierende lister skaber du flere prepare-varianter; chunking med fast blokstørrelse kan reducere variansen.
Logging: SQL + Kontext statt SQL + 2.400 Werte
I produktionslogs ønsker du sjældent at se hver enkelt værdi. Du vil have diagnostik med acceptabel logstørrelse og uden unødvendig dataeksponering. Typiske, nyttige felter er:
- Antal værdier (Count)
- Blokstørrelse og antal blokke
- Fingerprint af den normaliserede liste (f.eks. hash), for at genkende gentagelser uden at udskrive indholdet
- forkortet forhåndsvisning (f.eks. første/sidste 5 værdier), hvis det er acceptabelt i forhold til databeskyttelse og fagligt
Parameter-Arrays in FireDAC: der Begriff, der oft in die falsche Richtung zieht
FireDAC dokumenterer „Parameter-Arrays“ først og fremmest i konteksten af Array-DML (Batched Execution): mange poster udføres i ét statement ved at sætte parameterværdier som arrays. Det er et performance‑feature for INSERT/UPDATE/DELETE – men det løser ikke automatisk problemet „IN‑liste som én parameter“. Det er to forskellige brugstilfælde, der sprogligt kan lyde ens, men som operativt fungerer forskelligt.[Kilde]
Praktisk konsekvens for teamkommunikation: Når nogen siger „Parameter‑Arrays for IN“, er det værd at spørge tilbage: Mener du Array‑DML, eller mener du Expand/Chunking for WHERE IN? Den afklaring forhindrer, at værdier i sidste ende alligevel ender som tekstsubstitution i SQL.
Review-checkliste: typiske faldgruber, der senere bliver dyre
1) „Alles als String“ ist bequem, aber kann Indizes aushebeln
Hvis kolonnen er numerisk, bør de bundne parametre også være numeriske. Ellers kan implizite konverteringer opstå. De er svære at se, men dyre: de kan føre til, at indekser ikke bruges som forventet, eller at planer bryder sammen under load.
2) Duplikate und ungültige Werte treiben dich unnötig Richtung Limit
Fjernelse af dubletter reducerer antallet af parametre uden faglig ulempe. Det samme gælder tidlig fjernelse af tomme strenge eller klart ugyldige IDs. Det er ikke en spekulativ optimering, men reducerer direkte risikoen for at ramme grænser.
3) Klammerung ist Semantik, kein Stil
Forkert parentesering af en OR‑blok leverer forkerte data – ofte uden fejlmeddelelse. Det er det mest problematiske error‑mønster: stille, svært at reproducere og fagligt alvorligt. Når der anvendes chunking, bør parenteseringen eksplicit testes (ikke blot bekræfte at det „kører“).
4) Freies Expandieren erzeugt viele Statement-Varianten
Hvis listestørrelsen varierer kraftigt, varierer også antallet af placeholders og dermed statement‑teksten. Det øger antallet af prepare‑varianter og kan vise sig i overvågning som meget Parse/Prepare. Chunking med fast blokstørrelse (undtagen sidste blok) reducerer variationen, men fjerner den ikke fuldstændigt. Hvis det virkelig er et problem, er «værdier som tabel» ofte næste trin.
Umsetzungsfahrplan: so wird aus einem Randfall ein Standardbaustein
- Normaliser input: trimme, fjerne dubletter, kassere ugyldige værdier, evt. sortere (for stabilt fingerprint).
- Definer backend-profil: fastsæt limit per DB (IN‑expressions eller parametergrænse) og planlæg en reserve til ekstra parametre.
- Vælg strategi: små lister → Expand; uklare eller større lister → Chunking; meget store og hyppige lister → evaluer værdetabel‑tilgang.
- Generér SQL: kun pladsholdere; omslut OR‑blokke med parenteser; hold yderligere AND‑filtre klart uden for OR‑gruppen.
- Bind parametre: sæt passende typer; håndter NULL‑værdier bevidst (NULL i IN er som regel uden effekt og forvirrer debugging).
- Indbyg diagnostik: Count/Chunk/Fingerprint i loggen; dokumentér FDMonitor‑Trace som „dybere debug‑tilstand“ i runbook.
- Grænsetest: 0, 1, Limit‑1, Limit, Limit+1 (hver gang plus ekstra parametre), så adfærden forbliver stabil ved ændringer.
Wann sich der Mehraufwand wirklich lohnt (und wann nicht)
Ikke alle applikationer behøver hele værktøjskassen. Den ekstra indsats er især berettiget, når mindst ét af følgende forhold gør sig gældende:
- Lister stammer fra brugerudvælgelse eller rettigheds-scopes (størrelsen er svær at forudsige).
- Batch-processer kører uden opsyn (fejl skal kunne diagnosticeres hurtigt).
- Flere databaser understøttes (Oracle/SQL Server/SQLite-mix, f.eks. til værktøjer/tests).
- Den berørte tabel er stor og performancekritisk (typebinding og planstabilitet tæller).
Hvis du derimod har et klart afgrænset Backend og use casen garanterer små lister (f.eks. UI-Filter med maksimalt 50 IDs), kan en simpel Expand-løsning være tilstrækkelig – så længe du ikke glemmer nul-tilfældet og en grænsetest. Det er ikke en „Überarchitektur“, men beskyttelse mod det første reelle driftsgrænsetilfælde.
Konklusion: Stabilitet opstår ikke gennem tricks, men gennem grænser og observerbarhed
FireDAC gør det rigtige nemt: binde parametre, behandle Macros separat, forberede Statements ordentligt. Problemet opstår først dér, hvor IN-lister vokser ukontrolleret. Den, der bygger Expand/Chunking som en standardiseret byggesten, respekterer Limits per database, behandler tomme lister som en normal sti og accepterer FDMonitor som debug-sandhed, tager skrækken af emnet. Koden betaler sig, når du ikke længere vil gætte på, hvorfor en funktion „kun ved store data“ svigter – og når du i drift vil finde årsagen på minutter i stedet for timer.
Kilder og videre læsning
De faglige hovedpointer er redaktionelt sat i kontekst ud fra følgende eksterne kilder.
- Preprocessing Command Text (FireDAC) – RAD Studio (docwiki.embarcadero.com)
FireDAC adskiller parameterbinding fra Macros/Substitution og forbehandler Command-Text før Prepare; værdier hører i parametre, SQL-fragmenter i Macros. - IN Condition (docs.oracle.com)
Oracle tillader maksimalt 1000 udtryk i en IN-liste, derfor er Chunking eller en alternativ teknik nødvendig ved store lister. - Limit and conversion very long IN list : WHERE x IN ( ,,, …) – Ask TOM (asktom.oracle.com)
ORA-01795 betragtes som grænsen for IN-listen (max. 1000); typiske workarounds er opdeling og sammenkædning eller alternativer som join mod værdisæt. - Implementation Limits For SQLite (www.sqlite.org)
SQLite begrænser antallet af host-parametre (SQLITE_MAX_VARIABLE_NUMBER), hvilket direkte begrænser udvidede IN-lister. - FDMonitor – RAD Studio (docwiki.embarcadero.com)
FDMonitor er det centrale FireDAC-værktøj til at spore statements, parameterværdier, typer og eksekveringstrin, så de kan efterprøves. - Array DML (FireDAC) – RAD Studio (docwiki.embarcadero.com)
FireDAC-parameter-arrays er primært dokumenteret for Array-DML/Batched Execution og er ikke automatisk en løsning til IN-liste-binding.
]}
For dette emne er også FireDAC In Clause og Delphi parameterudvidelse vigtige. Indlægget placerer disse aspekter klart i kontekst og viser, hvad der er vigtigt i praksis.
Næste trin
Når emnet bliver til et reelt projekt, bør arkitektur, eksisterende systemer og drift tidligt vurderes samlet.
Vi støtter ikke kun ved enkeltspørsmål, men også når kildekodeudsnit, legacy-komponenter eller portalidéer skal udvikles til et robust virksomhedsprojekt.
- Eksisterende tilstand, målbillede og tekniske risici vurderes samlet.
- REST, dataadgang, portaler og udrulning bliver ikke udskudt som efterfølgende opgaver.
- De ser tidligt, hvilken vej der er økonomisk og driftsmæssigt bæredygtig.