sql-orm-tiberius 0.2.0-rc.1

Tiberius execution adapter for sql-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

use sql_orm_core::OrmError;
use tiberius::error::{Error as TiberiusError, IoErrorKind};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum TiberiusErrorContext {
    ConnectTcp,
    ConfigureTcp,
    InitializeClient,
    ExecuteQuery,
    ReadRowValue,
}

pub(crate) fn map_tiberius_error(
    error: &tiberius::error::Error,
    context: TiberiusErrorContext,
) -> OrmError {
    if error.is_deadlock() {
        return OrmError::new("SQL Server deadlock detected");
    }

    match context {
        TiberiusErrorContext::ConnectTcp => {
            OrmError::new("failed to connect to SQL Server over TCP")
        }
        TiberiusErrorContext::ConfigureTcp => {
            OrmError::new("failed to configure SQL Server TCP stream")
        }
        TiberiusErrorContext::InitializeClient => {
            OrmError::new("failed to initialize Tiberius client")
        }
        TiberiusErrorContext::ExecuteQuery => {
            OrmError::new(format!("failed to execute SQL Server query: {error}"))
        }
        TiberiusErrorContext::ReadRowValue => OrmError::new("failed to read SQL Server row value"),
    }
}

pub(crate) fn is_transient_tiberius_error(error: &TiberiusError) -> bool {
    if error.is_deadlock() {
        return true;
    }

    match error {
        TiberiusError::Io { kind, .. } => matches!(
            kind,
            IoErrorKind::TimedOut
                | IoErrorKind::ConnectionReset
                | IoErrorKind::ConnectionAborted
                | IoErrorKind::BrokenPipe
                | IoErrorKind::Interrupted
                | IoErrorKind::UnexpectedEof
                | IoErrorKind::WouldBlock
                | IoErrorKind::NotConnected
        ),
        TiberiusError::Server(_) => matches!(
            error.code(),
            Some(1222 | 40197 | 40501 | 40613 | 49918 | 49919 | 49920)
        ),
        _ => false,
    }
}

#[cfg(test)]
mod tests {
    use super::{TiberiusErrorContext, is_transient_tiberius_error, map_tiberius_error};
    use tiberius::error::{Error, IoErrorKind};

    #[test]
    fn maps_contextual_driver_error_to_orm_error() {
        let error = Error::Conversion("boom".into());

        assert_eq!(
            map_tiberius_error(&error, TiberiusErrorContext::ExecuteQuery).message(),
            "failed to execute SQL Server query: Conversion error: boom"
        );
    }

    #[test]
    fn classifies_transient_io_errors_for_retry() {
        let error = Error::Io {
            kind: IoErrorKind::TimedOut,
            message: "timed out".to_string(),
        };

        assert!(is_transient_tiberius_error(&error));
    }

    #[test]
    fn ignores_non_transient_conversion_errors_for_retry() {
        let error = Error::Conversion("boom".into());

        assert!(!is_transient_tiberius_error(&error));
    }
}