reql 0.0.6-alpha2

A native RethinkDB driver
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

//! Error Reference

use std::io::Error as IoError;
use std::str::Utf8Error;
use std::sync::mpsc::SendError;
use serde_json::error::Error as JsonError;
use protobuf::ProtobufError;
use serde_json::Value;

/// The most generic error message in ReQL
#[derive(Debug, Error)]
pub enum Error {
    #[error(msg_embedded, non_std, no_from)]
    Compile(String),
    Runtime(RuntimeError),
    Driver(DriverError),
}

/// The parent class of all runtime errors
///
/// All errors on the server unrelated to compilation. Programs may use this to catch any runtime
/// error, but the server will always return a more specific error class.
#[derive(Debug, Error)]
pub enum RuntimeError {
    /// The query contains a logical impossibility, such as adding a number to a string.
    #[error(msg_embedded, non_std, no_from)]
    QueryLogic(String),
    #[error(msg_embedded, non_std, no_from)]
    NonExistence(String),
    #[error(msg_embedded, non_std, no_from)]
    ResourceLimit(String),
    #[error(msg_embedded, non_std, no_from)]
    User(String),
    #[error(msg_embedded, non_std, no_from)]
    Internal(String),
    #[error(msg_embedded, non_std, no_from)]
    Timeout(String),
    Availability(AvailabilityError),
    #[error(msg_embedded, non_std, no_from)]
    Permission(String),
}

/// A server in the cluster is unavailable
///
/// The parent class of `OpFailedError` and `OpIndeterminateError`. Programs may use this
/// to catch any availability error, but the server will always return one of this class’s
/// children.
#[derive(Debug, Error)]
pub enum AvailabilityError {
    #[error(msg_embedded, non_std, no_from)]
    OpFailed(String),
    #[error(msg_embedded, non_std, no_from)]
    OpIndeterminate(String),
}

/// An error has occurred within the driver
///
/// This may be a driver bug, or it may be an unfulfillable command, such as an unserializable
/// query.
#[derive(Debug, Error)]
pub enum DriverError {
    #[error(msg_embedded, non_std, no_from)]
    Auth(String),
    Io(IoError),
    Response(ResponseError),
    Json(JsonError),
    Protobuf(ProtobufError),
    #[error(msg_embedded, non_std, no_from)]
    Other(String),
}

/// Response related errors
#[derive(Debug, Error)]
pub enum ResponseError {
    Parse(Utf8Error),
    #[error(non_std, no_from)]
    Db(Value),
}

impl From<ResponseError> for Error {
    fn from(err: ResponseError) -> Error {
        From::from(DriverError::Response(err))
    }
}

impl From<AvailabilityError> for Error {
    fn from(err: AvailabilityError) -> Error {
        From::from(RuntimeError::Availability(err))
    }
}

/// Converts from IO error
impl From<IoError> for Error {
    fn from(err: IoError) -> Error {
        From::from(DriverError::Io(err))
    }
}

/// Converts from Utf8Error error
impl From<Utf8Error> for Error {
    fn from(err: Utf8Error) -> Error {
        From::from(ResponseError::Parse(err))
    }
}

/// Converts from serde_json error
impl From<JsonError> for Error {
    fn from(err: JsonError) -> Error {
        From::from(DriverError::Json(err))
    }
}

impl From<ProtobufError> for Error {
    fn from(err: ProtobufError) -> Error {
        From::from(DriverError::Protobuf(err))
    }
}

impl<T> From<SendError<T>> for Error {
    fn from(err: SendError<T>) -> Error {
        let msg = format!("{:?}", err);
        From::from(DriverError::Other(msg))
    }
}