mool 0.2.0

A source-first Rust database toolkit for typed SQL queries, migrations, and model metadata
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

//! Typed SQL window-function builders.

use super::expr::{ExprNode, IntoExpr, OrderExpr};

/// SQL window specification used by `expr.over(...)`.
#[derive(Clone, Default)]
pub struct WindowSpec {
    pub(super) partitions: Vec<ExprNode>,
    pub(super) orders: Vec<OrderExpr>,
    pub(super) frame: Option<WindowFrame>,
}

/// SQL window frame definition.
#[derive(Clone)]
pub struct WindowFrame {
    pub(super) unit: FrameUnit,
    pub(super) start: FrameBound,
    pub(super) end: FrameBound,
}

/// SQL window frame bound.
#[derive(Clone)]
pub struct FrameBound {
    pub(super) kind: FrameBoundKind,
    pub(super) expr: Option<Box<ExprNode>>,
}

#[derive(Clone, Copy)]
pub(super) enum FrameUnit {
    Rows,
    Range,
}

#[derive(Clone, Copy)]
pub(super) enum FrameBoundKind {
    UnboundedPreceding,
    Preceding,
    CurrentRow,
    Following,
    UnboundedFollowing,
}

impl WindowSpec {
    pub(super) fn new() -> Self {
        Self::default()
    }

    /// Adds a typed `PARTITION BY` expression.
    pub fn partition_by<T>(mut self, expr: impl IntoExpr<T>) -> Self {
        self.partitions.push(expr.into_expr().node);
        self
    }

    /// Adds a typed `ORDER BY` expression.
    pub fn order_by(mut self, order: OrderExpr) -> Self {
        self.orders.push(order);
        self
    }

    /// Adds a `ROWS BETWEEN ... AND ...` frame.
    pub fn rows_between(mut self, start: FrameBound, end: FrameBound) -> Self {
        self.frame = Some(rows_between(start, end));
        self
    }

    /// Adds a `RANGE BETWEEN ... AND ...` frame.
    pub fn range_between(mut self, start: FrameBound, end: FrameBound) -> Self {
        self.frame = Some(range_between(start, end));
        self
    }

    /// Applies a prebuilt window frame.
    pub fn frame(mut self, frame: WindowFrame) -> Self {
        self.frame = Some(frame);
        self
    }
}

/// Starts an empty SQL window specification.
pub fn window() -> WindowSpec {
    WindowSpec::new()
}

/// Creates a `ROWS BETWEEN ... AND ...` window frame.
pub fn rows_between(start: FrameBound, end: FrameBound) -> WindowFrame {
    WindowFrame {
        unit: FrameUnit::Rows,
        start,
        end,
    }
}

/// Creates a `RANGE BETWEEN ... AND ...` window frame.
pub fn range_between(start: FrameBound, end: FrameBound) -> WindowFrame {
    WindowFrame {
        unit: FrameUnit::Range,
        start,
        end,
    }
}

/// Window frame bound `UNBOUNDED PRECEDING`.
pub fn unbounded_preceding() -> FrameBound {
    FrameBound::plain(FrameBoundKind::UnboundedPreceding)
}

/// Window frame bound `n PRECEDING`.
pub fn preceding(offset: impl IntoExpr<i64>) -> FrameBound {
    FrameBound::with_expr(FrameBoundKind::Preceding, offset.into_expr().node)
}

/// Window frame bound `CURRENT ROW`.
pub fn current_row() -> FrameBound {
    FrameBound::plain(FrameBoundKind::CurrentRow)
}

/// Window frame bound `n FOLLOWING`.
pub fn following(offset: impl IntoExpr<i64>) -> FrameBound {
    FrameBound::with_expr(FrameBoundKind::Following, offset.into_expr().node)
}

/// Window frame bound `UNBOUNDED FOLLOWING`.
pub fn unbounded_following() -> FrameBound {
    FrameBound::plain(FrameBoundKind::UnboundedFollowing)
}

impl FrameBound {
    fn plain(kind: FrameBoundKind) -> Self {
        Self { kind, expr: None }
    }

    fn with_expr(kind: FrameBoundKind, expr: ExprNode) -> Self {
        Self {
            kind,
            expr: Some(Box::new(expr)),
        }
    }
}