Skip to main content

uqa_sql/expr/call_dispatch/
named.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Named argument selection retains reordered values under the caller's allowance.
8
9use super::super::{array_transform, json_strip};
10use crate::error::Result;
11use uqa_core::{
12    memory::{Produced, ProductionControl, ProductionVec},
13    Value,
14};
15
16/// Reorder a built-in call's named arguments into declared positions, or `None` when the function has no such signature.
17///
18/// # Errors
19///
20/// Reports `PostgreSQL`'s named-argument diagnostics, an exhausted allowance and cancellation.
21pub fn builtin_named_args(
22    function: &str,
23    call_args: &[(Option<String>, Value)],
24    control: &ProductionControl<'_>,
25) -> Result<Option<Produced<Vec<Value>>>> {
26    control.check()?;
27    if matches!(function, "array_sort" | "array_reverse") {
28        return array_transform::reorder_named_values_with_control(function, call_args, control);
29    }
30    if matches!(function, "json_strip_nulls" | "jsonb_strip_nulls") {
31        return json_strip::reorder_named_values_with_control(function, call_args, control);
32    }
33    let names: &[&str] = match function {
34        "regexp_count" => match call_args.len() {
35            2 => &["string", "pattern"],
36            3 => &["string", "pattern", "start"],
37            4 => &["string", "pattern", "start", "flags"],
38            _ => return Ok(None),
39        },
40        "regexp_like"
41        | "regexp_match"
42        | "regexp_matches"
43        | "regexp_split_to_array"
44        | "regexp_split_to_table" => match call_args.len() {
45            2 => &["string", "pattern"],
46            3 => &["string", "pattern", "flags"],
47            _ => return Ok(None),
48        },
49        "regexp_substr" => match call_args.len() {
50            2 => &["string", "pattern"],
51            3 => &["string", "pattern", "start"],
52            4 => &["string", "pattern", "start", "N"],
53            5 => &["string", "pattern", "start", "N", "flags"],
54            6 => &["string", "pattern", "start", "N", "flags", "subexpr"],
55            _ => return Ok(None),
56        },
57        "regexp_instr" => match call_args.len() {
58            2 => &["string", "pattern"],
59            3 => &["string", "pattern", "start"],
60            4 => &["string", "pattern", "start", "N"],
61            5 => &["string", "pattern", "start", "N", "endoption"],
62            6 => &["string", "pattern", "start", "N", "endoption", "flags"],
63            7 => &[
64                "string",
65                "pattern",
66                "start",
67                "N",
68                "endoption",
69                "flags",
70                "subexpr",
71            ],
72            _ => return Ok(None),
73        },
74        "regexp_replace" => match call_args.len() {
75            3 => &["string", "pattern", "replacement"],
76            4 if call_args
77                .iter()
78                .any(|(name, _)| name.as_deref() == Some("flags")) =>
79            {
80                &["string", "pattern", "replacement", "flags"]
81            }
82            4 => &["string", "pattern", "replacement", "start"],
83            5 => &["string", "pattern", "replacement", "start", "N"],
84            6 => &["string", "pattern", "replacement", "start", "N", "flags"],
85            _ => return Ok(None),
86        },
87        "make_interval" => return make_interval_named_args(call_args, control),
88        _ => return Ok(None),
89    };
90    reorder_named_args(call_args, names, control)
91}
92
93fn reorder_named_args(
94    call_args: &[(Option<String>, Value)],
95    parameter_names: &[&str],
96    control: &ProductionControl<'_>,
97) -> Result<Option<Produced<Vec<Value>>>> {
98    if call_args.len() != parameter_names.len() {
99        return Ok(None);
100    }
101    let Some(slots) = select_slots(call_args, parameter_names, control)? else {
102        return Ok(None);
103    };
104    copy_slots(&slots, None, control)
105}
106
107fn select_slots<'a>(
108    call_args: &'a [(Option<String>, Value)],
109    parameter_names: &[&str],
110    control: &ProductionControl<'_>,
111) -> Result<Option<Produced<Vec<Option<&'a Value>>>>> {
112    let mut slots = ProductionVec::new(*control);
113    slots.reserve(parameter_names.len())?;
114    for _ in parameter_names {
115        slots.push_copy(None)?;
116    }
117    let mut slots = slots.finish()?;
118    let mut positional_index = 0;
119    let mut saw_named = false;
120    for (name, value) in call_args {
121        control.check()?;
122        let slot = if let Some(name) = name {
123            saw_named = true;
124            let Some(slot) = parameter_names
125                .iter()
126                .position(|candidate| candidate == name)
127            else {
128                return Ok(None);
129            };
130            slot
131        } else {
132            if saw_named {
133                return Ok(None);
134            }
135            let slot = positional_index;
136            positional_index += 1;
137            slot
138        };
139        let Some(selected) = slots.as_mut_slice().get_mut(slot) else {
140            return Ok(None);
141        };
142        if selected.is_some() {
143            return Ok(None);
144        }
145        *selected = Some(value);
146    }
147    Ok(Some(slots))
148}
149
150fn copy_slots(
151    slots: &[Option<&Value>],
152    default: Option<&Value>,
153    control: &ProductionControl<'_>,
154) -> Result<Option<Produced<Vec<Value>>>> {
155    let mut output = ProductionVec::new(*control);
156    output.reserve(slots.len())?;
157    for selected in slots {
158        let Some(value) = selected.or(default) else {
159            return Ok(None);
160        };
161        output.push_produced(control.copy_value(value)?)?;
162    }
163    Ok(Some(output.finish()?))
164}
165
166/// Map the existing interval names and omitted zero defaults to declaration order.
167fn make_interval_named_args(
168    call_args: &[(Option<String>, Value)],
169    control: &ProductionControl<'_>,
170) -> Result<Option<Produced<Vec<Value>>>> {
171    const NAMES: [&str; 7] = ["years", "months", "weeks", "days", "hours", "mins", "secs"];
172    let Some(slots) = select_slots(call_args, &NAMES, control)? else {
173        return Ok(None);
174    };
175    copy_slots(&slots, Some(&Value::Int(0)), control)
176}
177
178#[cfg(test)]
179mod tests;