Greedy Join-Aware Retrieval Algorithm

• The paper presents a greedy algorithm that iteratively selects tables by balancing semantic relevance, comprehensive query coverage, and structural joinability.
• It employs an iterative search framework using coarse and fine-grained relevance signals derived from cosine similarities across table and column embeddings.
• Empirical evaluations show that the approach achieves competitive recall metrics with significant speedups compared to NP-hard MIP-based retrieval methods.

The Greedy Join-Aware Retrieval algorithm addresses the challenge of multi-table retrieval in open-domain question answering over datalakes. The algorithm seeks to select a coherent subset of tables that are (a) semantically relevant to a user's natural-language query, (b) collectively cover all sub-query requirements, and (c) exhibit structural joinability, enabling valid PK–FK joins. Prior exact approaches such as Mixed-Integer Programming (MIP) provide optimality guarantees but are computationally prohibitive; more naive greedy heuristics fail to ensure the required structural composability. The Greedy Join-Aware Retrieval approach formalizes this selection as an iterative, utility-driven search that balances multiple soft signals for scalable and composition-aware retrieval (Boutaleb et al., 17 Nov 2025).

1. Problem Formalization and Objectives

Let $\mathcal{T} = \{T_1, ..., T_N\}$ denote the corpus of candidate tables. Given a natural-language query $Q$ decomposed into $M$ sub-queries $\{q_j\}_{j=1}^M$ (using an LLM), the goal is to select a subset $S \subseteq \mathcal{T}$ with $|S|=K$ that maximizes (a) table-level semantic relevance, (b) coverage of all fine-grained query concepts $q_j$, and (c) the propensity of $S$ to form a valid join graph as measured by precomputed pairwise joinability.

The dual-layer relevance structure comprises:

• Coarse-grained relevance: $$r_i = \cos(\mathrm{emb}(Q),\,\mathrm{emb}(T_i)) \in [-1, 1]$$.
• Fine-grained relevance: $$F_{ji} = \max_{c\in\mathrm{cols}(T_i)} \cos(\mathrm{emb}(q_j),\,\mathrm{emb}(c)) \in [-1, 1]$$.

Query coverage is formalized as a vector $\mathbf{q} \in \mathbb{R}^M$, where for $S$: $q_j(S) = \max_{T_i \in S} F_{ji}.$

Structural coherence is encoded in a join-compatibility matrix $\omega \in [0, 1]^{N \times N}$, with

$$\omega_{il} \approx P( T_i \Join T_l \text{ is a valid PK--FK join} ).$$

2. Iterative-Search Framework

The selection process is orchestrated by an iterative greedy search, where each round updates a context state and augments the candidate subset.

At each step $k$, the search maintains:

• The selected graph $G_k = (S_k, E_k)$, with $S_k$ the current selection and $$E_k = \{(i, l) \mid T_i, T_l \in S_k,\;\omega_{il} > 0\}$$ representing pairwise joinable edges.
• The coverage vector $\mathbf{q}_k$ where $(\mathbf{q}_k)_j = \max_{T_i \in S_k} F_{ji}$.

Selection and update proceed until $|S_k|=K$ or the coverage threshold $\theta$ is met:

• Selection: Pick

$$T_{k+1} = \arg\max_{T \in \mathcal{T} \setminus S_k} U( T, (G_k, \mathbf{q}_k) )$$

where $U$ scores global utility.

• Update: Augment $S$, $E$, and $\mathbf{q}$ accordingly, reflecting new entries and improved coverage.

3. Utility Function and Algorithmic Instantiation

The Greedy Join-Aware Retrieval algorithm specifies a utility function $U$ designed to holistically balance relevance, query coverage, and structural joinability.

Given current context $(S_{k-1}, \mathbf{q}_{k-1})$ and a candidate $T_i \notin S_{k-1}$, compute:

• Coarse relevance gain: $G_{\mathrm{coarse}}(T_i) = r_i$
• Coverage gain:

$$G_{\mathrm{cov}}(T_i \mid \mathbf{q}_{k-1}) = \sum_{j=1}^M \max\left(0, F_{ji} - (\mathbf{q}_{k-1})_j\right)$$

• Join gain (for $k > 1$):

$$G_{\mathrm{join}}(T_i \mid S_{k-1}) = \sum_{T_l \in S_{k-1}} \omega_{il}$$

The overall utility function (for $k > 1$): $$U \left(T_i, (G_{k-1}, \mathbf{q}_{k-1})\right) = \lambda_{\text{coarse}} r_i + \lambda_{\text{cov}} G_{\mathrm{cov}} (T_i \mid \mathbf{q}_{k-1}) + \lambda_{\text{join}} G_{\mathrm{join}} (T_i \mid S_{k-1})$$ For the initial step ($k = 1$), $G_{\mathrm{join}}$ is undefined: $$U(T_i) = \lambda_{\text{coarse}} r_i + \lambda_{\text{cov}} \sum_{j=1}^M F_{ji}$$

Balancing signals:

• $\lambda_{\text{coarse}}$ prioritizes semantically relevant tables.
• $\lambda_{\text{cov}}$ encourages coverage of unmet sub-queries.
• $\lambda_{\text{join}}$ promotes addition of joinable tables to preserve composability.

Ablation shows coarse relevance is the dominant signal, with coverage and joinability successively less impactful.

4. Complexity and Empirical Speedup

Complexity per query is $O(K \cdot N \cdot (M + K))$, where $K$ (number of tables to select) and $M$ (number of query sub-concepts) are typically much smaller than $N$ (candidate pool size). This is polynomial and, in practice, almost linear in $N$ for modest $K$ and $M$.

By contrast, the MIP-based join-aware re-ranker is NP-hard, exponential in $N$, and manifests in wallclock runtimes ranging from minutes to hours per query (up to 11,044 s on the hardest cases). The greedy method completes retrieval in 10–100 s per query across five NL2SQL benchmarks, amounting to a $4$–$400\times$ speedup, depending on scenario and search space (Boutaleb et al., 17 Nov 2025).

Method	Complexity	Typical Runtime (per query)
Greedy JAR	$O(K N (M + K))$	$10$–$100$ s
MIP-based JAR	exponential in $N$	$100$–$11,000$ s

5. Empirical Evaluation

The algorithm was evaluated on five multi-table NL2SQL benchmarks: SPIDER, BIRD, FIBEN, BEAVER-DW, and BEAVER-NW. Metrics include Recall@$K$ (fraction of gold tables in top-$K$) and Complete Recall@$K$ (all gold tables in top-$K$). Baselines comprise Contriever (dense retrieval), JAR (MIP), and CRUSH⁴SQL (coverage-only greedy).

Key empirical results:

• On BIRD at $K=3$, greedy achieves CR@3 = $70.5\%$ (vs. JAR $71.9\%$) with $> 135\times$ speedup.
• On BEAVER-NW at $K=5$, greedy achieves CR@5 = $10.5\%$ (vs. JAR $0\%$) with $> 240\times$ speedup.
• Across all five benchmarks and $K \in \{2,3,5,10\}$, retrieval performance is competitive or superior to MIP-based JAR, with substantially reduced runtime.

Ablation studies:

• Omitting coarse relevance drops SPIDER R@2 from $85.5\%$ to $71.6\%$.
• Omitting coverage reduces performance on coverage-heavy benchmarks.
• Omitting join gain adversely affects enterprise BI benchmarks, confirming the value of structural coherence in real-world schemas.

6. Qualitative Behavior and Interpretability

A case study queries for “high-school friendship pairs.” The algorithm first selects network₁.friend (maximal $r_i$/$F_{ji}$), then network₁.highschooler (maximal join $\omega$ and remaining coverage), thereby reconstructing the correct join path. In contrast, coverage-only greedy methods select structurally incoherent tables when fine segment scores are noisy, failing to form the correct join graph.

A plausible implication is that the join-aware utility prioritization robustly mitigates retrieval fragmentation even in the presence of noisy or inconsistent fine-grained semantic signals, especially in schema-rich, enterprise environments.

7. Limitations and Future Directions

Two primary limitations emerge:

• The approach is sensitive to initial seed selection; a poor first pick can cascade to suboptimal set composition.
• The process is purely greedy, precluding overt refinement or backtracking, thus potentially excluding globally optimal retrieval sets.

Proposed research extensions include incorporation of backtracking or beam search, dynamic adaptation of operator priorities (reach beyond JOIN to UNION and aggregation), hybrid schemes where greedy is complemented by MIP fallback on difficult queries, and broad-scope evaluation over open-domain corpora with LLM-guided retrieval operator learning.

Future work explores generalized, operator-agnostic iterative retrieval frameworks intersecting with dynamic symbolic composition and learning-augmented heuristic selection (Boutaleb et al., 17 Nov 2025).