Skip to main content

uqa_sql/expr/binary/
selected.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Selected scalar identities follow admitted values into relational consumers.
8
9use std::cmp::Ordering;
10use uqa_core::{memory::ProductionControl, Value};
11
12use super::Result;
13use crate::{
14    expr::{enums::EnumComparisonState, range::RangeComparisonValue, SQLValueCatalog},
15    ColumnType, SQLError,
16};
17
18/// Compare an admitted ordering key under its selected SQL type. The caller controls top-level NULL placement; this never infers a range type from a string.
19pub fn compare_selected_values_with_catalog(
20    left: &Value,
21    right: &Value,
22    ty: Option<&ColumnType>,
23    control: &ProductionControl<'_>,
24    catalog: Option<&dyn SQLValueCatalog>,
25    state: Option<&EnumComparisonState>,
26) -> Result<Ordering> {
27    if let Some(order) = selected_range_order(left, right, ty, control, catalog)? {
28        return Ok(order);
29    }
30    super::compare_typed_values_with_enum_catalog(left, right, control, catalog, state)
31}
32
33/// Preserve selected scalar types in internal equality grouping, retaining enum identity order rather than observing labels.
34pub fn compare_selected_grouping_values_with_catalog(
35    left: &Value,
36    right: &Value,
37    ty: Option<&ColumnType>,
38    control: &ProductionControl<'_>,
39    catalog: Option<&dyn SQLValueCatalog>,
40) -> Result<Ordering> {
41    if let Some(order) = selected_range_order(left, right, ty, control, catalog)? {
42        return Ok(order);
43    }
44    super::compare_grouping_values_with_enum_catalog(left, right, control, catalog)
45}
46
47/// Compare equality keys with their selected scalar type, including SQL grouping's equal NULLs.
48pub fn equal_selected_values_with_catalog(
49    left: &Value,
50    right: &Value,
51    ty: Option<&ColumnType>,
52    control: &ProductionControl<'_>,
53    catalog: Option<&dyn SQLValueCatalog>,
54) -> Result<bool> {
55    if let Some(order) = selected_range_order(left, right, ty, control, catalog)? {
56        return Ok(order.is_eq());
57    }
58    super::equal_typed_values_with_enum_catalog(left, right, control, catalog)
59}
60
61/// Evaluate a selected SQL equality predicate with its invoking session. Unlike grouping keys, cross-type datetime operands can require the session timezone.
62pub fn equal_selected_values_with_engine(
63    left: &Value,
64    right: &Value,
65    ty: Option<&ColumnType>,
66    control: &ProductionControl<'_>,
67    engine: Option<&dyn crate::expr::EngineHook>,
68) -> Result<bool> {
69    let catalog = engine.map(crate::expr::EngineValueCatalog);
70    if let Some(order) = selected_range_order(
71        left,
72        right,
73        ty,
74        control,
75        catalog
76            .as_ref()
77            .map(|catalog| catalog as &dyn SQLValueCatalog),
78    )? {
79        return Ok(order.is_eq());
80    }
81    Ok(super::eval_value_comparison_truth_with_engine(
82        crate::ast::BinaryOp::Equal,
83        left,
84        right,
85        control,
86        engine,
87        None,
88    )? == Some(true))
89}
90
91pub(super) fn selected_range_order(
92    left: &Value,
93    right: &Value,
94    ty: Option<&ColumnType>,
95    control: &ProductionControl<'_>,
96    catalog: Option<&dyn SQLValueCatalog>,
97) -> Result<Option<Ordering>> {
98    control.check()?;
99    if matches!(left, Value::Null) || matches!(right, Value::Null) {
100        return Ok(None);
101    }
102    let Some(ty) = ty else {
103        return Ok(None);
104    };
105    let Some(left) = RangeComparisonValue::from_type_with_control(left, ty, catalog, control)?
106    else {
107        return Ok(None);
108    };
109    let right = RangeComparisonValue::from_type_with_control(right, ty, catalog, control)?
110        .ok_or_else(|| {
111            SQLError::Internal("selected range comparison lost its right type".into())
112        })?;
113    left.cmp_with_catalog_and_control(&right, catalog, control)
114        .map(Some)
115}
116
117#[cfg(test)]
118mod tests {
119    use super::*;
120    use uqa_core::{memory::MemoryBudget, CancellationToken};
121
122    #[test]
123    fn selected_range_comparison_matches_postgresql_and_releases_scratch() {
124        let reference: serde_json::Value =
125            serde_json::from_str(include_str!("../range/comparison/postgresql.json")).unwrap();
126        let memory = MemoryBudget::new(1024 * 1024);
127        let token = CancellationToken::new();
128        let control = ProductionControl::new(&memory, &token, &token);
129        let mut observations = 0;
130        for family in reference["families"].as_array().unwrap() {
131            let name = family["kind"].as_str().unwrap();
132            let ty = ColumnType::from_sql_name(name).unwrap();
133            let values = family["values"]
134                .as_array()
135                .unwrap()
136                .iter()
137                .map(|v| {
138                    crate::expr::cast_value(&Value::Str(v.as_str().unwrap().into()), name).unwrap()
139                })
140                .collect::<Vec<_>>();
141            for (i, left) in values.iter().enumerate() {
142                for (j, right) in values.iter().enumerate() {
143                    let expected = family["comparisons"][i][j].as_i64().unwrap().cmp(&0);
144                    assert_eq!(
145                        compare_selected_values_with_catalog(
146                            left,
147                            right,
148                            Some(&ty),
149                            &control,
150                            None,
151                            None
152                        )
153                        .unwrap(),
154                        expected,
155                        "{name}: {i}/{j}"
156                    );
157                    assert_eq!(
158                        compare_selected_grouping_values_with_catalog(
159                            left,
160                            right,
161                            Some(&ty),
162                            &control,
163                            None
164                        )
165                        .unwrap(),
166                        expected
167                    );
168                    assert_eq!(
169                        equal_selected_values_with_catalog(left, right, Some(&ty), &control, None)
170                            .unwrap(),
171                        expected.is_eq()
172                    );
173                    assert_eq!(memory.used(), 0);
174                    observations += 1;
175                }
176            }
177        }
178        assert_eq!(observations, 1264);
179        let left = Value::Str("[1.0,3.00)".into());
180        let right = Value::Str("[1.00,3.0)".into());
181        assert!(!equal_selected_values_with_catalog(
182            &left,
183            &right,
184            Some(&ColumnType::Text),
185            &control,
186            None
187        )
188        .unwrap());
189        let ty = ColumnType::from_sql_name("numrange").unwrap();
190        assert!(equal_selected_values_with_catalog(
191            &Value::Null,
192            &Value::Null,
193            Some(&ty),
194            &control,
195            None
196        )
197        .unwrap());
198        assert!(!equal_selected_values_with_catalog(
199            &left,
200            &Value::Null,
201            Some(&ty),
202            &control,
203            None
204        )
205        .unwrap());
206        token.cancel();
207        assert!(compare_selected_values_with_catalog(
208            &left,
209            &right,
210            Some(&ty),
211            &control,
212            None,
213            None
214        )
215        .is_err());
216        assert_eq!(memory.used(), 0);
217    }
218}