aykroyd 0.3.1

Zero-overhead ergonomic data access for Rust.
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

//! Error handling.
//!
//! Errors can happen in one of a few different phases:
//!
//! * connecting to a database
//! * preparing a query
//! * executing a query
//! * retrieving values from the results
//! * transaction control
//!
//! Use the `kind()` method on [`Error`] to find out
//! which step it was.  If we have an underlying database
//! error it can be retrieved with the `inner()` method.

/// An error that occurred when trying to use the database.
#[derive(Debug, Clone)]
pub struct Error<ClientError> {
    message: String,
    kind: ErrorKind,
    inner: Option<ClientError>,
}

impl<ClientError> Error<ClientError> {
    pub fn kind(&self) -> ErrorKind {
        self.kind
    }

    pub fn inner(&self) -> Option<&ClientError> {
        self.inner.as_ref()
    }

    pub fn from_column_str<S: Into<String>>(message: S, inner: Option<ClientError>) -> Self {
        let kind = ErrorKind::FromColumn;
        let message = message.into();
        Error {
            message,
            kind,
            inner,
        }
    }

    pub fn prepare_str<S: Into<String>>(message: S, inner: Option<ClientError>) -> Self {
        let kind = ErrorKind::Prepare;
        let message = message.into();
        Error {
            message,
            kind,
            inner,
        }
    }

    pub fn query_str<S: Into<String>>(message: S, inner: Option<ClientError>) -> Self {
        let kind = ErrorKind::Query;
        let message = message.into();
        Error {
            message,
            kind,
            inner,
        }
    }

    pub fn connect_str<S: Into<String>>(message: S, inner: Option<ClientError>) -> Self {
        let kind = ErrorKind::Connect;
        let message = message.into();
        Error {
            message,
            kind,
            inner,
        }
    }

    pub fn transaction_str<S: Into<String>>(message: S, inner: Option<ClientError>) -> Self {
        let kind = ErrorKind::Transaction;
        let message = message.into();
        Error {
            message,
            kind,
            inner,
        }
    }
}

impl<ClientError: std::fmt::Display> Error<ClientError> {
    pub fn from_column(inner: ClientError) -> Self {
        let message = inner.to_string();
        Self::from_column_str(message, Some(inner))
    }

    pub fn prepare(inner: ClientError) -> Self {
        let message = inner.to_string();
        Self::prepare_str(message, Some(inner))
    }

    pub fn query(inner: ClientError) -> Self {
        let message = inner.to_string();
        Self::query_str(message, Some(inner))
    }

    pub fn connect(inner: ClientError) -> Self {
        let message = inner.to_string();
        Self::connect_str(message, Some(inner))
    }

    pub fn transaction(inner: ClientError) -> Self {
        let message = inner.to_string();
        Self::transaction_str(message, Some(inner))
    }
}

impl<ClientError: std::error::Error + 'static> std::error::Error for Error<ClientError> {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        self.inner.as_ref().map(|err| err as &(dyn std::error::Error + 'static))
    }
}

/// What operation prompted the error?
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ErrorKind {
    /// Database error while preparing a query.
    Prepare,

    /// Database error while executing a query.
    Query,

    /// Bad conversion from a database column.
    FromColumn,

    /// Problems connecting to the database.
    Connect,

    /// Error in transaction control.
    Transaction,
}

impl<ClientError> std::fmt::Display for Error<ClientError> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        self.message.fmt(f)
    }
}