uqa-core 0.3.6

Document sets, finite-support relations, posting storage, and value types for UQA
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

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

//! Durable access-control metadata for table-shaped relations.

use serde::{Deserialize, Serialize};

/// Grantable privileges carried by one table-shaped relation ACL path.
#[expect(
    clippy::struct_excessive_bools,
    reason = "models PostgreSQL's independently grantable table-shaped relation privileges"
)]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct TablePrivileges {
    #[serde(default)]
    pub select: bool,
    #[serde(default)]
    pub insert: bool,
    #[serde(default)]
    pub update: bool,
    #[serde(default)]
    pub delete: bool,
    #[serde(default)]
    pub truncate: bool,
    #[serde(default)]
    pub references: bool,
    #[serde(default)]
    pub trigger: bool,
    #[serde(default)]
    pub maintain: bool,
}

impl TablePrivileges {
    pub const ALL: Self = Self {
        select: true,
        insert: true,
        update: true,
        delete: true,
        truncate: true,
        references: true,
        trigger: true,
        maintain: true,
    };

    #[must_use]
    pub const fn is_empty(self) -> bool {
        !self.select
            && !self.insert
            && !self.update
            && !self.delete
            && !self.truncate
            && !self.references
            && !self.trigger
            && !self.maintain
    }

    #[must_use]
    pub const fn intersects(self, other: Self) -> bool {
        self.select && other.select
            || self.insert && other.insert
            || self.update && other.update
            || self.delete && other.delete
            || self.truncate && other.truncate
            || self.references && other.references
            || self.trigger && other.trigger
            || self.maintain && other.maintain
    }

    pub fn insert(&mut self, other: Self) {
        self.select |= other.select;
        self.insert |= other.insert;
        self.update |= other.update;
        self.delete |= other.delete;
        self.truncate |= other.truncate;
        self.references |= other.references;
        self.trigger |= other.trigger;
        self.maintain |= other.maintain;
    }

    pub fn remove(&mut self, other: Self) {
        self.select &= !other.select;
        self.insert &= !other.insert;
        self.update &= !other.update;
        self.delete &= !other.delete;
        self.truncate &= !other.truncate;
        self.references &= !other.references;
        self.trigger &= !other.trigger;
        self.maintain &= !other.maintain;
    }
}

/// One explicit table-shaped relation ACL path. Legacy entries without an explicit grantor originate from the relation owner.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct TableAclEntry {
    pub role: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub grantor: Option<String>,
    #[serde(default)]
    pub privileges: TablePrivileges,
    #[serde(default)]
    pub grant_options: TablePrivileges,
}