Skip to main content

uqa_sql/semantics/sets/validation/
production.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Full set-returning overload analysis retains the same observation order under the caller's planning owner.
8
9use crate::{
10    ast::FunctionBinding, routines::RoutineResolution, FunctionTypeResolver, RowSchema, SQLError,
11    SQLParam, ScalarExpr,
12};
13use uqa_core::memory::ProductionControl;
14
15pub struct SetFunctionAnalysis<'a> {
16    pub routines: &'a dyn RoutineResolution,
17    pub types: &'a dyn FunctionTypeResolver,
18}
19
20pub fn function_may_return_set_with_control(
21    context: SetFunctionAnalysis<'_>,
22    name: &str,
23    binding: Option<&FunctionBinding>,
24    args: &[ScalarExpr],
25    schema: &RowSchema,
26    params: &[SQLParam],
27    control: &ProductionControl<'_>,
28) -> Result<bool, SQLError> {
29    let engine = context.routines;
30    let resolver = context.types;
31    control.check()?;
32    if binding.and_then(|binding| binding.dispatch).is_some()
33        || binding.is_some_and(FunctionBinding::is_polymorphic_builtin_syntax)
34    {
35        return Ok(false);
36    }
37    if binding.is_some_and(|binding| !binding.builtin) {
38        let signature = crate::function_call_argument_signature_with_control(
39            args,
40            schema,
41            params,
42            Some(resolver),
43            control,
44        )?;
45        return selected_setness(engine, name, binding, &signature, control)
46            .map(|setness| setness.unwrap_or(false));
47    }
48    let identity = crate::semantics::lowercase_function_name_with_control(name, control)?;
49    let builtin =
50        crate::semantics::builtin_function_dispatch_name_with_control(identity.as_ref(), control)?;
51    let builtin_returns_set = super::builtin_returns_set(builtin.as_ref())
52        || engine.has_registered_table_function_with_control(identity.as_ref(), control)?;
53    if builtin_returns_set
54        && (binding.is_some()
55            || !engine
56                .visible_function_setness_with_control(name, control)?
57                .found)
58    {
59        return Ok(true);
60    }
61    let signature = crate::function_call_argument_signature_with_control(
62        args,
63        schema,
64        params,
65        Some(resolver),
66        control,
67    )?;
68    let visible = engine.visible_function_setness_with_control(name, control)?;
69    if !visible.found {
70        return Ok(false);
71    }
72    if !builtin_returns_set && !crate::is_fixed_builtin(name) {
73        if let Some(setness) = visible.uniform {
74            return Ok(setness);
75        }
76    }
77    if let Some(resolved) = crate::type_resolution::resolve_fixed_builtin_call_with_control(
78        name,
79        binding,
80        &signature.0,
81        &signature.1,
82        signature.2,
83        Some(resolver),
84        control,
85    )? {
86        if resolved.selected.binding.builtin {
87            return Ok(builtin_returns_set);
88        }
89        return selected_setness(
90            engine,
91            name,
92            Some(&resolved.selected.binding),
93            &signature,
94            control,
95        )
96        .map(|setness| setness.unwrap_or(false));
97    }
98    match selected_setness(engine, name, binding, &signature, control) {
99        Ok(Some(setness)) => Ok(setness),
100        Ok(None) => Ok(builtin_returns_set),
101        Err(error) if builtin_returns_set && error.sqlstate() == Some("42883") => Ok(true),
102        Err(error) if binding.is_none() && error.sqlstate() == Some("42883") => {
103            match crate::type_resolution::builtin_function_type_with_resolver_and_control(
104                builtin.as_ref(),
105                args,
106                &[],
107                schema,
108                params,
109                resolver,
110                control,
111            ) {
112                Ok(Some(_)) => Ok(false),
113                Err(resource) if matches!(resource.sqlstate(), Some("53200" | "57014")) => {
114                    Err(resource)
115                }
116                Ok(None) | Err(_) => Err(error),
117            }
118        }
119        Err(error) => Err(error),
120    }
121}
122
123fn selected_setness(
124    engine: &dyn RoutineResolution,
125    name: &str,
126    binding: Option<&FunctionBinding>,
127    signature: &(Vec<Option<String>>, Vec<Option<crate::ColumnType>>, bool),
128    control: &ProductionControl<'_>,
129) -> Result<Option<bool>, SQLError> {
130    engine.resolve_static_sql_function_setness_with_control(
131        name,
132        binding,
133        &signature.0,
134        &signature.1,
135        signature.2,
136        control,
137    )
138}
139
140#[expect(
141    clippy::too_many_lines,
142    reason = "preserves SELECT schema and row identity"
143)]
144pub fn expression_may_return_set_with_control(
145    engine: &dyn crate::routines::RoutineResolution,
146    resolver: &dyn FunctionTypeResolver,
147    expression: &ScalarExpr,
148    schema: &RowSchema,
149    params: &[SQLParam],
150    control: &ProductionControl<'_>,
151) -> Result<bool, SQLError> {
152    control.check()?;
153    match expression {
154        ScalarExpr::Func {
155            name,
156            binding,
157            args,
158            order_by,
159            filter,
160            ..
161        } => {
162            if function_may_return_set_with_control(
163                SetFunctionAnalysis {
164                    routines: engine,
165                    types: resolver,
166                },
167                name,
168                binding.as_ref(),
169                args,
170                schema,
171                params,
172                control,
173            )? || expressions_may_return_set_with_control(
174                engine, resolver, args, schema, params, control,
175            )? || expressions_may_return_set_with_control(
176                engine,
177                resolver,
178                order_by.iter().map(|order| &order.expr),
179                schema,
180                params,
181                control,
182            )? {
183                return Ok(true);
184            }
185            filter.as_deref().map_or(Ok(false), |filter| {
186                expression_may_return_set_with_control(
187                    engine, resolver, filter, schema, params, control,
188                )
189            })
190        }
191        ScalarExpr::Array(items)
192        | ScalarExpr::Row(items)
193        | ScalarExpr::CompositeRow { items, .. }
194        | ScalarExpr::And(items)
195        | ScalarExpr::Or(items) => expressions_may_return_set_with_control(
196            engine, resolver, items, schema, params, control,
197        ),
198        ScalarExpr::Binary { lhs, rhs, .. } => Ok(expression_may_return_set_with_control(
199            engine, resolver, lhs, schema, params, control,
200        )? || expression_may_return_set_with_control(
201            engine, resolver, rhs, schema, params, control,
202        )?),
203        ScalarExpr::Not(inner)
204        | ScalarExpr::UnaryMinus(inner)
205        | ScalarExpr::IsNull { expr: inner, .. }
206        | ScalarExpr::Cast { expr: inner, .. }
207        | ScalarExpr::Collated { expr: inner, .. } => {
208            expression_may_return_set_with_control(engine, resolver, inner, schema, params, control)
209        }
210        ScalarExpr::Between { expr, low, high } => {
211            Ok(expression_may_return_set_with_control(
212                engine, resolver, expr, schema, params, control,
213            )? || expression_may_return_set_with_control(
214                engine, resolver, low, schema, params, control,
215            )? || expression_may_return_set_with_control(
216                engine, resolver, high, schema, params, control,
217            )?)
218        }
219        ScalarExpr::InList { expr, list, .. } => Ok(expression_may_return_set_with_control(
220            engine, resolver, expr, schema, params, control,
221        )? || expressions_may_return_set_with_control(
222            engine, resolver, list, schema, params, control,
223        )?),
224        // A window call returns one value per row: its arguments, FILTER and frame admit no set-returning call, and its partition and ordering keys expand the rows below the window, as `expression_returns_set` treats `WindowFunc`.
225        ScalarExpr::WindowCall { .. } => Ok(false),
226        ScalarExpr::Case {
227            base,
228            when,
229            else_branch,
230        } => {
231            if let Some(base) = base {
232                if expression_may_return_set_with_control(
233                    engine, resolver, base, schema, params, control,
234                )? {
235                    return Ok(true);
236                }
237            }
238            for (condition, result) in when {
239                if expression_may_return_set_with_control(
240                    engine, resolver, condition, schema, params, control,
241                )? || expression_may_return_set_with_control(
242                    engine, resolver, result, schema, params, control,
243                )? {
244                    return Ok(true);
245                }
246            }
247            if let Some(branch) = else_branch {
248                if expression_may_return_set_with_control(
249                    engine, resolver, branch, schema, params, control,
250                )? {
251                    return Ok(true);
252                }
253            }
254            Ok(false)
255        }
256        ScalarExpr::InSubquery { expr, .. } => {
257            expression_may_return_set_with_control(engine, resolver, expr, schema, params, control)
258        }
259        ScalarExpr::Default
260        | ScalarExpr::Star
261        | ScalarExpr::QualifiedStar(_)
262        | ScalarExpr::Column(_)
263        | ScalarExpr::Position(_)
264        | ScalarExpr::InternalColumn(_)
265        | ScalarExpr::QualifiedColumn { .. }
266        | ScalarExpr::Literal(_)
267        | ScalarExpr::TypedLiteral { .. }
268        | ScalarExpr::RetainedLiteral(_)
269        | ScalarExpr::Param(_)
270        | ScalarExpr::ScalarSubquery(_)
271        | ScalarExpr::Exists { .. } => Ok(false),
272    }
273}
274
275pub fn expressions_may_return_set_with_control<'a>(
276    engine: &dyn crate::routines::RoutineResolution,
277    resolver: &dyn FunctionTypeResolver,
278    expressions: impl IntoIterator<Item = &'a ScalarExpr>,
279    schema: &RowSchema,
280    params: &[SQLParam],
281    control: &ProductionControl<'_>,
282) -> Result<bool, SQLError> {
283    for expression in expressions {
284        if expression_may_return_set_with_control(
285            engine, resolver, expression, schema, params, control,
286        )? {
287            return Ok(true);
288        }
289    }
290    Ok(false)
291}