uqa-sql 0.5.2

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

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

//! Caller-defined record columns retain the routine's original result semantics.

use super::{
    validate_sql_function_record, ColumnType, RoutineTypeCatalog, SQLError,
    SQLFunctionResultColumn, SQLFunctionResultKind,
};

/// SQL target lists assign each column; a whole SQL or procedural record keeps its producer's field identities.
pub fn validate_anonymous_record_result(
    types: &dyn RoutineTypeCatalog,
    source: &[Option<ColumnType>],
    target: &[SQLFunctionResultColumn],
    sql_kind: Option<SQLFunctionResultKind>,
) -> Result<(), SQLError> {
    if sql_kind == Some(SQLFunctionResultKind::Value) {
        return validate_sql_function_record(
            types,
            source,
            &target
                .iter()
                .map(|column| column.ty.clone())
                .collect::<Vec<_>>(),
        );
    }
    let tuple = sql_kind == Some(SQLFunctionResultKind::Tuple);
    if source.len() != target.len() {
        let detail = if tuple {
            format!(
                "Final statement returns too {} columns.",
                if source.len() < target.len() {
                    "few"
                } else {
                    "many"
                }
            )
        } else {
            format!(
                "Number of returned columns ({}) does not match expected column count ({}).",
                source.len(),
                target.len()
            )
        };
        return Err(mismatch(tuple, detail));
    }
    for (index, (source, target)) in source.iter().zip(target).enumerate() {
        if tuple
            && source
                .as_ref()
                .is_none_or(|source| crate::assignment_type_compatible(source, &target.ty))
        {
            continue;
        }
        if !tuple
            && source
                .as_ref()
                .is_some_and(|source| same_identity(source, &target.ty))
        {
            continue;
        }
        let source = source
            .as_ref()
            .map_or_else(|| Ok("unknown".into()), |source| types.format_type(source))?;
        let expected = types.format_type(&target.ty)?;
        let detail = if tuple {
            format!(
                "Final statement returns {source} instead of {expected} at column {}.",
                index + 1
            )
        } else {
            format!("Returned type {source} does not match expected type {expected} in column \"{}\" (position {}).", target.name, index + 1)
        };
        return Err(mismatch(tuple, detail));
    }
    Ok(())
}

fn same_identity(source: &ColumnType, target: &ColumnType) -> bool {
    use crate::catalog::type_metadata::{pg_type_modifier, pg_type_oid};
    pg_type_oid(source) == pg_type_oid(target)
        && (pg_type_modifier(target) < 0 || pg_type_modifier(source) == pg_type_modifier(target))
}

fn mismatch(tuple: bool, detail: String) -> SQLError {
    SQLError::Diagnostic {
        sqlstate: if tuple { "42P13" } else { "42804" }.into(),
        message: if tuple {
            "return type mismatch in function declared to return record"
        } else {
            "returned record type does not match expected record type"
        }
        .into(),
        detail: Some(detail),
        hint: None,
    }
}