uqa_sql/expr/call_dispatch/
production.rs1use super::named::builtin_named_args;
10use crate::{
11 ast::{FunctionBinding, FunctionDispatch},
12 error::{Result, SQLError},
13};
14use uqa_core::{
15 memory::{MemoryReservation, Produced, ProductionControl, ProductionVec},
16 Value,
17};
18
19pub fn eval_generated_function_call_with_control(
21 name: &str,
22 binding: Option<&FunctionBinding>,
23 arguments: Produced<Vec<(Option<String>, Value)>>,
24 control: &ProductionControl<'_>,
25) -> Result<Produced<Value>> {
26 eval_builtin_function_call_with_control(
27 name,
28 binding,
29 arguments,
30 control,
31 &super::EvalContext::new(None, &[]),
32 )
33}
34
35pub fn eval_builtin_function_call_with_control(
37 name: &str,
38 binding: Option<&FunctionBinding>,
39 arguments: Produced<Vec<(Option<String>, Value)>>,
40 control: &ProductionControl<'_>,
41 context: &super::EvalContext<'_>,
42) -> Result<Produced<Value>> {
43 if let Some(error) = binding.and_then(|binding| binding.resolution_error.as_ref()) {
44 return Err(error.sql_error());
45 }
46 control.check()?;
47 if binding.is_some_and(|binding| !binding.builtin) {
48 return Err(SQLError::Unsupported(
49 "bound user function requires a logical engine session".into(),
50 ));
51 }
52 if let (Some(binding), Some(hook)) = (binding, context.engine) {
53 hook.require_builtin_execute_with_control(binding, control)?;
54 }
55 if crate::semantics::sets::static_setness::builtin_call_returns_set(name, binding) {
56 return Err(crate::semantics::sets::placement::set_valued_call_error());
57 }
58 let _interval_style = super::super::interval_style::call_scope(
59 binding.map_or(name, |binding| binding.name.as_str()),
60 &arguments,
61 context.engine,
62 control,
63 )?;
64 if let Some((binding, dispatch)) =
65 binding.and_then(|binding| binding.dispatch.map(|dispatch| (binding, dispatch)))
66 {
67 if arguments.iter().any(|(name, _)| name.is_some()) {
68 return Err(SQLError::Internal(format!(
69 "bound {} expression retained a named argument",
70 dispatch.label(),
71 )));
72 }
73 let evaluated = MovedArguments::new(arguments, control)?;
74 return eval_dispatched(binding, dispatch, &evaluated.values, control, context);
75 }
76 let collation = FunctionBinding::selected_input_collation(binding);
77 let name = binding.map_or(name, |binding| binding.name.as_str());
78 let normalized =
79 super::super::call_arguments::normalized_function_name_with_control(name, control)?;
80 let name = normalized.as_ref();
81 let value = if arguments.iter().any(|(name, _)| name.is_some()) {
82 let Some(positional) = builtin_named_args(name, &arguments, control)? else {
83 return Err(super::super::diagnostics::unknown_function_error(
84 name, &arguments,
85 ));
86 };
87 eval_scalar(name, &positional, control, context, collation)?
88 } else {
89 let evaluated = MovedArguments::new(arguments, control)?;
90 eval_scalar(name, &evaluated.values, control, context, collation)?
91 };
92 if matches!(*value, Value::Int(_) | Value::Float(_)) {
93 if let Some(binding) = binding {
94 if let Some(ty) = crate::fixed_builtin_return_type_with_control(binding, control)? {
95 if matches!(
96 *ty,
97 crate::ColumnType::SmallInteger
98 | crate::ColumnType::Integer
99 | crate::ColumnType::Real
100 ) {
101 let name = ty.sql_name_with_control(control)?;
102 return super::super::cast_value_from_with_control(
103 &value, &name, None, control,
104 );
105 }
106 }
107 }
108 }
109 Ok(value)
110}
111
112fn eval_dispatched(
113 binding: &FunctionBinding,
114 dispatch: FunctionDispatch,
115 arguments: &[Value],
116 control: &ProductionControl<'_>,
117 context: &super::EvalContext<'_>,
118) -> Result<Produced<Value>> {
119 if let FunctionDispatch::Enum {
120 operation,
121 type_oid,
122 } = dispatch
123 {
124 return super::super::enums::enum_function_value_with_control(
125 context
126 .engine
127 .and_then(super::super::EngineHook::enum_labels),
128 operation,
129 type_oid,
130 arguments,
131 context.enum_comparison_state(),
132 control,
133 );
134 }
135 if let Some(result) = super::super::scalar_postgres::eval_comparison_with_context(
136 dispatch, arguments, control, context,
137 ) {
138 return result;
139 }
140 super::super::builtin::eval_dispatched_builtin_with_control(
141 binding, dispatch, arguments, control, context,
142 )
143}
144
145fn eval_scalar(
146 name: &str,
147 arguments: &[Value],
148 control: &ProductionControl<'_>,
149 context: &super::EvalContext<'_>,
150 collation: u32,
151) -> Result<Produced<Value>> {
152 if matches!(name, "nextval" | "currval" | "lastval" | "setval") {
153 return super::super::scalar_dispatch::eval_sequence_function_with_control(
154 name, arguments, context, control,
155 );
156 }
157 if matches!(name, "coalesce" | "nullif" | "greatest" | "least") {
158 return super::super::scalar_core::selection_with_context(
159 name, arguments, control, context,
160 );
161 }
162 super::super::scalar_dispatch::eval_generated_scalar_function_with_context(
163 name, arguments, control, context, collation,
164 )
165}
166
167struct MovedArguments {
169 values: Vec<Value>,
170 remaining: std::vec::IntoIter<(Option<String>, Value)>,
171 _memory: Option<MemoryReservation>,
172}
173
174impl MovedArguments {
175 fn new(
176 arguments: Produced<Vec<(Option<String>, Value)>>,
177 control: &ProductionControl<'_>,
178 ) -> Result<Self> {
179 let mut values = ProductionVec::new(*control);
180 values.reserve(arguments.len())?;
181 let (values, values_memory) = values.finish()?.into_parts();
182 let (arguments, argument_memory) = arguments.into_parts();
183 let mut output = Self {
184 values,
185 remaining: arguments.into_iter(),
186 _memory: control.combine(values_memory, argument_memory),
187 };
188 for (_, value) in output.remaining.by_ref() {
189 control.check()?;
190 output.values.push(value);
191 }
192 control.check()?;
193 Ok(output)
194 }
195}
196
197#[cfg(test)]
198mod tests;