scooby 0.5.0

An SQL query builder with a pleasant fluent API closely imitating actual SQL
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use std::fmt::{self, Display, Formatter};

use crate::postgres::general::{Column, Condition, Expression, TableName};

#[derive(Debug, Clone)]
pub enum ColumnConstraint {
    Null,
    NotNull,
    PrimaryKey,
    Unique,
    Default(Expression),
    References(TableName, Column),
    Check(Condition),
}

pub trait IntoColumnConstraint {
    fn into_column_constraint(self) -> Option<ColumnConstraint>;
}

impl Display for ColumnConstraint {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Null => write!(f, "NULL"),
            Self::NotNull => write!(f, "NOT NULL"),
            Self::PrimaryKey => write!(f, "PRIMARY KEY"),
            Self::Unique => write!(f, "UNIQUE"),
            Self::Default(expr) => write!(f, "DEFAULT {}", expr),
            Self::References(table_name, column) => {
                write!(f, "REFERENCES {}({})", table_name, column)
            }
            Self::Check(cond) => write!(f, "CHECK ({})", cond),
        }
    }
}

/* Generic markers for unspecified constraints, or for ones that should not be allowed */

#[derive(Debug)]
pub struct NoConstraint;

impl IntoColumnConstraint for NoConstraint {
    fn into_column_constraint(self) -> Option<ColumnConstraint> {
        None
    }
}

#[derive(Debug)]
pub struct ImpossibleConstraint;

/* Null and not null */

pub trait NullabilityConstraint: IntoColumnConstraint {}

#[derive(Debug)]
pub struct IsNull;

#[derive(Debug)]
pub struct IsNotNull;

impl NullabilityConstraint for NoConstraint {}
impl NullabilityConstraint for IsNotNull {}
impl NullabilityConstraint for IsNull {}

impl IntoColumnConstraint for IsNull {
    fn into_column_constraint(self) -> Option<ColumnConstraint> {
        Some(ColumnConstraint::Null)
    }
}

impl IntoColumnConstraint for IsNotNull {
    fn into_column_constraint(self) -> Option<ColumnConstraint> {
        Some(ColumnConstraint::NotNull)
    }
}

/* Primary key */

pub trait PrimaryKeyConstraint: IntoColumnConstraint {}

#[derive(Debug)]
pub struct IsPrimaryKey;

impl PrimaryKeyConstraint for NoConstraint {}
impl PrimaryKeyConstraint for IsPrimaryKey {}

impl IntoColumnConstraint for IsPrimaryKey {
    fn into_column_constraint(self) -> Option<ColumnConstraint> {
        Some(ColumnConstraint::PrimaryKey)
    }
}

/* Unique */

pub trait UniqueConstraint: IntoColumnConstraint {}

#[derive(Debug)]
pub struct IsUnique;

impl UniqueConstraint for NoConstraint {}
impl UniqueConstraint for IsUnique {}

impl IntoColumnConstraint for IsUnique {
    fn into_column_constraint(self) -> Option<ColumnConstraint> {
        Some(ColumnConstraint::Unique)
    }
}

/* Default */

pub trait DefaultConstraint: IntoColumnConstraint {}

#[derive(Debug)]
pub struct HasDefault(pub(crate) Expression);

impl DefaultConstraint for HasDefault {}
impl DefaultConstraint for NoConstraint {}

impl IntoColumnConstraint for HasDefault {
    fn into_column_constraint(self) -> Option<ColumnConstraint> {
        Some(ColumnConstraint::Default(self.0))
    }
}

/* References */

pub trait ReferencesConstraint: IntoColumnConstraint {}

#[derive(Debug)]
pub struct References(pub(crate) TableName, pub(crate) Column);

impl ReferencesConstraint for References {}
impl ReferencesConstraint for NoConstraint {}

impl IntoColumnConstraint for References {
    fn into_column_constraint(self) -> Option<ColumnConstraint> {
        Some(ColumnConstraint::References(self.0, self.1))
    }
}

/* Check */

pub trait CheckConstraint: IntoColumnConstraint {}

#[derive(Debug)]
pub struct Check(pub(crate) Condition);

impl CheckConstraint for Check {}
impl CheckConstraint for NoConstraint {}

impl IntoColumnConstraint for Check {
    fn into_column_constraint(self) -> Option<ColumnConstraint> {
        Some(ColumnConstraint::Check(self.0))
    }
}