Net-Base Revistă

08.11.2026

FireDAC: Tablouri de parametri pentru clauze IN – logică sigură de expandare, limite pe bază de date și depanare a SQL-ului final

IN (:ids) pare convenabil, dar eșuează la liste mari din cauza limitărilor DB și a miturilor de depanare. Acest ghid practic arată o logică sigură de expand și chunking în FireDAC, limite tipice și o configurare curată de trace cu FDMonitor.

08.11.2026

De la tema din revistă la practica în proiecte

Pagini relevante de servicii și pagini tehnice pentru articol

Video-Botschaft

FireDAC: Tablouri de parametri pentru clauze IN – logică sigură de expandare, limite pe bază de date și depanare a SQL-ului final

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.

Eroarea apare rar la primul test. Apare noaptea în batch, sau când un administrator în backoffice „doar marchează” o selecție mai mare. În jurnal apare ceva de genul „too many SQL variables”, ORA‑01795 sau o eroare de SQL Server care are puțin de-a face cu use case‑ul real. Cine la acest punct încă se bazează pe modelul comod WHERE id IN (:ids) observă rapid: nu e un feature de confort, ci o capcană.

Exact despre asta este vorba la BDE-înlocuire cu integrare nativă: Array-uri de parametri pentru clauze IN: nu e vorba de o cutie cu trucuri pentru a „împinge” liste arbitrare „într-un singur parametru”, ci de o logică robustă de expandare și fragmentare care respectă limitele DB și care se poate depana curat.

Conflictul de obiective din spate este real și se repetă în aproape fiecare sistem:

  • Securitate maximă și mentenabilitate: valorile sunt legate (fără SQL‑Injection), planurile pot fi reutilizate, logging‑ul rămâne controlabil.
  • Robustețe maximă pentru liste mari: limitele DB nu sunt depășite brusc, nu apar erori „doar la clientul X”, debugging reproducibil.

Ambele se pot obține – dar doar dacă separi clar mecanica: parametrii sunt valori, Macro‑uri/Substituție sunt text SQL. Și: listele mari au nevoie de măsuri de protecție.

FireDAC: Array‑uri de parametri pentru clauze IN în practică

BDE-Ablosung mit nativer Anbindung face în mod deliberat distincția între parametri (valori legate) și Macro‑uri/Substituție (fragmente de text care sunt inserate în textul SQL înainte de PREPARE). Preprocesarea poate transforma textul comenzii, poate extinde macro‑urile și poate genera structura finală a statement‑ului – dar binding‑ul valorilor rămâne separat.[Sursă]

Sună a formalism, dar e un punct esențial pentru securitate și operare: un parametru reprezintă în SQL tipic o valoare. Dacă „injectezi” o listă ca text între paranteze, ajungi rapid la concatenare de stringuri sau abuz de macro‑uri. Ambele transformă o interogare sigură într-una pe care trebuie să o aperi constant împotriva SQL‑Injection, a caracterelor speciale și a conversiilor de tip – și, în același timp, slăbesc caching‑ul planurilor în baza de date.

Linia de demarcație solidă este, prin urmare: fie generezi o listă IN din mai mulți placeholders și le legi (bind) pe fiecare valoare ca parametru, fie schimbi tehnica și oferi bazei de date o mulțime de valori ca „tabel” (tabel temporar, tip colecție/array, parametru de tip tabel). FireDAC în sine nu îți impune această decizie arhitecturală.

Hartă de evaluare: Trei metode pentru lista IN – beneficii, efort, riscuri

Înainte de a discuta detaliile de implementare, merită o privire clară asupra opțiunilor. Nu e vorba de „corect vs. greșit“, ci de întrebarea ce risc vrei să porți unde: în Delphi-Code sau în operarea bazei de date.

Varianta 1: Expand la mulți parametri (IN (:p0,:p1,…))

Beneficiu: rămâne în cadrul legării parametrilor, funcționează cu FireDAC pe diverse backenduri, fără obiecte DB suplimentare.
Efort: moderat (construire string + nume de parametri + Binding-uri).
Riscuri/Limitări: limite stricte (număr de parametri, expresii IN), variantele de statement explodează la dimensiuni ale listei foarte variabile.
Potrivit pentru: liste de filtrare până la „câteva sute“, retrofit în software de business existent, cross-DB.

Varianta 2: Chunking (mai multe blocuri IN legate prin OR, corect parantezate)

Beneficiu: respectă limitele, rămâne cross-DB, poate amortiza liste foarte mari fără funcționalități specifice DB.
Efort: mai mare (logică de parantezare, formare de blocuri, managementul parametrilor, teste).
Riscuri/Limitări: clauze WHERE foarte lungi; lanțurile de OR pot influența optimizerul/planurile; debugging-ul trebuie să furnizeze context (mărimea blocului/cantități).
Potrivit pentru: Oracle/SQL Server/SQLite într-o bază de cod, când liste mari apar sporadic.

Varianta 3: Transmiterea valorilor ca „tabel“ (tabel temporar / TVP / collection)

Beneficiu: SQL rămâne scurt, stabilitatea planului este adesea mai bună, cantități foarte mari sunt gestionabile.
Efort: specific DB; operarea/deploy (schemă, drepturi, cleanup/ tranzacții) devine parte a soluției.
Riscuri/Limitări: mai multe componente mobile (migrații, monitorizare, permisiuni).
Potrivit pentru: cantități mari regulate (mii+), procesare batch, când backendul e stabil și operarea poate susține soluția.

Limite stricte per bază de date: adevărații factori care conduc logica de expand

Limitele sunt motivul pentru care „merge local“ în producție nu e suficient. Decisiv nu e codul tău Delphi, ci ce acceptă backendul în privința formei statement-ului și a numărului de parametri.

Bază de date Limită relevantă Eroare tipică Consecință practică
Oracle Max. 1000 de expresii într-o listă IN ORA-01795 Chunking sau tehnică alternativă (Join/Collection) necesară, odată ce listele devin „cu adevărat“ mari
SQL Server Max. 2100 parametri per statement/batch Eroare la prea mulți parametri Planificați rezervă pentru parametri suplimentari; după prag, evaluați chunking sau TVP
SQLite Max. host-parameter (implicit istoric adesea 999, depinde de versiune/build) „too many SQL variables“ Activați chunking din timp; documentați limita în operare, pentru că variază în funcție de distribuție
PostgreSQL Numărul de parametri este limitat (din motive de protocol/implementare) Eroare la cantități extreme de parametri Definește o limită superioară; pentru cantități foarte mari, analizați o strategie cu tabele de valori

Pentru Oracle, pragul de 1000 este documentat clar: în condiția IN sunt permise până la 1000 de expresii.[Sursă] Importantă este concluzia: limita este considerată o limită structurală a condiției SQL, nu o „problemă de literali”. AskTOM clasifică ORA‑01795 ca o limită strictă a listei IN și menționează împărțirea/îmbinarea ca workaround tipic – alternativ, un JOIN împotriva unei mulțimi de valori.[Sursă]

SQLite este înșelător, pentru că nu te lovești de „IN-Expressions”, ci de numărul variabilelor de legare. Limita este documentată ca SQLITE_MAX_VARIABLE_NUMBER și poate varia semnificativ în funcție de versiune/build. Consecință: cei care folosesc SQLite doar „ocazional” (teste, unelte, clienți offline) au, în continuare, nevoie de o logică de expandare care să nu ajungă brusc la 999 de parametri.[Sursă]

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

Dacă implementezi Expand/Chunking, nu ca o „muncă cu stringuri”, ci ca o mică componentă de infrastructură. Ar trebui să execute fiabil patru lucruri:

  • Să creeze numai placeholderi: Valorile sunt legate exclusiv prin parametri FireDAC.
  • Tratarea explicită a listei goale: cale definită, fără erori de sintaxă SQL, fără modificări tăcute de semantică.
  • Luarea în considerare a limitelor și a rezervei: pentru fiecare DB un prag, plus un tampon pentru parametri suplimentari în statement.
  • Furnizarea contextului de debug: număr de valori, dimensiunea blocului, număr de blocuri, opțional amprentă – în loc de „totul în clar”.

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

„Fără ID-uri” se întâmplă mereu: filtre de permisiuni, filtre de căutare, înregistrări șterse, selecții goale. Și exact aici multe implementări devin neîngrijite, pentru că încearcă să salveze cumva „IN ()”.

Opțiuni pragmatice, ușor testabile:

  • Fără apel la DB: dacă cazul tău de utilizare trebuie să returneze un set de rezultate, returnează direct gol (deosebit de util în servicii și API-uri).
  • Condiție întotdeauna falsă: dacă din motive arhitecturale trebuie să execuți statement-ul, înlocuiește pasajul IN cu o condiție sigur falsă (de ex. 1=0), în loc să inventezi un „IN (NULL)”.

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

Chunking nu este doar „pentru Oracle”. Este asigurarea ta împotriva a două realități tipice: parametri suplimentari (tenant, status, interval de timp, permisiuni) și dimensiuni imprevizibile ale listelor.

Câteva reguli directoare care ar trebui remarcată în review-uri:

  • Dimensiunea blocului niciodată la maximum: dacă SQL Server permite 2100 de parametri, o dimensiune de bloc de 2090 nu este o idee bună, pentru că statement-ul rar este compus doar din lista IN.
  • Blocurile OR trebuie încadrate între paranteze: de îndată ce apare un alt AND, logica se schimbă fără paranteze.
  • Nume de parametri determinist: Prefix + index (de ex. :ids_0001) face trace-uri, repro-uri și analize diff mult mai simple.
  • Exemplu (construit): Dacă un job batch eșuează brusc „specific clientului”

    Debugging al SQL-ului final: De ce dorința este de înțeles — dar rareori este soluția potrivită

    Multe echipe caută „SQL-ul final”, adică un string în care toate valorile parametrilor sunt „înlocuite”. Pentru parametrii legați aceasta este adesea o cerință iluzorie: baza de date primește statement-ul și valorile separat. Acesta este cazul normal pentru execuție sigură și reutilizarea planului. Prin urmare, o singură „SQL de execuție” canonică deseori nu există în sensul în care o cunoaștem din SQL scris manual.

    În FireDAC drumul corect de debugging trece prin FDMonitor. Acolo vezi Prepare/Execute, textul statement-ului, valorile parametrilor (cu tipuri) și secvența acțiunilor. Asta este mai aproape de ceea ce se întâmplă cu adevărat în backend decât orice reconstrucție făcută manual a stringului.[Quelle]

    Ce ar trebui să evaluezi țintit în Trace

    1. Structura clauzei WHERE: Sunt blocurile OR încadrate între paranteze înainte de apariția altor filtre AND?
    2. Numărul de parametri: Câți parametri sunt cu adevărat – inclusiv mandant/status/interval de timp? Asta decide limitele pentru SQL Server și SQLite.
    3. Legarea de tip: Sunt ID-urile numerice legate numeric? Șiruri vs. numere nu e o chestiune cosmetică, ci poate influența utilizarea indexului și alegerea planului.
    4. Variante de statement: Orice număr diferit de placeholders este un text de statement diferit. La liste fluctuante generezi astfel mai multe variante de Prepare; chunking-ul cu mărime fixă a blocului poate reduce varianța.

    Logging: SQL + Kontext statt SQL + 2.400 Werte

    În logurile productive rar dorești să vezi fiecare valoare. Vrei diagnostice la o mărime rezonabilă a logului și fără expunere inutilă a datelor. Câmpurile tipice, utile sunt:

    • Numărul de valori (Count)
    • Mărimea blocului și numărul de blocuri
    • Fingerprint al listei normalizate (de ex. Hash), pentru a recunoaște repetările fără a scrie conținutul
    • Previzualizare trunchiată (de ex. primele/ultimele 5 valori), dacă acest lucru este justificat din perspectiva protecției datelor și a contextului funcțional

    Array-uri de parametri în FireDAC: termenul care deseori induce în direcția greșită

    FireDAC documentează „Parameter-Arrays” mai ales în contextul Array-DML (Batched Execution): multe înregistrări sunt executate într-un singur statement prin setarea valorilor parametrilor ca array-uri. Aceasta este o facilitate de performanță pentru INSERT/UPDATE/DELETE – dar nu rezolvă automat problema „listă IN ca un singur parametru”. Sunt două cazuri de utilizare diferite, care sună similar din punct de vedere lingvistic, dar funcționează operațional diferit.[Sursă]

    Consecință practică pentru comunicarea în echipă: dacă cineva spune „Parameter-Arrays pentru IN”, merită o întrebare de clarificare: te referi la Array-DML sau la Expand/Chunking pentru WHERE IN? Această claritate previne ca, la final, valorile să ajungă din nou prin substituție text în SQL.

    Listă de verificare pentru review: capcane tipice care pot deveni costisitoare

    1) „Totul ca string” e convenabil, dar poate anula indecșii

    Dacă coloana este numerică, parametrii asociați ar trebui să fie numerici. Altfel pot apărea conversii implicite. Acestea sunt greu de observat, dar costisitoare: pot face ca indecșii să nu fie folosiți conform așteptărilor sau pot schimba planurile sub sarcină.

    2) Duplicatele și valorile invalide te împing inutil către limită

    Deduplicarea reduce numărul de parametri fără dezavantaj funcțional. La fel și eliminarea timpurie a stringurilor goale sau a ID-urilor clar invalide. Aceasta nu este o optimizare „pe presupunere”, ci reduce direct riscul depășirii limitelor.

    3) Gruparea cu paranteze e semantică, nu stil

    Un bloc OR parantezat greșit returnează date eronate – adesea fără mesaj de eroare. Acesta este cel mai nefavorabil tip de eroare: silențios, greu de reprodus, cu impact funcțional. Dacă se folosește Chunking, gruparea cu paranteze ar trebui verificată explicit în teste (nu doar „rulează”).

    4) Expandarea liberă generează multe variante de statement

    Dacă dimensiunea listei variază puternic, variază și numărul de placeholderi, iar prin aceasta textul statement-ului. Asta crește variantele de Prepare și se poate vedea în monitorizare ca „mult Parse/Prepare”. Chunking-ul cu dimensiune fixă de bloc (în afară de ultimul bloc) reduce varietatea, dar nu o elimină complet. Dacă asta doare cu adevărat, următorul pas este, de regulă, abordarea „valori ca tabel”.

    Plan de implementare: cum un caz marginal devine un bloc standard

    1. Normalizarea intrării: trimmare, deduplicare, respingerea valorilor invalide, sortare opțională (pentru o amprentă stabilă).
    2. Definirea profilului backend: stabiliți limită per DB (expresii IN sau limită de parametri) și planificați o rezervă pentru parametri suplimentari.
    3. Alegerea strategiei: liste mici → Expand; liste neclare sau mai mari → Chunking; liste foarte mari și frecvente → evaluați abordarea cu tabele de valori.
    4. Generarea SQL: doar placeholderi; parantezați blocurile OR; păstrați filtrele suplimentare AND clar în afara grupului OR.
    5. Bindingul parametrilor: setați tipurile corespunzător; tratați conștient valorile NULL (NULL în IN este de obicei ineficient și complică debuggingul).
    6. Adăugați diagnoză: Count/Chunk/Fingerprint în log; FDMonitor-Trace documentat ca „mod debug aprofundat” în runbook.
    7. Teste de limită: 0, 1, Limit-1, Limit, Limit+1 (fiecare însoțit de parametri adiționali), pentru ca comportamentul la modificări să rămână stabil.

    Când merită cu adevărat efortul suplimentar (și când nu)

    Nu orice aplicație are nevoie de trusa completă de instrumente. Efortul suplimentar merită în special atunci când este îndeplinit cel puțin unul dintre următoarele puncte:

    • Listele provin din selecții ale utilizatorilor sau din scope-uri de autorizare (mărimea este greu de prevăzut).
    • Procese batch rulează nesupravegheate (erorile trebuie diagnosticate rapid).
    • Sunt suportate mai multe baze de date (Oracle/SQL Server/SQLite-Mix, de ex. pentru instrumente/teste).
    • Tabela afectată este mare și critică din punct de vedere al performanței (legarea de tip și stabilitatea planului contează).

    Dacă ai, în schimb, un backend clar delimitat și cazul de utilizare garantează liste mici (de ex. filtre UI cu maximum 50 de ID-uri), atunci o soluție simplă de tip Expand poate fi suficientă – atât timp cât nu uiți cazul nul și un test de limită. Aceasta nu este o „Überarchitektur“, ci protecție împotriva primului caz real de margină operațională.

    Concluzie: Stabilitatea nu apare prin trucuri, ci prin limite și observabilitate

    FireDAC face lucrurile corecte ușor: leagă parametrii, tratează Macros separat, pregătește curat Statements. Problema apare doar acolo unde IN-Listen cresc necontrolat. Cine construiește Expand/Chunking ca modul standardizat, respectă limitele pe bază de date, tratează listele goale ca drum normal și acceptă FDMonitor ca adevăr de depanare, reduce gravitatea problemei. Codul merită atunci când nu mai vrei să te întrebi de ce o funcționalitate cedează „nur bei großen Daten“ – și când vrei să ajungi la cauză în minute în loc de ore în producție.

    Surse și informații suplimentare

    Afirmările-cheie din punct de vedere tehnic au fost puse editorial în context pe baza următoarelor surse externe.

    1. Preprocessing Command Text (FireDAC) – RAD Studio (docwiki.embarcadero.com)
      FireDAC separă legarea parametrilor de Macros/Substitution și preprocesează Command-Text înainte de Prepare; valorile aparțin parametrilor, fragmentele SQL macro-urilor.
    2. IN Condition (docs.oracle.com)
      Oracle permite maximum 1000 de expresii într-o IN-Liste, de aceea Chunking sau o tehnică alternativă devine necesară pentru liste mari.
    3. Limit and conversion very long IN list : WHERE x IN ( ,,, …) – Ask TOM (asktom.oracle.com)
      ORA-01795 este identificat ca limită a listei IN (max. 1000); soluții tipice sunt divizarea și reconectarea sau alternative precum join-ul împotriva unor mulțimi de valori.
    4. Implementation Limits For SQLite (www.sqlite.org)
      SQLite limitează numărul de parametri host (SQLITE_MAX_VARIABLE_NUMBER), ceea ce restricționează direct listele IN expandate.
    5. FDMonitor – RAD Studio (docwiki.embarcadero.com)
      FDMonitor ist das zentrale FireDAC-Werkzeug, um Statements, Parameterwerte, Typen und Ausführungsschritte nachvollziehbar zu tracen.
    6. Array DML (FireDAC) – RAD Studio (docwiki.embarcadero.com)
      FireDAC-Parameter-Arrays sind primär für Array-DML/Batched Execution dokumentiert und nicht automatisch eine Lösung für IN-Listen-Binding.

    Für dieses Thema sind auch FireDAC In Clause und Delphi Parameter Expandieren wichtig. Der Beitrag ordnet diese Aspekte verständlich ein und zeigt, worauf es im Alltag ankommt.

    Projekt oder Modernisierungsvorhaben mit Net-Base besprechen.

    Pasul următor

    Dacă un subiect devine un proiect real, arhitectura, starea existentă și operarea ar trebui analizate împreună încă din faza incipientă.

    Nu oferim sprijin doar pentru întrebări punctuale, ci și atunci când fragmente de cod sursă, probleme legacy sau idei de portal trebuie transformate într-un proiect robust la nivel de companie.

    • Situația curentă, starea țintă și riscurile tehnice sunt evaluate împreună.
    • REST, accesul la date, portalurile și implementarea nu sunt amânate pentru etape ulterioare.
    • Veți vedea din timp care opțiune este viabilă din punct de vedere economic și operațional.

    Partajează postarea

    Distribuiți această postare direct

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

    E-mail

    Instagram se deschide într-o filă nouă. Linkul și textul scurt se copiază în prealabil în clipboard.

    Scrie un comentariu

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