1use super::{cache, BytesWriting, CacheReservation, FileDatabase};
8use crate::sqlite::StoreSql;
9use crate::{DbError, FileRef};
10use coven_foundation::files::FileName;
11
12impl FileDatabase {
13 #[expect(clippy::map_err_ignore, reason = "a stored name that won't decode is DamagedDatabase")]
19 pub async fn reserve_pin_download(
20 &self,
21 file: &FileRef,
22 fresh: FileName,
23 ) -> Result<(CacheReservation, u64), DbError> {
24 let database = &self.database;
25 let writing = BytesWriting::of(database).await;
26 let held = {
27 let file = file.clone();
28 database
29 .call(move |inner| {
30 let found = inner.access.with_writer(|writer, call| {
31 crate::transaction_constants::read_with_constants(writer, call, || {
32 partial(writer, &file)
33 })
34 })?;
35 let Some((path, size)) = found else {
36 return Ok(None);
37 };
38 let name = FileName::new(&path).map_err(|_| DbError::DamagedDatabase)?;
39 inner.staging.reserve([crate::file_removals::OwnedFile::Cached(name.clone())]);
40 Ok::<_, DbError>(Some((
41 CacheReservation {
42 reserved: inner.staging.clone(),
43 file,
44 name,
45 writing: Some(writing),
46 partial: true,
47 },
48 size,
49 )))
50 })
51 .await?
52 };
53 match held {
54 Some(held) => Ok(held),
55 None => Ok((self.reserve_cache_file(file, fresh).await?, 0)),
56 }
57 }
58
59 #[expect(
65 clippy::map_err_ignore,
66 reason = "a size past SQLite's integer is TooLarge, which names the field and size"
67 )]
68 pub async fn keep_pin_download(
69 &self,
70 reservation: &mut CacheReservation,
71 size: u64,
72 ) -> Result<(), DbError> {
73 let (file, name, kept) =
74 (reservation.file.clone(), reservation.name.clone(), reservation.partial);
75 let size = i64::try_from(size).map_err(|_| DbError::TooLarge {
76 field: "partial pin download",
77 actual: size,
78 maximum: i64::MAX as u64,
79 })?;
80 self.run(move |db, _, _, _, _| db.transaction(|db| record(db, &file, &name, size, kept)))
81 .await?;
82 reservation.partial = true;
83 Ok(())
84 }
85
86 #[cfg(any(test, feature = "test-utils"))]
89 #[expect(clippy::map_err_ignore, reason = "a stored name that won't decode is DamagedDatabase")]
90 pub async fn pin_download_kept(
91 &self,
92 file: &FileRef,
93 ) -> Result<Option<(FileName, u64)>, DbError> {
94 let file = file.clone();
95 let found = self.read(move |db, _| partial(db, &file)).await?;
96 found
97 .map(|(path, size)| {
98 Ok((FileName::new(&path).map_err(|_| DbError::DamagedDatabase)?, size))
99 })
100 .transpose()
101 }
102
103 pub async fn discard_pin_download(&self, file: &FileRef) -> Result<(), DbError> {
106 let file = file.clone();
107 let chosen = self
108 .run(move |db, _, _, _, _| {
109 let object = cache::object_path_of(&file)?;
110 let paths = remove(db, file.namespace(), &object)?;
111 Ok::<_, DbError>(crate::file_removals::choose_cache(&paths))
112 })
113 .await?;
114 self.removed(chosen).await
115 }
116}
117
118#[expect(clippy::map_err_ignore, reason = "a stored size that won't convert is DamagedDatabase")]
121fn partial(db: &StoreSql, file: &FileRef) -> Result<Option<(String, u64)>, DbError> {
122 let found = db
123 .query(
124 "SELECT path,size FROM _coven_cache_partials WHERE namespace=?1 AND object_path=?2",
125 (file.namespace(), cache::object_path_of(file)?),
126 |r| Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?)),
127 )?
128 .pop();
129 found
130 .map(|(path, size)| Ok((path, u64::try_from(size).map_err(|_| DbError::DamagedDatabase)?)))
131 .transpose()
132}
133
134fn record(
138 db: &StoreSql,
139 file: &FileRef,
140 name: &FileName,
141 size: i64,
142 kept: bool,
143) -> Result<(), DbError> {
144 if !cache::named(db, file)? {
145 return Err(DbError::NoLongerStored { file: file.id() });
146 }
147 let object = cache::object_path_of(file)?;
148 if kept {
149 let updated = db.execute(
150 "UPDATE _coven_cache_partials SET size=?4
151 WHERE namespace=?1 AND object_path=?2 AND path=?3",
152 sqlive::rusqlite::params![file.namespace(), object, name.as_str(), size],
153 )?;
154 return if updated == 1 { Ok(()) } else { Err(DbError::PinChanged { file: file.id() }) };
155 }
156 crate::file_removals::keep(db, "cache", name.as_str())?;
158 db.execute(
159 "INSERT INTO _coven_cache_partials(namespace,object_path,path,size) VALUES(?1,?2,?3,?4)",
160 sqlive::rusqlite::params![file.namespace(), object, name.as_str(), size],
161 )?;
162 Ok(())
163}
164
165pub(crate) fn remove(db: &StoreSql, namespace: &str, object: &str) -> Result<Vec<String>, DbError> {
168 let paths = db.query(
169 "DELETE FROM _coven_cache_partials WHERE namespace=?1 AND object_path=?2 RETURNING path",
170 (namespace, object),
171 |r| r.get::<_, String>(0),
172 )?;
173 for path in &paths {
174 crate::file_removals::record_cached(db, path)?;
175 }
176 Ok(paths)
177}