datafox 0.1.0

A small Datalog parser and streaming query engine for querying facts.
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

use crate::{Result, Storage, TupleStream, Value};

/// A read-only query snapshot over a storage backend.
#[derive(Debug, Clone)]
pub struct Universe<S> {
    storage: S,
}

impl<S> Universe<S> {
    pub fn new(storage: S) -> Self {
        Self { storage }
    }

    pub fn storage(&self) -> &S {
        &self.storage
    }
}

impl<S: Storage> Universe<S> {
    pub async fn get_facts_matching(
        &self,
        predicate: &str,
        pattern: Vec<Option<Value>>,
    ) -> Result<TupleStream> {
        self.storage.get_facts_matching(predicate, pattern).await
    }
}

#[cfg(test)]
mod tests {
    use tokio::runtime::Runtime;

    use crate::{InMemoryStorage, Universe, Value};

    #[test]
    fn universe_delegates_matching_reads_to_storage() {
        let universe = Universe::new(InMemoryStorage::from_facts([(
            "edge".to_string(),
            vec![vec![Value::integer(1), Value::integer(2)]],
        )]));

        let runtime = Runtime::new().expect("runtime");
        let tuples = runtime.block_on(async {
            let mut tuples = universe
                .get_facts_matching("edge", vec![Some(Value::integer(1)), None])
                .await
                .expect("tuples");
            let mut results = Vec::new();
            while let Some(tuple) = tuples.recv().await {
                results.push(tuple.expect("tuple result"));
            }
            results
        });

        assert_eq!(tuples, vec![vec![Value::integer(1), Value::integer(2)]]);
    }
}