Migrate to sqlx

src/db/model_utils.rs

@@ -1,14 +1,13 @@
 use crate::db::models::Periods;
 use chrono::{NaiveTime, Timelike};
-use diesel::deserialize::FromSql;
-use diesel::serialize::{IsNull, Output, ToSql};
-use diesel::sql_types::Binary;
-use diesel::sqlite::Sqlite;
-use diesel::{deserialize, serialize};
 use serde::{Deserialize, Serialize};
+use sqlx::{Decode, Encode, Sqlite, Type};
+use sqlx::database::HasArguments;
+use sqlx::encode::IsNull;
+use sqlx::error::BoxDynError;
+use sqlx::sqlite::{SqliteTypeInfo, SqliteValueRef};
 
-#[derive(Debug, Serialize, Deserialize, AsExpression, FromSqlRow, PartialEq, Clone)]
-#[diesel(sql_type = Binary)]
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
 pub struct Period {
 	#[serde(with = "period_format")]
 	pub start: NaiveTime,
@@ -52,13 +51,81 @@ impl Period {
 	}
 }
 
-impl ToSql<Binary, Sqlite> for Periods
-where
-	Vec<u8>: ToSql<Binary, Sqlite>,
-{
-	fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Sqlite>) -> serialize::Result {
-		let periods_u8: Vec<u8> = self
-			.0
+//impl ToSql<Binary, Sqlite> for Periods
+//where
+//	Vec<u8>: ToSql<Binary, Sqlite>,
+//{
+//	fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Sqlite>) -> serialize::Result {
+//		let periods_u8: Vec<u8> = self
+//			.0
+//			.iter()
+//			.flat_map(|period| {
+//				let vec = vec![
+//					period.start.hour() as u8,
+//					period.start.minute() as u8,
+//					period.end.hour() as u8,
+//					period.end.minute() as u8,
+//				];
+//				vec
+//			})
+//			.collect();
+//
+//		out.set_value(periods_u8);
+//
+//		Ok(IsNull::No)
+//	}
+//}
+//
+//impl<DB> FromSql<Binary, DB> for Periods
+//where
+//	DB: diesel::backend::Backend,
+//	Vec<u8>: FromSql<Binary, DB>,
+//{
+//	fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
+//		let blob: Vec<u8> = Vec::from_sql(bytes).unwrap();
+//
+//		let mut vec = Vec::new();
+//		for i in (3..blob.len()).step_by(4) {
+//			let start_val_h: u32 = blob[i - 3] as u32;
+//			let start_val_m: u32 = blob[i - 2] as u32;
+//			let end_val_h: u32 = blob[i - 1] as u32;
+//			let end_val_m: u32 = blob[i] as u32;
+//			vec.push(Period {
+//				start: NaiveTime::from_hms_opt(start_val_h, start_val_m, 0).unwrap(),
+//				end: NaiveTime::from_hms_opt(end_val_h, end_val_m, 0).unwrap(),
+//			});
+//		}
+//		Ok(Periods(vec))
+//	}
+//}
+
+impl Type<Sqlite> for Periods {
+	fn type_info() -> SqliteTypeInfo {
+		<&[u8] as Type<Sqlite>>::type_info()
+	}
+
+	fn compatible(ty: &SqliteTypeInfo) -> bool {
+		<&[u8] as Type<Sqlite>>::compatible(ty)
+	}
+}
+
+impl<'q> Encode<'q, Sqlite> for Periods {
+	//noinspection DuplicatedCode
+	fn encode_by_ref(&self, buf: &mut <Sqlite as HasArguments<'q>>::ArgumentBuffer) -> IsNull {
+		<&Vec<u8> as Encode<Sqlite>>::encode(&Vec::from(self), buf)
+	}
+}
+
+impl<'r> Decode<'r, Sqlite> for Periods {
+	fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
+		let blob = <&[u8] as Decode<Sqlite>>::decode(value)?;
+		Ok(Periods::from(Vec::from(blob)))
+	}
+}
+
+impl From<&Periods> for Vec<u8> {
+	fn from(periods: &Periods) -> Vec<u8> {
+		periods.0
 			.iter()
 			.flat_map(|period| {
 				let vec = vec![
@@ -69,33 +136,23 @@ where
 				];
 				vec
 			})
-			.collect();
-
-		out.set_value(periods_u8);
-
-		Ok(IsNull::No)
+			.collect()
 	}
 }
 
-impl<DB> FromSql<Binary, DB> for Periods
-where
-	DB: diesel::backend::Backend,
-	Vec<u8>: FromSql<Binary, DB>,
-{
-	fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
-		let blob: Vec<u8> = Vec::from_sql(bytes).unwrap();
-
+impl From<Vec<u8>> for Periods {
+	fn from(value: Vec<u8>) -> Self {
 		let mut vec = Vec::new();
-		for i in (3..blob.len()).step_by(4) {
-			let start_val_h: u32 = blob[i - 3] as u32;
-			let start_val_m: u32 = blob[i - 2] as u32;
-			let end_val_h: u32 = blob[i - 1] as u32;
-			let end_val_m: u32 = blob[i] as u32;
+		for i in (3..value.len()).step_by(4) {
+			let start_val_h: u32 = value[i - 3] as u32;
+			let start_val_m: u32 = value[i - 2] as u32;
+			let end_val_h: u32 = value[i - 1] as u32;
+			let end_val_m: u32 = value[i] as u32;
 			vec.push(Period {
 				start: NaiveTime::from_hms_opt(start_val_h, start_val_m, 0).unwrap(),
 				end: NaiveTime::from_hms_opt(end_val_h, end_val_m, 0).unwrap(),
 			});
 		}
-		Ok(Periods(vec))
+		Periods(vec)
 	}
 }