💬 NLP

FlexSQL: Flexible Exploration and Execution Make Better Text-to-SQL Agents

FlexSQL introduceert een text-naar-SQL-agent die op de Spider2-Snow-benchmark betere prestaties levert dan sterkere modellen door middel van een flexibel ontwerpprincipe dat dynamische schema-exploratie, data-inspectie en diverse uitvoeringsplannen mogelijk maakt, ondersteund door een tweeledig reparatiemechanisme gedurende het redeneerproces.

Oorspronkelijke auteurs: Quang Hieu Pham, Yang He, Ping Nie, Canwen Xu, Davood Rafiei, Yuepeng Wang, Xi Ye, Jocelyn Qiaochu Chen

Gepubliceerd 2026-05-06

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Quang Hieu Pham, Yang He, Ping Nie, Canwen Xu, Davood Rafiei, Yuepeng Wang, Xi Ye, Jocelyn Qiaochu Chen

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een detective bent die een mysterie probeert op te lossen, maar in plaats van een moordplek is je "moordplek" een enorme, chaotische bibliotheek met miljoenen boeken, bestanden en datapunten. Je baas geeft je een vaag aanwijzing: "Vind alle octrooien over materiaalkunde die begin 2014 zijn ingediend en tel hoeveel oudere octrooien ze citeren."

De meeste huidige computerprogramma's die dit proberen op te lossen, gedragen zich als een stijve robot. Ze krijgen één keer aan het begin een kaart van de bibliotheek. Ze kiezen een paar planken op basis van die kaart, schrijven een lijst met instructies (een query) en proberen deze vervolgens uit te voeren. Als ze vastlopen of het antwoord verkeerd is, kunnen ze alleen kleine typefouten in hun instructies herstellen. Ze kunnen niet teruggaan en zeggen: "Wacht, ik heb helemaal de verkeerde planken gekozen," of "Ik realiseerde me niet dat 'materiaalkunde' verstopt zat onder een code zoals 'MS-01'." Ze zitten vast aan hun initiële fout.

FlexSQL is een nieuw soort detective-agent die meer gedraagt als een nieuwsgierige menselijke ontdekkingsreiziger. In plaats van stijf te zijn, is het flexibel. Hier is hoe het werkt, met behulp van eenvoudige analogieën:

1. De "Flexibele Ontdekkingsreiziger" (Flexibele Interactie)

In plaats van één keer naar de bibliotheekkaart te kijken en een pad te kiezen, mag FlexSQL door de bibliotheek dwalen terwijl het nadenkt.

De Oude Manier: De robot kijkt naar de kaart, raadt dat "Materiaalkunde" in de sectie "Wetenschap" staat, en begint zijn lijst te schrijven.
De Manier van FlexSQL: De agent zegt: "Ik weet niet zeker waar 'Materiaalkunde' zit. Laat me naar de sectie 'Technologie' lopen, in een doosje kijken en de labels lezen."
Het gebruikt speciale tools om de planken te doorzoeken (schema), de werkelijke inhoud van de doosjes te lezen (datawaarden) en kleine testzoekopdrachten uit te voeren om te zien of zijn raadsels logisch zijn. Als het beseft dat het in de verkeerde gang staat, kan het direct omdraaien en naar de juiste gaan. Het blijft niet vastzitten in een doodlopende straat.

2. Het "Brainstormend Team" (Diverse Planning)

De aanwijzing "eerdere octrooien die elk citeert" is lastig. Betekent het alleen binnenlandse octrooien? Ook buitenlandse? Aanhangige aanvragen?

De Oude Manier: De robot kiest één interpretatie (bijvoorbeeld "Alleen binnenlandse") en blijft hierbij. Als het verkeerd is, is het hele antwoord verkeerd.
De Manier van FlexSQL: Het gedraagt zich als een team van detectives dat brainstormt. Het genereert meerdere verschillende theorieën (plannen) tegelijk.
- Plan A: Tel alleen binnenlandse citaten.
- Plan B: Tel binnenlandse en buitenlandse.
- Plan C: Tel alles, inclusief aanhangige aanvragen.
  Het voert al deze theorieën uit en laat vervolgens de "meerderheidsstem" beslissen welk antwoord het meest waarschijnlijk correct is. Op deze manier kan het team, zelfs als één theorie verkeerd is, nog steeds het juiste antwoord krijgen.

3. De "Tweetalige Vertaler" (Flexibele Uitvoering)

Soms is een taak te ingewikkeld om als één rechte instructie (SQL) te schrijven. Het kan een lus vereisen, een "als-dan"-beslissing of een stap-voor-stap berekening die rommelig is om in een database-taal te schrijven.

De Oude Manier: De robot probeert alles in één stijve SQL-zin te dwingen, wat het vaak te complex maakt en vatbaar voor breuk.
De Manier van FlexSQL: Het is tweetalig. Het kan de instructies schrijven in SQL (de taal die databases spreken) OF in Python (een flexibele programmeertaal).
- Als de taak een eenvoudige lijst is, gebruikt het SQL.
- Als de taak een complexe lus of een stap-voor-stap berekening vereist, schrijft het eerst een Python-script omdat het op die manier makkelijker is na te denken.
- Zodra het Python-script perfect werkt, vertaalt het het eindresultaat terug naar SQL zodat de database het begrijpt. Het is alsof je eerst een complex recept in een notitieboekje schrijft en het vervolgens vertaalt naar de officiële keukenbestelling.

4. De "Opnieuw Doen"-Knop (Terugkeren)

Als FlexSQL een plan schrijft en vervolgens beseft: "Oh nee, ik heb de vraag helemaal verkeerd begrepen," probeert het niet alleen de code te herstellen. Het drukt op de terugkeer-knop. Het gaat helemaal terug naar het begin, onderzoekt de bibliotheekplanken opnieuw, verandert zijn hele strategie en start een nieuw plan. Dit voorkomt dat het tijd verspillen door te proberen een gebroken fundament te herstellen.

De Resultaten

Het papier testte deze "flexibele detective" op een zeer moeilijke benchmark genaamd Spider2, die enorme, realistische bedrijfsdatabases simuleert.

De Score: Met een model genaamd gpt-oss-120b scoorde FlexSQL 65,4%.
De Vergelijking: Deze score was hoger dan andere top-systemen die veel grotere, krachtigere modellen gebruikten (zoals DeepSeek-R1 of gpt-o3).
De Conclusie: Door flexibel te zijn – door de bibliotheek te dwalen, meerdere theorieën te brainstormen, twee talen te spreken en op "ongedaan maken" te drukken wanneer nodig – loste FlexSQL problemen beter op dan de "stijve robots", zelfs met een kleiner brein.

Kortom, FlexSQL bewijst dat in de complexe wereld van big data flexibiliteit stijfheid verslaat. Het is beter een agent te zijn die kan verkennen, aanpassen en van mening kan veranderen dan een die koppig één vooraf geschreven kaart volgt.

Technische Samenvatting: FlexSQL

Probleemstelling

Text-to-SQL-systemen staan voor toenemende uitdagingen naarmate analytische databases groeien in schaal en complexiteit. Moderne data warehouses (bijv. Snowflake, BigQuery) bevatten vaak honderden tabellen die zijn georganiseerd in meerdere schema's, waarbij sommige databases meer dan 60.000 kolommen hebben. Huidige systemen volgen doorgaans een vast proces: ze halen schema-elementen eenmalig op, genereren een query op basis van dat statische momentopname, en keren pas na het optreden van fouten terug naar de database voor herstel.

Deze rigiditeit creëert twee primaire faalmodi:

Onvermogen om te herstellen van vroege fouten: Als een model tijdens de initiële fase van schema-linking de verkeerde tabellen selecteert of de betekenis van een kolom verkeerd begrijpt, kunnen downstream herstelmechanismen geen herstel bieden omdat de agent vastzit in een lus van het repareren van code in plaats van het herzien van zijn fundamentele aannames.
Query-ambiguïteit: Natuurlijke taalqueries staan vaak meerdere geldige interpretaties toe (bijv. welk subset van citatietabellen moet worden gebruikt). Vaste processen kiezen vaak voor één interpretatie, waardoor geldige alternatieve oplossingen worden gemist.

Methodologie: FlexSQL Framework

FlexSQL introduceert een text-to-SQL-agent die is ontworpen rondom flexibele database-interactie. In plaats van een vast proces kan de agent schemastructuren verkennen, gegevenswaarden inspecteren en verificatiequeries uitvoeren op elk punt tijdens het redeneren.

Kerncomponenten

Tool-gebaseerde database-interactie:
De agent is uitgerust met een suite tools om incrementeel met de database te interageren:
- Schema-navigatie: GetSchema (lijst tabellen in een schema) en GetTableCol (inspecteer kolommen en steekproefwaarden) maken top-down verkenning mogelijk.
- Gegevensinspectie: GetColValues en FindRows stellen de agent in staat beslissingen te verankeren in werkelijke gegevenswaarden (bijv. ontdekken dat "materiaalwetenschap" overeenkomt met specifieke codes zoals "MS-01") in plaats van uitsluitend te vertrouwen op metadata.
- Code-uitvoering: SQLExecutor en PythonExecutor stellen de agent in staat subqueries te testen, tussenresultaten te verifiëren en gedeeltelijke oplossingen iteratief te debuggen.
Diversiteitsgedwongen plangeneratie:
Om query-ambiguïteit te hanteren, genereert FlexSQL $K$ diverse uitvoeringsplannen met behulp van verbalized sampling. Deze plannen dekken verschillende interpretaties wat betreft tabelkeuzes, join-paden en predikaatlezingen. De agent verkent actief de database om elk plan te verankeren in echte gegevens voordat het wordt afgerond.
Tweetalige programmasynthese (SQL & Python):
FlexSQL staat toe dat elk plan wordt geïmplementeerd in SQL of Python, afhankelijk van de complexiteit van de taak.
- SQL wordt gebruikt voor declaratieve relationele queries.
- Python wordt ingezet voor procedurale workflows, multi-stap transformaties en iteratieve logica die in puur SQL omslachtig is.
- Python-oplossingen worden vervolgens getranspileerd naar SQL voor de uiteindelijke output.
Tweeledige reparatie en backtracking:
- Code-niveau reparatie: Als een gegenereerd programma faalt (syntaxisfouten, verkeerde aggregatie), genereert de agent de code opnieuw met foutfeedback.
- Plan-niveau backtracking: Als de fout voortkomt uit een dieper redeneerdefect (bijv. verkeerde tabelselectie of ontbrekende joins), gaat het systeem terug naar het stadium van Plangeneratie. De agent herziet het plan zelf, mogelijk door de database opnieuw te verkennen, in plaats van alleen de code te patchen.
Meerderheidsstemming:
Na het genereren van $K$ programma's (een mix van SQL en Python), groepeert het systeem ze op basis van uitvoeropbrengst. Het consensusantwoord (de grootste equivalentieklassen) wordt geselecteerd. Als het consensus een Python-oplossing is, wordt deze getranspileerd naar SQL.

Belangrijkste Bijdragen

Flexibele Interactiearchitectuur: Een text-to-SQL-agent die vaste processtadia vervangt door tools op aanvraag voor schema-navigatie, gegevensinspectie en code-uitvoering gedurende het hele redeneerproces.
Tweestaps Plan-naar-Programma met Backtracking: Een architectuur die agents toestaat niet alleen code, maar ook hun onderliggende plannen en schema-aannames te herzien wanneer fouten worden gedetecteerd.
Diversiteit en Tweetalige Generatie: Een combinatie van diversiteitsgedwongen planningsampling om ambiguïteit te hanteren en tweetalige (SQL/Python) generatie om diverse strategieën flexibel te implementeren.
Empirische Validatie: Sterke prestaties op de Spider2.0-benchmark, waarbij effectiviteit wordt aangetoond over verschillende modelgroottes en schaling tijdens het testen.

Experimentele Resultaten

De auteurs evalueerden FlexSQL op Spider2-Snow (544 vragen over Snowflake-databases) en Spider2-SQLite (135 vragen over SQLite-databases), en vergeleken dit met sterke open-source baselines (ReFoRCE en DSR-SQL) met behulp van gpt-oss-120b en gpt-oss-20b.

Prestaties: Met gpt-oss-120b behaalde FlexSQL 65,44% Majority@8 op Spider2-Snow. Dit presteerde beter dan DSR-SQL (met DeepSeek-R1) en ReFoRCE (met gpt-o3), ondanks dat FlexSQL een aanzienlijk kleiner backbone-model gebruikte.
Parameter-efficiëntie: De gpt-oss-20b variant van FlexSQL overtrof of bleef vergelijkbaar met baselines die de grotere 120b-modellen gebruikten.
Schaling tijdens het testen: FlexSQL toonde consistente winsten naarmate het sampling-budget ( $K$ ) toenam van 8 tot 64, wat de effectiviteit van de diversiteitsgedwongen aanpak bevestigt.
Ablatiestudies:
- Het verwijderen van Python-ondersteuning veroorzaakte de grootste prestatiedaling, wat de noodzaak van tweetalige generatie voor complexe logica benadrukt.
- Het verwijderen van diverse planning verlaagde de Majority@8-nauwkeurigheid, wat bevestigt dat het dekken van meerdere interpretaties de kwaliteit van de consensus verbetert.
- Het verwijderen van backtracking verlaagde de prestaties, wat de waarde aantoont van het herzien van hoog-niveau plannen in plaats van alleen code te repareren.
Generalisatie: Wanneer geïntegreerd als vaardigheden in een algemeen doel coderingsagent (Claude Code), leverde FlexSQL meer dan 10% relatieve verbetering op Spider2-Snow op.

Betekenis en Claims

Het paper beweert dat flexibiliteit een kernontwerpprincipe is voor text-to-SQL-agents van de volgende generatie. Door agents toe te staan schema's te verkennen, gegevens te inspecteren en op elk stadium terug te keren van fouten, overwint FlexSQL de beperkingen van vaste processen die niet in staat zijn zich te herstellen van vroege redeneerfouten.

De auteurs benadrukken dat hun aanpak:

Beslissingen verankert in werkelijke gegevens: Het overstijgen van statische schema-metadata om echte waarden te inspecteren lost ambiguïteiten op die metadata alleen niet kan oplossen.
Inferentie-tijd rekenkracht benut: Door diverse plannen te genereren en meerderheidsstemming te gebruiken, maakt het systeem effectief gebruik van verhoogde sampling-budgetten om robuustheid te verbeteren.
De kloof overbrugt tussen declaratieve en procedurale logica: De tweetalige aanpak (SQL/Python) stelt de agent in staat het meest effectieve hulpmiddel te kiezen voor de specifieke redeneertaak, en complexe procedurale logica terug te vertalen naar SQL voor uitvoering.

Het werk suggereert dat voor grootschalige, complexe analytische databases het vermogen om aannames iteratief te verkennen en te herzien kritischer is dan het simpelweg genereren van een query vanuit een vooraf opgehaalde schema-momentopname.