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

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

//! Candidate event catalogs and constraint identities for relation and dependency removal.
use super::{RuleCatalog, TriggerCatalog};
use crate::catalog::constraints::ConstraintIdentity;
use uqa_core::RelationIdentity;
pub struct RemovedRelationEvents {
    pub triggers: TriggerCatalog,
    pub rules: RuleCatalog,
    pub constraints: Vec<ConstraintIdentity>,
}
pub fn removed_relation_events(
    triggers: &TriggerCatalog,
    rules: &RuleCatalog,
    relation: &RelationIdentity,
) -> Result<Option<RemovedRelationEvents>, String> {
    let qualified = relation.qualified_name();
    let referenced_by_trigger = triggers.values().any(|entries| {
        entries.values().any(|trigger| {
            trigger.definition.referenced_table.as_deref() == Some(qualified.as_str())
        })
    });
    if !triggers.contains_key(relation) && !rules.contains_key(relation) && !referenced_by_trigger {
        return Ok(None);
    }
    let mut next_triggers = triggers.clone();
    let mut next_rules = rules.clone();
    let mut removed_constraint_identities = Vec::new();
    for (trigger_relation, entries) in triggers {
        for trigger in entries.values() {
            if trigger.definition.constraint
                && (trigger_relation == relation
                    || trigger.definition.referenced_table.as_deref() == Some(qualified.as_str()))
            {
                removed_constraint_identities.push(trigger.constraint_identity().map_err(
                    |error| format!("resolve dropped constraint-trigger identity: {error}"),
                )?);
            }
        }
    }
    next_triggers.remove(relation);
    for entries in next_triggers.values_mut() {
        entries.retain(|_, trigger| {
            trigger.definition.referenced_table.as_deref() != Some(qualified.as_str())
        });
    }
    next_triggers.retain(|_, entries| !entries.is_empty());
    next_rules.remove(relation);

    Ok(Some(RemovedRelationEvents {
        triggers: next_triggers,
        rules: next_rules,
        constraints: removed_constraint_identities,
    }))
}