1use 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 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}