Skip to main content

che_orm/
row.rs

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
16/// Converts a materialized database value into a model field.
17pub 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/// An owned row with the same decoding interface for either backend.
122#[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}