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
use {
crate::{
AlterError, CSVDatabaseError, DatabaseError, ExecuteError, FetchError, InterfaceError,
JoinError, ManualError, MemoryDatabaseError, PlanError, QueryError, RecipeError, RowError,
SelectError, SheetDatabaseError, TableError, ValidateError, ValueError,
},
serde::Serialize,
std::marker::{Send, Sync},
thiserror::Error as ThisError,
};
#[derive(ThisError, Serialize, Debug, PartialEq)]
pub enum WIPError {
#[error("TODO")]
TODO,
#[error("{0}")]
Debug(String),
}
#[derive(ThisError, Serialize, Debug)]
pub enum Error {
#[error(transparent)]
#[serde(with = "stringify")]
Database(#[from] Box<dyn std::error::Error>),
#[cfg(feature = "odbc-database")]
#[error(transparent)]
#[serde(with = "stringify")]
ODBC(#[from] odbc_api::Error),
#[error(transparent)]
Execute(#[from] ExecuteError),
#[error(transparent)]
Alter(#[from] AlterError),
#[error(transparent)]
Fetch(#[from] FetchError),
#[error(transparent)]
Select(#[from] SelectError),
#[error(transparent)]
Row(#[from] RowError),
#[error(transparent)]
Table(#[from] TableError),
#[error(transparent)]
Value(#[from] ValueError),
#[error(transparent)]
Recipe(#[from] RecipeError),
#[error(transparent)]
Join(#[from] JoinError),
#[error(transparent)]
Plan(#[from] PlanError),
#[error(transparent)]
Manual(#[from] ManualError),
#[error(transparent)]
Query(#[from] QueryError),
#[error(transparent)]
Validate(#[from] ValidateError),
#[error(transparent)]
WIP(#[from] WIPError),
#[error(transparent)]
DatabaseImplementation(#[from] DatabaseError),
#[error(transparent)]
CSVDatabase(#[from] CSVDatabaseError),
#[error(transparent)]
SheetDatabase(#[from] SheetDatabaseError),
#[error(transparent)]
MemoryDatabase(#[from] MemoryDatabaseError),
#[error(transparent)]
Interface(#[from] InterfaceError),
}
unsafe impl Send for Error {}
unsafe impl Sync for Error {}
pub type Result<T> = std::result::Result<T, Error>;
pub type MutResult<T, U> = std::result::Result<(T, U), (T, Error)>;
impl PartialEq for Error {
fn eq(&self, other: &Error) -> bool {
use Error::*;
match (self, other) {
(Execute(l), Execute(r)) => l == r,
(Alter(l), Alter(r)) => l == r,
(Fetch(l), Fetch(r)) => l == r,
(Select(l), Select(r)) => l == r,
(Row(l), Row(r)) => l == r,
(Table(l), Table(r)) => l == r,
(Value(l), Value(r)) => l == r,
(Recipe(l), Recipe(r)) => l == r,
(Join(l), Join(r)) => l == r,
(Plan(l), Plan(r)) => l == r,
(Manual(l), Manual(r)) => l == r,
(Query(l), Query(r)) => l == r,
(Validate(l), Validate(r)) => l == r,
(WIP(l), WIP(r)) => l == r,
(DatabaseImplementation(l), DatabaseImplementation(r)) => l == r,
(CSVDatabase(l), CSVDatabase(r)) => l == r,
(SheetDatabase(l), SheetDatabase(r)) => l == r,
(Interface(l), Interface(r)) => l == r,
(MemoryDatabase(l), MemoryDatabase(r)) => l == r,
_ => false,
}
}
}
mod stringify {
use {serde::Serializer, std::fmt::Display};
pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
where
T: Display,
S: Serializer,
{
serializer.collect_str(value)
}
}