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    ) -> Result<Option<uqa_execution::query::scored_input::ScoredEntriesProducer<'a>>, SQLError>
85    {
86        self.retrieval_query_context()
87            .prepare_accelerated(table, signal_table, predicate, params)
88    }
89    fn optimized(
90        &self,
91        table: &str,
92        predicate: Option<&ScalarExpr>,
93        params: &[SQLParam],
94    ) -> Result<Option<Vec<ScoredEntry>>, SQLError> {
95        self.retrieval_query_context()
96            .optimized(table, predicate, params)
97    }
98    fn function(
99        &self,
100        table: &str,
101        signal_table: &str,
102        name: &str,
103        args: &[ScalarExpr],
104        params: &[SQLParam],
105        top_k: Option<usize>,
106    ) -> Result<Vec<ScoredEntry>, SQLError> {
107        self.retrieval_query_context()
108            .function(table, signal_table, name, args, params, top_k)
109    }
110}