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
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
135

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

use super::*;

fn roles() -> BTreeMap<String, RoleDefinition> {
    BTreeMap::from([("uqa".into(), RoleDefinition::bootstrap())])
}

fn custom() -> ForeignWrapperDefinition {
    ForeignWrapperDefinition {
        name: "custom".into(),
        identity: ForeignWrapperReference {
            oid: 16_384,
            object_id: [1; 16],
        },
        owner: RoleIdentity::BOOTSTRAP,
        handler: ForeignWrapperHandler::None,
        validator: None,
        options: vec![("z".into(), "first".into()), ("a".into(), "second".into())],
    }
}

#[test]
fn native_implementations_and_ordered_options_have_durable_identities() {
    let mut wrappers = native_wrappers();
    wrappers.insert("custom".into(), custom());
    validate_wrappers(&wrappers, &roles()).unwrap();
    let serialized = serde_json::to_string(&wrappers).unwrap();
    assert_eq!(
        serde_json::from_str::<ForeignWrappers>(&serialized).unwrap(),
        wrappers
    );
    for native in [
        NativeForeignWrapper::Memory,
        NativeForeignWrapper::DuckDB,
        NativeForeignWrapper::Arrow,
    ] {
        let wrapper = bound_wrapper(&wrappers, native.name(), native.reference()).unwrap();
        assert_eq!(wrapper.handler, ForeignWrapperHandler::Native(native));
    }
    assert_eq!(wrappers["custom"].options[0].0, "z");
}

#[test]
fn a_recreated_name_never_retargets_a_stored_wrapper_reference() {
    let original = custom();
    let mut replacement = original.clone();
    replacement.identity.object_id = [2; 16];
    let wrappers = BTreeMap::from([("custom".into(), replacement)]);
    assert!(bound_wrapper(&wrappers, "custom", original.identity).is_err());
    assert!(bound_wrapper(&wrappers, "missing", original.identity).is_err());
}

#[test]
fn restoration_rejects_aliases_invalid_options_and_replaced_owners() {
    let original = custom();
    let mut variants = Vec::new();
    let mut bad = original.clone();
    bad.identity.oid = 1;
    variants.push(bad);
    let mut bad = original.clone();
    bad.identity.object_id = [0; 16];
    variants.push(bad);
    let mut bad = original.clone();
    bad.owner.object_id = [7; 16];
    variants.push(bad);
    let mut bad = original.clone();
    bad.options.push(("a".into(), "duplicate".into()));
    variants.push(bad);
    let mut bad = original.clone();
    bad.options.push(("a=b".into(), "ambiguous".into()));
    variants.push(bad);
    for bad in variants {
        assert!(validate_wrappers(&BTreeMap::from([("custom".into(), bad)]), &roles()).is_err());
    }
    let mut alias = original.clone();
    alias.name = "alias".into();
    assert!(validate_wrappers(
        &BTreeMap::from([("custom".into(), original), ("alias".into(), alias)]),
        &roles()
    )
    .is_err());
    let mut native = native_wrappers();
    native.get_mut("memory_fdw").unwrap().identity.object_id[0] ^= 1;
    assert!(validate_wrappers(&native, &roles()).is_err());
}

#[test]
fn missing_functions_are_retained_but_live_oid_conflicts_are_corruption() {
    let crate::ast::Statement::CreateFunction(mut definition) = crate::compile(
        "CREATE FUNCTION callback(text[],oid) RETURNS integer LANGUAGE SQL RETURN 1",
    )
    .unwrap()
    .remove(0) else {
        panic!("function");
    };
    definition.object_id = Some([5; 16]);
    definition.catalog_oid = Some(20_000);
    let binding = crate::ast::FunctionBinding {
        name: definition.name.clone(),
        object_id: definition.object_id,
        argument_types: crate::routines::routine_signature_types(&definition),
        builtin: false,
        dispatch: None,
        invocation: None,
        resolution_error: None,
    };
    let routines = BTreeMap::from([(
        definition.name.clone(),
        vec![std::sync::Arc::new(crate::routines::SQLUserFunction::new(
            *definition,
            crate::routines::RoutineBody::Source,
        ))],
    )]);
    let mut wrapper = custom();
    wrapper.validator = Some(ForeignWrapperFunction {
        oid: 20_000,
        binding,
    });
    let mut wrappers = BTreeMap::from([("custom".into(), wrapper)]);
    validate_functions(&wrappers, &routines).unwrap();
    validate_functions(&wrappers, &BTreeMap::new()).unwrap();
    wrappers
        .get_mut("custom")
        .unwrap()
        .validator
        .as_mut()
        .unwrap()
        .oid += 1;
    assert!(validate_functions(&wrappers, &routines).is_err());
}