nodedb 0.2.0

Local-first, real-time, edge-to-cloud hybrid database for multi-modal workloads
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

// SPDX-License-Identifier: BUSL-1.1

//! In-memory registry of synonym groups.
//!
//! Loaded from the system catalog on startup. Updated by DDL handlers.
//! The registry is the single source of truth for duplicate detection and
//! SHOW SYNONYM GROUPS queries in the Control Plane.
//!
//! Query-time synonym expansion happens in the Data Plane via the FTS backend.

use std::collections::HashMap;
use std::sync::RwLock;

use crate::control::security::catalog::StoredSynonymGroup;

/// In-memory synonym group registry (Control Plane, `Send + Sync`).
pub struct SynonymRegistry {
    /// `(tenant_id, group_name)` → `StoredSynonymGroup`.
    by_name: RwLock<HashMap<(u64, String), StoredSynonymGroup>>,
}

impl SynonymRegistry {
    pub fn new() -> Self {
        Self {
            by_name: RwLock::new(HashMap::new()),
        }
    }

    /// Insert or replace a synonym group in the registry.
    pub fn register(&self, def: StoredSynonymGroup) {
        let key = (def.tenant_id, def.name.clone());
        let mut map = self.by_name.write().unwrap_or_else(|p| p.into_inner());
        map.insert(key, def);
    }

    /// Remove a synonym group. Returns `true` if it existed.
    pub fn unregister(&self, tenant_id: u64, name: &str) -> bool {
        let key = (tenant_id, name.to_string());
        let mut map = self.by_name.write().unwrap_or_else(|p| p.into_inner());
        map.remove(&key).is_some()
    }

    /// Check whether a synonym group exists.
    pub fn exists(&self, tenant_id: u64, name: &str) -> bool {
        let key = (tenant_id, name.to_string());
        let map = self.by_name.read().unwrap_or_else(|p| p.into_inner());
        map.contains_key(&key)
    }

    /// Get a synonym group by name.
    pub fn get(&self, tenant_id: u64, name: &str) -> Option<StoredSynonymGroup> {
        let key = (tenant_id, name.to_string());
        let map = self.by_name.read().unwrap_or_else(|p| p.into_inner());
        map.get(&key).cloned()
    }

    /// List all synonym groups for a tenant.
    pub fn list_for_tenant(&self, tenant_id: u64) -> Vec<StoredSynonymGroup> {
        let map = self.by_name.read().unwrap_or_else(|p| p.into_inner());
        map.values()
            .filter(|g| g.tenant_id == tenant_id)
            .cloned()
            .collect()
    }

    /// Reload from catalog. Used at startup and by recovery verifier.
    pub fn reload_from_catalog(
        &self,
        catalog: &crate::control::security::catalog::SystemCatalog,
    ) -> crate::Result<()> {
        let fresh = catalog.load_all_synonym_groups()?;
        let mut map = self.by_name.write().unwrap_or_else(|p| p.into_inner());
        map.clear();
        for g in fresh {
            let key = (g.tenant_id, g.name.clone());
            map.insert(key, g);
        }
        Ok(())
    }
}

impl Default for SynonymRegistry {
    fn default() -> Self {
        Self::new()
    }
}