qbice 0.6.5

The Query-Based Incremental Computation Engine
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

use std::sync::Arc;

use crate::{
    engine::computation_graph::{
        ActiveComputationGuard, computing::QueryComputing, database::Timestamp,
    },
    query::QueryID,
};

#[derive(Clone)]
pub enum CallerReason {
    RequireValue(#[allow(unused)] Option<waitgroup::Worker>),
    Repair,
}

impl std::fmt::Debug for CallerReason {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::RequireValue(_) => {
                f.debug_tuple("RequireValue").finish_non_exhaustive()
            }
            Self::Repair => f.debug_tuple("Repair").finish(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct QueryCaller {
    query_id: QueryID,
    computing: Option<Arc<QueryComputing>>,
    reason: CallerReason,

    /// Pedantic repair forces the repair process to eagerly recursively invoke
    /// `repair` on its callees, instead of checking the dirtiness of the
    /// callee and only invoking `repair` when the callee is dirty.
    pedantic_repair: bool,
}

impl QueryCaller {
    pub const fn new_with_pedantic_repair(
        query_id: QueryID,
        reason: CallerReason,
        computing: Arc<QueryComputing>,
        pedantic_repair: bool,
    ) -> Self {
        Self { query_id, computing: Some(computing), reason, pedantic_repair }
    }

    pub const fn new_external_input(
        query_id: QueryID,
        worker: waitgroup::Worker,
    ) -> Self {
        Self {
            query_id,
            computing: None,
            reason: CallerReason::RequireValue(Some(worker)),
            pedantic_repair: false,
        }
    }

    pub const fn pedantic_repair(&self) -> bool { self.pedantic_repair }

    pub const fn try_computing(&self) -> Option<&Arc<QueryComputing>> {
        self.computing.as_ref()
    }

    #[must_use]
    pub const fn computing(&self) -> &Arc<QueryComputing> {
        self.computing
            .as_ref()
            .expect("`ExternalInput` cannot call other queries")
    }

    #[must_use]
    pub const fn query_id(&self) -> QueryID { self.query_id }

    #[must_use]
    pub const fn require_value(&self) -> bool {
        matches!(self.reason, CallerReason::RequireValue { .. })
    }
}

#[derive(Debug, Clone)]
pub struct CallerInformation {
    kind: CallerKind,
    timestamp: Timestamp,
    active_computation_guard: Option<ActiveComputationGuard>,
}

impl CallerInformation {
    pub const fn new(
        kind: CallerKind,
        timestamp: Timestamp,
        active_computation_guard: Option<ActiveComputationGuard>,
    ) -> Self {
        Self { kind, timestamp, active_computation_guard }
    }

    #[must_use]
    pub fn clone_active_computation_guard(
        &self,
    ) -> Option<ActiveComputationGuard> {
        self.active_computation_guard.clone()
    }

    #[must_use]
    pub const fn active_computation_guard(
        &self,
    ) -> Option<&ActiveComputationGuard> {
        self.active_computation_guard.as_ref()
    }

    pub const fn get_query_caller(&self) -> Option<&QueryCaller> {
        match &self.kind {
            CallerKind::RepairFirewall
            | CallerKind::BackwardProjectionPropagation
            | CallerKind::Tracing
            | CallerKind::User => None,

            CallerKind::Query(q) => Some(q),
        }
    }

    pub const fn require_value(&self) -> bool {
        match &self.kind {
            CallerKind::RepairFirewall
            | CallerKind::BackwardProjectionPropagation
            | CallerKind::Tracing => false,

            CallerKind::User => true,
            CallerKind::Query(q) => {
                matches!(q.reason, CallerReason::RequireValue { .. })
            }
        }
    }

    pub const fn timestamp(&self) -> Timestamp { self.timestamp }

    pub const fn kind(&self) -> &CallerKind { &self.kind }
}

#[derive(Debug, Clone)]
pub enum CallerKind {
    User,
    Query(QueryCaller),
    Tracing,

    /// The caller is either a firewall or projection query. The caller calls
    /// the query when the caller itself has changed its value and has to
    /// invoke all of its backward projections (projections that use the caller)
    /// in order to propagate the dirtiness.
    ///
    /// ```txt
    ///         Firewall <-- caller has changed its value
    ///          ^    ^
    ///         /      \
    ///   Projection1  Projection2 <-- both got called with
    ///                                 `BackwardProjectionPropagation`
    /// ```
    BackwardProjectionPropagation,

    RepairFirewall,
}