uqa_sql/routines/inlining/table/
owned.rs1use super::{
10 eligible_definition, FunctionBinding, FunctionVolatility, RoutineInliningContext, SQLError,
11 ScalarExpr,
12};
13use crate::{
14 plan::{MutableExecutablePlan, MutableQueryPlan},
15 routines::{
16 diagnostics::{sql_context_with_control, SQLRoutineStage},
17 result_check::{SQLFunctionResultColumn, SQLFunctionResultKind},
18 },
19 ColumnType,
20};
21use uqa_core::memory::{Produced, ProductionControl, ProductionVec};
22
23pub struct InlineOwnedRoutineQuery {
24 pub identity: [u8; 16],
25 pub query: MutableQueryPlan,
26 pub declared_columns: Option<Produced<Vec<String>>>,
27}
28
29impl RoutineInliningContext<'_> {
30 fn can_execute_inline(
31 &self,
32 definition: &crate::ast::CreateFunction,
33 control: &ProductionControl<'_>,
34 ) -> Result<bool, SQLError> {
35 match crate::routines::security::ensure_routine_execute_privilege_with_control(
36 self.authority,
37 definition,
38 control,
39 ) {
40 Ok(()) => Ok(true),
41 Err(error) if error.sqlstate() == Some("42501") => Ok(false),
42 Err(error) => Err(error),
43 }
44 }
45
46 fn table_result_columns(
47 &self,
48 column_names: &[String],
49 column_types: &[String],
50 control: &ProductionControl<'_>,
51 ) -> Result<Produced<Vec<SQLFunctionResultColumn>>, SQLError> {
52 let mut target = ProductionVec::new(*control);
53 target.reserve(column_names.len().min(column_types.len()))?;
54 for (name, ty) in column_names.iter().zip(column_types) {
55 let name = control.copy_text(name)?;
56 let ty = self
57 .types
58 .resolve_catalog_column_type_name_with_control(ty, control)?;
59 let (name, name_memory) = name.into_parts();
60 let (ty, type_memory) = ty.into_parts();
61 target.push_produced(control.finish(
62 SQLFunctionResultColumn { name, ty },
63 control.combine(name_memory, type_memory),
64 )?)?;
65 }
66 Ok(target.finish()?)
67 }
68
69 pub fn prepare_table_owned(
70 &self,
71 binding: &FunctionBinding,
72 arguments: &[ScalarExpr],
73 active: &[[u8; 16]],
74 column_names: &[String],
75 column_types: &[String],
76 control: &ProductionControl<'_>,
77 ) -> Result<Option<InlineOwnedRoutineQuery>, SQLError> {
78 let Some(function) =
79 crate::routines::selected_bound_function_with_control(self.routines, binding, control)?
80 else {
81 return Ok(None);
82 };
83 let Some(identity) = binding.object_id else {
84 return Ok(None);
85 };
86 let Some(invocation) = binding.invocation.as_deref() else {
87 return Ok(None);
88 };
89 let specialized = crate::routines::invocation::specialized_definition_with_control(
90 &function.def,
91 invocation,
92 control,
93 )?;
94 let definition = specialized.as_deref().unwrap_or(&function.def);
95 if active.contains(&identity) || !eligible_definition(definition) {
96 return Ok(None);
97 }
98 let Some(arguments) = super::super::owned_arguments::prepare(
99 self, definition, invocation, arguments, control,
100 )?
101 else {
102 return Ok(None);
103 };
104 let arguments = arguments.into_container(control)?;
105 let ScalarExpr::Or(argument_values) = &*arguments else {
106 unreachable!("routine arguments");
107 };
108 if !substitutable_arguments(self, argument_values, control)? {
109 return Ok(None);
110 }
111 if !self.can_execute_inline(definition, control)? {
112 return Ok(None);
113 }
114 let error_context =
115 sql_context_with_control(definition, SQLRoutineStage::Inlining, control)?;
116 let Some(body) = self
117 .analyze_plan_owned(&function, definition, control)
118 .map_err(|error| error.with_context(error_context.as_str()))?
119 else {
120 return Ok(None);
121 };
122 let MutableExecutablePlan::Query(query) = body.plan else {
123 return Ok(None);
124 };
125 if query.ctes.iter().any(|cte| cte.body.modifies_data()) {
126 return Ok(None);
127 }
128 let query = self
129 .bind_inline_relations_owned(query, control)
130 .map_err(|error| error.with_context(error_context.as_str()))?;
131 let layout = crate::routines::result_check::sql_function_result_layout_with_control(
132 self.types,
133 definition,
134 Some(&body.result),
135 control,
136 )
137 .map_err(|error| error.with_context(error_context.as_str()))?;
138 let overrides = if layout.kind == SQLFunctionResultKind::Tuple && !column_types.is_empty() {
139 let target = self.table_result_columns(column_names, column_types, control)?;
140 crate::routines::result_check::validate_sql_tuple_result_with_control(
141 self.types,
142 body.result.column_types().unwrap_or_default(),
143 &target,
144 control,
145 )
146 .map_err(|error| error.with_context(error_context.as_str()))?;
147 Some(target)
148 } else {
149 None
150 };
151 let columns = overrides
152 .as_deref()
153 .map(Vec::as_slice)
154 .or_else(|| layout.columns.as_deref());
155 let Some((query, width)) =
156 coerce_table_result(query, &body.result, &layout, columns, control)?
157 else {
158 return Ok(None);
159 };
160 let declared_columns = match crate::semantics::user_function_declared_columns_with_control(
161 self.routines,
162 &function,
163 Some(invocation),
164 control,
165 )? {
166 Some(columns) => Some(columns),
167 None => columns
168 .map(|columns| copy_result_names(columns, control))
169 .transpose()?,
170 };
171 let query = super::scopes_owned::substitute(query, argument_values, width, control)?;
172 Ok(Some(InlineOwnedRoutineQuery {
173 identity,
174 query,
175 declared_columns,
176 }))
177 }
178}
179
180fn substitutable_arguments(
181 context: &RoutineInliningContext<'_>,
182 arguments: &[ScalarExpr],
183 control: &ProductionControl<'_>,
184) -> Result<bool, SQLError> {
185 let schema = crate::RowSchema::empty_with_control(control)?;
186 for argument in arguments {
187 let mut subplan = false;
188 argument.visit(&mut |node| {
189 subplan |= matches!(
190 node,
191 ScalarExpr::ScalarSubquery(_)
192 | ScalarExpr::Exists { .. }
193 | ScalarExpr::InSubquery { .. }
194 );
195 });
196 if subplan
197 || super::super::properties::volatility_with_control(
198 context, argument, &schema, control,
199 )? == FunctionVolatility::Volatile
200 {
201 return Ok(false);
202 }
203 }
204 control.check()?;
205 Ok(true)
206}
207
208fn coerce_table_result(
209 query: MutableQueryPlan,
210 result: &crate::binding::statements::AnalyzedResult,
211 layout: &crate::routines::result_check::SQLFunctionResultLayout,
212 columns: Option<&[SQLFunctionResultColumn]>,
213 control: &ProductionControl<'_>,
214) -> Result<Option<(MutableQueryPlan, usize)>, SQLError> {
215 if layout.kind == SQLFunctionResultKind::Void
216 || layout.kind == SQLFunctionResultKind::Value
217 && matches!(
218 crate::type_resolution::base_type(&layout.declared_type),
219 ColumnType::Composite(_) | ColumnType::Record
220 )
221 {
222 return Ok(None);
223 }
224 let mut targets = ProductionVec::new(*control);
225 match columns {
226 Some(columns) => {
227 targets.reserve(columns.len())?;
228 for column in columns {
229 targets.push_produced(column.ty.clone_with_control(control)?)?;
230 }
231 }
232 None => targets.push_produced(layout.declared_type.clone_with_control(control)?)?,
233 }
234 let targets = targets.finish()?;
235 let sources = result.column_types().unwrap_or_default();
236 if sources.len() != targets.len() {
237 return Ok(None);
238 }
239 let query = super::scopes_owned::coerce_result(query, &targets, sources, control)?;
240 Ok(Some((query, targets.len())))
241}
242
243fn copy_result_names(
244 columns: &[SQLFunctionResultColumn],
245 control: &ProductionControl<'_>,
246) -> Result<Produced<Vec<String>>, uqa_core::ValueRetentionError> {
247 let mut names = ProductionVec::new(*control);
248 names.reserve(columns.len())?;
249 for column in columns {
250 names.push_produced(control.copy_text(&column.name)?)?;
251 }
252 names.finish()
253}