cartel-pg 0.27.2

Async PostgreSQL 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
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

use crate::dsl::{
    query::{self, ops},
    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> ops::Void for Rows2<A, B> {
    fn infer<R, T>(self, args: T) -> R {
        self.0.infer(args)
    }
}

impl<A, B, C> ops::Void for Rows3<A, B, C> {
    fn infer<R, T>(self, args: T) -> R {
        self.0.infer(args)
    }
}

impl<A, B, C, D> ops::Void for Rows4<A, B, C, D> {
    fn infer<R, T>(self, args: T) -> R {
        self.0.infer(args)
    }
}

impl<A, B> ops::Fetch<(A, B)> for Rows2<A, B> {}
impl<A, B, C> ops::Fetch<(A, B, C)> for Rows3<A, B, C> {}
impl<A, B, C, D> ops::Fetch<(A, B, C, D)> for Rows4<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)
    }
}