Hybrid Query Model Overview

• Hybrid query model is a framework that integrates diverse semantics, representations, and execution paths to answer complex queries beyond a single computational regime.
• It unifies relational operations, semantic reasoning, and vector retrieval to leverage the benefits of each approach while mitigating individual limitations.
• This design pattern enhances query precision, execution speed, and resource efficiency across systems including graph databases, relational engines, and multimodal retrieval.

A hybrid query model is a family of query formalisms and systems in which answering a query requires combining heterogeneous semantics, representations, or execution paths rather than relying on a single closed-world, purely relational, purely vector, or purely interpreted regime. In recent work, the term denotes at least five recurring patterns: query languages whose edges or predicates mix different matching semantics; retrieval systems that hybridize dense, sparse, multimodal, or hierarchical query representations; database frameworks that interleave relational operators with LLM-backed semantic operators; execution engines that mix interpreted and compiled, or cryptographic and enclave-backed, paths; and adaptive routers that choose a query strategy from the query itself (Wu et al., 2021, Uzan et al., 6 Oct 2025, Zhao et al., 2024, Mang et al., 10 Apr 2026, Ding et al., 2024).

1. Scope and recurring meanings

In the literature, “hybrid” does not denote a single canonical formalism. In graph querying, it refers to patterns in which some query edges denote direct adjacency while others denote reachability, so the query language itself mixes edge and path semantics (Wu et al., 2021). In beyond-database querying and semantic SQL, it refers to combining relational operators with LLM-generated or LLM-evaluated predicates, joins, projections, and aggregations (Zhao et al., 2024, Lin et al., 26 Apr 2026). In retrieval, it refers either to combining heterogeneous retrievers or to making the query representation itself the locus of hybridization, as in test-time query refinement or asymmetric dense+sparse query encoders (Uzan et al., 6 Oct 2025, Ma et al., 18 May 2025). In systems work, it often means that one query plan or one execution engine keeps two execution modes active at once, such as interpreted plus JIT-compiled execution, positions plus values, or ciphertext-native plus TEE-native operators (Kashuba et al., 2018, Klyuchikov et al., 2023, Li et al., 2024).

This diversity is substantive rather than terminological. Some papers use “hybrid” at the logical layer, where the query language or algebra is extended. Others use it at the physical layer, where the plan remains SQL-like but operator placement, indexing, or runtime routing mixes distinct computational substrates. Still others use it at the query-representation layer, where the final output is still an ordinary ranking or answer set, but the query state has been altered by another model’s signal (Uzan et al., 6 Oct 2025, Shahbazi et al., 2 Apr 2026).

A plausible implication is that “hybrid query model” is best treated as a design pattern rather than a single data model. What remains common across the surveyed work is the attempt to preserve the strengths of one regime while selectively importing capabilities from another: relational precision plus semantic reasoning, vector similarity plus structured filtering, or interpreter portability plus compiled hot paths (Yang et al., 24 Sep 2025, Arnold et al., 2019).

2. Logical and algebraic formulations

A clear logical formulation appears in hybrid graph pattern querying. A data graph is a directed, node-labeled graph $G=(V,E)$, reachability is written $u \prec v$, and a query graph $Q$ is connected and directed, with each query edge declared either as a direct edge or a reachability edge. A homomorphism $h:V(Q)\to V(G)$ preserves node labels and maps each direct query edge to a single data edge and each reachability query edge to a directed path of length at least $1$. The semantics are explicitly homomorphic, not injective, and the answer returns bindings of query nodes to data nodes rather than witness paths (Wu et al., 2021). The same work couples this logical model with transitive reduction on reachability edges, double simulation for pruning, and the runtime index graph as a compact query-specific search structure.

A second algebraic line extends relational algebra itself. SEMA-SQL formalizes Hybrid Relational Algebra (HRA), which preserves classical operators such as selection, projection, join, top-$k$, and aggregation, but allows their predicates or mappings to be supplied by an LLM UDF $U_M^l$, where $M$ is the model and $l$ is a natural-language expression that constructs prompts from selected columns (Lin et al., 26 Apr 2026). The operator interfaces remain relational: semantic selection returns a Boolean decision per tuple, semantic projection derives new columns, semantic join decides pairwise tuple compatibility, semantic top-$k$ provides a comparator, and semantic aggregation summarizes groups. This makes semantic reasoning compositional rather than external to the plan. SEMA-SQL then layers automatic query generation, cost-based optimization, and execution algorithms that reduce LLM invocations by an average of $u \prec v$0 in semantic joins through intelligent batching (Lin et al., 26 Apr 2026).

Hybrid logical models also appear in knowledge representation. Query-driven procedures for Hybrid MKNF knowledge bases combine a description logic ontology $u \prec v$1 with a rule base $u \prec v$2, using tabled rule evaluation extended by an external oracle for ontology reasoning. The procedure is sound with respect to the stable-model-based semantics of Hybrid MKNF and sound and complete with respect to its well-founded semantics; with an $u \prec v$3 oracle it preserves polynomial data complexity under WFS (Alferes et al., 2010). A related Datalog$u \prec v$4 line proposes a hybrid method for weakly-sticky programs: $u \prec v$5 compiles finite-rank existential behavior away, $u \prec v$6 grounds only the troublesome repeated marked variables, the result is a sticky program, and sticky query rewriting is then applied over the original extensional database (Milani et al., 2016).

These logical systems share a strong theme: hybridization is introduced while preserving an explicit answer semantics. Whether the query is a graph homomorphism, a relational-algebra expression with semantic UDFs, or a rule/ontology query under WFS, the hybrid extension is not merely procedural convenience; it is tied to a defined query meaning (Wu et al., 2021, Lin et al., 26 Apr 2026).

3. Query representations in retrieval systems

In retrieval, hybridization often moves from score fusion toward query-state construction. Guided Query Refinement (GQR) studies a two-retriever setting for visual document retrieval in which a primary retriever is a vision-centric multimodal retriever with late interaction and a complementary retriever is a lightweight text retriever over OCR or extracted text. The candidate set is the union of the top-$u \prec v$7 outputs of both retrievers, the primary query embedding is initialized as $u \prec v$8, and test-time optimization updates $u \prec v$9 so that the primary retriever’s distribution moves toward a consensus with the complementary retriever, using a KL objective over the candidate set (Uzan et al., 6 Oct 2025). The complementary retriever’s scores do not appear directly in the final ranking; instead, they shape a gradient signal that changes the primary query representation. On ViDoRe 2, the average percentage gain over the primary retriever is $Q$0, above tuned score-fusion baselines, and the method can be up to $Q$1 faster while requiring $Q$2 less memory than models with much larger representations (Uzan et al., 6 Oct 2025).

LightRetriever locates hybridization in an aggressively asymmetric dense+sparse query architecture. Documents keep a full LLM encoder on both the dense and sparse branches, but the dense query encoder is reduced at inference time to a precomputed vocabulary embedding table $Q$3 plus mean pooling,

$Q$4

while the sparse query branch is only tokenization plus token counting (Ma et al., 18 May 2025). Dense and sparse scores are then linearly interpolated for final hybrid retrieval. This removes all online query-side Transformer computation and yields over $Q$5 faster query inference with GPU acceleration while retaining about $Q$6 of the full-sized baseline performance on average (Ma et al., 18 May 2025).

Adaptive Hybrid Retrieval (AHR) treats the query itself as a routing object. A GPT-4o-mini query classifier assigns each query to one of four tiers: Tier 1 queries route to vector search, Tier 2–3 queries route to tree reasoning, and Tier 4 queries invoke both systems with result fusion (Hashmi, 14 Apr 2026). Tree Reasoning achieves the highest overall score, $Q$7, but no single paradigm dominates across all tiers: Vector RAG wins Tier 4 with $Q$8, while Hybrid AHR achieves the best performance on cross-reference, $Q$9, and multi-section queries, $h:V(Q)\to V(G)$0. Cross-reference recall reaches $h:V(Q)\to V(G)$1 for tree-based and hybrid approaches versus $h:V(Q)\to V(G)$2 for vector search, and on FinanceBench the scores are $h:V(Q)\to V(G)$3 for Tree Reasoning, $h:V(Q)\to V(G)$4 for Hybrid AHR, and $h:V(Q)\to V(G)$5 for Vector RAG (Hashmi, 14 Apr 2026).

Across these retrieval systems, the query is no longer merely a fixed input string or embedding. It may be optimized, factorized into dense and sparse symbolic components, or routed to a structurally different retrieval backend according to its complexity (Uzan et al., 6 Oct 2025, Ma et al., 18 May 2025, Hashmi, 14 Apr 2026).

4. Hybrid querying over structured, semi-structured, and multimodal databases

A separate line studies hybrid querying as a database capability rather than a retrieval pipeline. “Hybrid Querying Over Relational Databases and LLMs” formalizes a beyond-database question $h:V(Q)\to V(G)$6 over database $h:V(Q)\to V(G)$7 and an LLM-generated virtual table $h:V(Q)\to V(G)$8 through the task formulation $h:V(Q)\to V(G)$9 (Zhao et al., 2024). The implemented system, HQDL, follows a schema-expansion strategy: it prompts the LLM with key attributes, materializes generated values into SQLite tables, and executes ordinary SQL over the augmented schema. The paper also discusses a user-defined-function strategy in which LLM calls would be embedded directly in SQL. On the SWAN benchmark of 120 beyond-database questions across four databases, the best reported setting, GPT-4 Turbo with 5-shot prompting, reaches $1$0 execution accuracy and $1$1 data factuality, while consuming 6.3 million input tokens and 1.5 million output tokens under full materialization (Zhao et al., 2024).

DynaQuery addresses hybrid querying over multi-table relational schemas with linked unstructured assets. Its central component is the Schema Introspection and Linking Engine (SILE), which inspects the full schema, caches metadata, and produces a structured query plan over the complete schema before pruning (Hassini, 20 Oct 2025). The system then routes the plan to either a Zero-Shot NL-to-SQL Pipeline or a Generalized Multimodal Pipeline. In the multimodal path, relational SQL first retrieves a candidate set $1$2 using structured WHERE and JOIN logic plus IS NOT NULL filtering on multimodal columns, after which a multimodal LLM evaluates each candidate record and a decision module accepts or rejects it. On Spider, DynaQuery reaches $1$3 execution accuracy versus $1$4 for the RAG baseline; on BIRD it reaches $1$5 versus $1$6; and SCHEMA_HALLUCINATION falls from $1$7 of RAG failures to $1$8 of DynaQuery failures (Hassini, 20 Oct 2025).

OmniTQA pushes this operator view further. It targets semi-structured table question answering over hybrid schemas containing structured and unstructured attributes, models plans as DAGs of atomic steps, and treats semantic reasoning as a first-class operator alongside relational SCAN, FILTER, PROJECT, AGGREGATE, JOIN, SORT, LIMIT, and SET_OP (Shahbazi et al., 2 Apr 2026). Its semantic operators are $1$9, $k$0, $k$1, and $k$2, corresponding to semantic map, filter, join, and aggregate. The cost model is

$k$3

with semantic operator cost driven by input cardinality and token length. The system uses atomic query decomposition, selection pushing, projection pruning, join reordering, adaptive semantic deferral, and operator-aware batching; it reports particularly strong gains on complex queries, large tables, and multi-relation schemas (Shahbazi et al., 2 Apr 2026).

Taken together, these systems place hybridization in the executable plan itself. Structured retrieval, joins, and aggregation are preserved wherever possible, while LLM-backed operators are inserted only at points where schema-internal computation is insufficient (Zhao et al., 2024, Hassini, 20 Oct 2025, Shahbazi et al., 2 Apr 2026).

5. Execution-path and physical-plan hybrids

Hybrid query models also arise below the logical layer, where the main issue is not what a query means but how its operators are executed. In SQLite, a hybrid query execution engine keeps the normal VDBE interpreter as the authoritative path but dynamically replaces hot loops with runtime-generated native code. Loop detection watches for backward jumps in bytecode, a code emitter generates C code from opcode templates, GCC compiles it into a shared object, and the interpreter dispatches into the compiled fragment on subsequent visits. The design is therefore neither a pure interpreter nor a full ahead-of-time compiler, and it produced speedups of up to $k$4 in the reported microbenchmarks (Kashuba et al., 2018).

In disk-based column stores, hybridization can occur in the representation carried between operators. “Hybrid Materialization in a Disk-Based Column-Store” argues that early, late, and ultra-late materialization are all one-step models that use either positions or tuples but not both. Its hybrid materialization model introduces hybrid blocks containing both position columns and tuples, so operators can materialize some attributes while keeping others positional (Klyuchikov et al., 2023). The physical implementation decomposes operators into Fetch, Core, and Combine, and the algebra includes HYDataSource, HYFilter, HYProject, HYMaterialize, HYHashJoin, HYNestedLoopJoin, and HYToTuple. On TPC-H-based scenarios, hybrid materialization is reported as almost two times faster than its late and ultra-late counterparts (Klyuchikov et al., 2023).

Vector-relational systems expose yet another physical hybrid. CHASE defines hybrid queries that combine relational predicates with vector similarity search, classifies them into VKNN-SF, DR-SF, and W-VKNN-SF patterns, and introduces physical operators such as map for similarity-score reuse and updateState for category-aware early stopping (Ma et al., 9 Jan 2025). Its semantic analysis rewrites plans so ANN access, ranking, and relational filtering cooperate. Across six query templates, CHASE reports speedups ranging from $k$5 to $k$6 times compared to existing systems (Ma et al., 9 Jan 2025). ARCADE similarly unifies hybrid and continuous query processing across vector, spatial, text, and relational data, with hybrid NN queries scored by

$k$7

an NRA-style top-$k$8 algorithm, and an incremental materialized-view framework for continuous queries. It reports up to $k$9 speedup on read-heavy and $U_M^l$0 on write-heavy workloads (Yang et al., 24 Sep 2025).

Physical hybridization also appears in security and semantic-operator placement. Enc$U_M^l$1DB adaptively chooses between software cryptographic execution and SGX-backed execution using cost models

$U_M^l$2

with a microbenchmark-based estimate of enclave paging overhead (Li et al., 2024). Horrila, by contrast, keeps semantics fixed but optimizes where LLM-backed semantic filters should be placed relative to ordinary relational operators, minimizing

$U_M^l$3

On 44 semantic SQL queries, it reports up to $U_M^l$4 speedup and $U_M^l$5 cost reduction while maintaining average F1 of $U_M^l$6 against the unoptimized baseline (Mang et al., 10 Apr 2026).

6. Adaptive routing, active selection, and recurrent trade-offs

Some hybrid query models operate by deciding which model, simulator, or inference path should handle a query at all. “Hybrid LLM: Cost-Efficient and Quality-Aware Query Routing” defines a small model $U_M^l$7, a large model $U_M^l$8, and a router predicting a score related to the quality gap

$U_M^l$9

where $M$0 is BARTScore (Ding et al., 2024). With a threshold $M$1, queries with $M$2 are sent to the small model; the rest go to the large model. For favorable model pairs such as Llama-2 7b versus Llama-2 13b, the transformed probabilistic router achieves $M$3 cost advantage with $M$4 quality drop, and router latency is $M$5 s per query (Ding et al., 2024).

In active learning for regression, the hybrid query model is not a retrieval backend but a sample-selection policy. The $M$6-weighted Hybrid Query Strategy combines exploitation of a learned failure-probability model $M$7 with random exploration. At each iteration, it selects $M$8 samples uniformly from

$M$9

and the remaining $l$0 samples uniformly at random from the rest (Vardhan et al., 2022). The paper reports that the $l$1-greedy HQS saves $l$2 of samples relative to randomized sampling for the same accuracy level, corresponding to about 250 hours of data generation time in the expensive FEA case (Vardhan et al., 2022).

A different adaptive model appears in query recommendation. AIGQ frames pre-search query recommendation as a hybrid offline-online architecture: AIGQ-Direct performs nearline personalized user-to-query generation, while AIGQ-Think is a reasoning-enhanced model that produces trigger-to-query mappings for real-time recall (Xu et al., 20 Mar 2026). Training combines Interest-Aware List Supervised Fine-Tuning and Interest-aware List Group Relative Policy Optimization, and deployment integrates both u2q and x2q recall sources into Taobao’s online stack. In a 30-day online A/B test, the system improves HintQ UCTR by $l$3, attributed orders by $l$4, and attributed GMV by $l$5 (Xu et al., 20 Mar 2026).

Taken together, these works suggest that the decisive design question is often the locus of hybridization. Some systems hybridize at the level of logical edge semantics, others at query representation, others at operator placement or physical execution, and others at runtime routing. A second recurrent theme is a cost frontier defined by expensive semantic or model calls on one side and broader relational, indexing, or orchestration cost on the other. The literature repeatedly formulates hybrid query models as ways to move that frontier rather than as a single uniform architecture (Uzan et al., 6 Oct 2025, Mang et al., 10 Apr 2026, Ding et al., 2024, Klyuchikov et al., 2023).