uqa_execution/query/table_functions/
values.rs1use uqa_core::Value;
10use uqa_sql::assignment::conversion::{json_table_arg, json_table_value_to_text};
11use uqa_sql::SQLError;
12
13pub fn unnest_rows(evaluated: Vec<Value>) -> Result<crate::PhysicalProjectRows, SQLError> {
15 let arrays = evaluated
16 .into_iter()
17 .map(|value| match value {
18 Value::Array(array) => {
19 fn flatten(values: &[Value], output: &mut Vec<Value>) {
20 for value in values {
21 if let Value::List(nested) = value {
22 flatten(nested, output);
23 } else {
24 output.push(value.clone());
25 }
26 }
27 }
28
29 let mut values = Vec::new();
30 flatten(array.elements(), &mut values);
31 Ok(values)
32 }
33 Value::LegacyVector(vector) => Ok(vector.into_array().into_elements()),
34 Value::List(items) => Ok(items),
35 Value::Null => Ok(Vec::new()),
36 _ => Err(SQLError::UnknownFunction(
37 "unnest requires array arguments".into(),
38 )),
39 })
40 .collect::<Result<Vec<_>, _>>()?;
41 let row_count = arrays.iter().map(Vec::len).max().unwrap_or(0);
42 Ok(Box::new((0..row_count).map(move |row_position| {
43 Ok(crate::PhysicalRow::from_values(
44 arrays
45 .iter()
46 .map(|array| array.get(row_position).cloned().unwrap_or(Value::Null))
47 .collect(),
48 ))
49 })))
50}
51
52pub fn generate_series_values(
53 evaluated: Vec<Value>,
54) -> Result<Box<dyn Iterator<Item = Value> + Send>, SQLError> {
55 if !(2..=3).contains(&evaluated.len()) {
56 return Err(SQLError::TypeMismatch(
57 "generate_series requires 2-3 args".into(),
58 ));
59 }
60 if evaluated.iter().any(|value| matches!(value, Value::Null)) {
61 return Ok(Box::new(std::iter::empty()));
62 }
63 let start = generate_series_integer(&evaluated[0], "start")?;
64 let end = generate_series_integer(&evaluated[1], "stop")?;
65 let increment = evaluated
66 .get(2)
67 .map_or(Ok(1), |value| generate_series_integer(value, "step"))?;
68 if increment == 0 {
69 return Err(SQLError::Routine {
70 sqlstate: "22023".into(),
71 message: "step size cannot equal zero".into(),
72 });
73 }
74 let mut current = Some(start);
75 Ok(Box::new(std::iter::from_fn(move || {
76 let value = current?;
77 if (increment > 0 && value > end) || (increment < 0 && value < end) {
78 current = None;
79 return None;
80 }
81 current = value.checked_add(increment);
82 Some(Value::Int(value))
83 })))
84}
85
86pub fn generate_series_integer(value: &Value, label: &str) -> Result<i64, SQLError> {
87 match value {
88 Value::Int(value) => Ok(*value),
89 Value::Float(value)
90 if value.is_finite()
91 && value.fract() == 0.0
92 && *value >= i64::MIN as f64
93 && *value < -(i64::MIN as f64) =>
94 {
95 Ok(*value as i64)
96 }
97 _ => Err(SQLError::TypeMismatch(format!(
98 "generate_series {label} must be an integer"
99 ))),
100 }
101}
102
103pub fn string_to_table_values(
104 evaluated: Vec<Value>,
105) -> Result<Box<dyn Iterator<Item = Value> + Send>, SQLError> {
106 if evaluated.len() != 2 {
107 return Err(SQLError::TypeMismatch(
108 "string_to_table requires 2 args".into(),
109 ));
110 }
111 let source = match &evaluated[0] {
112 Value::Str(value) => value.clone(),
113 _ => return Err(SQLError::TypeMismatch("string_to_table arg 1".into())),
114 };
115 let delimiter = match &evaluated[1] {
116 Value::Str(value) => value.clone(),
117 _ => return Err(SQLError::TypeMismatch("string_to_table arg 2".into())),
118 };
119 Ok(Box::new(LiteralSplitValues {
120 source,
121 delimiter,
122 cursor: 0,
123 done: false,
124 }))
125}
126
127pub struct LiteralSplitValues {
128 source: String,
129 delimiter: String,
130 cursor: usize,
131 done: bool,
132}
133
134impl Iterator for LiteralSplitValues {
135 type Item = Value;
136
137 fn next(&mut self) -> Option<Self::Item> {
138 if self.done {
139 return None;
140 }
141 if self.delimiter.is_empty() {
142 let value = self.source[self.cursor..].chars().next()?;
143 self.cursor += value.len_utf8();
144 if self.cursor == self.source.len() {
145 self.done = true;
146 }
147 return Some(Value::Str(value.to_string()));
148 }
149 if let Some(relative) = self.source[self.cursor..].find(&self.delimiter) {
150 let delimiter_start = self.cursor + relative;
151 let piece = self.source[self.cursor..delimiter_start].to_string();
152 self.cursor = delimiter_start + self.delimiter.len();
153 return Some(Value::Str(piece));
154 }
155 self.done = true;
156 Some(Value::Str(self.source[self.cursor..].to_string()))
157 }
158}
159
160pub fn json_array_values(
161 name: &str,
162 evaluated: Vec<Value>,
163) -> Result<Box<dyn Iterator<Item = Value> + Send>, SQLError> {
164 if evaluated.len() != 1 {
165 return Err(SQLError::TypeMismatch(format!("{name} takes 1 arg")));
166 }
167 let parsed = json_table_arg(&evaluated[0], name)?;
168 let serde_json::Value::Array(items) = parsed else {
169 return Err(SQLError::TypeMismatch(format!(
170 "{name}: argument is not an array"
171 )));
172 };
173 Ok(Box::new(
174 items
175 .into_iter()
176 .map(|value| json_table_value_to_text(&value)),
177 ))
178}
179
180pub fn json_object_key_values(
181 name: &str,
182 evaluated: Vec<Value>,
183) -> Result<Box<dyn Iterator<Item = Value> + Send>, SQLError> {
184 if evaluated.len() != 1 {
185 return Err(SQLError::TypeMismatch(format!("{name} takes 1 arg")));
186 }
187 let parsed = json_table_arg(&evaluated[0], name)?;
188 let serde_json::Value::Object(object) = parsed else {
189 return Err(SQLError::TypeMismatch(format!(
190 "{name}: argument is not an object"
191 )));
192 };
193 Ok(Box::new(object.into_iter().map(|(key, _)| Value::Str(key))))
194}
195
196pub fn json_each_rows(
198 name: &str,
199 evaluated: Vec<Value>,
200) -> Result<crate::PhysicalProjectRows, SQLError> {
201 if evaluated.len() != 1 {
202 return Err(SQLError::TypeMismatch(format!("{name} takes 1 arg")));
203 }
204 let parsed = json_table_arg(&evaluated[0], name)?;
205 let serde_json::Value::Object(object) = parsed else {
206 return Err(SQLError::TypeMismatch(format!(
207 "{name}: argument is not an object"
208 )));
209 };
210 Ok(Box::new(object.into_iter().map(move |(key, value)| {
211 Ok(crate::PhysicalRow::from_values(vec![
212 Value::Str(key),
213 json_table_value_to_text(&value),
214 ]))
215 })))
216}