cartel-sqlite 0.20.0

SQLite driver for the dope runtime
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

use crate::dsl::{query, scope::never::Never};

pub struct Plan2<A, B>(Never<(A, B)>);
pub struct Plan3<A, B, C>(Never<(A, B, C)>);
pub struct Plan4<A, B, C, D>(Never<(A, B, C, D)>);

pub struct Rows2<A, B>(Never<(A, B)>);
pub struct Rows3<A, B, C>(Never<(A, B, C)>);
pub struct Rows4<A, B, C, D>(Never<(A, B, C, D)>);

impl<A, B> Plan2<A, B> {
    pub fn filter(self, pred: impl FnOnce(A, B) -> bool) -> Rows2<A, B> {
        self.0.infer(pred)
    }

    pub fn join<C>(self, pred: impl FnOnce(A, B, C) -> bool) -> Plan3<A, B, C> {
        self.0.infer(pred)
    }
}

impl<A, B, C> Plan3<A, B, C> {
    pub fn filter(self, pred: impl FnOnce(A, B, C) -> bool) -> Rows3<A, B, C> {
        self.0.infer(pred)
    }

    pub fn join<D>(self, pred: impl FnOnce(A, B, C, D) -> bool) -> Plan4<A, B, C, D> {
        self.0.infer(pred)
    }
}

impl<A, B, C, D> Plan4<A, B, C, D> {
    pub fn filter(self, pred: impl FnOnce(A, B, C, D) -> bool) -> Rows4<A, B, C, D> {
        self.0.infer(pred)
    }
}

impl<A, B> Rows2<A, B> {
    pub fn all<R>(self) -> Vec<R> {
        self.0.infer(())
    }

    pub fn count(self) -> i64 {
        self.0.infer(())
    }

    pub fn order_by<F, U>(self, key: F) -> Self
    where
        F: FnOnce(A, B) -> U,
    {
        self.0.infer(key)
    }

    pub fn select<F, R>(self, map: F) -> query::Select<R>
    where
        F: FnOnce(A, B) -> R,
    {
        self.0.infer(map)
    }
}

impl<A, B, C> Rows3<A, B, C> {
    pub fn all<R>(self) -> Vec<R> {
        self.0.infer(())
    }

    pub fn order_by<F, U>(self, key: F) -> Self
    where
        F: FnOnce(A, B, C) -> U,
    {
        self.0.infer(key)
    }
}

impl<A, B, C, D> Rows4<A, B, C, D> {
    pub fn all<R>(self) -> Vec<R> {
        self.0.infer(())
    }

    pub fn order_by<F, U>(self, key: F) -> Self
    where
        F: FnOnce(A, B, C, D) -> U,
    {
        self.0.infer(key)
    }
}