rqlite_client 0.0.1-alpha.7

rqlite database client with optional extra convenience
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

//! All obtainable [`Error`] values

#[cfg(feature = "migration")]
use crate::migration::MigrationError;

/// All obtainable [`Error`] values
#[derive(Debug)]
pub enum Error {
    /// `HttpError` not status 2xx
    HttpError(u16, String),

    /// [`std::io::Error`]
    IoError(std::io::Error),

    /// `MigrationError` (required feature _migration_)
    #[cfg(feature = "migration")]
    MigrationError(MigrationError),

    /// `Error`s ocurred during response handling
    ResponseError(crate::Value),

    /// `ResultError`
    ResultError(String),

    /// `serde_json::Error`
    SerdeError(serde_json::Error),

    /// [`ureq::Error`] (required feature _ureq_)
    #[cfg(feature = "ureq")]
    UreqError(Box<ureq::Error>, Box<Option<crate::Value>>),

    /// [`url::ParseError`] (required feature _url_)
    #[cfg(feature = "url")]
    UrlParseError(url::ParseError),
}

impl std::error::Error for Error {}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::HttpError(status, msg) => {
                f.write_fmt(format_args!("HTTP Status {status}: {msg}"))
            }

            Error::IoError(inner) => inner.fmt(f),

            #[cfg(feature = "migration")]
            Error::MigrationError(inner) => inner.fmt(f),

            Error::ResponseError(v) => f.write_fmt(format_args!("response error: {v:?}")),

            Error::ResultError(msg) => f.write_str(msg),

            Error::SerdeError(inner) => inner.fmt(f),

            #[cfg(feature = "ureq")]
            Error::UreqError(inner, sql) => f.write_fmt(format_args!("{inner} [{sql:?}]")),

            #[cfg(feature = "url")]
            Error::UrlParseError(inner) => inner.fmt(f),
        }
    }
}

impl From<&str> for Error {
    fn from(err: &str) -> Self {
        Self::ResultError(err.to_string())
    }
}

impl From<std::io::Error> for Error {
    fn from(value: std::io::Error) -> Self {
        Self::IoError(value)
    }
}

#[cfg(feature = "migration")]
impl From<MigrationError> for Error {
    fn from(value: MigrationError) -> Self {
        Self::MigrationError(value)
    }
}

impl From<serde_json::Error> for Error {
    fn from(value: serde_json::Error) -> Self {
        Self::SerdeError(value)
    }
}

#[cfg(feature = "ureq")]
impl From<ureq::Error> for Error {
    fn from(value: ureq::Error) -> Self {
        Self::UreqError(Box::new(value), Box::new(None))
    }
}

#[cfg(feature = "url")]
impl From<url::ParseError> for Error {
    fn from(value: url::ParseError) -> Self {
        Self::UrlParseError(value)
    }
}