321 lines
13 KiB
Rust
321 lines
13 KiB
Rust
use super::Database;
|
||
use crate::models::*;
|
||
use sqlx::Row;
|
||
use uuid::Uuid;
|
||
|
||
impl Database {
|
||
// ── 查询 ──
|
||
|
||
pub async fn get_all_albums(&self) -> Result<Vec<AlbumInfo>, sqlx::Error> {
|
||
let rows = sqlx::query(
|
||
r#"SELECT id, title, document, description, cover_image_id, image_count, created_at
|
||
FROM albums ORDER BY created_at DESC"#
|
||
).fetch_all(&self.pool).await?;
|
||
|
||
Ok(rows.iter().map(|r| {
|
||
let id_str = r.get::<String, _>("id");
|
||
AlbumInfo {
|
||
id: Uuid::parse_str(&id_str).unwrap_or_else(|_| Uuid::nil()),
|
||
title: r.get("title"),
|
||
document: r.get("document"),
|
||
description: r.get("description"),
|
||
cover_image_id: r.get("cover_image_id"),
|
||
image_count: r.get("image_count"),
|
||
created_at: r.get("created_at"),
|
||
tags: vec![],
|
||
persons: vec![],
|
||
}
|
||
}).collect())
|
||
}
|
||
|
||
/// 组合过滤搜索(懒加载):仅返回符合条件的相册,避免全量加载
|
||
///
|
||
/// 支持按 tag / person / 标题关键词 任意组合过滤(AND 关系)。
|
||
/// 参数传空字符串或 None 表示不过滤该维度。
|
||
/// 全参数为空时等价于 get_all_albums。
|
||
pub async fn search_albums_with_filters(
|
||
&self,
|
||
tag: Option<&str>,
|
||
person: Option<&str>,
|
||
title_q: Option<&str>,
|
||
limit: i64,
|
||
offset: i64,
|
||
) -> Result<Vec<AlbumInfo>, sqlx::Error> {
|
||
let has_tag = tag.map(|s| !s.is_empty()).unwrap_or(false);
|
||
let has_person = person.map(|s| !s.is_empty()).unwrap_or(false);
|
||
let has_q = title_q.map(|s| !s.is_empty()).unwrap_or(false);
|
||
|
||
if !has_tag && !has_person && !has_q {
|
||
// 无过滤条件 → 走缓存路径,这里回退到全量查询
|
||
return self.get_all_albums().await;
|
||
}
|
||
|
||
// 动态构建 SQL
|
||
let sql = {
|
||
let mut s = String::from(
|
||
"SELECT DISTINCT a.id, a.title, a.document, a.description, \
|
||
a.cover_image_id, a.image_count, a.created_at \
|
||
FROM albums a"
|
||
);
|
||
let mut joins = Vec::new();
|
||
let mut wheres = Vec::new();
|
||
|
||
if has_tag {
|
||
joins.push("JOIN album_tags t ON a.id = t.album_id");
|
||
wheres.push("t.tag = ?");
|
||
}
|
||
if has_person {
|
||
joins.push("JOIN person_albums pa ON a.id = pa.album_id");
|
||
joins.push("JOIN persons p ON pa.person_id = p.id");
|
||
wheres.push("(p.name = ? OR p.name LIKE ?)");
|
||
}
|
||
if has_q {
|
||
wheres.push("a.title LIKE ?");
|
||
}
|
||
|
||
for j in &joins {
|
||
s.push(' ');
|
||
s.push_str(j);
|
||
}
|
||
if !wheres.is_empty() {
|
||
s.push_str(" WHERE ");
|
||
s.push_str(&wheres.join(" AND "));
|
||
}
|
||
s.push_str(" ORDER BY a.created_at DESC");
|
||
|
||
if limit > 0 {
|
||
s.push_str(" LIMIT ? OFFSET ?");
|
||
}
|
||
|
||
s
|
||
};
|
||
|
||
let mut q = sqlx::query(&sql);
|
||
|
||
if has_tag {
|
||
q = q.bind(tag.unwrap());
|
||
}
|
||
if has_person {
|
||
let p = person.unwrap();
|
||
q = q.bind(p).bind(format!("%{}%", p));
|
||
}
|
||
if has_q {
|
||
q = q.bind(format!("%{}%", title_q.unwrap()));
|
||
}
|
||
if limit > 0 {
|
||
q = q.bind(limit).bind(offset);
|
||
}
|
||
|
||
let rows = q.fetch_all(&self.pool).await?;
|
||
Ok(rows.iter().map(|r| {
|
||
AlbumInfo {
|
||
id: Uuid::parse_str(&r.get::<String, _>("id")).unwrap_or_else(|_| Uuid::nil()),
|
||
title: r.get("title"),
|
||
document: r.get("document"),
|
||
description: r.get("description"),
|
||
cover_image_id: r.get("cover_image_id"),
|
||
image_count: r.get("image_count"),
|
||
created_at: r.get("created_at"),
|
||
tags: vec![],
|
||
persons: vec![],
|
||
}
|
||
}).collect())
|
||
}
|
||
|
||
pub async fn get_album_with_images(&self, album_id: Uuid) -> Result<Option<AlbumWithImages>, sqlx::Error> {
|
||
let row = sqlx::query("SELECT * FROM albums WHERE id = ?")
|
||
.bind(album_id.to_string())
|
||
.fetch_optional(&self.pool).await?;
|
||
|
||
let Some(row) = row else { return Ok(None) };
|
||
|
||
let id_str = row.get::<String, _>("id");
|
||
let id = Uuid::parse_str(&id_str).unwrap_or_else(|_| Uuid::nil());
|
||
let cover = row.get::<Option<String>, _>("cover_image_id")
|
||
.and_then(|s| Uuid::parse_str(&s).ok());
|
||
|
||
let album = Album {
|
||
id,
|
||
title: row.get("title"),
|
||
description: row.get("description"),
|
||
cover_image_id: cover,
|
||
image_count: row.get("image_count"),
|
||
created_at: row.get("created_at"),
|
||
updated_at: row.get("updated_at"),
|
||
};
|
||
|
||
let img_rows = sqlx::query("SELECT * FROM images WHERE album_id = ?")
|
||
.bind(album_id.to_string()).fetch_all(&self.pool).await?;
|
||
|
||
let mut images = Vec::new();
|
||
for r in &img_rows {
|
||
let img_id = Uuid::parse_str(&r.get::<String, _>("id")).unwrap_or_else(|_| Uuid::nil());
|
||
let aid = Uuid::parse_str(&r.get::<String, _>("album_id")).unwrap_or_else(|_| Uuid::nil());
|
||
images.push(super::image::Image {
|
||
id: img_id, album_id: aid,
|
||
filename: r.get("filename"),
|
||
original_url: r.get("original_url"),
|
||
title: r.get("title"),
|
||
description: r.get("description"),
|
||
file_size: r.get("file_size"),
|
||
width: r.get("width"),
|
||
height: r.get("height"),
|
||
mime_type: r.get("mime_type"),
|
||
created_at: r.get("created_at"),
|
||
});
|
||
}
|
||
|
||
Ok(Some(AlbumWithImages { album, images: images.clone(), image_count: images.len() as i64, tags: vec![], persons: vec![] }))
|
||
}
|
||
|
||
pub async fn get_all_albums_full(&self) -> Vec<AlbumMeta> {
|
||
let rows = sqlx::query(
|
||
r#"SELECT id, title, cover_image_id, image_count
|
||
FROM albums"#
|
||
).fetch_all(&self.pool).await.unwrap_or_default();
|
||
|
||
rows.iter().map(|r| AlbumMeta {
|
||
id: r.get("id"), title: r.get("title"),
|
||
cover_image_id: r.get("cover_image_id"),
|
||
image_count: r.get("image_count"),
|
||
}).collect()
|
||
}
|
||
|
||
/// 按 ID 列表批量查询相册元数据
|
||
pub async fn get_albums_by_ids(&self, ids: &[String]) -> Vec<AlbumMeta> {
|
||
if ids.is_empty() { return Vec::new(); }
|
||
|
||
let placeholders: Vec<String> = (0..ids.len()).map(|_| "?".to_string()).collect();
|
||
let sql = format!(
|
||
"SELECT id, title, cover_image_id, image_count
|
||
FROM albums WHERE id IN ({})",
|
||
placeholders.join(", ")
|
||
);
|
||
|
||
let mut query = sqlx::query(&sql);
|
||
for id in ids {
|
||
query = query.bind(id);
|
||
}
|
||
|
||
let rows = query.fetch_all(&self.pool).await.unwrap_or_default();
|
||
rows.iter().map(|r| AlbumMeta {
|
||
id: r.get("id"), title: r.get("title"),
|
||
cover_image_id: r.get("cover_image_id"),
|
||
image_count: r.get("image_count"),
|
||
}).collect()
|
||
}
|
||
|
||
/// 获取所有未处理的相册 ID(processed_at IS NULL),用于管线收集新相册
|
||
pub async fn get_unprocessed_album_ids(&self) -> Vec<String> {
|
||
let rows = sqlx::query_scalar::<_, String>(
|
||
"SELECT id FROM albums WHERE processed_at IS NULL"
|
||
).fetch_all(&self.pool).await.unwrap_or_default();
|
||
rows
|
||
}
|
||
|
||
// ── 写入 ──
|
||
|
||
pub async fn create_album(&self, album: CreateAlbum) -> Result<Uuid, sqlx::Error> {
|
||
let _guard = self.write_lock.lock().await;
|
||
let id = Uuid::new_v4();
|
||
let now = chrono::Utc::now().to_rfc3339();
|
||
sqlx::query(
|
||
"INSERT INTO albums (id, title, document, description, image_count, created_at, updated_at) VALUES (?, ?, ?, ?, 0, ?, ?)"
|
||
).bind(id.to_string()).bind(album.title).bind(album.document).bind(album.description).bind(&now).bind(&now)
|
||
.execute(&self.pool).await?;
|
||
Ok(id)
|
||
}
|
||
|
||
/// 将所有相册重置为未处理状态(processed_at = NULL),下次管线会重新解析全部相册
|
||
pub async fn reset_all_processed_at(&self) -> usize {
|
||
sqlx::query("UPDATE albums SET processed_at = NULL")
|
||
.execute(&self.pool).await.unwrap_or_default()
|
||
.rows_affected() as usize
|
||
}
|
||
|
||
pub async fn delete_album(&self, album_id: Uuid) -> Result<(), sqlx::Error> {
|
||
let _guard = self.write_lock.lock().await;
|
||
let aid = album_id.to_string();
|
||
// 先删除 person_albums(无 CASCADE)
|
||
sqlx::query("DELETE FROM person_albums WHERE album_id = ?").bind(&aid).execute(&self.pool).await?;
|
||
// 再删除 albums(images/favorites/album_tags 由 CASCADE 自动处理)
|
||
sqlx::query("DELETE FROM albums WHERE id = ?").bind(&aid).execute(&self.pool).await?;
|
||
Ok(())
|
||
}
|
||
|
||
/// 批量删除相册(级联清理所有关联数据)
|
||
pub async fn delete_albums_batch(&self, album_ids: &[Uuid]) -> usize {
|
||
if album_ids.is_empty() { return 0; }
|
||
let _guard = self.write_lock.lock().await;
|
||
for id in album_ids {
|
||
let aid = id.to_string();
|
||
sqlx::query("DELETE FROM person_albums WHERE album_id = ?").bind(&aid).execute(&self.pool).await.ok();
|
||
sqlx::query("DELETE FROM albums WHERE id = ?").bind(&aid).execute(&self.pool).await.ok();
|
||
}
|
||
album_ids.len()
|
||
}
|
||
|
||
/// 查询 image_count = 0 的空相册
|
||
pub async fn get_empty_albums(&self) -> Vec<AlbumInfo> {
|
||
let rows = sqlx::query(
|
||
r#"SELECT id, title, document, description, cover_image_id, image_count, created_at
|
||
FROM albums WHERE image_count IS NULL OR image_count = 0
|
||
ORDER BY created_at DESC"#
|
||
).fetch_all(&self.pool).await.unwrap_or_default();
|
||
rows.iter().map(|r| {
|
||
let id_str = r.get::<String, _>("id");
|
||
AlbumInfo {
|
||
id: Uuid::parse_str(&id_str).unwrap_or_else(|_| Uuid::nil()),
|
||
title: r.get("title"), document: r.get("document"),
|
||
description: r.get("description"), cover_image_id: r.get("cover_image_id"),
|
||
image_count: r.get("image_count"), created_at: r.get("created_at"),
|
||
tags: vec![], persons: vec![],
|
||
}
|
||
}).collect()
|
||
}
|
||
|
||
/// 查找重名相册,返回结构:每个元素为 (keep_id, keep_document, [(dup_id, dup_document)])
|
||
pub async fn find_duplicate_albums(&self) -> Vec<(Uuid, String, Vec<(Uuid, String)>)> {
|
||
let rows = sqlx::query(
|
||
r#"SELECT id, title, document FROM albums WHERE title != '' ORDER BY created_at ASC"#
|
||
).fetch_all(&self.pool).await.unwrap_or_default();
|
||
|
||
// title → [(id, document)]
|
||
let mut title_map: std::collections::HashMap<String, Vec<(Uuid, String)>> = std::collections::HashMap::new();
|
||
for r in &rows {
|
||
let title: String = r.get("title");
|
||
let id_str: String = r.get("id");
|
||
let doc: String = r.get("document");
|
||
if let Ok(id) = Uuid::parse_str(&id_str) {
|
||
title_map.entry(title).or_default().push((id, doc));
|
||
}
|
||
}
|
||
|
||
title_map.into_iter()
|
||
.filter(|(_, items)| items.len() > 1)
|
||
.map(|(_, items)| {
|
||
let keep = items[0].clone(); // (keep_id, keep_document)
|
||
let dups = items[1..].to_vec();
|
||
(keep.0, keep.1, dups)
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
pub async fn update_album_cover(&self, album_id: Uuid, image_id: Uuid) -> Result<(), sqlx::Error> {
|
||
sqlx::query("UPDATE albums SET cover_image_id = ? WHERE id = ?")
|
||
.bind(image_id.to_string()).bind(album_id.to_string()).execute(&self.pool).await?;
|
||
Ok(())
|
||
}
|
||
|
||
pub async fn update_album_image_count(&self, album_id: Uuid) -> Result<(), sqlx::Error> {
|
||
sqlx::query(
|
||
r#"UPDATE albums SET image_count = (SELECT COUNT(*) FROM images WHERE album_id = ?), updated_at = datetime('now') WHERE id = ?"#
|
||
).bind(album_id.to_string()).bind(album_id.to_string()).execute(&self.pool).await?;
|
||
Ok(())
|
||
}
|
||
|
||
pub async fn get_album_image_count(&self, album_id: Uuid) -> Result<i64, sqlx::Error> {
|
||
sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM images WHERE album_id = ?")
|
||
.bind(album_id.to_string()).fetch_one(&self.pool).await
|
||
}
|
||
} |