1use crate::sqlite::StoreSql;
9use crate::DbError;
10use coven_foundation::id_source::FileId;
11
12#[derive(
14 Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize,
15)]
16pub struct MoveId(pub i64);
17
18impl sqlive::rusqlite::ToSql for MoveId {
21 fn to_sql(&self) -> sqlive::rusqlite::Result<sqlive::rusqlite::types::ToSqlOutput<'_>> {
22 Ok(self.0.into())
23 }
24}
25
26impl sqlive::rusqlite::types::FromSql for MoveId {
27 fn column_result(
28 value: sqlive::rusqlite::types::ValueRef<'_>,
29 ) -> sqlive::rusqlite::types::FromSqlResult<Self> {
30 i64::column_result(value).map(Self)
31 }
32}
33
34#[derive(Clone, Copy, Debug, PartialEq, Eq)]
36pub(crate) enum MoveState {
37 Moving,
39 Failed,
43 Cancelled,
45 Finished,
47}
48
49impl MoveState {
50 fn text(self) -> &'static str {
51 match self {
52 Self::Moving => "moving",
53 Self::Failed => "failed",
54 Self::Cancelled => "cancelled",
55 Self::Finished => "finished",
56 }
57 }
58}
59
60pub(crate) fn create(db: &StoreSql) -> Result<MoveId, DbError> {
62 Ok(db.query_row("INSERT INTO _coven_moves(state) VALUES('moving') RETURNING id", [], |r| {
63 r.get(0)
64 })?)
65}
66
67pub(crate) fn state(db: &StoreSql, id: MoveId) -> Result<Option<MoveState>, DbError> {
69 db.query("SELECT state FROM _coven_moves WHERE id=?1", [id], |r| r.get::<_, String>(0))?
70 .pop()
71 .map(|state| match state.as_str() {
72 "moving" => Ok(MoveState::Moving),
73 "failed" => Ok(MoveState::Failed),
74 "cancelled" => Ok(MoveState::Cancelled),
75 "finished" => Ok(MoveState::Finished),
76 _ => Err(DbError::DamagedDatabase),
77 })
78 .transpose()
79}
80
81pub(crate) fn bound(db: &StoreSql, id: MoveId) -> Result<bool, DbError> {
84 Ok(db.query_row(
85 "SELECT EXISTS(SELECT 1 FROM _coven_file_uploads WHERE move=?1 AND holds IS NOT NULL)",
86 [id],
87 |r| r.get(0),
88 )?)
89}
90
91pub(crate) fn of_upload(db: &StoreSql, upload: i64) -> Result<MoveId, DbError> {
93 db.query_row("SELECT move FROM _coven_file_uploads WHERE id=?1", [upload], |r| r.get(0))
94 .map_err(|error| match error {
95 sqlive::Error::Sqlite(sqlive::rusqlite::Error::QueryReturnedNoRows) => {
96 DbError::Invariant { what: "a queued upload belongs to a move" }
97 }
98 error => DbError::from(error),
99 })
100}
101
102pub(crate) fn of_file(db: &StoreSql, file: FileId) -> Result<Option<MoveId>, DbError> {
105 Ok(db.query("SELECT move FROM _coven_move_files WHERE file=?1", [file], |r| r.get(0))?.pop())
106}
107
108pub(crate) fn list_all(db: &StoreSql, files: &[(MoveId, FileId)]) -> Result<(), DbError> {
111 let rows: Vec<_> = files
112 .iter()
113 .map(|(id, file)| {
114 Ok(vec![crate::insert_rows::value(id)?, crate::insert_rows::value(file)?])
115 })
116 .collect::<Result<_, DbError>>()?;
117 crate::insert_rows::insert_rows(
118 db,
119 2,
120 &rows,
121 |values| format!("INSERT INTO _coven_move_files(move,file) VALUES{values}"),
122 |_| Ok(()),
123 )?;
124 Ok(())
125}
126
127pub(crate) fn join(db: &StoreSql, from: FileId, to: FileId) -> Result<(), DbError> {
130 db.execute(
131 "INSERT INTO _coven_move_files(move,file)
132 SELECT u.move,?2 FROM _coven_upload_files AS l
133 JOIN _coven_file_uploads AS u ON u.id=l.upload WHERE l.file=?1",
134 sqlive::rusqlite::params![from, to],
135 )?;
136 Ok(())
137}
138
139pub(crate) fn forget(db: &StoreSql, file: FileId) -> Result<(), DbError> {
141 db.execute("DELETE FROM _coven_move_files WHERE file=?1", [file])?;
142 Ok(())
143}
144
145fn set(db: &StoreSql, id: MoveId, state: MoveState) -> Result<(), DbError> {
148 match state {
149 MoveState::Cancelled | MoveState::Finished => {
150 db.execute("DELETE FROM _coven_move_files WHERE move=?1", [id])?;
151 }
152 MoveState::Moving | MoveState::Failed => {}
153 }
154 db.execute(
155 "UPDATE _coven_moves SET state=?2 WHERE id=?1",
156 sqlive::rusqlite::params![id, state.text()],
157 )?;
158 Ok(())
159}
160
161pub(crate) fn end_unswitched(db: &StoreSql, id: MoveId, state: MoveState) -> Result<(), DbError> {
168 crate::file_queue::unswitch_move(db, id)?;
169 set(db, id, state)
170}
171
172pub(crate) fn complete(db: &StoreSql) -> Result<Vec<(MoveId, Vec<i64>)>, DbError> {
176 let moves = db.query(
177 "SELECT m.id FROM _coven_moves AS m WHERE m.state='moving'
178 AND NOT EXISTS(SELECT 1 FROM _coven_file_uploads AS u
179 WHERE u.move=m.id AND u.stored=0
180 AND EXISTS(SELECT 1 FROM _coven_upload_files AS l WHERE l.upload=u.id))",
181 [],
182 |r| r.get(0),
183 )?;
184 moves
185 .into_iter()
186 .map(|id| {
187 let uploads = db.query(
188 "SELECT u.id FROM _coven_file_uploads AS u WHERE u.move=?1
189 AND EXISTS(SELECT 1 FROM _coven_upload_files AS l WHERE l.upload=u.id)
190 ORDER BY u.id",
191 [id],
192 |r| r.get(0),
193 )?;
194 Ok((id, uploads))
195 })
196 .collect()
197}
198
199pub(crate) fn finish(db: &StoreSql, id: MoveId) -> Result<(), DbError> {
201 set(db, id, MoveState::Finished)?;
202 crate::pending::clear_move(db, id)
203}
204
205#[cfg(test)]
206#[path = "file_moves_tests.rs"]
207pub(crate) mod tests;