uqa-sql 0.5.4

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

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

//! Validate a containing call after its original children have been analyzed.

use super::functions::{
    validate_ordered_function, validate_scalar_function, validate_window_function,
    ScalarFunctionValidation,
};
use crate::{
    routines::RoutineResolution, schema::ScalarTypeSchema, FunctionTypeResolver, SQLError,
    SQLParam, ScalarExpr,
};

pub(in crate::binding) fn validate_call(
    routines: &dyn RoutineResolution,
    expression: &ScalarExpr,
    schema: &dyn ScalarTypeSchema,
    params: &[SQLParam],
    resolver: &dyn FunctionTypeResolver,
) -> Result<(), SQLError> {
    match expression {
        ScalarExpr::Func {
            order_syntax,
            name,
            binding,
            args,
            distinct,
            order_by,
            filter,
        } => {
            let within_group = super::super::ordered_calls::uses_ordered_arguments(
                *order_syntax,
                name,
                binding.as_ref(),
                order_by.len(),
            );
            if within_group || super::super::ordered_calls::is_ordered_set(name) {
                return validate_ordered_function(
                    routines,
                    ScalarFunctionValidation {
                        name,
                        binding: binding.as_ref(),
                        args,
                        order_by,
                        expression,
                        schema,
                        params,
                        resolver,
                    },
                    within_group,
                    *distinct,
                    filter.is_some(),
                );
            }
            validate_scalar_function(
                routines,
                ScalarFunctionValidation {
                    name,
                    binding: binding.as_ref(),
                    args,
                    order_by,
                    expression,
                    schema,
                    params,
                    resolver,
                },
            )?;
            if crate::semantics::is_builtin_aggregate(expression)
                || routines.has_registered_aggregate_function(name)
            {
                return Ok(());
            }
            // `ParseFuncOrColumn` names the first aggregate modifier an ordinary function cannot take.
            let modifier = if *distinct {
                Some("DISTINCT")
            } else if !order_by.is_empty() {
                Some("ORDER BY")
            } else if filter.is_some() {
                Some("FILTER")
            } else {
                None
            };
            modifier.map_or(Ok(()), |modifier| {
                Err(SQLError::Routine {
                    sqlstate: "42809".into(),
                    message: format!(
                        "{modifier} specified, but {name} is not an aggregate function"
                    ),
                })
            })
        }
        ScalarExpr::WindowCall {
            name,
            args,
            filter,
            modifiers,
            ..
        } => validate_window_function(
            routines,
            name,
            (args, filter.is_some(), *modifiers),
            schema,
            params,
            resolver,
        ),
        _ => Err(SQLError::Internal(
            "call validation requires a function".into(),
        )),
    }
}