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 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}