prax-sqlite 0.7.3

SQLite database driver for Prax ORM
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
155
156
157
158
159

//! Error types for SQLite operations.

use std::fmt;

use prax_query::error::QueryError;

/// Result type for SQLite operations.
pub type SqliteResult<T> = Result<T, SqliteError>;

/// Error type for SQLite operations.
#[derive(Debug)]
pub enum SqliteError {
    /// Pool error.
    Pool(String),
    /// SQLite driver error.
    Sqlite(tokio_rusqlite::Error),
    /// Configuration error.
    Config(String),
    /// Connection error.
    Connection(String),
    /// Query error.
    Query(String),
    /// Deserialization error.
    Deserialization(String),
    /// Type conversion error.
    TypeConversion(String),
    /// Timeout error.
    Timeout(String),
    /// Internal error.
    Internal(String),
}

impl SqliteError {
    /// Create a pool error.
    pub fn pool(msg: impl Into<String>) -> Self {
        Self::Pool(msg.into())
    }

    /// Create a configuration error.
    pub fn config(msg: impl Into<String>) -> Self {
        Self::Config(msg.into())
    }

    /// Create a connection error.
    pub fn connection(msg: impl Into<String>) -> Self {
        Self::Connection(msg.into())
    }

    /// Create a query error.
    pub fn query(msg: impl Into<String>) -> Self {
        Self::Query(msg.into())
    }

    /// Create a deserialization error.
    pub fn deserialization(msg: impl Into<String>) -> Self {
        Self::Deserialization(msg.into())
    }

    /// Create a type conversion error.
    pub fn type_conversion(msg: impl Into<String>) -> Self {
        Self::TypeConversion(msg.into())
    }

    /// Create a timeout error.
    pub fn timeout(msg: impl Into<String>) -> Self {
        Self::Timeout(msg.into())
    }

    /// Create an internal error.
    pub fn internal(msg: impl Into<String>) -> Self {
        Self::Internal(msg.into())
    }
}

impl fmt::Display for SqliteError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Pool(msg) => write!(f, "Pool error: {}", msg),
            Self::Sqlite(e) => write!(f, "SQLite error: {}", e),
            Self::Config(msg) => write!(f, "Configuration error: {}", msg),
            Self::Connection(msg) => write!(f, "Connection error: {}", msg),
            Self::Query(msg) => write!(f, "Query error: {}", msg),
            Self::Deserialization(msg) => write!(f, "Deserialization error: {}", msg),
            Self::TypeConversion(msg) => write!(f, "Type conversion error: {}", msg),
            Self::Timeout(msg) => write!(f, "Timeout error: {}", msg),
            Self::Internal(msg) => write!(f, "Internal error: {}", msg),
        }
    }
}

impl std::error::Error for SqliteError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Self::Sqlite(e) => Some(e),
            _ => None,
        }
    }
}

impl From<tokio_rusqlite::Error> for SqliteError {
    fn from(err: tokio_rusqlite::Error) -> Self {
        Self::Sqlite(err)
    }
}

impl From<rusqlite::Error> for SqliteError {
    fn from(err: rusqlite::Error) -> Self {
        Self::Sqlite(tokio_rusqlite::Error::Rusqlite(err))
    }
}

impl From<SqliteError> for QueryError {
    fn from(err: SqliteError) -> Self {
        match err {
            SqliteError::Pool(msg) => QueryError::connection(msg),
            SqliteError::Sqlite(e) => QueryError::database(e.to_string()),
            SqliteError::Config(msg) => QueryError::internal(format!("config: {}", msg)),
            SqliteError::Connection(msg) => QueryError::connection(msg),
            SqliteError::Query(msg) => QueryError::database(msg),
            SqliteError::Deserialization(msg) => QueryError::serialization(msg),
            SqliteError::TypeConversion(msg) => QueryError::serialization(format!("type: {}", msg)),
            SqliteError::Timeout(_) => QueryError::timeout(5000), // Default timeout duration
            SqliteError::Internal(msg) => QueryError::internal(msg),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_error_display() {
        let err = SqliteError::config("invalid path");
        assert!(err.to_string().contains("Configuration error"));
        assert!(err.to_string().contains("invalid path"));
    }

    #[test]
    fn test_error_constructors() {
        assert!(matches!(SqliteError::pool("test"), SqliteError::Pool(_)));
        assert!(matches!(
            SqliteError::config("test"),
            SqliteError::Config(_)
        ));
        assert!(matches!(
            SqliteError::connection("test"),
            SqliteError::Connection(_)
        ));
        assert!(matches!(SqliteError::query("test"), SqliteError::Query(_)));
    }

    #[test]
    fn test_error_conversion() {
        let err = SqliteError::timeout("connection timed out");
        let query_err: QueryError = err.into();
        assert!(query_err.is_timeout());
    }
}