1use crate::{DatabaseValue, DbEnum, Uuid};
2
3#[derive(Debug, thiserror::Error)]
4pub enum DecodeError {
5 #[error("invalid column index: {0}")]
6 InvalidColumnIndex(usize),
7 #[error("expected {expected}, got {actual}")]
8 TypeMismatch {
9 expected: &'static str,
10 actual: &'static str,
11 },
12 #[error("invalid database value: {0}")]
13 InvalidValue(String),
14}
15
16pub trait FromDatabaseValue: Sized {
18 fn from_database_value(value: &DatabaseValue) -> Result<Self, DecodeError>;
19}
20
21impl DatabaseValue {
22 fn kind(&self) -> &'static str {
23 match self {
24 Self::Integer(_) => "integer",
25 Self::Real(_) => "real",
26 Self::Text(_) => "text",
27 Self::Binary(_) => "binary",
28 Self::Boolean(_) => "boolean",
29 Self::DateTime(_) => "datetime",
30 Self::Uuid(_) => "uuid",
31 Self::Null => "null",
32 }
33 }
34 fn mismatch(&self, expected: &'static str) -> DecodeError {
35 DecodeError::TypeMismatch {
36 expected,
37 actual: self.kind(),
38 }
39 }
40}
41
42macro_rules! scalar {
43 ($ty:ty, $variant:ident, $kind:literal) => {
44 impl FromDatabaseValue for $ty {
45 fn from_database_value(value: &DatabaseValue) -> Result<Self, DecodeError> {
46 match value {
47 DatabaseValue::$variant(value) => Ok(value.clone()),
48 other => Err(other.mismatch($kind)),
49 }
50 }
51 }
52 };
53}
54scalar!(i64, Integer, "integer");
55scalar!(String, Text, "text");
56scalar!(Vec<u8>, Binary, "binary");
57
58impl FromDatabaseValue for f64 {
59 fn from_database_value(value: &DatabaseValue) -> Result<Self, DecodeError> {
60 match value {
61 DatabaseValue::Real(value) => Ok(*value),
62 DatabaseValue::Integer(value) => Ok(*value as f64),
63 other => Err(other.mismatch("real")),
64 }
65 }
66}
67
68impl FromDatabaseValue for bool {
69 fn from_database_value(value: &DatabaseValue) -> Result<Self, DecodeError> {
70 match value {
71 DatabaseValue::Boolean(value) => Ok(*value),
72 DatabaseValue::Integer(value) => Ok(*value != 0),
73 other => Err(other.mismatch("boolean")),
74 }
75 }
76}
77
78impl FromDatabaseValue for Uuid {
79 fn from_database_value(value: &DatabaseValue) -> Result<Self, DecodeError> {
80 match value {
81 DatabaseValue::Uuid(value) => Ok(*value),
82 DatabaseValue::Binary(value) => Self::from_slice(value)
83 .map_err(|error| DecodeError::InvalidValue(error.to_string())),
84 other => Err(other.mismatch("uuid")),
85 }
86 }
87}
88
89impl FromDatabaseValue for time::OffsetDateTime {
90 fn from_database_value(value: &DatabaseValue) -> Result<Self, DecodeError> {
91 match value {
92 DatabaseValue::DateTime(value) => Ok(value.to_offset(time::UtcOffset::UTC)),
93 DatabaseValue::Text(value) => {
94 Self::parse(value, &time::format_description::well_known::Rfc3339)
95 .map(|value| value.to_offset(time::UtcOffset::UTC))
96 .map_err(|error| DecodeError::InvalidValue(error.to_string()))
97 }
98 other => Err(other.mismatch("datetime")),
99 }
100 }
101}
102
103impl<T: FromDatabaseValue> FromDatabaseValue for Option<T> {
104 fn from_database_value(value: &DatabaseValue) -> Result<Self, DecodeError> {
105 if matches!(value, DatabaseValue::Null) {
106 Ok(None)
107 } else {
108 T::from_database_value(value).map(Some)
109 }
110 }
111}
112
113impl<T: DbEnum> FromDatabaseValue for T {
114 fn from_database_value(value: &DatabaseValue) -> Result<Self, DecodeError> {
115 let text = String::from_database_value(value)?;
116 T::from_str(&text)
117 .ok_or_else(|| DecodeError::InvalidValue(format!("invalid enum value: {text}")))
118 }
119}
120
121#[derive(Debug, Clone)]
123pub struct Row {
124 values: Vec<DatabaseValue>,
125}
126
127impl Row {
128 pub fn new(values: Vec<DatabaseValue>) -> Self {
129 Self { values }
130 }
131 pub fn get<T: FromDatabaseValue>(&self, index: usize) -> Result<T, DecodeError> {
132 T::from_database_value(
133 self.values
134 .get(index)
135 .ok_or(DecodeError::InvalidColumnIndex(index))?,
136 )
137 }
138 #[cfg(feature = "sqlite")]
139 pub fn from_sqlite(row: &rusqlite::Row<'_>) -> rusqlite::Result<Self> {
140 use rusqlite::types::ValueRef;
141 let values = (0..row.as_ref().column_count())
142 .map(|index| {
143 Ok(match row.get_ref(index)? {
144 ValueRef::Null => DatabaseValue::Null,
145 ValueRef::Integer(value) => DatabaseValue::Integer(value),
146 ValueRef::Real(value) => DatabaseValue::Real(value),
147 ValueRef::Text(value) => DatabaseValue::Text(
148 std::str::from_utf8(value)
149 .map_err(|error| {
150 rusqlite::Error::FromSqlConversionFailure(
151 index,
152 rusqlite::types::Type::Text,
153 Box::new(error),
154 )
155 })?
156 .to_owned(),
157 ),
158 ValueRef::Blob(value) => DatabaseValue::Binary(value.to_vec()),
159 })
160 })
161 .collect::<rusqlite::Result<Vec<_>>>()?;
162 Ok(Self::new(values))
163 }
164}
165
166#[doc(hidden)]
167#[cfg(feature = "sqlite")]
168#[macro_export]
169macro_rules! __sqlite_db_enum_adapter {
170 ($name:ty) => {
171 impl $crate::rusqlite::types::FromSql for $name {
172 fn column_result(
173 value: $crate::rusqlite::types::ValueRef<'_>,
174 ) -> $crate::rusqlite::types::FromSqlResult<Self> {
175 <Self as $crate::DbEnum>::from_str(value.as_str()?)
176 .ok_or($crate::rusqlite::types::FromSqlError::InvalidType)
177 }
178 }
179 };
180}
181
182#[doc(hidden)]
183#[cfg(not(feature = "sqlite"))]
184#[macro_export]
185macro_rules! __sqlite_db_enum_adapter {
186 ($name:ty) => {};
187}