uqa_engine/capabilities/
retrieval_execution.rs1use 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}