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