369 lines
14 KiB
Rust
369 lines
14 KiB
Rust
//! 搜索读取方法 — SearchDb 的只读接口
|
||
//!
|
||
//! 所有搜索相关的数据读取都从这里进行，完全不碰主库。
|
||
|
||
use sqlx::Row;
|
||
use std::collections::HashMap;
|
||
use uuid::Uuid;
|
||
|
||
use crate::models::*;
|
||
use super::SearchDb;
|
||
|
||
impl SearchDb {
|
||
// ═══════════════════════════════════════
|
||
// 相册搜索
|
||
// ═══════════════════════════════════════
|
||
|
||
/// 组合搜索：按 tag/person/标题关键词 任意组合过滤（AND）
|
||
pub async fn search_albums(
|
||
&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;
|
||
}
|
||
|
||
let mut sql = String::from(
|
||
"SELECT DISTINCT a.id, a.title, a.cover_image_id, a.image_count, a.created_at
|
||
FROM albums a"
|
||
);
|
||
let mut conditions: Vec<String> = Vec::new();
|
||
|
||
if has_tag {
|
||
sql.push_str(" JOIN album_tags at ON a.id = at.album_id JOIN tags t ON at.tag_id = t.id");
|
||
conditions.push("t.name = ?".to_string());
|
||
}
|
||
if has_person {
|
||
sql.push_str(" JOIN album_persons ap ON a.id = ap.album_id JOIN persons p ON ap.person_id = p.id");
|
||
conditions.push("(p.name = ? OR LOWER(p.name) LIKE ?)".to_string());
|
||
}
|
||
|
||
if !conditions.is_empty() {
|
||
sql.push_str(" WHERE ");
|
||
sql.push_str(&conditions.join(" AND "));
|
||
}
|
||
if has_q {
|
||
if conditions.is_empty() {
|
||
sql.push_str(" WHERE ");
|
||
} else {
|
||
sql.push_str(" AND ");
|
||
}
|
||
sql.push_str("a.title LIKE ?");
|
||
}
|
||
|
||
sql.push_str(" ORDER BY a.created_at DESC LIMIT ? OFFSET ?");
|
||
|
||
let mut query = sqlx::query(&sql);
|
||
|
||
if has_tag { query = query.bind(tag.unwrap()); }
|
||
if has_person {
|
||
let p = person.unwrap();
|
||
query = query.bind(p).bind(format!("%{}%", p));
|
||
}
|
||
if has_q { query = query.bind(format!("%{}%", title_q.unwrap())); }
|
||
|
||
query = query.bind(limit).bind(offset);
|
||
|
||
let rows = query.fetch_all(&self.pool).await?;
|
||
Ok(rows.iter().map(|r| {
|
||
let id_str: String = r.get("id");
|
||
AlbumInfo {
|
||
id: Uuid::parse_str(&id_str).unwrap_or_else(|_| Uuid::nil()),
|
||
title: r.get("title"),
|
||
document: String::new(),
|
||
description: None,
|
||
cover_image_id: r.get("cover_image_id"),
|
||
image_count: r.get("image_count"),
|
||
created_at: r.get("created_at"),
|
||
}
|
||
}).collect())
|
||
}
|
||
|
||
/// 获取全量相册列表（缓存烘焙用）
|
||
pub async fn get_all_albums(&self) -> Result<Vec<AlbumInfo>, sqlx::Error> {
|
||
let rows = sqlx::query(
|
||
"SELECT id, title, 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: String = r.get("id");
|
||
AlbumInfo {
|
||
id: Uuid::parse_str(&id_str).unwrap_or_else(|_| Uuid::nil()),
|
||
title: r.get("title"),
|
||
document: String::new(),
|
||
description: None,
|
||
cover_image_id: r.get("cover_image_id"),
|
||
image_count: r.get("image_count"),
|
||
created_at: r.get("created_at"),
|
||
}
|
||
}).collect())
|
||
}
|
||
|
||
// ═══════════════════════════════════════
|
||
// 标签搜索
|
||
// ═══════════════════════════════════════
|
||
|
||
/// 获取热门标签（按使用次数排序）
|
||
pub async fn get_popular_tags(&self, limit: usize) -> Vec<TagStat> {
|
||
let limit = limit.min(500);
|
||
let rows = sqlx::query(
|
||
r#"SELECT t.name, COUNT(at.album_id) as cnt
|
||
FROM tags t
|
||
JOIN album_tags at ON t.id = at.tag_id
|
||
GROUP BY t.id, t.name
|
||
ORDER BY cnt DESC LIMIT ?"#
|
||
).bind(limit as i64).fetch_all(&self.pool).await.unwrap_or_default();
|
||
|
||
rows.iter().map(|r| TagStat {
|
||
tag: r.get("name"),
|
||
count: r.get("cnt"),
|
||
album_count: 0,
|
||
}).collect()
|
||
}
|
||
|
||
/// 获取标签倒排索引：tag → albums（缓存烘焙用）
|
||
pub async fn get_all_tag_albums(&self) -> HashMap<String, Vec<AlbumInfo>> {
|
||
let rows = sqlx::query(
|
||
r#"SELECT t.name as tag_name,
|
||
a.id, a.title, a.cover_image_id, a.image_count, a.created_at
|
||
FROM tags t
|
||
JOIN album_tags at ON t.id = at.tag_id
|
||
JOIN albums a ON a.id = at.album_id
|
||
ORDER BY a.created_at DESC"#
|
||
).fetch_all(&self.pool).await.unwrap_or_default();
|
||
|
||
let mut map: HashMap<String, Vec<AlbumInfo>> = HashMap::new();
|
||
for r in &rows {
|
||
let tag_name: String = r.get("tag_name");
|
||
let id_str: String = r.get("id");
|
||
let album = AlbumInfo {
|
||
id: Uuid::parse_str(&id_str).unwrap_or_else(|_| Uuid::nil()),
|
||
title: r.get("title"),
|
||
document: String::new(),
|
||
description: None,
|
||
cover_image_id: r.get("cover_image_id"),
|
||
image_count: r.get("image_count"),
|
||
created_at: r.get("created_at"),
|
||
};
|
||
map.entry(tag_name).or_default().push(album);
|
||
}
|
||
map
|
||
}
|
||
|
||
/// 按标签搜索相册
|
||
pub async fn search_albums_by_tag(&self, tag: &str) -> Vec<AlbumInfo> {
|
||
let rows = sqlx::query(
|
||
r#"SELECT a.id, a.title, a.cover_image_id, a.image_count, a.created_at
|
||
FROM albums a
|
||
JOIN album_tags at ON a.id = at.album_id
|
||
JOIN tags t ON at.tag_id = t.id
|
||
WHERE t.name = ?
|
||
ORDER BY a.created_at DESC"#
|
||
).bind(tag).fetch_all(&self.pool).await.unwrap_or_default();
|
||
|
||
rows.iter().map(|r| {
|
||
let id_str: String = r.get("id");
|
||
AlbumInfo {
|
||
id: Uuid::parse_str(&id_str).unwrap_or_else(|_| Uuid::nil()),
|
||
title: r.get("title"),
|
||
document: String::new(),
|
||
description: None,
|
||
cover_image_id: r.get("cover_image_id"),
|
||
image_count: r.get("image_count"),
|
||
created_at: r.get("created_at"),
|
||
}
|
||
}).collect()
|
||
}
|
||
|
||
/// 获取标签共现数据（关联推荐用）
|
||
pub async fn get_tag_co_occurrences(&self, tag: &str, limit: i64) -> Vec<TagCoOccurrence> {
|
||
let rows = sqlx::query(
|
||
r#"SELECT t2.name as co_tag, COUNT(*) as cnt
|
||
FROM album_tags at1
|
||
JOIN album_tags at2 ON at1.album_id = at2.album_id AND at1.tag_id != at2.tag_id
|
||
JOIN tags t1 ON at1.tag_id = t1.id
|
||
JOIN tags t2 ON at2.tag_id = t2.id
|
||
WHERE t1.name = ?
|
||
GROUP BY t2.name
|
||
ORDER BY cnt DESC LIMIT ?"#
|
||
).bind(tag).bind(limit).fetch_all(&self.pool).await.unwrap_or_default();
|
||
|
||
let total: i64 = sqlx::query_scalar(
|
||
"SELECT COUNT(*) FROM album_tags at JOIN tags t ON at.tag_id = t.id WHERE t.name = ?"
|
||
).bind(tag).fetch_one(&self.pool).await.unwrap_or(1);
|
||
|
||
rows.iter().map(|r| TagCoOccurrence {
|
||
tag: tag.to_string(),
|
||
co_tag: r.get("co_tag"),
|
||
count: r.get("cnt"),
|
||
score: r.get::<i64, _>("cnt") as f64 / total as f64,
|
||
}).collect()
|
||
}
|
||
|
||
// ═══════════════════════════════════════
|
||
// 人物搜索
|
||
// ═══════════════════════════════════════
|
||
|
||
/// 获取人物别名列表
|
||
pub async fn get_person_aliases(&self, person_id: i64) -> Vec<PersonAlias> {
|
||
let rows = sqlx::query(
|
||
"SELECT id, person_id, alias_type, alias_name, created_at FROM person_aliases WHERE person_id = ?"
|
||
).bind(person_id).fetch_all(&self.pool).await.unwrap_or_default();
|
||
|
||
rows.iter().map(|r| PersonAlias {
|
||
id: r.get("id"),
|
||
person_id: r.get("person_id"),
|
||
alias_type: r.get("alias_type"),
|
||
alias_name: r.get("alias_name"),
|
||
created_at: r.get("created_at"),
|
||
}).collect()
|
||
}
|
||
|
||
/// 获取所有人物（含别名、排序）
|
||
pub async fn get_all_persons_with_aliases(&self) -> Vec<PersonWithCounts> {
|
||
let persons = sqlx::query(
|
||
"SELECT id, name, display_name, total_albums, total_images FROM persons ORDER BY total_albums DESC"
|
||
).fetch_all(&self.pool).await.unwrap_or_default();
|
||
|
||
let mut results = Vec::new();
|
||
for r in &persons {
|
||
let id: i64 = r.get("id");
|
||
let name: String = r.get("name");
|
||
let aliases: Vec<String> = sqlx::query_scalar(
|
||
"SELECT alias_name FROM person_aliases WHERE person_id = ? ORDER BY alias_type"
|
||
).bind(id).fetch_all(&self.pool).await.unwrap_or_default();
|
||
|
||
results.push(PersonWithCounts {
|
||
id,
|
||
name,
|
||
display_name: r.get("display_name"),
|
||
total_albums: r.get("total_albums"),
|
||
total_images: r.get("total_images"),
|
||
aliases,
|
||
});
|
||
}
|
||
results
|
||
}
|
||
|
||
/// 按名称查找人物
|
||
pub async fn get_person_by_name(&self, name: &str) -> Option<PersonWithCounts> {
|
||
let row = sqlx::query(
|
||
"SELECT id, name, display_name, total_albums, total_images FROM persons WHERE name = ?"
|
||
).bind(name).fetch_optional(&self.pool).await.ok()??;
|
||
|
||
let id: i64 = row.get("id");
|
||
let aliases: Vec<String> = sqlx::query_scalar(
|
||
"SELECT alias_name FROM person_aliases WHERE person_id = ? ORDER BY alias_type"
|
||
).bind(id).fetch_all(&self.pool).await.unwrap_or_default();
|
||
|
||
Some(PersonWithCounts {
|
||
id,
|
||
name: row.get("name"),
|
||
display_name: row.get("display_name"),
|
||
total_albums: row.get("total_albums"),
|
||
total_images: row.get("total_images"),
|
||
aliases,
|
||
})
|
||
}
|
||
|
||
/// 获取人物的所有相册
|
||
pub async fn get_person_albums(&self, person_id: i64) -> Vec<AlbumInfo> {
|
||
let rows = sqlx::query(
|
||
r#"SELECT a.id, a.title, a.cover_image_id, a.image_count, a.created_at
|
||
FROM albums a
|
||
JOIN album_persons ap ON a.id = ap.album_id
|
||
WHERE ap.person_id = ?
|
||
ORDER BY a.created_at DESC"#
|
||
).bind(person_id).fetch_all(&self.pool).await.unwrap_or_default();
|
||
|
||
rows.iter().map(|r| {
|
||
let id_str: String = r.get("id");
|
||
AlbumInfo {
|
||
id: Uuid::parse_str(&id_str).unwrap_or_else(|_| Uuid::nil()),
|
||
title: r.get("title"),
|
||
document: String::new(),
|
||
description: None,
|
||
cover_image_id: r.get("cover_image_id"),
|
||
image_count: r.get("image_count"),
|
||
created_at: r.get("created_at"),
|
||
}
|
||
}).collect()
|
||
}
|
||
|
||
/// 获取人物的 top 标签（用于详情页）
|
||
pub async fn get_person_top_tags(&self, person_id: i64, limit: usize) -> Vec<(String, i64)> {
|
||
let rows = sqlx::query(
|
||
r#"SELECT t.name, COUNT(*) as cnt
|
||
FROM tags t
|
||
JOIN album_tags at ON t.id = at.tag_id
|
||
JOIN album_persons ap ON at.album_id = ap.album_id
|
||
WHERE ap.person_id = ?
|
||
GROUP BY t.name
|
||
ORDER BY cnt DESC LIMIT ?"#
|
||
).bind(person_id).bind(limit as i64)
|
||
.fetch_all(&self.pool).await.unwrap_or_default();
|
||
|
||
rows.iter().map(|r| (r.get("name"), r.get("cnt"))).collect()
|
||
}
|
||
|
||
/// 搜索人物（按名称/别名模糊匹配，内存）
|
||
pub fn search_persons_inline(persons: &[PersonWithCounts], query: &str) -> Vec<PersonWithCounts> {
|
||
let q = query.to_lowercase().trim().to_string();
|
||
if q.is_empty() || q.len() < 2 { return Vec::new(); }
|
||
|
||
let mut seen = std::collections::HashSet::new();
|
||
let mut results = Vec::new();
|
||
|
||
for p in persons {
|
||
let name_lower = p.name.to_lowercase();
|
||
let alias_matches = p.aliases.iter().any(|a| a.to_lowercase().contains(&q));
|
||
|
||
let matched = name_lower == q
|
||
|| name_lower.starts_with(&q)
|
||
|| name_lower.contains(&q)
|
||
|| alias_matches;
|
||
|
||
if matched && seen.insert(p.id) {
|
||
results.push(p.clone());
|
||
}
|
||
}
|
||
|
||
results.sort_by(|a, b| b.total_albums.cmp(&a.total_albums));
|
||
results
|
||
}
|
||
|
||
// ═══════════════════════════════════════
|
||
// 元数据统计
|
||
// ═══════════════════════════════════════
|
||
|
||
/// 获取全局统计信息
|
||
pub async fn get_metadata_stats(&self) -> MetadataStats {
|
||
let total_persons: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM persons")
|
||
.fetch_one(&self.pool).await.unwrap_or(0);
|
||
let total_aliases: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM person_aliases")
|
||
.fetch_one(&self.pool).await.unwrap_or(0);
|
||
let total_albums: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM albums")
|
||
.fetch_one(&self.pool).await.unwrap_or(0);
|
||
let total_images: i64 = sqlx::query_scalar("SELECT COALESCE(SUM(image_count), 0) FROM albums")
|
||
.fetch_one(&self.pool).await.unwrap_or(0);
|
||
let total_tags: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM album_tags")
|
||
.fetch_one(&self.pool).await.unwrap_or(0);
|
||
|
||
MetadataStats {
|
||
total_persons,
|
||
total_aliases,
|
||
total_albums,
|
||
total_images,
|
||
total_tags,
|
||
}
|
||
}
|
||
}
|