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(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
198/// The rows of `json_each` and its variants: one key and value per member of a JSON object.
199pub 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}