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