cozo 0.7.6

A general-purpose, transactional, relational database that uses Datalog and focuses on graph data and algorithms
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
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
116
117

/*
 * Copyright 2022, The Cozo Project Authors.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
 * If a copy of the MPL was not distributed with this file,
 * You can obtain one at https://mozilla.org/MPL/2.0/.
 */

use std::collections::{BTreeMap, BTreeSet};
use std::fmt::{Display, Formatter};

use crossbeam::channel::Sender;
use smartstring::{LazyCompact, SmartString};

use crate::{Db, NamedRows, Storage};

/// Represents the kind of operation that triggered the callback
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum CallbackOp {
    /// Triggered by Put operations
    Put,
    /// Triggered by Rm operations
    Rm,
}

impl Display for CallbackOp {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            CallbackOp::Put => f.write_str("Put"),
            CallbackOp::Rm => f.write_str("Rm"),
        }
    }
}

impl CallbackOp {
    /// Get the string representation
    pub fn as_str(&self) -> &'static str {
        match self {
            CallbackOp::Put => "Put",
            CallbackOp::Rm => "Rm",
        }
    }
}

#[allow(dead_code)]
pub struct CallbackDeclaration {
    pub(crate) dependent: SmartString<LazyCompact>,
    pub(crate) sender: Sender<(CallbackOp, NamedRows, NamedRows)>,
}

pub(crate) type CallbackCollector =
    BTreeMap<SmartString<LazyCompact>, Vec<(CallbackOp, NamedRows, NamedRows)>>;

#[allow(dead_code)]
pub(crate) type EventCallbackRegistry = (
    BTreeMap<u32, CallbackDeclaration>,
    BTreeMap<SmartString<LazyCompact>, BTreeSet<u32>>,
);

impl<'s, S: Storage<'s>> Db<S> {
    pub(crate) fn current_callback_targets(&self) -> BTreeSet<SmartString<LazyCompact>> {
        #[cfg(not(target_arch = "wasm32"))]
        {
            self.event_callbacks
                .read()
                .unwrap()
                .1
                .keys()
                .cloned()
                .collect()
        }

        #[cfg(target_arch = "wasm32")]
        {
            Default::default()
        }
    }
    #[cfg(not(target_arch = "wasm32"))]
    pub(crate) fn send_callbacks(&'s self, collector: CallbackCollector) {
        let mut to_remove = vec![];

        for (table, vals) in collector {
            for (op, new, old) in vals {
                let (cbs, cb_dir) = &*self.event_callbacks.read().unwrap();
                if let Some(cb_ids) = cb_dir.get(&table) {
                    let mut it = cb_ids.iter();
                    if let Some(fst) = it.next() {
                        for cb_id in it {
                            if let Some(cb) = cbs.get(cb_id) {
                                if cb.sender.send((op, new.clone(), old.clone())).is_err() {
                                    to_remove.push(*cb_id)
                                }
                            }
                        }

                        if let Some(cb) = cbs.get(fst) {
                            if cb.sender.send((op, new, old)).is_err() {
                                to_remove.push(*fst)
                            }
                        }
                    }
                }
            }
        }

        if !to_remove.is_empty() {
            let (cbs, cb_dir) = &mut *self.event_callbacks.write().unwrap();
            for removing_id in &to_remove {
                if let Some(removed) = cbs.remove(removing_id) {
                    if let Some(set) = cb_dir.get_mut(&removed.dependent) {
                        set.remove(removing_id);
                    }
                }
            }
        }
    }
}