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
160
161
162
163
164
use std::error;
use std::fmt;
use std::path::PathBuf;
use std::str;
use libc::c_int;
use {ffi, errmsg_to_string};

/// Old name for `Error`. `SqliteError` is deprecated.
pub type SqliteError = Error;

/// Enum listing possible errors from rusqlite.
#[derive(Debug)]
pub enum Error {
    /// An error from an underlying SQLite call.
    SqliteFailure(ffi::Error, Option<String>),

    /// Error reported when attempting to open a connection when SQLite was configured to
    /// allow single-threaded use only.
    SqliteSingleThreadedMode,

    /// An error case available for implementors of the `FromSql` trait.
    FromSqlConversionFailure(Box<error::Error + Send + Sync>),

    /// Error converting a string to UTF-8.
    Utf8Error(str::Utf8Error),

    /// Error converting a string to a C-compatible string because it contained an embedded nul.
    NulError(::std::ffi::NulError),

    /// Error when using SQL named parameters and passing a parameter name not present in the SQL.
    InvalidParameterName(String),

    /// Error converting a file path to a string.
    InvalidPath(PathBuf),

    /// Error returned when an `execute` call returns rowss.
    ExecuteReturnedResults,

    /// Error when a query that was expected to return at least one row (e.g., for `query_row`)
    /// did not return any.
    QueryReturnedNoRows,

    /// Error when trying to access a `Row` after stepping past it. See the discussion on
    /// the `Rows` type for more details.
    GetFromStaleRow,

    /// Error when the value of a particular column is requested, but the index is out of range
    /// for the statement.
    InvalidColumnIndex(c_int),

    /// Error when the value of a particular column is requested, but the type of the result in
    /// that column cannot be converted to the requested Rust type.
    InvalidColumnType,

    /// Error returned by `functions::Context::get` when the function argument cannot be converted
    /// to the requested type.
    #[cfg(feature = "functions")]
    InvalidFunctionParameterType,

    /// An error case available for implementors of custom user functions (e.g.,
    /// `create_scalar_function`).
    #[cfg(feature = "functions")]
    #[allow(dead_code)]
    UserFunctionError(Box<error::Error + Send + Sync>),
}

impl From<str::Utf8Error> for Error {
    fn from(err: str::Utf8Error) -> Error {
        Error::Utf8Error(err)
    }
}

impl From<::std::ffi::NulError> for Error {
    fn from(err: ::std::ffi::NulError) -> Error {
        Error::NulError(err)
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            &Error::SqliteFailure(ref err, None) => err.fmt(f),
            &Error::SqliteFailure(_, Some(ref s)) => write!(f, "{}", s),
            &Error::SqliteSingleThreadedMode => write!(f, "SQLite was compiled or configured for single-threaded use only"),
            &Error::FromSqlConversionFailure(ref err) => err.fmt(f),
            &Error::Utf8Error(ref err) => err.fmt(f),
            &Error::NulError(ref err) => err.fmt(f),
            &Error::InvalidParameterName(ref name) => write!(f, "Invalid parameter name: {}", name),
            &Error::InvalidPath(ref p) => write!(f, "Invalid path: {}", p.to_string_lossy()),
            &Error::ExecuteReturnedResults => write!(f, "Execute returned results - did you mean to call query?"),
            &Error::QueryReturnedNoRows => write!(f, "Query returned no rows"),
            &Error::GetFromStaleRow => write!(f, "Attempted to get a value from a stale row"),
            &Error::InvalidColumnIndex(i) => write!(f, "Invalid column index: {}", i),
            &Error::InvalidColumnType => write!(f, "Invalid column type"),

            #[cfg(feature = "functions")]
            &Error::InvalidFunctionParameterType => write!(f, "Invalid function parameter type"),
            #[cfg(feature = "functions")]
            &Error::UserFunctionError(ref err) => err.fmt(f),
        }
    }
}

impl error::Error for Error {
    fn description(&self) -> &str {
        match self {
            &Error::SqliteFailure(ref err, None) => err.description(),
            &Error::SqliteFailure(_, Some(ref s)) => s,
            &Error::SqliteSingleThreadedMode => "SQLite was compiled or configured for single-threaded use only",
            &Error::FromSqlConversionFailure(ref err) => err.description(),
            &Error::Utf8Error(ref err) => err.description(),
            &Error::InvalidParameterName(_) => "invalid parameter name",
            &Error::NulError(ref err) => err.description(),
            &Error::InvalidPath(_) => "invalid path",
            &Error::ExecuteReturnedResults => "execute returned results - did you mean to call query?",
            &Error::QueryReturnedNoRows => "query returned no rows",
            &Error::GetFromStaleRow => "attempted to get a value from a stale row",
            &Error::InvalidColumnIndex(_) => "invalid column index",
            &Error::InvalidColumnType => "invalid column type",

            #[cfg(feature = "functions")]
            &Error::InvalidFunctionParameterType => "invalid function parameter type",
            #[cfg(feature = "functions")]
            &Error::UserFunctionError(ref err) => err.description(),
        }
    }

    fn cause(&self) -> Option<&error::Error> {
        match self {
            &Error::SqliteFailure(ref err, _) => Some(err),
            &Error::SqliteSingleThreadedMode => None,
            &Error::FromSqlConversionFailure(ref err) => Some(&**err),
            &Error::Utf8Error(ref err) => Some(err),
            &Error::NulError(ref err) => Some(err),
            &Error::InvalidParameterName(_) => None,
            &Error::InvalidPath(_) => None,
            &Error::ExecuteReturnedResults => None,
            &Error::QueryReturnedNoRows => None,
            &Error::GetFromStaleRow => None,
            &Error::InvalidColumnIndex(_) => None,
            &Error::InvalidColumnType => None,

            #[cfg(feature = "functions")]
            &Error::InvalidFunctionParameterType => None,
            #[cfg(feature = "functions")]
            &Error::UserFunctionError(ref err) => Some(&**err),
        }
    }
}

// These are public but not re-exported by lib.rs, so only visible within crate.

pub fn error_from_sqlite_code(code: c_int, message: Option<String>) -> Error {
    Error::SqliteFailure(ffi::Error::new(code), message)
}

pub fn error_from_handle(db: *mut ffi::Struct_sqlite3, code: c_int) -> Error {
    let message = if db.is_null() {
        None
    } else {
        Some(unsafe { errmsg_to_string(ffi::sqlite3_errmsg(db)) })
    };
    error_from_sqlite_code(code, message)
}