elefant-client 0.1.0

A pure rust implementation of a postgres client that is independent of the executor runtime
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

use crate::protocol;
use crate::protocol::FieldDescription;
use std::error::Error;
use std::fmt::{Display, Formatter};

#[derive(Debug)]
pub enum ElefantClientError {
    IoError(std::io::Error),
    PostgresMessageParseError(protocol::PostgresMessageParseError),
    UnexpectedBackendMessage(String),
    PostgresError(String),
    UnsupportedFieldType {
        desired_rust_type: &'static str,
        postgres_field: FieldDescription,
    },
    DataTypeParseError {
        original_error: Box<dyn Error + Sync + Send>,
        column_index: usize,
    },
    NoResultsReturned,
    UnexpectedNullValue {
        postgres_field: FieldDescription,
    },
    NotEnoughColumns {
        desired: usize,
        actual: usize,
    },
    UnsupportedAuthenticationMethod(String),
    TlsError(String),
    BatchQueryUnexpectedEnd,
}

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

impl From<protocol::PostgresMessageParseError> for ElefantClientError {
    fn from(value: protocol::PostgresMessageParseError) -> Self {
        ElefantClientError::PostgresMessageParseError(value)
    }
}

impl Display for ElefantClientError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            ElefantClientError::IoError(e) => {
                write!(f, "IO error: {e}")
            }
            ElefantClientError::PostgresMessageParseError(e) => {
                write!(f, "Postgres message parse error: {e}")
            }
            ElefantClientError::UnexpectedBackendMessage(e) => {
                write!(f, "Unexpected backend message: {e}")
            }
            ElefantClientError::PostgresError(e) => {
                write!(f, "Postgres error: {e}")
            }
            ElefantClientError::UnsupportedFieldType {
                postgres_field,
                desired_rust_type,
            } => {
                write!(f, "Unsupported field type: {postgres_field:?} for desired rust type: {desired_rust_type}")
            }
            ElefantClientError::DataTypeParseError {
                column_index,
                original_error,
            } => {
                write!(
                    f,
                    "Error while parsing response data: {original_error:?} as index {column_index}"
                )
            }
            ElefantClientError::NoResultsReturned => {
                write!(f, "No results returned from query.")
            }
            ElefantClientError::UnexpectedNullValue { postgres_field } => {
                write!(
                    f,
                    "Unexpected null value when processing field: {postgres_field:?}."
                )
            }
            ElefantClientError::NotEnoughColumns { desired, actual } => {
                write!(
                    f,
                    "Not enough columns returned. Desired: {desired}, Actual: {actual}"
                )
            }
            ElefantClientError::UnsupportedAuthenticationMethod(method) => {
                write!(f, "Unsupported authentication method: {method}")
            }
            ElefantClientError::TlsError(msg) => {
                write!(f, "TLS error: {msg}")
            }
            ElefantClientError::BatchQueryUnexpectedEnd => {
                write!(
                    f,
                    "Batch query ended unexpectedly: expected more result sets"
                )
            }
        }
    }
}

impl Error for ElefantClientError {}