uqa-execution 0.4.6

Volcano physical operators with row-batch pipelines
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

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

use super::*;

fn alteration() -> AlterRoleStmt {
    AlterRoleStmt {
        name: "target".into(),
        attributes: BTreeMap::from([(RoleAttribute::Login, true)]),
        connection_limit: None,
        membership_action: None,
        members: Vec::new(),
    }
}

#[test]
fn alteration_does_not_retry_a_committed_definition_even_when_attributes_match() {
    for change_attribute in [false, true] {
        let catalog = Catalog::new();
        catalog.role("target", &[]);
        let mut committed = catalog.roles.borrow().clone();
        let target = committed.get_mut("target").unwrap();
        target.advance_revision().unwrap();
        if change_attribute {
            target.attributes.insert(RoleAttribute::Login);
        }
        catalog
            .refreshed_roles
            .borrow_mut()
            .push_back(committed.clone());
        assert_eq!(
            alter_role(&catalog.context(), &alteration())
                .unwrap_err()
                .sqlstate(),
            Some("XX000")
        );
        assert_eq!(*catalog.roles.borrow(), committed);
        assert_eq!(catalog.epoch.get(), 0);
        assert!(!catalog
            .events
            .borrow()
            .iter()
            .any(|event| event == "persist roles"));
        catalog.released();
    }
}

#[test]
fn tuple_publication_preserves_an_unrelated_definition_committed_during_the_wait() {
    let catalog = Catalog::new();
    catalog.role("target", &[]);
    catalog.role("peer", &[]);
    let mut committed = catalog.roles.borrow().clone();
    let peer = committed.get_mut("peer").unwrap();
    peer.attributes.insert(RoleAttribute::Login);
    peer.advance_revision().unwrap();
    catalog
        .refreshed_roles
        .borrow_mut()
        .push_back(committed.clone());
    alter_role(&catalog.context(), &alteration()).unwrap();
    let roles = catalog.roles.borrow();
    assert_eq!(roles["peer"], committed["peer"]);
    assert!(roles["target"].has(RoleAttribute::Login));
    assert_eq!(roles["target"].revision, 2);
}

#[test]
fn denied_alteration_never_waits_for_a_definition_tuple() {
    let catalog = Catalog::new();
    catalog.role("target", &[]);
    catalog.role("actor", &[RoleAttribute::CreateRole]);
    *catalog.current.borrow_mut() = "actor".into();
    assert_eq!(
        alter_role(&catalog.context(), &alteration())
            .unwrap_err()
            .sqlstate(),
        Some("42501")
    );
    assert!(catalog.tuple_locks.borrow().is_empty());
    assert!(catalog.catalog_locks.borrow().is_empty());
    assert_eq!(catalog.epoch.get(), 0);
}

#[test]
fn deletion_revalidates_the_tuple_selected_after_dependency_exclusion() {
    let catalog = Catalog::new();
    catalog.role("target", &[]);
    let original = catalog.roles.borrow().clone();
    let mut committed = original.clone();
    committed
        .get_mut("target")
        .unwrap()
        .advance_revision()
        .unwrap();
    catalog
        .refreshed_roles
        .borrow_mut()
        .extend([original, committed.clone()]);
    let statement = DropRoleStmt {
        names: vec!["target".into()],
        if_exists: false,
    };
    assert_eq!(
        drop_roles(&catalog.context(), &statement)
            .unwrap_err()
            .sqlstate(),
        Some("XX000")
    );
    assert_eq!(*catalog.roles.borrow(), committed);
    assert_eq!(catalog.epoch.get(), 0);
    assert!(!catalog
        .events
        .borrow()
        .iter()
        .any(|event| event == "persist roles"));
    catalog.released();
}