Skip to main content

uqa_sql/expr/call_dispatch/
production.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Evaluated arguments for validated generated built-ins keep their existing payload owner through SQL dispatch.
8
9use 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
19/// Execute a built-in selected by generated-column validation. This boundary has no session, host-function or query callbacks; general runtime dispatch remains with `eval_function_call`. Argument values arrive already admitted by their producers.
20pub 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
35/// Execute SQL-owned native built-ins with admitted arguments and the caller's catalog/comparison context. Session and user-function callbacks keep their separate execution boundaries.
36pub 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(binding)?;
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, "coalesce" | "nullif" | "greatest" | "least") {
153        return super::super::scalar_core::selection_with_context(
154            name, arguments, control, context,
155        );
156    }
157    super::super::scalar_dispatch::eval_generated_scalar_function_with_context(
158        name, arguments, control, context, collation,
159    )
160}
161
162/// Moving positional values must not make a second payload copy. The new vector's complete capacity is admitted by Core before movement; the original argument buffer and payload lease remain with this guard until dispatch finishes. Both vectors precede the shared lease on every failure path.
163struct MovedArguments {
164    values: Vec<Value>,
165    remaining: std::vec::IntoIter<(Option<String>, Value)>,
166    _memory: Option<MemoryReservation>,
167}
168
169impl MovedArguments {
170    fn new(
171        arguments: Produced<Vec<(Option<String>, Value)>>,
172        control: &ProductionControl<'_>,
173    ) -> Result<Self> {
174        let mut values = ProductionVec::new(*control);
175        values.reserve(arguments.len())?;
176        let (values, values_memory) = values.finish()?.into_parts();
177        let (arguments, argument_memory) = arguments.into_parts();
178        let mut output = Self {
179            values,
180            remaining: arguments.into_iter(),
181            _memory: control.combine(values_memory, argument_memory),
182        };
183        for (_, value) in output.remaining.by_ref() {
184            control.check()?;
185            output.values.push(value);
186        }
187        control.check()?;
188        Ok(output)
189    }
190}
191
192#[cfg(test)]
193mod tests;