Skip to main content

uqa_execution/query/table_functions/
values.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Lazy generate-series, string, and JSON value streams.
8
9use uqa_core::Value;
10use uqa_sql::assignment::conversion::{json_table_arg, json_table_value_to_text};
11use uqa_sql::SQLError;
12
13/// The rows of `unnest(array [, ...])`: one per position of the longest array, with NULL past the end of a shorter one.
14pub 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
196/// The rows of `json_each` and its variants: one key and value per member of a JSON object.
197pub 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}