1use 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}