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        self.session
39            .routine_bodies
40            .plpgsql_body(function, definition, relation, |definition| {
41                uqa_execution::routines::invocation::bodies::compile_session_body(
42                    self,
43                    &self.routine_definition_context().compilation.analysis,
44                    definition,
45                )
46            })
47    }
48    fn depth_limit(&self) -> usize {
49        self.sql_function_depth_limit()
50    }
51    fn state_guard(
52        &self,
53        configured: bool,
54        security_definer: bool,
55    ) -> Box<dyn RoutineInvocationState + '_> {
56        Box::new(self.routine_invocation_state_guard(configured, security_definer))
57    }
58    fn set_current_user(&self, user: uqa_core::catalog_role::RoleIdentity) -> Result<(), SQLError> {
59        let RoleReference::Bound(role) =
60            RoleReference::from_identity(user, &self.durable.roles.read())?
61        else {
62            unreachable!("identity lookup returns a bound role")
63        };
64        self.session.state.write().authorization.set_effective(role);
65        Ok(())
66    }
67    fn set_configured_parameter(&self, name: &str, value: &str) -> Result<(), SQLError> {
68        Engine::set_configured_parameter(self, name, value)
69    }
70    fn plpgsql_variable_conflict(&self) -> uqa_sql::plpgsql::VariableConflict {
71        self.load_language("plpgsql");
72        uqa_sql::plpgsql::VariableConflict::from_name(
73            &self.session.setting("plpgsql.variable_conflict"),
74        )
75        .unwrap_or_default()
76    }
77}
78impl Engine {
79    pub(crate) fn routine_invocation_context(&self) -> RoutineInvocationContext<'_> {
80        RoutineInvocationContext {
81            runtime: self.routine_execution_context(),
82            session: self,
83            lookup: self,
84            overloads: RoutineOverloadContext { catalog: self },
85            types: self,
86            authority: self,
87        }
88    }
89    pub(crate) fn anonymous_block_context(&self) -> AnonymousBlockContext<'_> {
90        AnonymousBlockContext {
91            runtime: self.routine_execution_context(),
92            session: self,
93            types: self,
94            parsers: self,
95        }
96    }
97}
98type AnonymousRecordDefinition<'a> = (&'a [String], &'a [String]);
99pub(crate) fn call_user_scalar_function(
100    engine: &Engine,
101    name: &str,
102    args: &[(Option<String>, Value)],
103) -> Option<Result<Value, SQLError>> {
104    invocation::call_user_scalar_function(&engine.routine_invocation_context(), name, args)
105}
106pub(crate) fn call_bound_user_scalar_function(
107    engine: &Engine,
108    binding: &FunctionBinding,
109    args: &[(Option<String>, Value)],
110) -> Option<Result<Value, SQLError>> {
111    invocation::call_bound_user_scalar_function(&engine.routine_invocation_context(), binding, args)
112}
113pub(crate) fn resolved_user_function_returns_set(
114    engine: &Engine,
115    name: &str,
116    args: &[(Option<String>, Value)],
117) -> Option<Result<bool, SQLError>> {
118    invocation::resolved_user_function_returns_set(&engine.routine_invocation_context(), name, args)
119}
120pub(crate) fn resolved_bound_user_function_returns_set(
121    engine: &Engine,
122    binding: &FunctionBinding,
123    args: &[(Option<String>, Value)],
124) -> Option<Result<bool, SQLError>> {
125    invocation::resolved_bound_user_function_returns_set(
126        &engine.routine_invocation_context(),
127        binding,
128        args,
129    )
130}
131pub(crate) fn call_user_table_function(
132    engine: &Engine,
133    name: &str,
134    args: &[(Option<String>, Value)],
135    record_definition: Option<AnonymousRecordDefinition<'_>>,
136) -> Option<Result<SQLTableFunctionResult, SQLError>> {
137    invocation::call_user_table_function(
138        &engine.routine_invocation_context(),
139        name,
140        args,
141        record_definition,
142    )
143}
144pub(crate) fn call_bound_user_table_function(
145    engine: &Engine,
146    binding: &FunctionBinding,
147    args: &[(Option<String>, Value)],
148    record_definition: Option<AnonymousRecordDefinition<'_>>,
149) -> Option<Result<SQLTableFunctionResult, SQLError>> {
150    invocation::call_bound_user_table_function(
151        &engine.routine_invocation_context(),
152        binding,
153        args,
154        record_definition,
155    )
156}
157pub(crate) fn execute_trigger_routine(
158    engine: &Engine,
159    function: &SQLUserFunction,
160    context: &TriggerRoutineContext,
161) -> Result<Value, SQLError> {
162    invocation::execute_trigger_routine(&engine.routine_invocation_context(), function, context)
163}