1use 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
18pub 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
33pub 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
47pub 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}