Skip to main content

uqa_sql/routines/inlining/table/
owned.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! SQL table expansion retains independent argument, body, result-layout and source owners.
8
9use 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}