uqa-sql 0.3.6

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

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

//! Static EXECUTE argument shape, assignment compatibility, and safe constant evaluation.

use super::error;
use crate::{ast::FunctionVolatility, plan::ExpressionPlan, ColumnType, SQLError, ScalarExpr};

pub struct ArgumentValidationContext<'a> {
    pub aggregates: &'a dyn crate::plan::AggregateClassifier,
    pub volatility: &'a dyn crate::semantics::volatility::VolatilityCatalog,
    pub cast_type: &'a dyn Fn(&str) -> Option<ColumnType>,
}

pub fn validate_assignment_type(
    index: usize,
    source: &ColumnType,
    target: &ColumnType,
) -> Result<(), SQLError> {
    if !crate::assignment_type_compatible(source, target) {
        return Err(error(
            "42804",
            format!(
                "parameter ${} of type {} cannot be coerced to the expected type {}",
                index + 1,
                source.sql_name(),
                target.sql_name()
            ),
        ));
    }
    Ok(())
}

pub fn parameter_base_type(mut ty: &ColumnType) -> &ColumnType {
    while let ColumnType::Domain { base, .. } = ty {
        ty = base;
    }
    ty
}

pub fn contains_domain(ty: &ColumnType) -> bool {
    match ty {
        ColumnType::Domain { .. } => true,
        ColumnType::Array(element) => contains_domain(element),
        _ => false,
    }
}

pub fn immutable_argument(
    context: &ArgumentValidationContext<'_>,
    expression: &ScalarExpr,
) -> bool {
    let mut immutable = true;
    expression.visit(&mut |expression| match expression {
        ScalarExpr::Param(_)
        | ScalarExpr::Column(_)
        | ScalarExpr::QualifiedColumn { .. }
        | ScalarExpr::InternalColumn(_)
        | ScalarExpr::Position(_) => immutable = false,
        ScalarExpr::Func {
            name,
            binding,
            args,
            ..
        } => {
            immutable &= crate::semantics::volatility::function_volatility_with_binding(
                context.volatility,
                name,
                binding.as_ref(),
                args.len(),
            ) == FunctionVolatility::Immutable;
        }
        ScalarExpr::Cast { ty, .. } => {
            immutable &= !(context.cast_type)(ty)
                .as_ref()
                .is_some_and(contains_domain);
        }
        _ => {}
    });
    immutable
}

pub fn validate_argument(
    aggregates: &dyn crate::plan::AggregateClassifier,
    argument: &ExpressionPlan,
) -> Result<(), SQLError> {
    if !argument.subqueries.is_empty() {
        return Err(error("0A000", "cannot use subquery in EXECUTE parameter"));
    }
    if argument.scalar.contains_window() {
        return Err(error(
            "42P20",
            "window functions are not allowed in EXECUTE parameters",
        ));
    }
    if crate::semantics::aggregates::contains_aggregate(aggregates, &argument.scalar) {
        return Err(error(
            "42803",
            "aggregate functions are not allowed in EXECUTE parameters",
        ));
    }
    Ok(())
}