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

//! Executable type definitions.

use std::marker::PhantomData;

use super::super::expr::{ColumnRef, ExprNode};
use super::super::scope::{QueryScope, ReturningScope};

/// Fetch-all executable produced by `all::<T>()`.
#[derive(Clone)]
pub struct All<T> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) _marker: PhantomData<fn() -> T>,
}

/// Fetch-one executable produced by `one::<T>()`.
#[derive(Clone)]
pub struct One<T> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) _marker: PhantomData<fn() -> T>,
}

/// Fetch-optional executable produced by `first::<T>()`.
#[derive(Clone)]
pub struct First<T> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) _marker: PhantomData<fn() -> T>,
}

/// Limited fetch executable produced by `slice::<T>(...)`.
#[derive(Clone)]
pub struct Slice<T> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) offset: usize,
    pub(in crate::queries) count: usize,
    pub(in crate::queries) _marker: PhantomData<fn() -> T>,
}

/// `COUNT(*)` executable.
pub struct Count {
    pub(in crate::queries) scope: QueryScope,
}

/// `EXISTS(...)` executable.
pub struct Exists {
    pub(in crate::queries) scope: QueryScope,
}

/// Scalar select executable.
pub struct Scalar<V> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) expr: ExprNode,
    pub(in crate::queries) _marker: PhantomData<fn() -> V>,
}

/// Single-row insert executable.
pub struct Insert<T> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) row: T,
}

/// Single-row update executable.
pub struct Update<T> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) row: T,
}

/// Delete executable.
pub struct Delete {
    pub(in crate::queries) scope: QueryScope,
}

/// Multi-row insert executable.
pub struct BatchInsert<'a, T> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) rows: &'a [T],
}

/// Multi-row upsert executable.
pub struct BatchUpsert<'a, T> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) rows: &'a [T],
    pub(in crate::queries) conflict: Vec<ColumnRef>,
}

/// Owned single-row insert executable.
pub struct OwnedInsert<T> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) row: T,
}

/// Owned single-row update executable.
pub struct OwnedUpdate<T> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) row: T,
}

/// Owned multi-row insert executable.
pub struct OwnedBatchInsert<T> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) rows: Vec<T>,
}

/// Owned multi-row upsert executable.
pub struct OwnedBatchUpsert<T> {
    pub(in crate::queries) scope: QueryScope,
    pub(in crate::queries) rows: Vec<T>,
    pub(in crate::queries) conflict: Vec<ColumnRef>,
}

/// Returning insert executable.
pub struct ReturningInsert<R, T> {
    pub(in crate::queries) returning: ReturningScope<R>,
    pub(in crate::queries) row: T,
}

/// Returning update executable.
pub struct ReturningUpdate<R, T> {
    pub(in crate::queries) returning: ReturningScope<R>,
    pub(in crate::queries) row: T,
}

/// Returning delete executable.
pub struct ReturningDelete<R> {
    pub(in crate::queries) returning: ReturningScope<R>,
}

/// Returning multi-row insert executable.
pub struct ReturningBatchInsert<'a, R, T> {
    pub(in crate::queries) returning: ReturningScope<R>,
    pub(in crate::queries) rows: &'a [T],
}

/// Returning multi-row upsert executable.
pub struct ReturningBatchUpsert<'a, R, T> {
    pub(in crate::queries) returning: ReturningScope<R>,
    pub(in crate::queries) rows: &'a [T],
    pub(in crate::queries) conflict: Vec<ColumnRef>,
}