Skip to main content

uqa_engine/capabilities/
routine_invocation.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Compose routine invocation with the active interpreter, catalog, and retained session state.
8use crate::{Engine, SQLTableFunctionResult};
9use uqa_core::Value;
10use uqa_execution::routines::{
11    invocation::{
12        self,
13        context::{
14            AnonymousBlockContext, RoutineInvocationContext, RoutineInvocationSession,
15            RoutineInvocationState,
16        },
17    },
18    TriggerRoutineContext,
19};
20use uqa_sql::catalog::roles::RoleReference;
21use uqa_sql::{
22    ast::FunctionBinding,
23    routines::{resolution::RoutineOverloadContext, SQLUserFunction},
24    SQLError,
25};
26impl RoutineInvocationState for crate::roles::RoutineSessionStateGuard<'_> {
27    fn finish(&mut self) {
28        self.finish();
29    }
30}
31impl RoutineInvocationSession for Engine {
32    fn plpgsql_body(
33        &self,
34        function: &SQLUserFunction,
35        definition: &uqa_sql::ast::CreateFunction,
36        relation: Option<i64>,
37    ) -> Result<std::sync::Arc<uqa_sql::routines::CompiledFunctionBody>, SQLError> {
38        let owner = uqa_sql::plan::ExecutablePlanOptimizer::planning_control(self)?;
39        self.session.routine_bodies.plpgsql_body(
40            function,
41            definition,
42            relation,
43            &owner.control(),
44            |definition| {
45                uqa_execution::routines::invocation::bodies::compile_session_body(
46                    self,
47                    &self.routine_definition_context().compilation.analysis,
48                    definition,
49                )
50            },
51        )
52    }
53    fn depth_limit(&self) -> usize {
54        self.sql_function_depth_limit()
55    }
56    fn state_guard(
57        &self,
58        configured: bool,
59        security_definer: bool,
60    ) -> Box<dyn RoutineInvocationState + '_> {
61        Box::new(self.routine_invocation_state_guard(configured, security_definer))
62    }
63    fn set_current_user(&self, user: uqa_core::catalog_role::RoleIdentity) -> Result<(), SQLError> {
64        let RoleReference::Bound(role) =
65            RoleReference::from_identity(user, &self.durable.roles.read())?
66        else {
67            unreachable!("identity lookup returns a bound role")
68        };
69        self.session.state.write().authorization.set_effective(role);
70        Ok(())
71    }
72    fn set_configured_parameter(&self, name: &str, value: &str) -> Result<(), SQLError> {
73        Engine::set_configured_parameter(self, name, value)
74    }
75    fn plpgsql_variable_conflict(&self) -> uqa_sql::plpgsql::VariableConflict {
76        self.load_language("plpgsql");
77        uqa_sql::plpgsql::VariableConflict::from_name(
78            &self.session.setting("plpgsql.variable_conflict"),
79        )
80        .unwrap_or_default()
81    }
82}
83impl Engine {
84    pub(crate) fn routine_invocation_context(&self) -> RoutineInvocationContext<'_> {
85        RoutineInvocationContext {
86            runtime: self.routine_execution_context(),
87            session: self,
88            lookup: self,
89            overloads: RoutineOverloadContext { catalog: self },
90            types: self,
91            authority: self,
92        }
93    }
94    pub(crate) fn anonymous_block_context(&self) -> AnonymousBlockContext<'_> {
95        AnonymousBlockContext {
96            runtime: self.routine_execution_context(),
97            session: self,
98            types: self,
99            parsers: self,
100        }
101    }
102}
103type AnonymousRecordDefinition<'a> = (&'a [String], &'a [String]);
104pub(crate) fn call_user_scalar_function(
105    engine: &Engine,
106    name: &str,
107    args: &[(Option<String>, Value)],
108) -> Option<Result<Value, SQLError>> {
109    invocation::call_user_scalar_function(&engine.routine_invocation_context(), name, args)
110}
111pub(crate) fn call_bound_user_scalar_function(
112    engine: &Engine,
113    binding: &FunctionBinding,
114    args: &[(Option<String>, Value)],
115) -> Option<Result<Value, SQLError>> {
116    invocation::call_bound_user_scalar_function(&engine.routine_invocation_context(), binding, args)
117}
118pub(crate) fn resolved_user_function_returns_set(
119    engine: &Engine,
120    name: &str,
121    args: &[(Option<String>, Value)],
122) -> Option<Result<bool, SQLError>> {
123    invocation::resolved_user_function_returns_set(&engine.routine_invocation_context(), name, args)
124}
125pub(crate) fn resolved_bound_user_function_returns_set(
126    engine: &Engine,
127    binding: &FunctionBinding,
128    args: &[(Option<String>, Value)],
129) -> Option<Result<bool, SQLError>> {
130    invocation::resolved_bound_user_function_returns_set(
131        &engine.routine_invocation_context(),
132        binding,
133        args,
134    )
135}
136pub(crate) fn call_user_table_function(
137    engine: &Engine,
138    name: &str,
139    args: &[(Option<String>, Value)],
140    record_definition: Option<AnonymousRecordDefinition<'_>>,
141) -> Option<Result<SQLTableFunctionResult, SQLError>> {
142    invocation::call_user_table_function(
143        &engine.routine_invocation_context(),
144        name,
145        args,
146        record_definition,
147    )
148}
149pub(crate) fn call_bound_user_table_function(
150    engine: &Engine,
151    binding: &FunctionBinding,
152    args: &[(Option<String>, Value)],
153    record_definition: Option<AnonymousRecordDefinition<'_>>,
154) -> Option<Result<SQLTableFunctionResult, SQLError>> {
155    invocation::call_bound_user_table_function(
156        &engine.routine_invocation_context(),
157        binding,
158        args,
159        record_definition,
160    )
161}
162pub(crate) fn execute_trigger_routine(
163    engine: &Engine,
164    function: &SQLUserFunction,
165    context: &TriggerRoutineContext,
166) -> Result<Value, SQLError> {
167    invocation::execute_trigger_routine(&engine.routine_invocation_context(), function, context)
168}