Skip to main content

uqa_sql/routines/declaration/
shells.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Undefined type notices precede language validation without creating a callable value type.
8
9use 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    /// PL/pgSQL validates return and argument pseudotypes even with `check_function_bodies` disabled.
75    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    // A column already has a value type; its structured reference is resolved by declaration binding.
123    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;