uqa-engine 0.5.0

Engine: schema-aware table store, catalog restore, transactions
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

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

//! Bind relation removal to active registries, session locks and existing publication boundaries.
use crate::Engine;
use uqa_execution::schema::removal::entry::{
    DomainRemovalWrite, DropStatementBindings, ForeignServerRemovalWrite, SchemaRemovalWrite,
};
use uqa_execution::schema::removal::{
    RelationRemovalContext, RelationRemovalEvents, RelationRemovalLocks, RelationRemovalPrivileges,
    RelationRemovalTransactions, RelationRemovalViews, RelationRemovalWrite,
};
use uqa_sql::{
    catalog::resolution::RelationResolution, schema::removal::RelationDropCatalog, SQLError,
    SQLResult,
};

impl DropStatementBindings for Engine {
    fn with_foreign_server_removal_write(
        &self,
        write: ForeignServerRemovalWrite<'_>,
    ) -> Result<SQLResult, SQLError> {
        self.with_implicit_definition_transaction(|engine| {
            write(&engine.foreign_server_removal_context())
        })
    }
    fn with_schema_removal_write(
        &self,
        write: SchemaRemovalWrite<'_>,
    ) -> Result<SQLResult, SQLError> {
        self.with_implicit_transaction(|engine| write(&engine.schema_removal_context()))
    }
    fn with_domain_removal_write(
        &self,
        write: DomainRemovalWrite<'_>,
    ) -> Result<SQLResult, SQLError> {
        self.with_implicit_transaction(|engine| write(&engine.domain_removal_context()))
    }
    fn with_relation_removal_inputs(
        &self,
        run: RelationRemovalWrite<'_>,
    ) -> Result<SQLResult, SQLError> {
        run(&self.relation_removal_context())
    }
}

impl Engine {
    pub(crate) fn relation_removal_context(&self) -> RelationRemovalContext<'_> {
        RelationRemovalContext {
            deletion: self,
            catalog: self,
            tables: self.table_removal_context(),
            privileges: self,
            views: self,
            sequences: self,
            identities: self,
            locks: self,
            transactions: self,
            notices: self.query_runtime_view().notices,
            indexes: self.index_removal_context(),
        }
    }
}
impl RelationDropCatalog for Engine {
    fn resolve_relation_kind(&self, name: &str) -> Result<RelationResolution, SQLError> {
        self.resolve_visible_relation_kind(name)
    }
    fn resolve_age_label_relation_name(&self, name: &str) -> Result<Option<String>, SQLError> {
        uqa_execution::catalog::projection::resolve_age_label_relation_name(
            &self.catalog_execution(),
            name,
        )
    }
}
impl RelationRemovalPrivileges for Engine {
    fn ensure_table_drop_authority(&self, table: &str) -> Result<(), SQLError> {
        Engine::ensure_table_drop_authority(self, table)
    }
    fn ensure_foreign_table_drop_authority(&self, table: &str) -> Result<(), SQLError> {
        Engine::ensure_foreign_table_drop_authority(self, table)
    }
}
impl RelationRemovalEvents for Engine {
    fn ensure_no_pending_trigger_events(&self, table: &str, action: &str) -> Result<(), SQLError> {
        Engine::ensure_no_pending_trigger_events(self, table, action)
    }
}
impl RelationRemovalViews for Engine {
    fn lock_dependent_views(&self, names: &[String]) -> Result<(), SQLError> {
        uqa_execution::schema::view_removal::locking::lock_dependent_views(self, self, names)
            .map(|_| ())
    }
    fn ensure_view_drop_authority(&self, name: &str) -> Result<(), SQLError> {
        uqa_execution::schema::view_removal::ensure_view_drop_authorities(
            &self.view_removal_context(),
            &[name.to_string()],
        )
    }
}

impl RelationRemovalLocks for Engine {
    fn lock_exclusive(&self, table: &str) -> Result<(), SQLError> {
        self.lock_relation(table, crate::row_locks::RelationLockMode::AccessExclusive)
    }
}
impl RelationRemovalTransactions for Engine {
    fn with_relation_write(&self, write: RelationRemovalWrite<'_>) -> Result<SQLResult, SQLError> {
        self.with_implicit_definition_transaction(|engine| {
            write(&engine.relation_removal_context())
        })
    }
}