uqa_sql/routines/declaration/
shells.rs1use crate::{
10 ast::{CreateFunction, FunctionParamMode, FunctionReturns, RoutineColumnTypeReference},
11 routines::{
12 compilation::{RoutineCompilationContext, RoutineParserCatalog},
13 declaration::RoutineTypeCatalog,
14 },
15 SQLError, SQLNotice,
16};
17
18#[derive(Default)]
19pub struct RoutineShellTypes {
20 argument: Option<u32>,
21 result: Option<u32>,
22 output: Option<u32>,
23 outputs: usize,
24}
25
26impl RoutineShellTypes {
27 pub(super) fn argument(
28 &mut self,
29 context: &RoutineCompilationContext<'_>,
30 language: &str,
31 name: &str,
32 reference: Option<&RoutineColumnTypeReference>,
33 mode: FunctionParamMode,
34 ) -> Result<Option<u32>, SQLError> {
35 let oid = resolve(
36 context.types,
37 context.parsers,
38 language,
39 name,
40 reference,
41 false,
42 )?;
43 if self.argument.is_none() {
44 self.argument = oid;
45 }
46 if matches!(
47 mode,
48 FunctionParamMode::Out | FunctionParamMode::InOut | FunctionParamMode::Table
49 ) {
50 self.outputs += 1;
51 self.output = oid;
52 }
53 Ok(oid)
54 }
55
56 pub(super) fn result(
57 &mut self,
58 context: &RoutineCompilationContext<'_>,
59 language: &str,
60 name: &str,
61 reference: Option<&RoutineColumnTypeReference>,
62 ) -> Result<bool, SQLError> {
63 self.result = resolve(
64 context.types,
65 context.parsers,
66 language,
67 name,
68 reference,
69 true,
70 )?;
71 Ok(self.result.is_some())
72 }
73
74 pub fn reject_unsupported(
76 &self,
77 context: &RoutineCompilationContext<'_>,
78 def: &CreateFunction,
79 ) -> Result<(), SQLError> {
80 if self.argument.is_none() && self.result.is_none() {
81 return Ok(());
82 }
83 if let (Some(output), 1, FunctionReturns::Scalar { .. } | FunctionReturns::SetOf { .. }) =
84 (self.output, self.outputs, &def.returns)
85 {
86 if self.result != Some(output) {
87 return Err(super::routine_definition_error(format!(
88 "function result type must be {} because of OUT parameters",
89 context.types.format_type_oid(output)?
90 )));
91 }
92 }
93 super::validate_routine_declaration(def)?;
94 let result = self.result.or_else(|| {
95 (matches!(def.returns, FunctionReturns::None | FunctionReturns::Table)
96 && self.outputs == 1)
97 .then_some(self.output)
98 .flatten()
99 });
100 if let Some((oid, operation)) = result
101 .map(|oid| (oid, "return"))
102 .or_else(|| self.argument.map(|oid| (oid, "accept")))
103 {
104 let name = context.types.format_type_oid(oid)?;
105 return Err(SQLError::Routine {
106 sqlstate: "0A000".into(),
107 message: format!("PL/pgSQL functions cannot {operation} type {name}"),
108 });
109 }
110 Ok(())
111 }
112}
113
114fn resolve(
115 types: &dyn RoutineTypeCatalog,
116 parsers: &dyn RoutineParserCatalog,
117 language: &str,
118 name: &str,
119 reference: Option<&RoutineColumnTypeReference>,
120 result: bool,
121) -> Result<Option<u32>, SQLError> {
122 if reference.is_some() {
124 return Ok(None);
125 }
126 let Some(oid) = types.shell_type_oid(name)? else {
127 return Ok(None);
128 };
129 let parsed = crate::parse_regtype_name(name)?
130 .ok_or_else(|| SQLError::Internal("shell routine type has no name".into()))?;
131 let written = parsed.names.join(".");
132 if language == "sql" {
133 let operation = if result { "return" } else { "accept" };
134 return Err(super::routine_definition_error(format!(
135 "SQL function cannot {operation} shell type {written}"
136 )));
137 }
138 let position = if result { "return" } else { "argument" };
139 parsers.parser_notice(
140 SQLNotice::notice(format!("{position} type {written} is only a shell"))
141 .with_sqlstate("42809"),
142 );
143 types.require_type_oid_usage(oid)?;
144 Ok(Some(oid))
145}
146
147#[cfg(test)]
148mod tests;