uqa-sql 0.3.5

PostgreSQL-compatible SQL compiler built on libpg_query
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Creation-time relation identities in SQL-standard bodies and argument defaults.

use super::{declaration::RoutineTypeCatalog, lifecycle::relations::is_regclass};
use crate::{
    ast::{ColumnType, CreateFunction, Expr, FunctionBody},
    SQLError,
};
use uqa_core::Value;

pub trait RoutineRegclassCatalog {
    fn resolve_routine_regclass(&self, reference: &str) -> Result<Option<i64>, SQLError>;
}
pub fn bind_routine_regclass_constants(
    types: &dyn RoutineTypeCatalog,
    relations: &dyn RoutineRegclassCatalog,
    definition: &mut CreateFunction,
) -> Result<bool, SQLError> {
    RegclassBinding { types, relations }.bind_routine_constants(definition)
}
struct RegclassBinding<'a> {
    types: &'a dyn RoutineTypeCatalog,
    relations: &'a dyn RoutineRegclassCatalog,
}
impl RegclassBinding<'_> {
    fn regclass_base_type(&self, name: &str) -> bool {
        let Some(mut ty) = self.types.resolve_catalog_column_type(name) else {
            return false;
        };
        while let ColumnType::Domain { base, .. } = ty {
            ty = *base;
        }
        matches!(ty, ColumnType::Regclass)
    }

    fn bind_regclass_literal(&self, expression: &mut Expr) -> Result<bool, SQLError> {
        if let Expr::Func { binding, args, .. } = expression {
            if binding.as_ref().and_then(|binding| binding.dispatch)
                == Some(crate::ast::FunctionDispatch::NamedArgument)
            {
                return args
                    .get_mut(1)
                    .map_or(Ok(false), |argument| self.bind_regclass_literal(argument));
            }
        }
        let Expr::Literal(Value::Str(reference)) = expression else {
            return Ok(false);
        };
        let oid = self
            .relations
            .resolve_routine_regclass(reference)?
            .ok_or_else(|| SQLError::Routine {
                sqlstate: "42P01".into(),
                message: format!("relation \"{reference}\" does not exist"),
            })?;
        *expression = Expr::TypedLiteral {
            value: Value::Int(oid),
            ty: "regclass".into(),
        };
        Ok(true)
    }

    fn bind_regclass_expression(&self, expression: &mut Expr) -> Result<bool, SQLError> {
        match expression {
            Expr::Cast { expr, ty } if is_regclass(ty) => self.bind_regclass_literal(expr),
            Expr::Func {
                name,
                binding,
                args,
                ..
            } if binding.as_ref().is_none_or(|binding| binding.builtin)
                && matches!(
                    name.strip_prefix("pg_catalog.").unwrap_or(name),
                    "nextval" | "currval" | "setval"
                ) =>
            {
                args.first_mut()
                    .map_or(Ok(false), |argument| self.bind_regclass_literal(argument))
            }
            Expr::Func {
                binding: Some(binding),
                args,
                ..
            } => {
                let targets = binding
                    .invocation
                    .as_ref()
                    .map_or(binding.argument_types.as_slice(), |invocation| {
                        invocation.argument_targets.as_slice()
                    });
                let mut changed = false;
                for (argument, target) in args.iter_mut().zip(targets) {
                    if self.regclass_base_type(target) {
                        changed |= self.bind_regclass_literal(argument)?;
                    }
                }
                Ok(changed)
            }
            _ => Ok(false),
        }
    }

    fn bind_routine_constants(&self, definition: &mut CreateFunction) -> Result<bool, SQLError> {
        let mut changed = false;
        for parameter in &mut definition.params {
            if let Some(default) = &mut parameter.default {
                if self.regclass_base_type(&parameter.type_name) {
                    changed |= self.bind_regclass_literal(default)?;
                }
                crate::catalog::stored_ast::visit_stored_expression(default, &mut |expression| {
                    changed |= self.bind_regclass_expression(expression)?;
                    Ok(())
                })?;
            }
        }
        if let FunctionBody::Statements(statements) = &mut definition.body {
            for statement in statements {
                crate::catalog::stored_ast::visit_stored_statement_expressions(
                    statement,
                    &mut |expression| {
                        changed |= self.bind_regclass_expression(expression)?;
                        Ok(())
                    },
                )?;
            }
        }
        Ok(changed)
    }
}