1mod binding;
10mod calls;
11mod constants;
12mod description;
13mod fusion;
14mod graph;
15mod ir;
16mod joins;
17mod predicates;
18#[cfg(test)]
19mod tests;
20use crate::semantics::graph_functions::{
21 default_graph_name as default_operator_graph, GraphNameCatalog,
22};
23use crate::{ast::BinaryOp, SQLError, SQLParam, ScalarExpr};
24pub use binding::{lower_sql_function_bound, lower_where_bound};
25pub use description::{
26 describe_vector_call, describe_vector_call_with_control, ProducedVectorCallDescription,
27 VectorCallDescription,
28};
29pub use ir::{AttentionSpec, MultiStageEntry, RetrievalExpr, TextScoringMode};
30pub use joins::lower_operator_join_table_function;
31use std::collections::BTreeSet;
32use uqa_core::{
33 retrieval::{Direction as DeepGraphDirection, ExternalPriorMode, GatingSpec, MultiStageCutoff},
34 Predicate, Value,
35};
36type BindingResult<T> = Result<T, SQLError>;
37
38pub type ConstantEvaluator<'a> = dyn Fn(&ScalarExpr, &[SQLParam]) -> Result<Value, SQLError> + 'a;
40pub type ControlledConstantEvaluator<'a> = dyn Fn(
42 &ScalarExpr,
43 &[SQLParam],
44 &uqa_core::memory::ProductionControl<'_>,
45 ) -> Result<uqa_core::memory::Produced<Value>, SQLError>
46 + 'a;
47pub struct RetrievalConstants<'a> {
48 pub params: &'a [SQLParam],
49 pub evaluate: &'a ConstantEvaluator<'a>,
50 pub stores: &'a dyn Fn(&str) -> bool,
52}
53impl RetrievalConstants<'_> {
54 fn without_parameters(&self) -> RetrievalConstants<'_> {
55 RetrievalConstants {
56 params: &[],
57 evaluate: self.evaluate,
58 stores: self.stores,
59 }
60 }
61}
62
63#[must_use]
65pub fn names_engine_pseudo_column(expression: &ScalarExpr) -> bool {
66 let mut names = false;
67 expression.visit(&mut |node| {
68 if let ScalarExpr::Column(column) | ScalarExpr::QualifiedColumn { column, .. } = node {
69 names |= crate::semantics::is_engine_pseudo_column(column);
70 }
71 });
72 names
73}
74pub trait RetrievalArguments: GraphNameCatalog {
76 fn evaluate_argument(
77 &self,
78 expression: &ScalarExpr,
79 params: &[SQLParam],
80 ) -> Result<Value, SQLError>;
81}
82
83use calls::{
84 bind_operator_argument, checked_retrieval_call_tree_present, lower_bayesian_match_with_prior,
85 lower_calibrated_vector_match, lower_multi_field_match, lower_operator_arg, lower_signal_arg,
86 lower_staged_retrieval, try_lower_fts_match, try_lower_knn_match, try_lower_text_match,
87 validate_checked_retrieval_call_tree, validate_operator_function_arity,
88 validate_probability_signal_contract,
89};
90use constants::{
91 const_bool, const_f64, const_f64_vector, const_gating, const_optional_string, const_string,
92 const_temporal_bound, const_usize, const_value, named_arg_expr,
93};
94use fusion::{
95 lower_bayesian_evidence_fusion, lower_learned_fusion, lower_positive_evidence_pool,
96 try_lower_attention_fusion,
97};
98use graph::lower_graph_function;
99use predicates::{column_name, lower_comparison, lower_document_boolean, lower_function};
100
101enum OptionalStringConstant {
102 Null,
103 Value(String),
104}
105impl OptionalStringConstant {
106 fn into_option(self) -> Option<String> {
107 match self {
108 Self::Null => None,
109 Self::Value(value) => Some(value),
110 }
111 }
112}
113
114pub fn lower_where(expr: &ScalarExpr, constants: &RetrievalConstants<'_>) -> Option<RetrievalExpr> {
116 if let Some(membership) = crate::semantics::membership_operands(expr) {
117 return lower_membership(
118 membership.value,
119 membership.items,
120 membership.negated,
121 constants,
122 );
123 }
124 match expr {
125 ScalarExpr::And(parts) => {
126 if let Some(range) = predicates::lower_range(parts, constants) {
127 return Some(range);
128 }
129 let mut out: Vec<RetrievalExpr> = Vec::with_capacity(parts.len());
130 for p in parts {
131 out.push(lower_where(p, constants)?);
132 }
133 Some(lower_document_boolean(out, false))
134 }
135 ScalarExpr::Or(parts) => {
136 let mut out: Vec<RetrievalExpr> = Vec::with_capacity(parts.len());
137 for p in parts {
138 out.push(lower_where(p, constants)?);
139 }
140 Some(lower_document_boolean(out, true))
141 }
142 ScalarExpr::Not(inner) if crate::semantics::expr_is_null_free(inner) => Some(
149 RetrievalExpr::Complement(Box::new(lower_where(inner, constants)?)),
150 ),
151 ScalarExpr::Func { name, args, .. } => lower_function(name, args, constants),
152 ScalarExpr::Binary { op, lhs, rhs } => lower_comparison(*op, lhs, rhs, constants),
153 ScalarExpr::IsNull { expr, negated } => {
154 let field = predicates::filter_field(expr, constants)?;
155 let predicate = if *negated {
156 Predicate::IsNotNull
157 } else {
158 Predicate::IsNull
159 };
160 Some(RetrievalExpr::Filter {
161 field,
162 predicate,
163 source: None,
164 })
165 }
166 ScalarExpr::Between { expr, low, high } => {
167 let field = predicates::filter_field(expr, constants)?;
168 let lo = predicates::filter_constant(low, constants)?;
169 let hi = predicates::filter_constant(high, constants)?;
170 Some(RetrievalExpr::Filter {
171 field,
172 predicate: Predicate::Between { low: lo, high: hi },
173 source: None,
174 })
175 }
176 _ => None,
177 }
178}
179
180fn lower_membership(
181 expr: &ScalarExpr,
182 list: crate::semantics::MembershipItems<'_>,
183 negated: bool,
184 constants: &RetrievalConstants<'_>,
185) -> Option<RetrievalExpr> {
186 let field = predicates::filter_field(expr, constants)?;
187 let mut set: BTreeSet<Value> = BTreeSet::new();
188 let mut has_null = false;
189 for item in list.iter() {
190 let value = match item {
191 crate::semantics::MembershipItem::Expression(expression) => {
192 const_value(expression, constants)?
193 }
194 crate::semantics::MembershipItem::Constant(value) => value.clone(),
195 };
196 if matches!(value, Value::Array(_) | Value::Temporal(_)) {
198 return None;
199 }
200 if matches!(value, Value::Null) {
201 has_null = true;
202 continue;
203 }
204 set.insert(value);
205 }
206 if negated {
207 if has_null {
211 return Some(RetrievalExpr::Empty);
212 }
213 let filter = RetrievalExpr::Filter {
214 field: field.clone(),
215 predicate: Predicate::InSet(set),
216 source: None,
217 };
218 let not_null = RetrievalExpr::Filter {
219 field,
220 predicate: Predicate::IsNotNull,
221 source: None,
222 };
223 return Some(RetrievalExpr::Intersect(vec![
224 RetrievalExpr::Complement(Box::new(filter)),
225 not_null,
226 ]));
227 }
228 Some(RetrievalExpr::Filter {
229 field,
230 predicate: Predicate::InSet(set),
231 source: None,
232 })
233}