codd 0.1.0

codd is a minimal in-memory database with relational algebraic expressions as queries.
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

use super::{Expression, Visitor};
use crate::Tuple;
use std::marker::PhantomData;

/// Is the type of the view identifiers in a database.
#[derive(PartialEq, Eq, Clone, Hash, Debug)]
pub struct ViewRef(pub(crate) i32);

/// Represents a view in the database.
///
/// **Example**:
/// ```rust
/// use codd::{Database, expression::{Product, View}};
///
/// let mut db = Database::new();
/// let dividends = db.add_relation("dividends").unwrap();
/// let divisors = db.add_relation("divisors").unwrap();
///
/// db.insert(&dividends, vec![6, 12, 18].into()).unwrap();
/// db.insert(&divisors, vec![2, 3].into()).unwrap();
///
/// // divide all elements of `dividends` by all elements of `divisors`:
/// let quotients = Product::new(
///     dividends.clone(),
///     divisors.clone(),
///     |&l, &r| l/r
/// );
/// let view = db.store_view(quotients.clone()).unwrap();
///
/// // `view` and `quotients` evaluate to the same result:
/// assert_eq!(vec![2, 3, 4, 6, 9], db.evaluate(&quotients).unwrap().into_tuples());
/// assert_eq!(vec![2, 3, 4, 6, 9], db.evaluate(&view).unwrap().into_tuples());
///
/// db.insert(&dividends, vec![24, 30].into());
/// db.insert(&divisors, vec![1].into());
///
/// // the view gets updated automatically:
/// assert_eq!(
///    vec![2, 3, 4, 6, 8, 9, 10, 12, 15, 18, 24, 30],
///    db.evaluate(&view).unwrap().into_tuples()
/// );
///
/// use codd::expression::Difference;
/// // incremental view update for `Difference` is currently not supported:
/// assert!(db.store_view(Difference::new(dividends, divisors)).is_err());
/// ```
#[derive(PartialEq, Eq, Clone, Debug)]
pub struct View<T, E>
where
    T: Tuple,
    E: Expression<T>,
{
    reference: ViewRef,
    view_deps: Vec<ViewRef>,
    _phantom: PhantomData<(T, E)>,
}

impl<T, E> View<T, E>
where
    T: Tuple,
    E: Expression<T>,
{
    /// Creates a new view with a given reference.
    pub(crate) fn new(reference: ViewRef) -> Self {
        Self {
            view_deps: vec![reference.clone()],
            reference,
            _phantom: PhantomData,
        }
    }

    /// Returns the reference to this view.
    #[inline(always)]
    pub(crate) fn reference(&self) -> &ViewRef {
        &self.reference
    }

    /// Returns a reference to the view dependencies of the receiver.
    #[inline(always)]
    pub(crate) fn view_deps(&self) -> &[ViewRef] {
        &self.view_deps
    }
}

impl<T, E> Expression<T> for View<T, E>
where
    T: Tuple + 'static,
    E: Expression<T> + 'static,
{
    fn visit<V>(&self, visitor: &mut V)
    where
        V: Visitor,
    {
        visitor.visit_view(&self);
    }
}

#[cfg(test)]
mod tests {
    use crate::{Database, Tuples};

    #[test]
    fn test_clone() {
        let mut database = Database::new();
        let r = database.add_relation::<i32>("r").unwrap();
        let v = database.store_view(r.clone()).unwrap().clone();
        database.insert(&r, vec![1, 2, 3].into()).unwrap();
        assert_eq!(
            Tuples::<i32>::from(vec![1, 2, 3]),
            database.evaluate(&v).unwrap()
        );
    }
}