uqa-sql 0.5.3

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

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

//! Rule and trigger predicates shared by live execution and retained metadata inquiries.

use super::{RuleCatalog, StoredRule, TriggerCatalog};
use crate::ast::{RuleEvent, TriggerEvent, TriggerTiming};
use std::collections::BTreeMap;
use uqa_core::RelationIdentity;

fn matching_rules<'a>(
    catalog: &'a RuleCatalog,
    relation: &RelationIdentity,
    event: RuleEvent,
) -> impl Iterator<Item = &'a StoredRule> {
    catalog
        .get(relation)
        .into_iter()
        .flat_map(BTreeMap::values)
        .filter(move |rule| rule.definition.event == event)
}

pub fn rule_definitions(
    catalog: &RuleCatalog,
    relation: &RelationIdentity,
    event: RuleEvent,
) -> Vec<StoredRule> {
    matching_rules(catalog, relation, event).cloned().collect()
}

pub fn active_rules(
    catalog: &RuleCatalog,
    relation: &RelationIdentity,
    event: RuleEvent,
    replica: bool,
) -> Vec<StoredRule> {
    matching_rules(catalog, relation, event)
        .filter(|rule| {
            if replica {
                rule.enabled.fires_in_replica()
            } else {
                rule.enabled.fires_in_origin()
            }
        })
        .cloned()
        .collect()
}

pub fn has_trigger_definition(
    catalog: &TriggerCatalog,
    relation: &RelationIdentity,
    timing: TriggerTiming,
    event: TriggerEvent,
    row: bool,
) -> bool {
    catalog.get(relation).is_some_and(|entries| {
        entries.values().any(|trigger| {
            trigger.definition.timing == timing
                && trigger.definition.row == row
                && trigger.definition.events.contains(&event)
        })
    })
}