Skip to main content

uqa_sql/routines/inlining/
preparation.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Caller-owned routine bodies admit their executable destinations directly and retain ordered input analysis through scalar extraction.
8
9use super::{selection::InlineSelection, InlineOwnedRoutineExpression, RoutineInliningContext};
10use crate::{
11    ast::{CreateFunction, FunctionBinding, FunctionBody},
12    binding::statements::AnalyzedResult,
13    plan::{MutableExecutablePlan, OwnedScalarExpr, QueryScalarSlot, RelationalPlan, UnifiedPlan},
14    routines::{CompiledFunctionBody, RoutineBody, SQLUserFunction},
15    ColumnType, SQLError, SQLParam, ScalarExpr,
16};
17use uqa_core::memory::{Produced, ProductionControl};
18
19type OwnedInlineScalar = (OwnedScalarExpr, Produced<Vec<SQLParam>>);
20
21pub(super) struct OwnedAnalyzedBody {
22    pub plan: MutableExecutablePlan,
23    pub result: AnalyzedResult,
24    pub parameters: Produced<Vec<SQLParam>>,
25}
26
27impl RoutineInliningContext<'_> {
28    pub fn prepare_owned(
29        &self,
30        binding: &FunctionBinding,
31        arguments: &[ScalarExpr],
32        active: &[[u8; 16]],
33        control: &ProductionControl<'_>,
34    ) -> Result<Option<InlineOwnedRoutineExpression>, SQLError> {
35        match self.select_inline_with_control(binding, arguments, active, control)? {
36            InlineSelection::Declined => Ok(None),
37            InlineSelection::Expression(expression) => Ok(Some(expression)),
38            InlineSelection::Body(candidate) => {
39                let Some((expression, parameters)) = self
40                    .analyze_body_owned(&candidate.function, candidate.definition(), control)
41                    .map_err(|error| error.with_context(candidate.error_context.as_str()))?
42                else {
43                    return Ok(None);
44                };
45                candidate.substitute(expression, &parameters, control, self)
46            }
47        }
48    }
49
50    fn analyze_body_owned(
51        &self,
52        function: &SQLUserFunction,
53        definition: &CreateFunction,
54        control: &ProductionControl<'_>,
55    ) -> Result<Option<OwnedInlineScalar>, SQLError> {
56        let Some(OwnedAnalyzedBody {
57            plan,
58            result,
59            parameters,
60        }) = self.analyze_plan_owned(function, definition, control)?
61        else {
62            return Ok(None);
63        };
64        let MutableExecutablePlan::Query(query) = plan else {
65            return Ok(None);
66        };
67        if !query.ctes.is_empty() {
68            return Ok(None);
69        }
70        let RelationalPlan::QueryBlock(block) = &query.root else {
71            return Ok(None);
72        };
73        if !block.is_single_expression() {
74            return Ok(None);
75        }
76        let layout = crate::routines::result_check::sql_function_result_layout_with_control(
77            self.types,
78            definition,
79            Some(&result),
80            control,
81        )?;
82        use crate::routines::result_check::SQLFunctionResultKind;
83        if layout.kind == SQLFunctionResultKind::Tuple {
84            return Ok(None);
85        }
86        let actual = result
87            .column_types()
88            .and_then(|types| types.first())
89            .and_then(Option::as_ref);
90        if layout.kind == SQLFunctionResultKind::Void && actual != Some(&ColumnType::Void) {
91            return Ok(None);
92        }
93        let mut expression = query
94            .select_scalar(QueryScalarSlot::Projection(0), control)?
95            .expect("single-expression projection");
96        if actual != Some(&layout.declared_type) {
97            expression = OwnedScalarExpr::cast(
98                expression,
99                layout.declared_type.catalog_name_with_control(control)?,
100                true,
101                control,
102            )?;
103        }
104        Ok(Some((expression, parameters)))
105    }
106
107    pub(super) fn analyze_plan_owned(
108        &self,
109        function: &SQLUserFunction,
110        definition: &CreateFunction,
111        control: &ProductionControl<'_>,
112    ) -> Result<Option<OwnedAnalyzedBody>, SQLError> {
113        let Some(plan) = self.body_plan_owned(function, control)? else {
114            return Ok(None);
115        };
116        let parameters = crate::routines::body_validation::routine_parameter_values_with_control(
117            self.types, definition, control,
118        )?;
119        let names = matches!(definition.body, FunctionBody::Source(_))
120            .then(|| {
121                crate::routines::body_parameters::sql_body_parameter_scope_with_control(
122                    definition,
123                    &parameters,
124                    control,
125                )
126            })
127            .transpose()?;
128        let mut snapshot = self.catalog.binding_snapshot_with_control(control)?;
129        let namespace = self.catalog.stored_query_namespace_with_control(control)?;
130        snapshot
131            .ctes
132            .retain(|name, _| namespace.transition_relations.contains(name));
133        snapshot.deferred_ctes.clear();
134        snapshot.non_returning_ctes.clear();
135        snapshot.scalar_subqueries = crate::plan::RetainedQueryArena::default();
136        let prepared = {
137            let _placement = if matches!(definition.body, FunctionBody::Statements(_)) {
138                crate::semantics::sets::placement_scope::SetPlacementScope::stored_definition()
139            } else {
140                crate::semantics::sets::placement_scope::SetPlacementScope::compiled_source()
141            };
142            crate::binding::prepare_routine_body_inputs_owned(
143                self.routines,
144                plan,
145                &parameters,
146                snapshot.context_with_control(control)?,
147                self.catalog,
148                names.as_ref(),
149                control,
150            )?
151        };
152        Ok(Some(OwnedAnalyzedBody {
153            plan: prepared.plan,
154            result: prepared.result,
155            parameters,
156        }))
157    }
158
159    fn body_plan_owned(
160        &self,
161        function: &SQLUserFunction,
162        control: &ProductionControl<'_>,
163    ) -> Result<Option<MutableExecutablePlan>, SQLError> {
164        control.check()?;
165        match &function.body {
166            RoutineBody::Bound(body) => match body.as_ref() {
167                CompiledFunctionBody::SQL(plans) if plans.len() == 1 => {
168                    plans[0].copy_for_rewrite(control).map(Some)
169                }
170                _ => Ok(None),
171            },
172            RoutineBody::Source => {
173                let FunctionBody::Source(source) = &function.def.body else {
174                    return Err(SQLError::Internal(
175                        "source routine has no SQL source".into(),
176                    ));
177                };
178                super::super::compilation::with_parser_context(self.parsers, || {
179                    let statements =
180                        crate::compiler::parse_statements_with_control(source, control)?;
181                    let [statement] = statements.as_slice() else {
182                        return Ok(None);
183                    };
184                    let syntax = statement.compile()?;
185                    UnifiedPlan::lower_borrowed_for_rewrite(
186                        &syntax,
187                        &AggregateLookup(self.routines),
188                        control,
189                    )
190                    .map(Some)
191                })
192            }
193        }
194    }
195}
196
197struct AggregateLookup<'a>(&'a dyn crate::routines::RoutineResolution);
198impl crate::plan::AggregateClassifier for AggregateLookup<'_> {
199    fn is_registered_aggregate(&self, name: &str) -> bool {
200        self.0.has_registered_aggregate_function(name)
201    }
202    fn is_registered_aggregate_with_control(
203        &self,
204        name: &str,
205        control: &ProductionControl<'_>,
206    ) -> Result<bool, SQLError> {
207        self.0
208            .has_registered_aggregate_function_with_control(name, control)
209    }
210}