uqa_sql/expr/call_dispatch/
named.rs1use super::super::{array_transform, json_strip};
10use crate::error::Result;
11use uqa_core::{
12 memory::{Produced, ProductionControl, ProductionVec},
13 Value,
14};
15
16pub 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
166fn 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;