Skip to main content

uqa_engine/capabilities/
retrieval_execution.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind retrieval leaves to the active statement state.
8
9use crate::{Engine, ScoringMode};
10use uqa_core::{DocId, ScoredEntry};
11use uqa_execution::query::retrieval::context::{
12    RetrievalDocuments, TextRetrieval, VectorPoolRetrieval,
13};
14use uqa_scoring::BayesianBM25Params;
15use uqa_sql::{SQLError, SQLParam, ScalarExpr};
16use uqa_storage::document_store::Document;
17
18impl TextRetrieval for Engine {
19    fn bayesian_params(&self, table: &str, field: &str) -> Result<BayesianBM25Params, SQLError> {
20        self.bayesian_params_for_in_execution(table, field)
21    }
22    fn search(
23        &self,
24        table: &str,
25        field: &str,
26        query: &str,
27        mode: &ScoringMode,
28        top_k: usize,
29    ) -> Result<Vec<ScoredEntry>, SQLError> {
30        self.search_leaf(table, field, query, mode, top_k, None)
31    }
32}
33
34impl RetrievalDocuments for Engine {
35    fn get_document(&self, table: &str, doc_id: DocId) -> Result<Option<Document>, SQLError> {
36        self.get_query_document(table, doc_id)
37    }
38}
39
40impl VectorPoolRetrieval for Engine {
41    fn query_pool(
42        &self,
43        table: &str,
44        field: &str,
45        query_vector: &[f32],
46        k: usize,
47        diagnostics: Option<&uqa_execution::query::diagnostics::CapturedDiagnostics>,
48    ) -> Result<Vec<ScoredEntry>, SQLError> {
49        self.query_pool_vector_search_leaf(table, field, query_vector, k, diagnostics)
50    }
51}
52
53impl Engine {
54    pub(crate) fn retrieval_binding(
55        &self,
56    ) -> uqa_execution::operator_tree::binding::RetrievalBinding<'_> {
57        uqa_execution::operator_tree::binding::RetrievalBinding {
58            hook: self,
59            graphs: self,
60        }
61    }
62}
63
64impl Engine {
65    pub(crate) fn retrieval_query_context(
66        &self,
67    ) -> uqa_execution::operator_tree::query::RetrievalQueryContext<'_> {
68        uqa_execution::operator_tree::query::RetrievalQueryContext {
69            binding: self.retrieval_binding(),
70            trees: self.tree_execution_context(),
71            planner: self,
72            graphs: self,
73        }
74    }
75}
76
77impl uqa_execution::query::block::context::RelationRetrieval for Engine {
78    fn prepare_accelerated<'a>(
79        &'a self,
80        table: &'a str,
81        signal_table: &'a str,
82        predicate: Option<&ScalarExpr>,
83        params: &'a [SQLParam],
84        capture_complete_scores: bool,
85    ) -> Result<Option<uqa_execution::query::scored_input::ScoredEntriesProducer<'a>>, SQLError>
86    {
87        self.retrieval_query_context().prepare_accelerated(
88            table,
89            signal_table,
90            predicate,
91            params,
92            capture_complete_scores,
93        )
94    }
95    fn optimized(
96        &self,
97        table: &str,
98        predicate: Option<&ScalarExpr>,
99        params: &[SQLParam],
100    ) -> Result<Option<Vec<ScoredEntry>>, SQLError> {
101        self.retrieval_query_context()
102            .optimized(table, predicate, params)
103    }
104    fn captured(
105        &self,
106        table: &str,
107        predicate: Option<&ScalarExpr>,
108        params: &[SQLParam],
109    ) -> Result<Option<uqa_execution::query::scored_input::ProducedScoredEntries>, SQLError> {
110        self.retrieval_query_context()
111            .captured(table, predicate, params)
112    }
113    fn function(
114        &self,
115        table: &str,
116        signal_table: &str,
117        name: &str,
118        args: &[ScalarExpr],
119        params: &[SQLParam],
120        top_k: Option<usize>,
121    ) -> Result<Vec<ScoredEntry>, SQLError> {
122        self.retrieval_query_context()
123            .function(table, signal_table, name, args, params, top_k)
124    }
125}