Hybrid SDG for SQL Framework

• Hybrid SDG for SQL is a framework that merges traditional schema-driven techniques with LLM-backed methods to generate syntactically valid SQL queries.
• It employs advanced schema linking, grammar decomposition, and semantic operator integration to enforce schema adherence and minimize generation errors.
• The framework leverages reinforcement learning and reward shaping to enhance execution accuracy and efficiency across diverse database systems.

A hybrid Structure-Driven Generation (SDG) framework for SQL represents a convergence of formal relational reasoning, LLM capabilities, and reinforcement learning, designed to translate natural language questions into executable SQL queries across structured and unstructured data. Recent frameworks such as SGU-SQL, HES-SQL, and SABER exemplify this trend by leveraging structural graph-based schema understanding, semantic operator algebra, skeleton-guided constrained generation, and latency-aware reward modeling to produce both accurate and efficient SQL programs. These systems systematically fuse classic schema-aware constraints, syntax-driven decomposition, and LLM-backed semantic operations, balancing syntactic correctness, pragmatic execution, and flexible interface compatibility across database modalities.

1. Formal Architecture of Hybrid SDG for SQL

Hybrid SDG systems model the text-to-SQL problem as learning a conditional mapping from a natural language query $Q$ and a database schema $S$ to a SQL query $Y$, optimizing $P(Y | Q, S)$ (Zhang et al., 2024). This mapping is typically factored by (i) inferring an intermediate latent structure $Z$—comprising schema links and syntactic parse trees—and (ii) generating SQL conditioned on $Z$, formalized as:

$$P(Y \mid Q,S) = \sum_Z P(Z \mid Q,S)\, P(Y \mid Z, Q, S)$$

Rather than marginalizing over $Z$, state-of-the-art SDG systems deterministically construct $Z$ using graph-based schema linking and grammar-driven decomposition. Subsequently, LLMs are prompted in a structured, step-wise fashion to produce SQL tokens that comply with both the schema and syntactic constraints.

This two-stage pipeline—structure construction followed by generative decoding—enables tight control over the query’s adherence to schema, while leveraging LLMs' diverse paraphrasing and generation capabilities, even for complex compositional queries (Zhang et al., 2024, Qiu et al., 10 Oct 2025).

2. Structure-Aware Schema Linking and Grammar Decomposition

SGU-SQL (Zhang et al., 2024) introduces a multi-graph schema linking mechanism:

• The query graph $\mathcal{G}_q$ encodes the syntactic and adjacency relations within the question;
• The schema graph $\mathcal{G}_s$ represents table and column relationships via “has,” primary/foreign-key, etc.;
• The linking graph $R_{\mathrm{link}}$ establishes node-to-node correspondences between tokens in $Q$ and schema elements in $S$, computed by a Relational Graph Attention Transformer (RGAT).

Each candidate link is scored by encoding the union subgraph $\mathcal{G}(a, s)$ for token $a$ and schema node $s$:

$$\boldsymbol{h} = \mathrm{RGAT}(\mathcal{G}(a, s)),\quad \mathrm{Score}_{(a, s)} = \sigma\left(\sum_{i \in \mathcal{G}(a, s)} h_i\right)$$

High-scoring edges are categorized as “Exact-Linking” or other relation types (Forward-Syntax, Foreign-Key, Value-Linking).

For grammar decomposition, natural language queries are parsed using a context-free grammar (e.g., Stanford Parser). Constituency tree nodes are mapped to meta-operations:

• A: top-level SELECT,
• R: root/nested SELECT,
• T: table reference,
• C: column reference.

Pre-order traversal yields a subtask list, allowing fine-grained decomposition where each subproblem aligns with a single SQL grammar production.

The serialization of $(Q, S, R_{\mathrm{link}})$, together with subtask structure, is assembled into a prompt that guides LLM generation one subtask at a time, enforcing both schema and syntactic correctness (Zhang et al., 2024).

3. Semantic Operator Algebra and SQL Compatibility

The SABER system (Lee et al., 29 Aug 2025) generalizes SDG concepts by extending classical relational algebra to a hybrid semantic algebra, incorporating LLM-based “semantic versions” of typical relational operators. Key definitions:

• $\sigma_P^{\mathrm{sem}}$: semantic selection via LLM-prompted predicates.
• $\pi_F^{\mathrm{sem}}$: semantic projection via prompt-driven transformations.
• $\delta^{\mathrm{sem}}$, $\tau^{\mathrm{sem}}$, $\gamma^{\mathrm{sem}}$, $\xi^{\mathrm{sem}}$: semantic deduplication, sorting, grouping, aggregation, all performed by LLM-evaluated functions.

Each semantic operator is defined as a bag-to-bag map: for example, semantic join $r \bowtie_Q^{\mathrm{sem}} s$ retains tuple pairs for which $\mathrm{EvalLLM}(Q, t, u) = \mathrm{true}$. These operator semantics preserve closure and compatibility with classical optimization rules, as semantic predicates are treated as black-box functions substituting for syntactic equality.

Operators are exposed to SQL via SQL UDFs, permitting direct statement-level integration:

• SEM_WHERE, SEM_SELECT, SEM_JOIN, SEM_GROUP_BY, etc., enabling queries over mixed structured and unstructured data (e.g., applying semantic filtering on document text within a SQL workflow). The entire hybrid plan can then be optimized and partially executed in-database, with semantic UDFs delegated to LLM-backed components (Lee et al., 29 Aug 2025).

4. Skeleton Guidance, Reward Shaping, and Hybrid Training Objectives

HES-SQL (Qiu et al., 10 Oct 2025) and related frameworks incorporate structural skeleton guidance to improve robustness and efficiency. The “skeleton” of a SQL query is formed by abstracting away schema and literal tokens, keeping only the sequence of operators and control structures (e.g., replacing names/numbers with [col]/[tab]/[val]). The skeleton completeness score,

$$S_{\mathrm{skeleton}}(q, q^*) = \alpha\,\mathrm{MatchRatio}(\mathrm{skel}(q), \mathrm{skel}(q^*)) + (1-\alpha)\,\mathrm{Jaccard}(S_{\mathrm{gen}}, S_{\mathrm{gt}})$$

determines whether a generated query sufficiently matches the expected structural scaffold ($\alpha = 0.7$). Only skeleton-complete candidates are considered for further evaluation.

The overall hybrid training loss combines:

• Supervised fine-tuning (SFT) on data labeled by “thinking mode” (direct, fast, slow—i.e., with or without chain-of-thought output),
• Group Relative Policy Optimization (GRPO), a population-based reinforcement learning objective with relative advantage calculations and PPO-style clipping,
• Self-distillation to preserve reasoning capability (by training on Mode 3 chains produced by the current checkpoint),
• Composite rewards fusing skeleton completeness, execution correctness, schema validation, and latency-aware efficiency scores.

The query-latency-aware reward,

$$R(q) = \alpha\,\mathbf{1}[\mathrm{Exe}(\hat q) = \mathrm{Exe}(q^*)] + (1-\alpha)\,\tau_{\mathrm{eff}}(q),\quad \tau_{\mathrm{eff}}(q) = \min(1.0, t_{\mathrm{gold}}/t_{\mathrm{pred}})$$

ensures generated SQL is not only correct but also efficient to execute in the target DBMS environment. This dual focus directly addresses longstanding challenges in practical semantic parsing (Qiu et al., 10 Oct 2025).

5. Empirical Performance and Error Correction

Experimental results from SGU-SQL (Zhang et al., 2024) and HES-SQL (Qiu et al., 10 Oct 2025) establish that hybrid SDG frameworks consistently outperform previous state-of-the-art text-to-SQL systems:

Model	Benchmark	Exec Acc	EM Acc
SGU-SQL + GPT-4 (Zhang et al., 2024)	Spider (dev)	0.8791	0.7679
SGU-SQL + GPT-4 (Zhang et al., 2024)	BIRD	0.5771	0.4989
HES-SQL (Qiu et al., 10 Oct 2025)	BIRD (MySQL 8.0)	0.7914	—
HES-SQL (Qiu et al., 10 Oct 2025)	KaggleDBQA	—	0.549

SGU-SQL demonstrates improvements of 3–5 points across multiple LLMs and prompt ablations. Error analysis shows:

• ≈38% reduction in schema-linking errors via RGAT-based matching,
• ≈35% reduction in JOIN/Group-By structural errors due to grammar-tree decomposition,
• Overall failure rates are reduced by ≈33% compared to chain-of-thought methods.

Hybrid reward shaping and skeleton-completeness further improve both exact-match and execution accuracy, with query latency improvements in the 11–20% range relative to pure supervised baselines (Zhang et al., 2024, Qiu et al., 10 Oct 2025).

6. Optimization, Rewrite Rules, and System Integration

The SABER framework (Lee et al., 29 Aug 2025) demonstrates that hybrid SDG systems can preserve classical algebraic optimization properties when semantic (LLM-driven) operators are treated as pure functions over tuple bags. Classical rewrite rules—selection pushdown, operator fusion, projection pullup, deduplication propagation, join reordering—generalize when logical equivalence is based on semantic equality via the LLM. This enables optimizers to reposition and aggregate operators for improved cost efficiency, leveraging DBMS-native performance for structured tasks while isolating costly semantic operator calls (which can be batched, memoized, or filtered with vector indexes).

The integration of semantic UDFs allows existing SQL-based data systems to dynamically combine structured and unstructured processing, further extending the reach of hybrid SDG to document, knowledge graph, and entity search scenarios (Lee et al., 29 Aug 2025).

7. Limitations, Open Challenges, and Future Directions

Despite their empirical and architectural advances, hybrid SDG systems exhibit certain limitations:

• Dependence on black-box LLMs (e.g., GPT-4) and external API stability (Zhang et al., 2024).
• Grammar and schema coverage: new or unseen SQL constructs (WINDOW, CTE), as well as unanticipated schema patterns, require targeted grammar extension and additional linking logic.
• Value-level linking and multi-turn refinement remain underexplored; new methods for execution-informed feedback, subquery coordination, and user clarification are active research areas (Zhang et al., 2024).
• Efficiency bottlenecks persist in semantic operator execution, particularly for large data volumes and high-frequency LLM calls; future designs may incorporate embedding-based candidate pruning, cost-based operator placement, and further DBMS integration for hybrid execution (Lee et al., 29 Aug 2025).

A plausible implication is that as LLM-based systems mature, hybrid SDG is likely to serve as the unified substrate not only for text-to-SQL generation but also for broader semantic querying and reasoning tasks, blending classical formalism with large-scale language understanding in a composable framework.