Skip to main content

uqa_sql/catalog/events/
persistence.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Durable event-catalog envelopes and persistence selection over live relation metadata.
8use super::{RuleCatalog, StoredRule, StoredTrigger, TriggerCatalog};
9use crate::ast::RelationPersistence;
10use serde::{Deserialize, Serialize};
11use uqa_core::RelationIdentity;
12/// Format 4 rule conditions record each call's input collation.
13pub const RULE_CATALOG_FORMAT_VERSION: u32 = 4;
14pub trait EventRelationPersistence {
15    fn rule_relation_is_temporary(&self, relation: &RelationIdentity) -> bool;
16    fn trigger_relation_persistence(
17        &self,
18        relation: &RelationIdentity,
19    ) -> Option<RelationPersistence>;
20}
21#[derive(Default, Serialize, Deserialize)]
22pub struct StoredTriggerCatalog {
23    #[serde(default, skip_serializing_if = "Vec::is_empty")]
24    pub triggers: Vec<StoredTrigger>,
25}
26
27#[derive(Default, Serialize, Deserialize)]
28pub struct StoredRuleCatalog {
29    #[serde(default)]
30    pub format_version: u32,
31    #[serde(default, skip_serializing_if = "Vec::is_empty")]
32    pub rules: Vec<StoredRule>,
33}
34
35pub fn stored_rules_snapshot(
36    rules: &RuleCatalog,
37    relations: &dyn EventRelationPersistence,
38) -> StoredRuleCatalog {
39    StoredRuleCatalog {
40        format_version: RULE_CATALOG_FORMAT_VERSION,
41        rules: rules
42            .iter()
43            .filter(|(relation, _)| !relations.rule_relation_is_temporary(relation))
44            .flat_map(|(_, entries)| entries.values().cloned())
45            .collect(),
46    }
47}
48
49pub fn stored_triggers_snapshot(
50    triggers: &TriggerCatalog,
51    relations: &dyn EventRelationPersistence,
52) -> StoredTriggerCatalog {
53    StoredTriggerCatalog {
54        triggers: triggers
55            .iter()
56            .filter(|(relation, _)| {
57                relations
58                    .trigger_relation_persistence(relation)
59                    .is_some_and(|persistence| persistence != RelationPersistence::Temporary)
60            })
61            .flat_map(|(_, entries)| entries.values().cloned())
62            .collect(),
63    }
64}
65
66pub fn rule_catalog_requires_migration(
67    format_version: u32,
68    allows_migration: bool,
69) -> Result<bool, String> {
70    if format_version > RULE_CATALOG_FORMAT_VERSION {
71        return Err(format!(
72            "rule catalog format {format_version} is newer than supported format {RULE_CATALOG_FORMAT_VERSION}"
73        ));
74    }
75    let migrating_catalog = format_version < RULE_CATALOG_FORMAT_VERSION;
76    if migrating_catalog && !allows_migration {
77        return Err("rule catalog requires an initial-open format migration".into());
78    }
79
80    Ok(migrating_catalog)
81}
82
83#[cfg(test)]
84mod tests;