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
61pub(super) fn selected_range_order(
62    left: &Value,
63    right: &Value,
64    ty: Option<&ColumnType>,
65    control: &ProductionControl<'_>,
66    catalog: Option<&dyn SQLValueCatalog>,
67) -> Result<Option<Ordering>> {
68    control.check()?;
69    if matches!(left, Value::Null) || matches!(right, Value::Null) {
70        return Ok(None);
71    }
72    let Some(ty) = ty else {
73        return Ok(None);
74    };
75    let Some(left) = RangeComparisonValue::from_type_with_control(left, ty, catalog, control)?
76    else {
77        return Ok(None);
78    };
79    let right = RangeComparisonValue::from_type_with_control(right, ty, catalog, control)?
80        .ok_or_else(|| {
81            SQLError::Internal("selected range comparison lost its right type".into())
82        })?;
83    left.cmp_with_catalog_and_control(&right, catalog, control)
84        .map(Some)
85}
86
87#[cfg(test)]
88mod tests {
89    use super::*;
90    use uqa_core::{memory::MemoryBudget, CancellationToken};
91
92    #[test]
93    fn selected_range_comparison_matches_postgresql_and_releases_scratch() {
94        let reference: serde_json::Value =
95            serde_json::from_str(include_str!("../range/comparison/postgresql.json")).unwrap();
96        let memory = MemoryBudget::new(1024 * 1024);
97        let token = CancellationToken::new();
98        let control = ProductionControl::new(&memory, &token, &token);
99        let mut observations = 0;
100        for family in reference["families"].as_array().unwrap() {
101            let name = family["kind"].as_str().unwrap();
102            let ty = ColumnType::from_sql_name(name).unwrap();
103            let values = family["values"]
104                .as_array()
105                .unwrap()
106                .iter()
107                .map(|v| {
108                    crate::expr::cast_value(&Value::Str(v.as_str().unwrap().into()), name).unwrap()
109                })
110                .collect::<Vec<_>>();
111            for (i, left) in values.iter().enumerate() {
112                for (j, right) in values.iter().enumerate() {
113                    let expected = family["comparisons"][i][j].as_i64().unwrap().cmp(&0);
114                    assert_eq!(
115                        compare_selected_values_with_catalog(
116                            left,
117                            right,
118                            Some(&ty),
119                            &control,
120                            None,
121                            None
122                        )
123                        .unwrap(),
124                        expected,
125                        "{name}: {i}/{j}"
126                    );
127                    assert_eq!(
128                        compare_selected_grouping_values_with_catalog(
129                            left,
130                            right,
131                            Some(&ty),
132                            &control,
133                            None
134                        )
135                        .unwrap(),
136                        expected
137                    );
138                    assert_eq!(
139                        equal_selected_values_with_catalog(left, right, Some(&ty), &control, None)
140                            .unwrap(),
141                        expected.is_eq()
142                    );
143                    assert_eq!(memory.used(), 0);
144                    observations += 1;
145                }
146            }
147        }
148        assert_eq!(observations, 1264);
149        let left = Value::Str("[1.0,3.00)".into());
150        let right = Value::Str("[1.00,3.0)".into());
151        assert!(!equal_selected_values_with_catalog(
152            &left,
153            &right,
154            Some(&ColumnType::Text),
155            &control,
156            None
157        )
158        .unwrap());
159        let ty = ColumnType::from_sql_name("numrange").unwrap();
160        assert!(equal_selected_values_with_catalog(
161            &Value::Null,
162            &Value::Null,
163            Some(&ty),
164            &control,
165            None
166        )
167        .unwrap());
168        assert!(!equal_selected_values_with_catalog(
169            &left,
170            &Value::Null,
171            Some(&ty),
172            &control,
173            None
174        )
175        .unwrap());
176        token.cancel();
177        assert!(compare_selected_values_with_catalog(
178            &left,
179            &right,
180            Some(&ty),
181            &control,
182            None,
183            None
184        )
185        .is_err());
186        assert_eq!(memory.used(), 0);
187    }
188}