uqa-sql 0.5.0

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

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

use super::*;
use crate::ast::Statement;

fn declaration(sql: &str) -> crate::ast::CreateForeignWrapper {
    let Statement::CreateForeignWrapper(definition) = crate::compile(sql).unwrap().remove(0) else {
        panic!("wrapper declaration");
    };
    definition
}

#[test]
fn compilation_preserves_clause_order_and_defers_qualified_name_errors() {
    let definition = declaration("CREATE FOREIGN DATA WRAPPER w VALIDATOR a.b.c.d NO HANDLER NO VALIDATOR OPTIONS (z 'last',a 'first',z 'again')");
    assert_eq!(
        definition.functions,
        vec![
            ForeignWrapperFunctionOption::Validator(Some(vec![
                "a".into(),
                "b".into(),
                "c".into(),
                "d".into()
            ])),
            ForeignWrapperFunctionOption::Handler(None),
            ForeignWrapperFunctionOption::Validator(None),
        ]
    );
    assert_eq!(
        definition.options,
        [
            ("z".into(), "last".into()),
            ("a".into(), "first".into()),
            ("z".into(), "again".into())
        ]
    );
    let error = bind_functions(&definition.functions, |_, _, _| {
        panic!("invalid name precedes lookup")
    })
    .err()
    .unwrap();
    assert_eq!(error.sqlstate(), Some("42601"));
    assert_eq!(
        error.to_string(),
        "improper qualified name (too many dotted names): a.b.c.d"
    );
}

#[test]
fn duplicate_function_clauses_are_checked_after_earlier_lookups() {
    let definition = declaration("CREATE FOREIGN DATA WRAPPER w HANDLER absent NO HANDLER");
    let mut visited = Vec::new();
    let error = bind_functions(&definition.functions, |name, args, _| {
        visited.push(name.to_owned());
        assert!(args.is_empty());
        Err(SQLError::Routine {
            sqlstate: "42883".into(),
            message: "missing handler".into(),
        })
    })
    .err()
    .unwrap();
    assert_eq!(error.sqlstate(), Some("42883"));
    assert_eq!(visited, ["absent"]);
    let definition = declaration("CREATE FOREIGN DATA WRAPPER w NO HANDLER HANDLER absent");
    assert_eq!(
        bind_functions(&definition.functions, |_, _, _| panic!(
            "duplicate before lookup"
        ))
        .err()
        .unwrap()
        .sqlstate(),
        Some("42601")
    );
}

#[test]
fn validator_requests_exact_signature_and_ignores_return_type() {
    let definition = declaration("CREATE FOREIGN DATA WRAPPER w VALIDATOR \"Mixed.Name\"");
    let functions = bind_functions(&definition.functions, |name, args, display| {
        assert_eq!(name, "\"Mixed.Name\"");
        assert_eq!(args, [1009, 26]);
        assert_eq!(display, ["text[]", "oid"]);
        Ok(ForeignWrapperRoutine {
            oid: 20001,
            return_oid: 23,
            binding: FunctionBinding {
                object_id: Some([1; 16]),
                name: name.into(),
                argument_types: display.to_vec(),
                builtin: false,
                dispatch: None,
                invocation: None,
                resolution_error: None,
            },
        })
    })
    .unwrap();
    assert_eq!(functions.validator.unwrap().return_oid, 23);
}

#[test]
fn option_validation_preserves_written_order() {
    let options = vec![("z".into(), "last".into()), ("a".into(), "first".into())];
    assert_eq!(creation_options(&options).unwrap(), options);
    assert_eq!(
        creation_options(&[("a".into(), "1".into()), ("a".into(), "2".into())])
            .unwrap_err()
            .sqlstate(),
        Some("42710")
    );
    assert_eq!(
        creation_options(&[("a=b".into(), "1".into())])
            .unwrap_err()
            .sqlstate(),
        Some("22023")
    );
}