Compare commits

...

34 Commits

Author SHA1 Message Date
lychang
ec52439622 update code level 2026-07-21 04:59:33 +08:00
lychang
7c9c80fe39 update code level 2026-07-21 04:46:01 +08:00
lychang
f6c7baee5e update code level 2026-07-21 04:21:57 +08:00
lychang
d86cce34bc update code level 2026-07-21 04:00:11 +08:00
lychang
4321cfa62f update code level 2026-07-21 03:50:02 +08:00
lychang
d64b85bc9a update code level 2026-07-21 03:33:35 +08:00
lychang
f1dba9f24d update code level 2026-07-21 03:10:27 +08:00
lychang
49c0a0d307 update code level 2026-07-21 02:53:47 +08:00
lychang
4a80e3272f update code level 2026-07-21 02:48:52 +08:00
lychang
992ee32e9b update code level 2026-07-21 02:45:14 +08:00
lychang
12880dd480 update code level 2026-07-21 02:40:41 +08:00
lychang
cff2eb2886 update code level 2026-07-21 02:25:36 +08:00
lychang
005688b58f update code level 2026-07-21 02:17:46 +08:00
lychang
f572c7370d update code level 2026-07-21 02:11:53 +08:00
lychang
9c3ce4ec0d update code level 2026-07-21 02:01:52 +08:00
lychang
c8778c0ed1 update code level 2026-07-21 01:46:57 +08:00
lychang
284e610140 update code level 2026-07-21 01:44:42 +08:00
lychang
f68a8f880d update code level 2026-07-21 01:43:16 +08:00
lychang
90c493d41b update code level 2026-07-21 01:25:27 +08:00
lychang
9d81c5077c update code level 2026-07-21 01:05:06 +08:00
lychang
a85b4c869e update code level 2026-07-21 00:51:55 +08:00
lychang
81bbc67432 update code level 2026-07-21 00:43:40 +08:00
lychang
0a5dd1c920 update code level 2026-07-21 00:00:27 +08:00
lychang
ee1092c5a9 update code level 2026-07-20 23:50:07 +08:00
lychang
56dd82fb63 update code level 2026-07-20 23:46:39 +08:00
lychang
84409207e2 update code level 2026-07-20 23:12:20 +08:00
lychang
923f9bd7cf update code level 2026-07-20 14:24:04 +08:00
lychang
faa5b416da update code level 2026-07-20 14:08:16 +08:00
lychang
c6639778a4 update code level 2026-07-20 07:43:29 +08:00
lychang
a33ef65bd7 update code level 2026-07-20 07:35:26 +08:00
lychang
5e6b27f26d update code level 2026-07-20 07:03:08 +08:00
lychang
76cf668c08 Merge remote-tracking branch 'origin/master'
# Conflicts:
#	.gitignore
#	Cargo.lock
2026-07-20 06:57:18 +08:00
lychang
9879aab614 update code level 2026-07-20 06:56:54 +08:00
lychang
94af7695ff update code level 2026-07-20 06:56:08 +08:00
36 changed files with 3711 additions and 1336 deletions

6
.gitignore vendored
View File

@@ -1,3 +1,5 @@
/target /target
/albums/ /albums
.idea /.idea
/data
/scripts

73
Cargo.lock generated
View File

@@ -285,13 +285,13 @@ dependencies = [
[[package]] [[package]]
name = "async-trait" name = "async-trait"
version = "0.1.89" version = "0.1.91"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" checksum = "ae36dc4177970ef04fde5178d3e2429882def40e57a451f919c098f72baa6cec"
dependencies = [ dependencies = [
"proc-macro2", "proc-macro2",
"quote", "quote",
"syn 2.0.119", "syn 3.0.0",
] ]
[[package]] [[package]]
@@ -395,9 +395,9 @@ checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
[[package]] [[package]]
name = "bytemuck" name = "bytemuck"
version = "1.25.1" version = "1.25.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d6aedf8ae72766347502cf3cb4f41cf5e9cc37d28bee90f1fdaaae15f9cf9424" checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797"
[[package]] [[package]]
name = "byteorder" name = "byteorder"
@@ -785,9 +785,9 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
[[package]] [[package]]
name = "fastrand" name = "fastrand"
version = "2.4.1" version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6" checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
[[package]] [[package]]
name = "fdeflate" name = "fdeflate"
@@ -1327,7 +1327,6 @@ dependencies = [
"image", "image",
"jieba-rs", "jieba-rs",
"lazy_static", "lazy_static",
"mimalloc",
"rand 0.8.7", "rand 0.8.7",
"rayon", "rayon",
"regex", "regex",
@@ -1516,15 +1515,6 @@ version = "0.2.16"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
[[package]]
name = "libmimalloc-sys"
version = "0.1.49"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a45a52f43e1c16f667ccfe4dd8c85b7f7c204fd5e3bf46c5b0db9a5c3c0b8e9"
dependencies = [
"cc",
]
[[package]] [[package]]
name = "libredox" name = "libredox"
version = "0.1.18" version = "0.1.18"
@@ -1614,15 +1604,6 @@ version = "2.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
[[package]]
name = "mimalloc"
version = "0.1.52"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2d4139bb28d14ad1facf21d5eb8825051b326e172d216b39f6d31df53cc97862"
dependencies = [
"libmimalloc-sys",
]
[[package]] [[package]]
name = "mime" name = "mime"
version = "0.3.17" version = "0.3.17"
@@ -1992,18 +1973,18 @@ dependencies = [
[[package]] [[package]]
name = "proc-macro2" name = "proc-macro2"
version = "1.0.106" version = "1.0.107"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
dependencies = [ dependencies = [
"unicode-ident", "unicode-ident",
] ]
[[package]] [[package]]
name = "quote" name = "quote"
version = "1.0.46" version = "1.0.47"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368" checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
dependencies = [ dependencies = [
"proc-macro2", "proc-macro2",
] ]
@@ -2331,9 +2312,9 @@ checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
[[package]] [[package]]
name = "serde" name = "serde"
version = "1.0.228" version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
dependencies = [ dependencies = [
"serde_core", "serde_core",
"serde_derive", "serde_derive",
@@ -2341,22 +2322,22 @@ dependencies = [
[[package]] [[package]]
name = "serde_core" name = "serde_core"
version = "1.0.228" version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
dependencies = [ dependencies = [
"serde_derive", "serde_derive",
] ]
[[package]] [[package]]
name = "serde_derive" name = "serde_derive"
version = "1.0.228" version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
dependencies = [ dependencies = [
"proc-macro2", "proc-macro2",
"quote", "quote",
"syn 2.0.119", "syn 3.0.0",
] ]
[[package]] [[package]]
@@ -2406,6 +2387,12 @@ dependencies = [
"digest 0.11.3", "digest 0.11.3",
] ]
[[package]]
name = "sha1_smol"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbfa15b3dddfee50a0fff136974b3e1bde555604ba463834a7eb7deb6417705d"
[[package]] [[package]]
name = "sha2" name = "sha2"
version = "0.10.9" version = "0.10.9"
@@ -2763,6 +2750,17 @@ dependencies = [
"unicode-ident", "unicode-ident",
] ]
[[package]]
name = "syn"
version = "3.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2fac314a64dc9a36e61a9eb4261a5e9bbfbc922b27e518af97bc32b926cf967"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]] [[package]]
name = "sync_wrapper" name = "sync_wrapper"
version = "0.1.2" version = "0.1.2"
@@ -3141,6 +3139,7 @@ dependencies = [
"getrandom 0.4.3", "getrandom 0.4.3",
"js-sys", "js-sys",
"serde_core", "serde_core",
"sha1_smol",
"wasm-bindgen", "wasm-bindgen",
] ]

View File

@@ -11,7 +11,7 @@ serde_json = "1"
tokio = { version = "1", features = ["full"] } tokio = { version = "1", features = ["full"] }
sqlx = { version = "0.7", features = ["sqlite", "runtime-tokio", "migrate"] } sqlx = { version = "0.7", features = ["sqlite", "runtime-tokio", "migrate"] }
chrono = { version = "0.4", features = ["serde"] } chrono = { version = "0.4", features = ["serde"] }
uuid = { version = "1.0", features = ["v4", "serde"] } uuid = { version = "1.0", features = ["v4", "v5", "serde"] }
image = { version = "0.24", default-features = false, features = ["jpeg", "png", "gif", "webp"] } image = { version = "0.24", default-features = false, features = ["jpeg", "png", "gif", "webp"] }
reqwest = { version = "0.11", default-features = false, features = ["rustls-tls", "json"] } reqwest = { version = "0.11", default-features = false, features = ["rustls-tls", "json"] }
config = "0.13" config = "0.13"
@@ -19,7 +19,6 @@ rand = "0.8"
tracing = "0.1" tracing = "0.1"
tracing-subscriber = "0.3" tracing-subscriber = "0.3"
thiserror = "1.0" thiserror = "1.0"
mimalloc = "0.1.48"
regex = "1" regex = "1"
lazy_static = "1.4" lazy_static = "1.4"
jieba-rs = "0.7" jieba-rs = "0.7"

View File

@@ -235,7 +235,7 @@ async function loadAlbum(albumId) {
// 显示骨架屏 // 显示骨架屏
showImageSkeleton(); showImageSkeleton();
const response = await fetch(`/api/album/${albumId}`); const response = await fetch(`${API_BASE}/album/${albumId}`);
if (!response.ok) { if (!response.ok) {
if (response.status === 404) { if (response.status === 404) {
throw new Error('相册不存在'); throw new Error('相册不存在');
@@ -245,6 +245,9 @@ async function loadAlbum(albumId) {
const albumData = await response.json(); const albumData = await response.json();
currentAlbum = albumData.album; currentAlbum = albumData.album;
// tags/persons 在 albumData 顶层(AlbumWithImages),存到 currentAlbum 方便渲染
currentAlbum.tags = albumData.tags || [];
currentAlbum.persons = albumData.persons || [];
images = albumData.images; images = albumData.images;
updateAlbumInfo(); updateAlbumInfo();
@@ -323,47 +326,26 @@ function updateAlbumMeta() {
let chips = []; let chips = [];
// 添加人名标签 // 添加人名标签(从 search.db 返回的 persons 数组)
if (currentAlbum.person_name_cleaned) { if (currentAlbum.persons && Array.isArray(currentAlbum.persons)) {
chips.push({ currentAlbum.persons.forEach(name => {
text: currentAlbum.person_name_cleaned, chips.push({
type: 'person', text: name,
category: 'person', type: 'person',
query: currentAlbum.person_name_cleaned category: 'person',
query: name
});
}); });
} }
// 添加标签(支持多种格式) // 添加标签(从 search.db 返回的 tags 数组)
if (currentAlbum.tags) { if (currentAlbum.tags && Array.isArray(currentAlbum.tags)) {
let tagList = []; currentAlbum.tags.forEach(tag => {
try {
const parsed = JSON.parse(currentAlbum.tags);
if (Array.isArray(parsed)) {
parsed.forEach(item => {
if (Array.isArray(item)) {
tagList.push({ text: item[0], category: item[1] || 'default' });
} else if (typeof item === 'string') {
tagList.push({ text: item, category: getTagCategory(item) });
} else if (item.tag || item.name) {
const t = item.tag || item.name;
const c = item.category || item.type || getTagCategory(t);
tagList.push({ text: t, category: c });
}
});
}
} catch (e) {
currentAlbum.tags.split(',').forEach(tag => {
const t = tag.trim();
if (t) tagList.push({ text: t, category: getTagCategory(t) });
});
}
tagList.forEach(t => {
chips.push({ chips.push({
text: t.text, text: tag,
type: 'tag', type: 'tag',
category: t.category, category: getTagCategory(tag),
query: t.text query: tag
}); });
}); });
} }
@@ -431,7 +413,7 @@ function displayImages() {
let dataSrc = ''; let dataSrc = '';
if (image.id) { if (image.id) {
dataSrc = `/api/image/${image.id}`; dataSrc = `${API_BASE}/image/${image.id}`;
imageUrl = '/assets/placeholder.svg'; // 初始使用占位图 imageUrl = '/assets/placeholder.svg'; // 初始使用占位图
} else if (image.original_url) { } else if (image.original_url) {
dataSrc = image.original_url; dataSrc = image.original_url;
@@ -545,7 +527,7 @@ function updateLightboxContent(newIndex) {
// 在lightbox中优先使用原始图片以获得更好的显示效果 // 在lightbox中优先使用原始图片以获得更好的显示效果
let imageUrl = '/assets/placeholder.svg'; let imageUrl = '/assets/placeholder.svg';
if (image.id) { if (image.id) {
imageUrl = `/api/image/${image.id}`; imageUrl = `${API_BASE}/image/${image.id}`;
} else if (image.original_url) { } else if (image.original_url) {
imageUrl = image.original_url; imageUrl = image.original_url;
} }

View File

@@ -369,7 +369,7 @@ function appendAlbums(albums) {
let dataSrc = ''; let dataSrc = '';
if (album.cover_image_id) { if (album.cover_image_id) {
dataSrc = `/api/image/${album.cover_image_id}`; dataSrc = `${API_BASE}/image/${album.cover_image_id}`;
coverImageUrl = '/assets/placeholder.svg'; // 初始使用占位图 coverImageUrl = '/assets/placeholder.svg'; // 初始使用占位图
} }
@@ -585,7 +585,7 @@ function displayAlbums(albums) {
let dataSrc = ''; let dataSrc = '';
if (album.cover_image_id) { if (album.cover_image_id) {
dataSrc = `/api/image/${album.cover_image_id}`; dataSrc = `${API_BASE}/image/${album.cover_image_id}`;
coverImageUrl = '/assets/placeholder.svg'; // 初始使用占位图 coverImageUrl = '/assets/placeholder.svg'; // 初始使用占位图
} }
@@ -1473,7 +1473,8 @@ async function filterByPerson(personName) {
showSkeleton(6); showSkeleton(6);
const response = await fetch(`${API_BASE}/people/search?q=${encodeURIComponent(personName)}`); const response = await fetch(`${API_BASE}/people/search?q=${encodeURIComponent(personName)}`);
if (!response.ok) throw new Error('搜索失败'); if (!response.ok) throw new Error('搜索失败');
const persons = await response.json(); const personData = await response.json();
const persons = personData.persons || personData;
if (persons && persons.length > 0) { if (persons && persons.length > 0) {
try { try {
@@ -1494,12 +1495,21 @@ async function filterByPerson(personName) {
} }
} catch (e) { /* 回退 */ } } catch (e) { /* 回退 */ }
} }
// 回退到全站搜索,也要保存过滤结果 // 回退到全站搜索
filteredAlbums = await performServerSearchWithResult(personName); filteredAlbums = await performServerSearchWithResult(personName);
} catch (error) { } catch (error) {
console.error('人物筛选失败:', error); console.error('人物筛选失败:', error);
filteredAlbums = await performServerSearchWithResult(personName); filteredAlbums = await performServerSearchWithResult(personName);
} }
// 无论回退搜索是否找到结果,都要渲染页面(移除骨架屏)
if (filteredAlbums !== null) {
currentDisplayPage = 1;
hasMoreAlbums = filteredAlbums.length > albumsPerPage;
displayAlbums(filteredAlbums);
updateStats(filteredAlbums);
initLazyLoading();
}
} }
// 显示筛选状态 // 显示筛选状态

View File

@@ -2,18 +2,59 @@
"version": 4, "version": 4,
"description": "标签词典 v4 — 全量 keymap + stopwords(人物规则已融入 keymap)", "description": "标签词典 v4 — 全量 keymap + stopwords(人物规则已融入 keymap)",
"metadata": { "metadata": {
"style": { "label": "风格", "color_bg": "#f0f9ff", "color_fg": "#0284c7" }, "style": {
"outfit": { "label": "服装", "color_bg": "#fdf2f8", "color_fg": "#db2777" }, "label": "风格",
"scene": { "label": "场景", "color_bg": "#f0fdf4", "color_fg": "#15803d" }, "color_bg": "#f0f9ff",
"body": { "label": "身体", "color_bg": "#fef3c7", "color_fg": "#b45309" }, "color_fg": "#0284c7"
"mood": { "label": "情绪", "color_bg": "#faf5ff", "color_fg": "#7c3aed" }, },
"topic": { "label": "主题", "color_bg": "#f0f9ff", "color_fg": "#0369a1" }, "outfit": {
"position": { "label": "姿势", "color_bg": "#fefce8", "color_fg": "#a16207" }, "label": "服装",
"location": { "label": "地点", "color_bg": "#f0fdfa", "color_fg": "#0f766e" }, "color_bg": "#fdf2f8",
"brand": { "label": "品牌/工作室", "color_bg": "#fff7ed", "color_fg": "#c2410c" }, "color_fg": "#db2777"
"person": { "label": "人物", "color_bg": "#ecfdf5", "color_fg": "#059669" } },
"scene": {
"label": "场景",
"color_bg": "#f0fdf4",
"color_fg": "#15803d"
},
"body": {
"label": "身体",
"color_bg": "#fef3c7",
"color_fg": "#b45309"
},
"mood": {
"label": "情绪",
"color_bg": "#faf5ff",
"color_fg": "#7c3aed"
},
"topic": {
"label": "主题",
"color_bg": "#f0f9ff",
"color_fg": "#0369a1"
},
"position": {
"label": "姿势",
"color_bg": "#fefce8",
"color_fg": "#a16207"
},
"location": {
"label": "地点",
"color_bg": "#f0fdfa",
"color_fg": "#0f766e"
},
"brand": {
"label": "品牌/工作室",
"color_bg": "#fff7ed",
"color_fg": "#c2410c"
},
"person": {
"label": "人物",
"color_bg": "#ecfdf5",
"color_fg": "#059669"
}
}, },
"keymap": { "keymap": {
"嫩模": "topic",
"108TV": "brand", "108TV": "brand",
"108酱": "brand", "108酱": "brand",
"Adidas": "brand", "Adidas": "brand",
@@ -294,23 +335,13 @@
"waist": "body", "waist": "body",
"skin": "body", "skin": "body",
"tattoo": "body", "tattoo": "body",
"清纯": "mood",
"诱惑": "mood", "诱惑": "mood",
"唯美": "mood", "唯美": "mood",
"清新": "mood",
"冷艳": "mood",
"妩媚": "mood",
"娇羞": "mood", "娇羞": "mood",
"俏皮": "mood",
"温柔": "mood",
"野性": "mood",
"冷傲": "mood", "冷傲": "mood",
"热情": "mood", "热情": "mood",
"慵懒": "mood", "慵懒": "mood",
"迷离": "mood", "迷离": "mood",
"甜美": "mood",
"知性": "mood",
"可爱": "mood",
"神秘": "mood", "神秘": "mood",
"忧郁": "mood", "忧郁": "mood",
"伤感": "mood", "伤感": "mood",
@@ -327,15 +358,9 @@
"天真": "mood", "天真": "mood",
"无辜": "mood", "无辜": "mood",
"纯真": "mood", "纯真": "mood",
"pure": "mood",
"sweet": "mood",
"fresh": "mood",
"elegant": "mood",
"cute": "mood",
"wild": "mood",
"lazy": "mood", "lazy": "mood",
"sweet": "mood",
"写真": "topic", "写真": "topic",
"cos": "topic",
"私房": "topic", "私房": "topic",
"街拍": "topic", "街拍": "topic",
"旅拍": "topic", "旅拍": "topic",
@@ -537,25 +562,100 @@
"熊吖": "person" "熊吖": "person"
}, },
"stop_words": [ "stop_words": [
"photos", "photo", "pictures", "picture", "images", "image", "re",
"video", "videos", "cosplay", "cos", "photos",
"and", "the", "of", "in", "a", "an", "is", "to", "for", "photo",
"part", "vol", "collection", "special", "extra", "bonus", "pictures",
"new", "old", "selfie", "official", "original", "picture",
"set", "gallery", "album", "page", "issue", "images",
"model", "idol", "star", "actor", "actress", "singer", "image",
"秀人", "网", "图", "套", "合集", "系列", "作品", "video",
"美女", "模特", "女神", "小姐姐", "高清", "原版", "无水印", "videos",
"番号", "编号", "with", "without", "preview", "patreon", "cos",
"no", "site", "web", "online", "digital", "exclusive", "premium", "and",
"classic", "photography", "shoot", "shot", "the",
"xxx", "com", "www", "https", "http", "of",
"Impact", "写真", "系列" "in",
"a",
"an",
"is",
"to",
"for",
"part",
"vol",
"collection",
"special",
"extra",
"bonus",
"new",
"old",
"selfie",
"official",
"original",
"set",
"gallery",
"album",
"page",
"issue",
"model",
"idol",
"star",
"actor",
"actress",
"singer",
"网",
"新人",
"图",
"套",
"合集",
"系列",
"作品",
"高清",
"原版",
"无水印",
"番号",
"编号",
"with",
"without",
"preview",
"patreon",
"no",
"site",
"web",
"online",
"digital",
"exclusive",
"premium",
"classic",
"photography",
"shoot",
"shot",
"xxx",
"com",
"www",
"https",
"http",
"Impact"
], ],
"person_prefixes": [ "person_prefixes": [
"美女模特", "性感女神", "清纯美女", "气质美女", "可爱女孩",
"甜美少女", "时尚达人", "女神", "美女", "模特", "小姐姐", "写真",
"小仙女", "御姐", "萝莉", "辣妹", "潮人" "系列",
"美女模特",
"性感女神",
"清纯美女",
"气质美女",
"可爱女孩",
"甜美少女",
"时尚达人",
"女神",
"美女",
"模特",
"小姐姐",
"小仙女",
"御姐",
"萝莉",
"辣妹",
"潮人"
] ]
} }

687
docs/api.md Normal file
View File

@@ -0,0 +1,687 @@
# Imager API 文档
Base URL: `http://<host>:<port>/api`
---
## 相册
### GET /api/albums
获取全量相册列表(从内存缓存)。
**参数**:无
**响应**:`AlbumInfo[]`
```json
[
{
"id": "uuid",
"title": "相册标题",
"document": "文件夹名",
"description": "描述",
"cover_image_id": "uuid",
"image_count": 100,
"created_at": "2024-01-01T00:00:00",
"tags": ["标签1", "标签2"],
"persons": ["人物1"]
}
]
```
---
### GET /api/search
组合搜索(关键词/标签/人物过滤)。
**参数**(query):
| 参数 | 类型 | 默认值 | 说明 |
|------|------|--------|------|
| q | string | - | 标题关键词模糊匹配 |
| tag | string | - | 标签精确匹配 |
| person | string | - | 人物精确或模糊匹配 |
| page | int | 1 | 页码 |
| limit | int | 50 | 每页条数(最大 200) |
**响应**:`AlbumInfo[]`
---
### GET /api/album/random
从缓存随机返回一个相册。
**参数**:无
**响应**:`AlbumInfo`
---
### GET /api/album/{id}
获取相册详情(含图片列表、标签、人物)。
**参数**(path):
| 参数 | 类型 | 说明 |
|------|------|------|
| id | uuid | 相册 ID |
**响应**:`AlbumWithImages`
```json
{
"album": {
"id": "uuid",
"title": "标题",
"description": "描述",
"cover_image_id": "uuid",
"image_count": 100,
"created_at": "...",
"updated_at": "..."
},
"images": [
{
"id": "uuid",
"album_id": "uuid",
"filename": "1.jpg",
"original_url": "...",
"title": "图片标题",
"description": null,
"file_size": 123456,
"width": 1920,
"height": 1080,
"mime_type": "image/jpeg",
"created_at": "..."
}
],
"image_count": 100,
"tags": ["标签1", "标签2"],
"persons": ["人物1"]
}
```
---
### POST /api/albums
创建新相册。
**请求体**:
```json
{
"title": "相册标题",
"document": "文件夹名",
"description": "描述(可选)"
}
```
**响应**(201 Created):
```json
{
"id": "uuid"
}
```
---
## 图片
### GET /api/image/{id}
获取图片原始二进制数据。
**参数**(path):
| 参数 | 类型 | 说明 |
|------|------|------|
| id | uuid | 图片 ID |
**响应**:二进制图片数据,Content-Type 按实际 mime 类型。带 ETag,Cache-Control: public, max-age=31536000。
---
## 收藏
### GET /api/favorites
获取当前用户的收藏列表。
**参数**:无(用户固定为 default_user)
**响应**:`FavoriteWithImage[]`
---
### GET /api/favorites/status/{id}
检查某图片的收藏状态。
**参数**(path):
| 参数 | 类型 | 说明 |
|------|------|------|
| id | uuid | 图片 ID |
---
### POST /api/favorites
添加收藏。
**请求体**:
```json
{
"image_id": "uuid",
"album_id": "uuid"
}
```
**响应**(201 Created):
```json
{
"id": "uuid"
}
```
---
### DELETE /api/favorites/{id}
按收藏 ID 取消收藏。
**参数**(path):
| 参数 | 类型 | 说明 |
|------|------|------|
| id | uuid | 收藏 ID |
---
### DELETE /api/favorites/image/{id}
按图片 ID 取消收藏。
**参数**(path):
| 参数 | 类型 | 说明 |
|------|------|------|
| id | uuid | 图片 ID |
---
## 人物
### GET /api/people
从内存缓存获取所有人名列表。
**参数**:无
**响应**:
```json
{
"total": 100,
"persons": [
{
"id": 1,
"name": "人物名",
"display_name": "显示名",
"total_albums": 10,
"total_images": 50,
"aliases": ["别名1", "别名2"]
}
]
}
```
---
### GET /api/people/search
从内存缓存搜索人名。
**参数**(query):
| 参数 | 类型 | 说明 |
|------|------|------|
| q | string | 搜索关键词 |
**响应**:同上 `PersonListResponse`
---
### GET /api/people/{name}
获取人物详情及关联相册。
**参数**(path):
| 参数 | 类型 | 说明 |
|------|------|------|
| name | string | 人物名称 |
**响应**:`PersonWithAlbums`
```json
{
"album_count": 10,
"person": {
"id": 1,
"name": "人物名",
"display_name": "显示名",
"total_albums": 10,
"total_images": 50,
"original_names": null,
"created_at": "",
"updated_at": ""
},
"albums": [/* AlbumInfo[] */]
}
```
---
### GET /api/people/{id}/aliases
查询人物别名。
**参数**(path):
| 参数 | 类型 | 说明 |
|------|------|------|
| id | int | 人物 ID |
---
### POST /api/people/delete/{name}
删除人物(从 imager.db + search.db 中清除),并重新解析受影响的相册。
**参数**(path):
| 参数 | 类型 | 说明 |
|------|------|------|
| name | string | 人物名(URL 编码) |
**响应**:
```json
{
"success": true,
"person": "人物名",
"albums_affected": 5,
"persons_updated": 3,
"tags_updated": 8,
"synced": 5,
"message": "人物 '人物名' 已删除,影响 5 个相册,重新解析完成..."
}
```
---
## 标签 / 元数据
### GET /api/metadata/stats
从内存缓存计算元数据统计。
**参数**:无
**响应**:
```json
{
"total_persons": 100,
"total_aliases": 50,
"total_albums": 10000,
"total_images": 50000,
"total_tags": 2000
}
```
---
### GET /api/tags/search
按标签搜索相册。
**参数**(query):
| 参数 | 类型 | 说明 |
|------|------|------|
| tag | string | **必填**,标签名 |
**响应**:`AlbumInfo[]`
---
### GET /api/tags/popular
获取热门标签。
**参数**(query):
| 参数 | 类型 | 默认值 | 说明 |
|------|------|--------|------|
| limit | int | 50 | 返回数量 |
**响应**:
```json
{
"total": 50,
"tags": [
{ "tag": "标签名", "count": 1000, "album_count": 1000 }
]
}
```
---
### POST /api/tags/delete/{name}
删除标签(从 dict/album_tags/tags 表中清除),并重新解析受影响的相册。
**参数**(path):
| 参数 | 类型 | 说明 |
|------|------|------|
| name | string | 标签名(URL 编码) |
**响应**:
```json
{
"success": true,
"tag": "标签名",
"albums_affected": 5,
"persons_updated": 3,
"tags_updated": 8,
"synced": 5,
"message": "标签 '标签名' 已删除,影响 5 个相册,重新解析完成..."
}
```
---
## 推荐
### GET /api/recommend/tags
标签自动补全推荐。
**参数**(query):
| 参数 | 类型 | 默认值 | 说明 |
|------|------|--------|------|
| q | string | - | 输入前缀 |
| limit | int | 10 | 返回数量 |
---
### GET /api/recommend/persons
人物自动补全推荐。
**参数**(query):
| 参数 | 类型 | 默认值 | 说明 |
|------|------|--------|------|
| q | string | - | 输入名称 |
| limit | int | 10 | 返回数量 |
---
### GET /api/recommend/related
关联推荐(标签共现 + 共现人物)。
**参数**(query):
| 参数 | 类型 | 说明 |
|------|------|------|
| context | string | **必填**,标签或人名 |
| limit | int | 默认 15 |
---
### GET /api/recommend/popular-persons
获取热门人物排行榜。
**参数**(query):
| 参数 | 类型 | 默认值 | 说明 |
|------|------|--------|------|
| limit | int | 20(最大 50) | 返回数量 |
**响应**:
```json
[
{
"name": "人物名",
"display_name": "显示名",
"total_albums": 10,
"total_images": 50,
"top_tags": ["标签1", "标签2"],
"aliases": ["别名1"]
}
]
```
---
## 管线
### POST /api/pipeline/run
手动触发完整管线(dict 优先匹配解析)。
**参数**:无
**响应**:
```json
{
"success": true,
"tags_cleaned": 0,
"short_tags_removed": 0,
"person_like_tags_removed": 0,
"dirty_albums_detected": 0,
"non_persons_deleted": 0,
"stop_word_persons_removed": 0,
"new_albums_found": 0,
"persons_updated": 0,
"tags_updated": 0,
"empty_albums_deleted": 0,
"dup_albums_deleted": 0,
"search_db_synced": 0,
"message": "管线执行完毕:..."
}
```
---
### POST /api/pipeline/reparse
重置所有相册为未处理状态,重新解析全部标签和人物并同步到 search.db。
**参数**:无
**响应**:
```json
{
"success": true,
"albums_parsed": 100,
"persons_updated": 80,
"tags_updated": 200,
"synced_to_search_db": 100,
"message": "重新解析完成:..."
}
```
---
### POST /api/pipeline/reparse-persons
重置所有相册,重新解析全部人物(清空 search.db 的人物关联后运行完整管线)。
**参数**:无
**响应**:
```json
{
"success": true,
"albums_parsed": 100,
"persons_updated": 80,
"non_persons_deleted": 2,
"stop_word_persons_removed": 1,
"synced_to_search_db": 100,
"message": "人物重新解析完成:..."
}
```
---
### POST /api/pipeline/reparse-tags
重置所有相册,重新解析全部标签(清空 search.db 的标签关联后运行完整管线)。
**参数**:无
**响应**:
```json
{
"success": true,
"albums_parsed": 100,
"tags_updated": 200,
"short_tags_removed": 5,
"synced_to_search_db": 100,
"message": "标签重新解析完成:..."
}
```
---
## 词典
### GET /api/dict/stats
查看标签词典状态。
**参数**:无
**响应**:
```json
{
"stats": "标签词典: ...",
"categories": [
{ "name": "style", "label": "风格", "count": 50 }
],
"total_tags": 2000,
"total_stop_words": 20,
"person_prefixes": ["prefix1"],
"excluded_person_names": ["name1"],
"included_person_names": ["name2"]
}
```
---
### POST /api/dict/reload
从 search.db 的 dict 表热重载词典到内存。
**参数**:无
**响应**:
```json
{
"success": true,
"message": "词典已从 search.db 重载: ..."
}
```
---
### POST /api/dict/update
批量更新 dict 表条目,并自动重载内存词典。
**请求体**(数组):
```json
[
{
"word": "写真",
"type": "tag",
"category": "topic",
"freq": null,
"merged_to": null
},
{
"word": "张三",
"type": "person",
"category": null,
"freq": null,
"merged_to": null
}
]
```
**type 可选值**:`tag`、`person`、`stop_word`、`person_prefix`、`excluded_person`
**响应**:
```json
{
"success": true,
"message": "更新 2 条字典条目,词典已从 search.db 重载: ...",
"updated": 2
}
```
---
## 缓存
### POST /api/cache/refresh
手动刷新所有内存缓存(AlbumsCache / TagCache / PersonCache)。
**参数**:无
**响应**:
```json
{
"success": true,
"message": "缓存已刷新"
}
```
---
## 迁移
### GET /api/migration/stats
查看当前数据库迁移状态。
**参数**:无
---
### POST /api/migration/run
执行从旧数据库的数据迁移。
**参数**(query):
| 参数 | 类型 | 说明 |
|------|------|------|
| path | string | **必填**,旧数据库文件路径 |
---
## 队列
### GET /api/queue/stats
获取任务队列状态。
**参数**:无
---
## 静态页面
| 方法 | 路径 | 说明 |
|------|------|------|
| GET | `/` | 首页(相册列表) |
| GET | `/album` | 相册详情页(需 ?id=xxx 参数) |
| GET | `/assets/*` | 静态资源文件 |
---
> 所有 API 响应均为 JSON 格式(仅 `/api/image/{id}` 返回二进制)。无认证鉴权。

View File

@@ -0,0 +1,3 @@
-- 为 person_albums 添加 album_id 索引,优化 JOIN 查询和按相册查找的性能
-- person_id 已有主键索引 (person_id, album_id) 覆盖,无需重复创建
CREATE INDEX IF NOT EXISTS idx_pa_album ON person_albums(album_id);

View File

@@ -0,0 +1,6 @@
-- 清理不再使用的索引
-- 注意:不重建 albums 表,因为 4 张子表(images/favorites/album_tags/person_albums)
-- 通过 FOREIGN KEY 引用了 albums(id),DROP TABLE 即使关闭外键检查也会失败。
-- 未使用的列(person_name_original/all_words/tags)已由应用层忽略,不影响功能。
DROP INDEX IF EXISTS idx_albums_cleaned;

100
src/cache/mod.rs vendored
View File

@@ -1,7 +1,9 @@
//! 缓存层 — 内存缓存管理 //! 缓存层 — 内存缓存管理
use crate::search_db::SearchDb;
use crate::db::Database; use crate::db::Database;
use crate::models::*; use crate::models::*;
use sqlx::Row;
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::Arc; use std::sync::Arc;
use tokio::sync::RwLock; use tokio::sync::RwLock;
@@ -114,9 +116,9 @@ impl TagCache {
pub struct PersonCache { pub struct PersonCache {
pub persons: Vec<PersonWithCounts>, pub persons: Vec<PersonWithCounts>,
/// 搜索索引:关键词小写 → person_id 集合 /// 搜索索引:关键词小写 → person_id 集合
pub search_index: HashMap<String, Vec<i64>>, pub search_index: HashMap<String, Vec<String>>,
/// person_id → person 投影(用于按 id 快速访问) /// person_id → person 投影(用于按 id 快速访问)
pub id_map: HashMap<i64, PersonWithCounts>, pub id_map: HashMap<String, PersonWithCounts>,
pub last_updated: chrono::DateTime<chrono::Utc>, pub last_updated: chrono::DateTime<chrono::Utc>,
} }
@@ -130,31 +132,31 @@ impl PersonCache {
let name_lower = p.name.to_lowercase(); let name_lower = p.name.to_lowercase();
for word in name_lower.split_whitespace() { for word in name_lower.split_whitespace() {
if word.len() >= 2 { if word.len() >= 2 {
self.search_index.entry(word.to_string()).or_default().push(p.id); self.search_index.entry(word.to_string()).or_default().push(p.id.clone());
} }
} }
self.search_index.entry(name_lower.clone()).or_default().push(p.id); self.search_index.entry(name_lower.clone()).or_default().push(p.id.clone());
// 显示名 // 显示名
if let Some(ref dn) = p.display_name { if let Some(ref dn) = p.display_name {
let dn_lower = dn.to_lowercase(); let dn_lower = dn.to_lowercase();
for word in dn_lower.split_whitespace() { for word in dn_lower.split_whitespace() {
if word.len() >= 2 { if word.len() >= 2 {
self.search_index.entry(word.to_string()).or_default().push(p.id); self.search_index.entry(word.to_string()).or_default().push(p.id.clone());
} }
} }
self.search_index.entry(dn_lower).or_default().push(p.id); self.search_index.entry(dn_lower).or_default().push(p.id.clone());
} }
// 别名 // 别名
for alias in &p.aliases { for alias in &p.aliases {
let alias_lower = alias.to_lowercase(); let alias_lower = alias.to_lowercase();
for word in alias_lower.split_whitespace() { for word in alias_lower.split_whitespace() {
if word.len() >= 2 { if word.len() >= 2 {
self.search_index.entry(word.to_string()).or_default().push(p.id); self.search_index.entry(word.to_string()).or_default().push(p.id.clone());
} }
} }
self.search_index.entry(alias_lower).or_default().push(p.id); self.search_index.entry(alias_lower).or_default().push(p.id.clone());
} }
self.id_map.insert(p.id, p.clone()); self.id_map.insert(p.id.clone(), p.clone());
} }
self.persons = persons; self.persons = persons;
@@ -173,7 +175,7 @@ impl PersonCache {
// 1. 完整匹配 // 1. 完整匹配
if let Some(ids) = self.search_index.get(&q) { if let Some(ids) = self.search_index.get(&q) {
for id in ids { for id in ids {
if seen.insert(*id) {} if seen.insert(id.clone()) {}
} }
} }
// 2. 单词匹配 // 2. 单词匹配
@@ -181,7 +183,7 @@ impl PersonCache {
if word.len() >= 2 { if word.len() >= 2 {
if let Some(ids) = self.search_index.get(word) { if let Some(ids) = self.search_index.get(word) {
for id in ids { for id in ids {
seen.insert(*id); seen.insert(id.clone());
} }
} }
} }
@@ -193,7 +195,7 @@ impl PersonCache {
p.display_name.as_deref().unwrap_or(""), p.display_name.as_deref().unwrap_or(""),
p.aliases.join(" ").to_lowercase()); p.aliases.join(" ").to_lowercase());
if full.contains(&q) { if full.contains(&q) {
seen.insert(p.id); seen.insert(p.id.clone());
} }
} }
} }
@@ -205,26 +207,72 @@ impl PersonCache {
} }
/// 刷新所有缓存(相册 + 标签 + 人物) /// 刷新所有缓存(相册 + 标签 + 人物)
/// 相册从主库读取,标签/人物从 search.db 读取
pub async fn refresh_all_caches( pub async fn refresh_all_caches(
db: &Database, db: &Database,
search_db: &SearchDb,
albums_cache: &Arc<RwLock<AlbumsCache>>, albums_cache: &Arc<RwLock<AlbumsCache>>,
persons_cache: &Arc<RwLock<PersonCache>>, persons_cache: &Arc<RwLock<PersonCache>>,
tags_cache: &Arc<RwLock<TagCache>>, tags_cache: &Arc<RwLock<TagCache>>,
) { ) {
// 1. 刷新相册 // 1. 从主库读取相册(tags 和 persons 从 search.db 关联)
if let Ok(albums) = db.get_all_albums().await { if let Ok(albums) = db.get_all_albums().await {
let mut c = albums_cache.write().await; // 从 search.db 批量获取 album → tags 映射
c.update(albums.clone()); let tag_rows = sqlx::query(
r#"SELECT at.album_id, t.name FROM album_tags at JOIN tags t ON at.tag_id = t.id"#
).fetch_all(&search_db.pool).await.unwrap_or_default();
let mut album_tags: std::collections::HashMap<String, Vec<String>> = std::collections::HashMap::new();
for r in &tag_rows {
let aid: String = r.get("album_id");
let tag: String = r.get("name");
album_tags.entry(aid).or_default().push(tag);
}
// 2. 刷新标签 // 从 search.db 批量获取 album → persons 映射
let popular_tags = db.get_popular_tags(200).await; let person_rows = sqlx::query(
let tag_albums = db.get_all_tag_albums().await; r#"SELECT ap.album_id, p.name FROM album_persons ap JOIN persons p ON ap.person_id = p.id"#
).fetch_all(&search_db.pool).await.unwrap_or_default();
let mut album_persons: std::collections::HashMap<String, Vec<String>> = std::collections::HashMap::new();
for r in &person_rows {
let aid: String = r.get("album_id");
let name: String = r.get("name");
album_persons.entry(aid).or_default().push(name);
}
let enriched: Vec<AlbumInfo> = albums.into_iter().map(|mut a| {
let id_str = a.id.to_string();
a.tags = album_tags.remove(&id_str).unwrap_or_default();
a.persons = album_persons.remove(&id_str).unwrap_or_default();
a
}).collect();
// 2. 刷新标签(tag→albums 倒排索引直接从已富化的 album 列表构建,零 DB 查询)
let popular_tags = search_db.get_popular_tags(200).await;
let mut tag_albums: HashMap<String, Vec<AlbumInfo>> = HashMap::new();
for album in &enriched {
for tag in &album.tags {
tag_albums.entry(tag.clone()).or_default().push(album.clone());
}
}
let mut tc = tags_cache.write().await; let mut tc = tags_cache.write().await;
tc.update(popular_tags, tag_albums); tc.update(popular_tags, tag_albums);
// 3. 刷新相册缓存(依赖 enriched 数据,必须在标签刷新之后执行)
let mut c = albums_cache.write().await;
c.update(enriched);
} }
// 3. 刷新人物 // 3. 刷新人物(从 search.db,修正 total_albums/total_images)
let persons = db.get_all_persons_with_aliases().await; let mut persons = search_db.get_all_persons_with_aliases().await;
// 从 album_persons 重新计算实际相册数(修复缓存中 total_albums 可能为 0 的问题)
for p in &mut persons {
let actual: i64 = sqlx::query_scalar(
"SELECT COUNT(*) FROM album_persons WHERE person_id = ?"
).bind(&p.id).fetch_one(&search_db.pool).await.unwrap_or(0);
if actual > 0 {
p.total_albums = actual;
}
}
let mut pc = persons_cache.write().await; let mut pc = persons_cache.write().await;
pc.update(persons); pc.update(persons);
@@ -232,8 +280,16 @@ pub async fn refresh_all_caches(
} }
/// 仅刷新人物缓存(管线执行后调用) /// 仅刷新人物缓存(管线执行后调用)
pub async fn refresh_persons_cache(db: &Database, persons_cache: &Arc<RwLock<PersonCache>>) { pub async fn refresh_persons_cache(search_db: &SearchDb, persons_cache: &Arc<RwLock<PersonCache>>) {
let persons = db.get_all_persons_with_aliases().await; let mut persons = search_db.get_all_persons_with_aliases().await;
for p in &mut persons {
let actual: i64 = sqlx::query_scalar(
"SELECT COUNT(*) FROM album_persons WHERE person_id = ?"
).bind(&p.id).fetch_one(&search_db.pool).await.unwrap_or(0);
if actual > 0 {
p.total_albums = actual;
}
}
let mut pc = persons_cache.write().await; let mut pc = persons_cache.write().await;
pc.update(persons); pc.update(persons);
} }

View File

@@ -22,6 +22,8 @@ impl Database {
cover_image_id: r.get("cover_image_id"), cover_image_id: r.get("cover_image_id"),
image_count: r.get("image_count"), image_count: r.get("image_count"),
created_at: r.get("created_at"), created_at: r.get("created_at"),
tags: vec![],
persons: vec![],
} }
}).collect()) }).collect())
} }
@@ -114,6 +116,8 @@ impl Database {
cover_image_id: r.get("cover_image_id"), cover_image_id: r.get("cover_image_id"),
image_count: r.get("image_count"), image_count: r.get("image_count"),
created_at: r.get("created_at"), created_at: r.get("created_at"),
tags: vec![],
persons: vec![],
} }
}).collect()) }).collect())
} }
@@ -138,8 +142,6 @@ impl Database {
image_count: row.get("image_count"), image_count: row.get("image_count"),
created_at: row.get("created_at"), created_at: row.get("created_at"),
updated_at: row.get("updated_at"), updated_at: row.get("updated_at"),
person_name_cleaned: row.get("person_name_cleaned"),
tags: row.get("tags"),
}; };
let img_rows = sqlx::query("SELECT * FROM images WHERE album_id = ?") let img_rows = sqlx::query("SELECT * FROM images WHERE album_id = ?")
@@ -163,30 +165,54 @@ impl Database {
}); });
} }
Ok(Some(AlbumWithImages { album, images: images.clone(), image_count: images.len() as i64 })) 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> { pub async fn get_all_albums_full(&self) -> Vec<AlbumMeta> {
let has_col = sqlx::query_scalar::<_, i64>(
"SELECT COUNT(*) FROM pragma_table_info('albums') WHERE name = 'person_name_original'"
).fetch_one(&self.pool).await.unwrap_or(0);
if has_col == 0 { return Vec::new(); }
let rows = sqlx::query( let rows = sqlx::query(
r#"SELECT id, title, person_name_original, person_name_cleaned, tags, all_words, raw_title, processed_at, image_count r#"SELECT id, title, cover_image_id, image_count
FROM albums ORDER BY created_at DESC"# FROM albums"#
).fetch_all(&self.pool).await.unwrap_or_default(); ).fetch_all(&self.pool).await.unwrap_or_default();
rows.iter().map(|r| AlbumMeta { rows.iter().map(|r| AlbumMeta {
id: r.get("id"), title: r.get("title"), id: r.get("id"), title: r.get("title"),
person_name_original: r.get("person_name_original"), cover_image_id: r.get("cover_image_id"),
person_name_cleaned: r.get("person_name_cleaned"),
tags: r.get("tags"), all_words: r.get("all_words"),
raw_title: r.get("raw_title"), processed_at: r.get("processed_at"),
image_count: r.get("image_count"), image_count: r.get("image_count"),
}).collect() }).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> { pub async fn create_album(&self, album: CreateAlbum) -> Result<Uuid, sqlx::Error> {
@@ -200,12 +226,81 @@ impl Database {
Ok(id) 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> { pub async fn delete_album(&self, album_id: Uuid) -> Result<(), sqlx::Error> {
let _guard = self.write_lock.lock().await; let _guard = self.write_lock.lock().await;
sqlx::query("DELETE FROM albums WHERE id = ?").bind(album_id.to_string()).execute(&self.pool).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(()) 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> { 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 = ?") sqlx::query("UPDATE albums SET cover_image_id = ? WHERE id = ?")
.bind(image_id.to_string()).bind(album_id.to_string()).execute(&self.pool).await?; .bind(image_id.to_string()).bind(album_id.to_string()).execute(&self.pool).await?;

View File

@@ -25,58 +25,50 @@ impl Database {
) -> Result<(), sqlx::Error> { ) -> Result<(), sqlx::Error> {
for result in results { for result in results {
let album_id = &result.album_id; let album_id = &result.album_id;
let person_name = result.person_name.as_deref();
if let Some(name) = person_name { // ── 标记处理时间(无论是否有人物,只要进了解析管线就标记)──
// ── update 相册 person 字段 ── sqlx::query(
sqlx::query( "UPDATE albums SET processed_at = datetime('now') WHERE id = ?"
"UPDATE albums SET person_name_original = ?, person_name_cleaned = ?, processed_at = datetime('now') WHERE id = ?" )
) .bind(album_id)
.bind(name).bind(name).bind(album_id) .execute(&mut **tx).await?;
.execute(&mut **tx).await?;
// ── insert or ignore 人物 ── // ── 先清空旧人物关联,再写新关联 ──
let pid = sqlx::query_scalar::<_, i64>( if !result.person_names.is_empty() {
"INSERT INTO persons (name, display_name) VALUES (?, ?) ON CONFLICT(name) DO UPDATE SET name = name RETURNING id"
)
.bind(name).bind(name)
.fetch_one(&mut **tx).await?;
// ── 清旧关联 + 写新关联 ──
sqlx::query("DELETE FROM person_albums WHERE album_id = ?") sqlx::query("DELETE FROM person_albums WHERE album_id = ?")
.bind(album_id).execute(&mut **tx).await?; .bind(album_id).execute(&mut **tx).await?;
sqlx::query("INSERT OR IGNORE INTO person_albums (person_id, album_id) VALUES (?, ?)")
.bind(pid).bind(album_id).execute(&mut **tx).await?;
// ── 更新计数 ── for name in &result.person_names {
sqlx::query( // ── insert or ignore 人物 ──
"UPDATE persons SET total_albums = (SELECT COUNT(*) FROM person_albums WHERE person_id = ?), \ let pid = sqlx::query_scalar::<_, i64>(
total_images = COALESCE((SELECT SUM(image_count) FROM albums \ "INSERT INTO persons (name, display_name) VALUES (?, ?) ON CONFLICT(name) DO UPDATE SET name = name RETURNING id"
JOIN person_albums ON albums.id = person_albums.album_id \ )
WHERE person_albums.person_id = ?), 0) \ .bind(name).bind(name)
WHERE id = ?" .fetch_one(&mut **tx).await?;
)
.bind(pid).bind(pid).bind(pid) // ── 写新关联 ──
.execute(&mut **tx).await?; sqlx::query("INSERT OR IGNORE INTO person_albums (person_id, album_id) VALUES (?, ?)")
.bind(pid).bind(album_id).execute(&mut **tx).await?;
// ── 更新该人物的计数 ──
sqlx::query(
"UPDATE persons SET total_albums = (SELECT COUNT(*) FROM person_albums WHERE person_id = ?), \
total_images = COALESCE((SELECT SUM(image_count) FROM albums \
JOIN person_albums ON albums.id = person_albums.album_id \
WHERE person_albums.person_id = ?), 0) \
WHERE id = ?"
)
.bind(pid).bind(pid).bind(pid)
.execute(&mut **tx).await?;
}
} else {
// 无人名时也清空旧关联(避免残留)
sqlx::query("DELETE FROM person_albums WHERE album_id = ?")
.bind(album_id).execute(&mut **tx).await?;
} }
// ── 写标签 ── // ── 写标签(tags/all_words 列已迁移到 search.db,只维护 album_tags 表)──
if !result.tags.is_empty() { if !result.tags.is_empty() {
let tags_json = serde_json::to_string(
&result.tags.iter().map(|(t, _)| t).collect::<Vec<_>>()
).unwrap_or_else(|_| "[]".to_string());
let all_words: Vec<[String; 2]> = result.tags.iter()
.map(|(t, c)| [t.clone(), c.clone()])
.collect();
let words_json = serde_json::to_string(&all_words).unwrap_or_else(|_| "[]".to_string());
sqlx::query(
"UPDATE albums SET tags = ?, all_words = ? WHERE id = ?"
)
.bind(&tags_json).bind(&words_json).bind(album_id)
.execute(&mut **tx).await?;
// ── 同步 album_tags 表 ──
sqlx::query("DELETE FROM album_tags WHERE album_id = ?") sqlx::query("DELETE FROM album_tags WHERE album_id = ?")
.bind(album_id).execute(&mut **tx).await?; .bind(album_id).execute(&mut **tx).await?;
for (t, _) in &result.tags { for (t, _) in &result.tags {

View File

@@ -45,6 +45,8 @@ impl Database {
title: r.get("title"), document: r.get("document"), title: r.get("title"), document: r.get("document"),
description: r.get("description"), cover_image_id: r.get("cover_image_id"), description: r.get("description"), cover_image_id: r.get("cover_image_id"),
image_count: r.get("image_count"), created_at: r.get("created_at"), image_count: r.get("image_count"), created_at: r.get("created_at"),
tags: vec![],
persons: vec![],
}).collect() }).collect()
} }
@@ -72,7 +74,7 @@ impl Database {
rows.iter().map(|r| { rows.iter().map(|r| {
let pid = r.get::<i64, _>("id"); let pid = r.get::<i64, _>("id");
PersonWithCounts { PersonWithCounts {
id: pid, name: r.get("name"), display_name: r.get("display_name"), id: pid.to_string(), name: r.get("name"), display_name: r.get("display_name"),
total_albums: r.get("total_albums"), total_images: r.get("total_images"), total_albums: r.get("total_albums"), total_images: r.get("total_images"),
aliases: aliases.get(&pid).cloned().unwrap_or_default(), aliases: aliases.get(&pid).cloned().unwrap_or_default(),
} }
@@ -89,7 +91,7 @@ impl Database {
rows.iter().map(|r| { rows.iter().map(|r| {
let pid = r.get::<i64, _>("id"); let pid = r.get::<i64, _>("id");
PersonWithCounts { PersonWithCounts {
id: pid, name: r.get("name"), display_name: r.get("display_name"), id: pid.to_string(), name: r.get("name"), display_name: r.get("display_name"),
total_albums: r.get("total_albums"), total_images: r.get("total_images"), total_albums: r.get("total_albums"), total_images: r.get("total_images"),
aliases: aliases.get(&pid).cloned().unwrap_or_default(), aliases: aliases.get(&pid).cloned().unwrap_or_default(),
} }
@@ -182,6 +184,7 @@ impl Database {
title: r.get("title"), document: r.get("document"), title: r.get("title"), document: r.get("document"),
description: r.get("description"), cover_image_id: r.get("cover_image_id"), description: r.get("description"), cover_image_id: r.get("cover_image_id"),
image_count: r.get("image_count"), created_at: r.get("created_at"), image_count: r.get("image_count"), created_at: r.get("created_at"),
tags: vec![], persons: vec![],
}; };
map.entry(tag).or_default().push(album); map.entry(tag).or_default().push(album);
} }
@@ -216,28 +219,23 @@ impl Database {
title: r.get("title"), document: r.get("document"), title: r.get("title"), document: r.get("document"),
description: r.get("description"), cover_image_id: r.get("cover_image_id"), description: r.get("description"), cover_image_id: r.get("cover_image_id"),
image_count: r.get("image_count"), created_at: r.get("created_at"), image_count: r.get("image_count"), created_at: r.get("created_at"),
tags: vec![], persons: vec![],
}).collect() }).collect()
} }
// ── 统计 ──
pub async fn get_metadata_stats(&self) -> MetadataStats {
MetadataStats {
total_persons: sqlx::query_scalar("SELECT COUNT(*) FROM persons").fetch_one(&self.pool).await.unwrap_or(0),
total_aliases: sqlx::query_scalar("SELECT COUNT(*) FROM person_aliases").fetch_one(&self.pool).await.unwrap_or(0),
total_albums_with_person: sqlx::query_scalar("SELECT COUNT(*) FROM albums WHERE person_name_original IS NOT NULL AND person_name_original != ''").fetch_one(&self.pool).await.unwrap_or(0),
total_albums_without_person: sqlx::query_scalar("SELECT COUNT(*) FROM albums WHERE person_name_original IS NULL OR person_name_original = ''").fetch_one(&self.pool).await.unwrap_or(0),
total_tags: sqlx::query_scalar("SELECT COUNT(*) FROM album_tags").fetch_one(&self.pool).await.unwrap_or(0),
}
}
// ── 写入 ── // ── 写入 ──
pub async fn insert_person(&self, name: &str, display_name: Option<&str>) -> i64 { pub async fn insert_person(&self, name: &str, display_name: Option<&str>) -> i64 {
if let Some(p) = self.get_person_by_name(name).await { return p.id; } if let Some(p) = self.get_person_by_name_internal(name).await { return p; }
sqlx::query("INSERT OR IGNORE INTO persons (name, display_name) VALUES (?, ?)") sqlx::query("INSERT OR IGNORE INTO persons (name, display_name) VALUES (?, ?)")
.bind(name).bind(display_name).execute(&self.pool).await.ok(); .bind(name).bind(display_name).execute(&self.pool).await.ok();
self.get_person_by_name(name).await.map(|p| p.id).unwrap_or(0) self.get_person_by_name_internal(name).await.unwrap_or(0)
}
/// 内部方法:按名称查找人员,直接返回 i64 id(避免 String 转换开销)
async fn get_person_by_name_internal(&self, name: &str) -> Option<i64> {
sqlx::query_scalar::<_, i64>("SELECT id FROM persons WHERE name = ?")
.bind(name).fetch_optional(&self.pool).await.ok().flatten()
} }
/// 与 insert_person 相同,但使用已有的事务 /// 与 insert_person 相同,但使用已有的事务
@@ -314,6 +312,8 @@ impl Database {
/// 把 src_id 的所有相册关联、别名移动到 dst_id,然后删除 src_id /// 把 src_id 的所有相册关联、别名移动到 dst_id,然后删除 src_id
pub async fn merge_person_into(&self, src_id: i64, dst_id: i64) { pub async fn merge_person_into(&self, src_id: i64, dst_id: i64) {
let _guard = self.write_lock.lock().await;
// 整个合并过程是一个原子操作,用事务包裹避免逐条 autocommit // 整个合并过程是一个原子操作,用事务包裹避免逐条 autocommit
let mut tx = match self.pool.begin().await { let mut tx = match self.pool.begin().await {
Ok(t) => t, Ok(t) => t,
@@ -328,9 +328,9 @@ impl Database {
sqlx::query("INSERT OR IGNORE INTO person_aliases (person_id, alias_type, alias_name) SELECT ?, alias_type, alias_name FROM person_aliases WHERE person_id = ?") sqlx::query("INSERT OR IGNORE INTO person_aliases (person_id, alias_type, alias_name) SELECT ?, alias_type, alias_name FROM person_aliases WHERE person_id = ?")
.bind(dst_id).bind(src_id).execute(tx.deref_mut()).await.ok(); .bind(dst_id).bind(src_id).execute(tx.deref_mut()).await.ok();
// 3. 把 src 的原名也作为别名加入 dst // 3. 把 src 的原名也作为别名加入 dst(使用事务连接,避免额外占用连接池)
if let Some(r) = sqlx::query("SELECT id, name, display_name FROM persons WHERE id = ?") if let Some(r) = sqlx::query("SELECT id, name, display_name FROM persons WHERE id = ?")
.bind(src_id).fetch_optional(&self.pool).await.ok().flatten() .bind(src_id).fetch_optional(tx.deref_mut()).await.ok().flatten()
{ {
let src_name: String = r.get("name"); let src_name: String = r.get("name");
let src_display: Option<String> = r.get("display_name"); let src_display: Option<String> = r.get("display_name");
@@ -355,34 +355,34 @@ impl Database {
pub async fn get_person_by_id(&self, id: i64) -> Option<Person> { pub async fn get_person_by_id(&self, id: i64) -> Option<Person> {
let r = sqlx::query("SELECT * FROM persons WHERE id = ?").bind(id).fetch_optional(&self.pool).await.ok()??; let r = sqlx::query("SELECT * FROM persons WHERE id = ?").bind(id).fetch_optional(&self.pool).await.ok()??;
let db_id: i64 = r.get("id");
Some(Person { Some(Person {
id: r.get("id"), name: r.get("name"), display_name: r.get("display_name"), id: db_id.to_string(), name: r.get("name"), display_name: r.get("display_name"),
total_albums: r.get("total_albums"), total_images: r.get("total_images"), total_albums: r.get("total_albums"), total_images: r.get("total_images"),
original_names: r.get("original_names"), created_at: r.get("created_at"), updated_at: r.get("updated_at"), original_names: r.get("original_names"), created_at: r.get("created_at"), updated_at: r.get("updated_at"),
}) })
} }
pub async fn update_album_person(&self, album_id: &str, person_name_original: &str, person_name_cleaned: &str) { pub async fn update_album_person(&self, album_id: &str, _person_name_original: &str, _person_name_cleaned: &str) {
sqlx::query("UPDATE albums SET person_name_original = ?, person_name_cleaned = ?, processed_at = datetime('now') WHERE id = ?") sqlx::query("UPDATE albums SET processed_at = datetime('now') WHERE id = ?")
.bind(person_name_original).bind(person_name_cleaned).bind(album_id).execute(&self.pool).await.ok(); .bind(album_id).execute(&self.pool).await.ok();
} }
pub async fn update_album_person_with_tx(&self, tx: &mut Transaction<'_, Sqlite>, album_id: &str, person_name_original: &str, person_name_cleaned: &str) { pub async fn update_album_person_with_tx(&self, tx: &mut Transaction<'_, Sqlite>, album_id: &str, _person_name_original: &str, _person_name_cleaned: &str) {
sqlx::query("UPDATE albums SET person_name_original = ?, person_name_cleaned = ?, processed_at = datetime('now') WHERE id = ?") sqlx::query("UPDATE albums SET processed_at = datetime('now') WHERE id = ?")
.bind(person_name_original).bind(person_name_cleaned).bind(album_id).execute(tx.deref_mut()).await.ok(); .bind(album_id).execute(tx.deref_mut()).await.ok();
} }
/// 清空该人物所有关联相册的 person 字段(当该人物被确认为非人物后调用) /// 清空该人物所有关联相册的 person 字段(当该人物被确认为非人物后调用)
pub async fn update_album_person_by_person_id(&self, person_id: i64) { pub async fn update_album_person_by_person_id(&self, person_id: i64) {
sqlx::query( sqlx::query(
"UPDATE albums SET person_name_original = NULL, person_name_cleaned = NULL, \ "UPDATE albums SET processed_at = datetime('now') WHERE id IN (SELECT album_id FROM person_albums WHERE person_id = ?)"
processed_at = datetime('now') WHERE id IN (SELECT album_id FROM person_albums WHERE person_id = ?)"
).bind(person_id).execute(&self.pool).await.ok(); ).bind(person_id).execute(&self.pool).await.ok();
} }
pub async fn update_album_tags(&self, album_id: &str, tags_json: &str, all_words_json: &str) { pub async fn update_album_tags(&self, album_id: &str, tags_json: &str, _all_words_json: &str) {
sqlx::query("UPDATE albums SET tags = ?, all_words = ?, processed_at = datetime('now') WHERE id = ?") sqlx::query("UPDATE albums SET processed_at = datetime('now') WHERE id = ?")
.bind(tags_json).bind(all_words_json).bind(album_id).execute(&self.pool).await.ok(); .bind(album_id).execute(&self.pool).await.ok();
// 用一个事务批量替换 album_tags,避免逐条 autocommit 导致巨慢 // 用一个事务批量替换 album_tags,避免逐条 autocommit 导致巨慢
if let Ok(tags) = serde_json::from_str::<Vec<String>>(tags_json) { if let Ok(tags) = serde_json::from_str::<Vec<String>>(tags_json) {
@@ -416,9 +416,9 @@ impl Database {
} }
/// 与 update_album_tags 相同,但使用已有的事务(不启动内部子事务) /// 与 update_album_tags 相同,但使用已有的事务(不启动内部子事务)
pub async fn update_album_tags_with_tx(&self, tx: &mut Transaction<'_, Sqlite>, album_id: &str, tags_json: &str, all_words_json: &str) { pub async fn update_album_tags_with_tx(&self, tx: &mut Transaction<'_, Sqlite>, album_id: &str, tags_json: &str, _all_words_json: &str) {
sqlx::query("UPDATE albums SET tags = ?, all_words = ?, processed_at = datetime('now') WHERE id = ?") sqlx::query("UPDATE albums SET processed_at = datetime('now') WHERE id = ?")
.bind(tags_json).bind(all_words_json).bind(album_id).execute(tx.deref_mut()).await.ok(); .bind(album_id).execute(tx.deref_mut()).await.ok();
sqlx::query("DELETE FROM album_tags WHERE album_id = ?") sqlx::query("DELETE FROM album_tags WHERE album_id = ?")
.bind(album_id) .bind(album_id)

View File

@@ -1,7 +1,6 @@
//! 核心引擎层 — 标题解析、人名匹配、标签提取、推荐计算 //! 核心引擎层 — 标题解析、标签提取、推荐计算
pub mod title_parser; pub mod title_parser;
pub mod person_merger;
pub mod tag_dict; pub mod tag_dict;
pub mod tag_extractor; pub mod tag_extractor;
pub mod recommend; pub mod recommend;
@@ -9,7 +8,6 @@ pub mod pipeline;
pub mod crawler; pub mod crawler;
#[allow(unused)] pub use title_parser::*; #[allow(unused)] pub use title_parser::*;
#[allow(unused)] pub use person_merger::*;
#[allow(unused)] pub use tag_dict::*; #[allow(unused)] pub use tag_dict::*;
#[allow(unused)] pub use tag_extractor::*; #[allow(unused)] pub use tag_extractor::*;
pub use recommend::*; pub use recommend::*;

View File

@@ -1,434 +0,0 @@
//! 人名匹配与合并
//! 对应 Python 的 match_person_from_title.py + merge_persons_by_core.py
//! 所有函数均为 async,因为底层 Database 操作是异步的
use crate::db::Database;
use crate::engine::title_parser::{extract_cn, is_excluded_name};
use std::collections::{HashMap, HashSet};
/// 匹配模式
#[derive(Debug, Clone)]
pub struct Pattern {
pub text: String,
pub person_name: String,
pub source: String, // "name" | "alias"
pub length: usize,
}
/// 匹配结果
#[derive(Debug, Clone)]
pub struct MatchResult {
pub matched: bool,
pub method: String,
pub person: Option<String>,
pub matched_text: Option<String>,
pub all_persons: Vec<String>,
pub multi_person: bool,
}
/// 深度匹配结果
#[derive(Debug, Clone)]
pub struct DeepMatchResult {
pub matched: bool,
pub method: String, // "jieba_extract" | "exact_name_match" | "alias_fuzzy_match"
pub person: Option<String>,
pub matched_text: Option<String>,
pub all_persons: Vec<String>,
pub multi_person: bool,
}
// ── Pass1: 收集模式 ──
/// 收集所有人名和别名,构建匹配模式列表
/// 按长度降序排列,确保长名优先匹配
pub async fn collect_person_patterns(db: &Database) -> Vec<Pattern> {
let mut patterns = Vec::new();
// 1. 收集所有人名
let rows = db.get_all_person_names().await;
for (name, _albums) in &rows {
if is_excluded_name(name) {
continue;
}
patterns.push(Pattern {
text: name.clone(),
person_name: name.clone(),
source: "name".to_string(),
length: name.len(),
});
}
// 2. 收集所有别名
let aliases = db.get_all_aliases().await;
for (alias_name, person_name) in &aliases {
if is_excluded_name(person_name) || is_excluded_name(alias_name) {
continue;
}
if alias_name != person_name {
patterns.push(Pattern {
text: alias_name.clone(),
person_name: person_name.clone(),
source: "alias".to_string(),
length: alias_name.len(),
});
}
}
// 3. 去重
let mut best_map: HashMap<String, Pattern> = HashMap::new();
for p in patterns {
let key = p.text.to_lowercase();
best_map.entry(key).or_insert(p);
}
let mut patterns: Vec<Pattern> = best_map.into_values().collect();
// 4. 按长度降序排列
patterns.sort_by(|a, b| b.length.cmp(&a.length));
patterns
}
/// Pass1: 简单子串匹配
pub fn match_title(title: &str, patterns: &[Pattern]) -> Option<(String, String, String)> {
if title.is_empty() {
return None;
}
for p in patterns {
if p.text.len() < 2 {
continue;
}
if title.contains(&p.text) {
return Some((p.text.clone(), p.person_name.clone(), p.source.clone()));
}
}
None
}
/// Pass2: 深度匹配(多重策略)
pub fn deep_match_title(
title: &str,
known_names: &HashSet<String>,
known_aliases: &HashSet<String>,
) -> DeepMatchResult {
let mut result = DeepMatchResult {
matched: false,
method: String::new(),
person: None,
matched_text: None,
all_persons: Vec::new(),
multi_person: false,
};
if title.is_empty() {
return result;
}
let title_clean = title.trim();
// 策略1: 用正则提取人名
let extracted = crate::engine::title_parser::extract_person_name_from_title(title_clean);
if let Some(ref e) = extracted {
if known_names.contains(e) {
result.matched = true;
result.method = "jieba_extract".to_string();
result.person = Some(e.clone());
result.matched_text = Some(e.clone());
return result;
}
}
// 策略2: 标题中精确子串匹配已知人名(长名优先)
let mut found: Vec<String> = Vec::new();
let mut sorted_names: Vec<&String> = known_names.iter().collect();
sorted_names.sort_by(|a, b| b.len().cmp(&a.len()));
for name in &sorted_names {
if name.len() < 2 {
continue;
}
if title_clean.contains(name.as_str()) {
found.push(name.to_string());
}
}
if !found.is_empty() {
found.sort_by(|a, b| b.len().cmp(&a.len()));
let best = found[0].clone();
result.matched = true;
result.method = "exact_name_match".to_string();
result.person = Some(best.clone());
result.matched_text = Some(best);
result.all_persons = found.clone();
result.multi_person = found.len() > 1;
return result;
}
// 策略3: 别名模糊匹配
let title_lower = title_clean.to_lowercase();
let mut sorted_aliases: Vec<&String> = known_aliases.iter().collect();
sorted_aliases.sort_by(|a, b| b.len().cmp(&a.len()));
for alias in &sorted_aliases {
if alias.len() < 2 {
continue;
}
if title_lower.contains(alias.to_lowercase().as_str()) {
result.matched = true;
result.method = "alias_fuzzy_match".to_string();
result.person = Some(alias.to_string());
result.matched_text = Some(alias.to_string());
return result;
}
}
result
}
/// 收集所有已知人名和别名
pub async fn collect_known_names(db: &Database) -> (HashSet<String>, HashSet<String>) {
let mut known_names = HashSet::new();
let mut known_aliases = HashSet::new();
for (name, _) in db.get_all_person_names().await {
known_names.insert(name);
}
for (alias_name, _) in db.get_all_aliases().await {
known_aliases.insert(alias_name);
}
(known_names, known_aliases)
}
/// 检测含多个人名的相册
pub async fn detect_multi_person_titles(
db: &Database,
known_names: Option<&HashSet<String>>,
) -> Vec<(String, String, Vec<String>)> {
let names = match known_names {
Some(n) => n.clone(),
None => collect_known_names(db).await.0,
};
let albums = db.get_all_albums_full().await;
let mut multi_person = Vec::new();
for album in &albums {
let title = album.title.as_deref().unwrap_or("");
if title.is_empty() {
continue;
}
let mut found: Vec<String> = Vec::new();
let mut sorted_names: Vec<&String> = names.iter().collect();
sorted_names.sort_by(|a, b| b.len().cmp(&a.len()));
for name in &sorted_names {
if name.len() < 2 {
continue;
}
if title.contains(name.as_str()) {
found.push(name.to_string());
}
}
if found.len() > 1 {
multi_person.push((
album.id.clone(),
title.to_string(),
found,
));
}
}
multi_person
}
// ── 中文核心合并分析 ──
/// 分析所有人名的中文核心分组
/// 返回: {core: [(id, name, albums, images), ...]}
pub async fn analyze_groups(db: &Database) -> HashMap<String, Vec<(i64, String, i64, i64)>> {
let persons = db.get_all_persons_with_counts().await;
let mut groups: HashMap<String, Vec<(i64, String, i64, i64)>> = HashMap::new();
for (pid, name, albums, images) in persons {
if let Some(cn) = extract_cn(&name) {
if cn.len() >= 2 {
groups.entry(cn).or_default().push((pid, name, albums, images));
}
}
}
for items in groups.values_mut() {
items.sort_by(|a, b| b.2.cmp(&a.2));
}
groups.retain(|_, v| v.len() >= 2);
groups
}
/// 合并结果统计
#[derive(Debug, Clone, Default)]
pub struct MergeResult {
pub groups_analyzed: usize,
pub persons_merged: usize,
pub aliases_moved: usize,
}
/// 执行合并:扫描所有可合并的人物组,合并到相册数最多的那个
/// 返回合并统计
pub async fn execute_merge(db: &Database) -> MergeResult {
let groups = analyze_groups(db).await;
let mut result = MergeResult::default();
result.groups_analyzed = groups.len();
for (_core, items) in &groups {
if items.len() < 2 {
continue;
}
// 第一个(相册数最多)作为目标
let dst_id = items[0].0;
let dst_name = &items[0].1;
// 其余的合并到目标
for (src_id, src_name, _, _) in &items[1..] {
println!("[合并] {} (id={}) → {} (id={})", src_name, src_id, dst_name, dst_id);
// 合并前统计 src 的别名数
let src_aliases = db.get_person_aliases(*src_id).await;
let alias_count_before = src_aliases.len();
db.merge_person_into(*src_id, dst_id).await;
// 合并后统计新增的别名数 (= src 别名数 + src 原名)
result.persons_merged += 1;
// src 原名 + src 的 display_name + src 原有的别名
let moved = alias_count_before + 1; // +1 因为原名会成为 merged_original 别名
result.aliases_moved += moved;
}
}
if result.persons_merged > 0 {
println!("[合并] 完成:分析 {} 组,合并 {} 个人物,迁移 {} 个别名",
result.groups_analyzed, result.persons_merged, result.aliases_moved);
}
result
}
/// 统计匹配分析
#[derive(Debug, Clone)]
pub struct MatchStats {
pub total_albums: usize,
pub matched: usize,
pub unmatched: usize,
pub already_set: usize,
pub changed: usize,
pub by_source: HashMap<String, usize>,
pub name_frequency: HashMap<String, usize>,
}
/// 执行 Pass1 匹配分析
pub async fn analyze_matches(db: &Database, patterns: &[Pattern]) -> MatchStats {
let albums = db.get_all_albums_full().await;
let mut stats = MatchStats {
total_albums: albums.len(),
matched: 0,
unmatched: 0,
already_set: 0,
changed: 0,
by_source: HashMap::new(),
name_frequency: HashMap::new(),
};
for album in &albums {
let title = album.title.as_deref().unwrap_or("");
let current = album.person_name_original.as_deref().unwrap_or("");
if let Some((_text, person, source)) = match_title(title, patterns) {
*stats.by_source.entry(source).or_insert(0) += 1;
*stats.name_frequency.entry(person.clone()).or_insert(0) += 1;
if current.is_empty() {
stats.matched += 1;
} else if current != person {
stats.changed += 1;
} else {
stats.already_set += 1;
}
} else {
stats.unmatched += 1;
}
}
stats
}
/// 深度匹配分析统计
#[derive(Debug, Clone)]
pub struct DeepMatchStats {
pub total_albums: usize,
pub pass1_matched: usize,
pub pass1_unmatched: usize,
pub pass2_jieba_match: usize,
pub pass2_exact_match: usize,
pub pass2_alias_match: usize,
pub pass2_still_unmatched: usize,
pub pass2_multi_person: usize,
}
/// 执行 Pass2 深度匹配分析
pub async fn analyze_deep_matches(db: &Database) -> DeepMatchStats {
let (known_names, known_aliases) = collect_known_names(db).await;
let albums = db.get_all_albums_full().await;
let mut stats = DeepMatchStats {
total_albums: albums.len(),
pass1_matched: 0,
pass1_unmatched: 0,
pass2_jieba_match: 0,
pass2_exact_match: 0,
pass2_alias_match: 0,
pass2_still_unmatched: 0,
pass2_multi_person: 0,
};
for album in &albums {
let title = album.title.as_deref().unwrap_or("");
let current = album.person_name_original.as_deref().unwrap_or("");
if title.is_empty() {
continue;
}
if !current.is_empty() && known_names.contains(current) {
stats.pass1_matched += 1;
continue;
}
stats.pass1_unmatched += 1;
let result = deep_match_title(title, &known_names, &known_aliases);
if !result.matched {
stats.pass2_still_unmatched += 1;
continue;
}
match result.method.as_str() {
"jieba_extract" => stats.pass2_jieba_match += 1,
"exact_name_match" => stats.pass2_exact_match += 1,
"alias_fuzzy_match" => stats.pass2_alias_match += 1,
_ => {}
}
if result.multi_person {
stats.pass2_multi_person += 1;
}
}
stats
}

View File

@@ -1,32 +1,32 @@
//! 处理管线 — 批量处理相册元数据 //! 处理管线 — 批量处理相册元数据
//! //!
//! 核心架构:脏集追踪 + 增量解析 //! 核心架构:脏集追踪 + 增量解析,dict 优先匹配
//! //!
//! Phase 0 清洗标签标点 //! 流程:
//! Phase A1 检测标签中的人名并直接提取到 person 字段 → 加入脏集 //! Phase Z0 删除空相册
//! Phase A2 清理非人物 → 加入脏集 //! Phase Z1 去重同名相册
//! Phase A3 收集新相册/半成品 → 加入脏集 //! Phase ① 收集新相册(未处理)
//! Phase 1 解析脏集相册(增量解析,不扫全库) //! Phase ② 合并人物清理(非人物/停用词人物)→ 1次人物扫描
//! Phase C 全量重计所有 person 的相册计数 //! Phase ③ dict 优先解析脏集相册 → 只扫脏集
//! Phase 2 人物合并 //! Phase C 全量重计人物计数
//! Phase B 后校验标签中的人名
//! //!
//! 脏集(DirtySet)贯穿各阶段,每个阶段发现的"需要重新解析"的相册都会加入脏集, //! 脏集(DirtySet)贯穿各阶段,每个阶段发现的"需要重新解析"的相册都会加入脏集,
//! 最终只处理脏集里的相册,而非全库扫描,大幅提升效率。 //! 最终只处理脏集里的相册,而非全库扫描,大幅提升效率。
use crate::db::Database; use crate::db::Database;
use crate::engine::title_parser; use crate::engine::title_parser;
use crate::engine::tag_extractor;
use crate::engine::person_merger;
use crate::engine::tag_dict; use crate::engine::tag_dict;
use crate::search_db::SearchDb;
use std::collections::HashSet; use std::collections::HashSet;
use rayon::prelude::*; use rayon::prelude::*;
use sqlx;
// ════════════════════════════════════════════════ // ════════════════════════════════════════════════
// 脏集 — 追踪需要重新解析的相册 ID // 脏集 — 追踪需要重新解析的相册 ID
// ════════════════════════════════════════════════ // ════════════════════════════════════════════════
/// 脏集:记录哪些相册需要重新解析 /// 脏集:记录哪些相册需要重新解析
#[derive(Debug, Clone)]
pub struct DirtySet { pub struct DirtySet {
ids: HashSet<String>, ids: HashSet<String>,
} }
@@ -41,265 +41,22 @@ impl DirtySet {
pub fn into_inner(self) -> HashSet<String> { self.ids } pub fn into_inner(self) -> HashSet<String> { self.ids }
} }
// ════════════════════════════════════════════════ impl Default for DirtySet {
// Phase 0:清洗已有标签中的头尾标点 fn default() -> Self { Self::new() }
// ════════════════════════════════════════════════
pub async fn phase_clean_tags(db: &Database) -> usize {
let albums = db.get_all_albums_full().await;
let mut cleaned_count = 0usize;
let mut removed_tags = HashSet::new();
for album in &albums {
let tags_json = match album.tags.as_deref() {
Some(t) if !t.is_empty() && t != "[]" => t,
_ => continue,
};
let old_tags: Vec<String> = match serde_json::from_str(tags_json) {
Ok(t) => t, Err(_) => continue,
};
if old_tags.is_empty() { continue; }
let mut changed = false;
let mut new_tags = Vec::new();
for tag in old_tags {
let cleaned = match tag_extractor::clean_tag(&tag) {
Some(t) => t,
None => { removed_tags.insert(tag); changed = true; continue; }
};
if cleaned != tag { removed_tags.insert(tag); changed = true; }
new_tags.push(cleaned);
}
if !changed { continue; }
cleaned_count += 1;
let tags_json_new = serde_json::to_string(&new_tags).unwrap_or_else(|_| "[]".to_string());
let all_words_json = album.all_words.as_deref().unwrap_or("[]");
let all_words_new: Vec<[String; 2]> = serde_json::from_str::<Vec<[String; 2]>>(all_words_json)
.unwrap_or_default()
.into_iter()
.filter_map(|pair| { let cleaned = tag_extractor::clean_tag(&pair[0])?; Some([cleaned, pair[1].clone()]) })
.collect();
let all_words_json_new = serde_json::to_string(&all_words_new).unwrap_or_else(|_| "[]".to_string());
db.update_album_tags(&album.id, &tags_json_new, &all_words_json_new).await;
}
if cleaned_count > 0 {
println!("[管线·Phase0] 标签清洗完成:清洗 {} 个相册,移除标签: {:?}",
cleaned_count, removed_tags.iter().collect::<Vec<_>>());
} else {
println!("[管线·Phase0] 标签清洗完成:无需要清洗的标签");
}
cleaned_count
} }
// ════════════════════════════════════════════════ /// 判断一个标签是否"过短"——有效字符(汉字+字母)少于 2 个
// Phase A1:检测标签中的人名并直接提取到 person 字段 fn is_short_tag(tag: &str) -> bool {
// ════════════════════════════════════════════════ let mut valid_count = 0usize;
for ch in tag.chars() {
/// Phase A1:检测标签中可能的人名并直接提取到 person_name if ch.is_ascii_alphabetic() {
/// valid_count += 1;
/// 核心变化:不再只标记脏集等待 Phase 1,而是直接从 tags 中提取人名写入 person 字段。 } else if ('\u{4e00}'..='\u{9fff}').contains(&ch) {
/// 因为 tags 中的人名比从 title 重解析更直接、更准确。 valid_count += 1;
///
/// 两层检测 + 最终写入:
/// 1. 逐个标签 — 标签是已知人物或像人名 → 收集为候选人名(中文加权)
/// 2. jieba 合并(空格分隔)— 发现跨标签拆分的人名(["杨晨","晨Yome"])
/// 3. 最佳候选人名 → 写入 person_name,从标签中移除关联标签
///
/// 返回 (脏集, 从标签中移除的人名标签数)
pub async fn phase_detect_person_in_tags(db: &Database) -> (DirtySet, usize) {
let albums = db.get_all_albums_full().await;
let mut dirty = DirtySet::new();
let mut person_like_removed = 0usize;
let known_persons: HashSet<String> = db.get_all_person_names().await
.into_iter().map(|(n, _)| n.to_lowercase()).collect();
for album in &albums {
let tags_json = match album.tags.as_deref() {
Some(t) if !t.is_empty() && t != "[]" => t,
_ => continue,
};
let old_tags: Vec<String> = match serde_json::from_str(tags_json) {
Ok(t) => t, Err(_) => continue,
};
let has_person = album.person_name_original.as_deref()
.map(|s| !s.is_empty()).unwrap_or(false);
// 快速判断是否需要处理
let has_known_tag = old_tags.iter().any(|t| known_persons.contains(&t.to_lowercase()));
let has_like_tag = !has_person && old_tags.iter().any(|t|
title_parser::is_likely_person_name(t) && !title_parser::is_excluded_name(t));
if has_person && !has_known_tag && !has_like_tag { continue; }
// ── 第一层:逐个标签收集候选人名 ──
let mut known_person_found: Option<String> = None;
let mut person_like_tags: Vec<String> = Vec::new();
for tag in &old_tags {
let tag_lower = tag.to_lowercase();
if known_persons.contains(&tag_lower) {
known_person_found = Some(tag.clone());
continue;
}
if !has_person && title_parser::is_likely_person_name(tag) && !title_parser::is_excluded_name(tag) {
person_like_tags.push(tag.clone());
continue;
}
}
// 从 person_like_tags 中选最优(中文加权)
let best_layer1 = person_like_tags.into_iter().max_by_key(|t| {
if let Some(cn) = title_parser::extract_cn(t) {
if cn.len() >= 2 { cn.len() * 10 + t.len() } else { t.len() }
} else { t.len() }
});
// ── 第二层:空格连接所有标签,用 jieba 提取人名 ──
let combined = old_tags.join(" ");
let (jieba_name, _) = title_parser::extract_person_and_tags(&combined);
// ── 确定最终人名 ──
let final_person = known_person_found.or_else(|| {
match (&jieba_name, &best_layer1) {
(Some(j), Some(b)) => {
// jieba 结果更完整 → 用 jieba
let j_len: usize = j.len();
let b_len: usize = b.len();
if j_len > b_len || title_parser::is_excluded_name(b) { Some(j.clone()) } else { Some(b.clone()) }
}
(Some(j), None) => Some(j.clone()),
(None, Some(b)) => Some(b.clone()),
(None, None) => None,
}
});
if let Some(ref person_name) = final_person {
// ── 从标签中移除所有人名相关标签 ──
let mut changed = false;
let mut clean_tags: Vec<String> = Vec::new();
let person_lower = person_name.to_lowercase();
let (primary_cleaned, _) = title_parser::split_person_name_with_aliases(person_name);
let primary_lower = primary_cleaned.to_lowercase();
for tag in &old_tags {
let tag_lower = tag.to_lowercase();
let should_remove =
tag_lower == person_lower // 完全匹配
|| tag_lower == primary_lower // 中文核心匹配
|| (tag.len() >= 2 && tag.chars().all(|c| c.is_ascii_alphabetic())
&& !tag_lower.starts_with("cos")
&& person_lower.contains(&tag_lower)) // 英文后缀
|| (tag_lower.len() >= 2 && person_lower.contains(&tag_lower)); // 人名包含
if should_remove {
person_like_removed += 1;
changed = true;
continue;
}
clean_tags.push(tag.clone());
}
if changed || !has_person {
// ── 只清理标签中的人名,不写入 person 字段 ──
// 人名提取统一由 Phase 1 从标题解析完成,保证一个相册只有一个 pid
let tags_json_new = serde_json::to_string(&clean_tags).unwrap_or_else(|_| "[]".to_string());
let all_words_json = album.all_words.as_deref().unwrap_or("[]");
let all_words_new: Vec<[String; 2]> = serde_json::from_str::<Vec<[String; 2]>>(all_words_json)
.unwrap_or_default()
.into_iter()
.filter(|pair| !known_persons.contains(&pair[0].to_lowercase()))
.collect();
let words_json_new = serde_json::to_string(&all_words_new).unwrap_or_else(|_| "[]".to_string());
db.update_album_tags(&album.id, &tags_json_new, &words_json_new).await;
dirty.add(&album.id);
}
} }
// 数字、符号等不算有效字符
} }
valid_count < 2
if person_like_removed > 0 {
println!("[管线·PhaseA1] 从标签中检测并提取人名:移除 {} 个人名标签,写入 {} 个相册的 person 字段",
person_like_removed, dirty.len());
} else {
println!("[管线·PhaseA1] 检测标签中的人名:无异常");
}
(dirty, person_like_removed)
}
// ════════════════════════════════════════════════
// Phase A2:清理 persons 表中的非人物
// ════════════════════════════════════════════════
pub async fn phase_clean_persons(db: &Database) -> (DirtySet, usize) {
let persons = db.get_all_persons_with_counts().await;
let mut dirty = DirtySet::new();
let mut deleted = 0usize;
for (pid, name, _albums, _images) in &persons {
if title_parser::is_excluded_name(name) || !title_parser::is_likely_person_name(name) {
let album_list = db.get_person_albums(*pid).await;
let album_ids: Vec<String> = album_list.into_iter().map(|a| a.id.to_string()).collect();
for aid in &album_ids { dirty.add(aid); }
println!("[管线·PhaseA2] 删除非人物:{} (id={}),释放 {} 个相册", name, pid, album_ids.len());
db.update_album_person_by_person_id(*pid).await;
db.delete_person_completely(*pid).await;
deleted += 1;
}
}
if deleted > 0 {
println!("[管线·PhaseA2] 清理完成:删除 {} 个非人物,标记 {} 个脏相册", deleted, dirty.len());
} else {
println!("[管线·PhaseA2] 清理完成:无非人物需要删除");
}
(dirty, deleted)
}
// ════════════════════════════════════════════════
// Phase A2B:清理 persons 表中与停用词重叠的人物
// ════════════════════════════════════════════════
/// Phase A2B:检查 persons 表中的人名是否在停用词词典中。
///
/// 当用户在词典中添加了新的停用词,而这些词恰好已被作为人物创建时,
/// 需要删除该人物并释放对应的相册,让它们在后续 Phase 1 中重新解析。
/// 这样可以防止停用词(如 "photo"、"model" 等通用词)被错误识别为人物。
pub async fn phase_clean_stop_word_persons(db: &Database) -> (DirtySet, usize) {
let persons = db.get_all_persons_with_counts().await;
let mut dirty = DirtySet::new();
let mut deleted = 0usize;
for (pid, name, _albums, _images) in &persons {
// 使用 tag_dict 的 is_excluded_person 进行判断(含包含匹配)
let is_excluded = tag_dict::get_tag_dict().is_excluded_person(name);
// 也检查中文核心(如 "秀人" 是排除词,"秀人网" 也会包含)
let cn_check = title_parser::extract_cn(name)
.map(|cn| tag_dict::get_tag_dict().is_excluded_person(&cn))
.unwrap_or(false);
if is_excluded || cn_check {
let album_list = db.get_person_albums(*pid).await;
let album_ids: Vec<String> = album_list.into_iter().map(|a| a.id.to_string()).collect();
for aid in &album_ids { dirty.add(aid); }
println!("[管线·PhaseA2B] 排除人名命中:{} (id={}),释放 {} 个相册", name, pid, album_ids.len());
// 清空相册的 person 字段
db.update_album_person_by_person_id(*pid).await;
// 彻底删除该人物
db.delete_person_completely(*pid).await;
deleted += 1;
}
}
if deleted > 0 {
println!("[管线·PhaseA2B] 清理完成:移除 {} 个被排除的人物,标记 {} 个脏相册", deleted, dirty.len());
} else {
println!("[管线·PhaseA2B] 清理完成:无被排除的人物");
}
(dirty, deleted)
} }
// ════════════════════════════════════════════════ // ════════════════════════════════════════════════
@@ -307,22 +64,10 @@ pub async fn phase_clean_stop_word_persons(db: &Database) -> (DirtySet, usize) {
// ════════════════════════════════════════════════ // ════════════════════════════════════════════════
pub async fn phase_collect_new_albums(db: &Database) -> DirtySet { pub async fn phase_collect_new_albums(db: &Database) -> DirtySet {
let albums = db.get_all_albums_full().await; let ids = db.get_unprocessed_album_ids().await;
let mut dirty = DirtySet::new(); let mut dirty = DirtySet::new();
let mut new_count = 0usize; for id in &ids { dirty.add(id); }
let mut partial_count = 0usize; println!("[管线·PhaseA3] 收集相册:{} 个未处理", dirty.len());
for album in &albums {
let tags_empty = album.tags.as_deref()
.map(|t| t.is_empty() || t == "[]" || t == "null").unwrap_or(true);
if tags_empty { dirty.add(&album.id); new_count += 1; continue; }
let has_person = album.person_name_original.as_deref()
.map(|s| !s.is_empty()).unwrap_or(false);
if !has_person { dirty.add(&album.id); partial_count += 1; }
}
println!("[管线·PhaseA3] 收集相册:{} 个全新,{} 个半成品,脏集合计 {} 个", new_count, partial_count, dirty.len());
dirty dirty
} }
@@ -331,15 +76,19 @@ pub async fn phase_collect_new_albums(db: &Database) -> DirtySet {
// ┌─ Phase 1a:并行解析(CPU 密集,rayon par_iter) // ┌─ Phase 1a:并行解析(CPU 密集,rayon par_iter)
// └─ Phase 1b:批量写库(IO 密集,一个事务) // └─ Phase 1b:批量写库(IO 密集,一个事务)
pub async fn phase_parse_dirty(db: &Database, dirty_set: &DirtySet) -> (usize, usize) { pub async fn phase_parse_dirty(db: &Database, search_db: &SearchDb, dirty_set: &DirtySet) -> (usize, usize) {
if dirty_set.is_empty() { if dirty_set.is_empty() {
println!("[管线·Phase1] 增量解析跳过:脏集为空"); println!("[管线·Phase3] dict 优先解析跳过:脏集为空");
return (0, 0); return (0, 0);
} }
let albums = db.get_all_albums_full().await; let dirty_ids: Vec<String> = dirty_set.clone().into_inner().into_iter().collect();
let albums = db.get_albums_by_ids(&dirty_ids).await;
// ── Phase 1a:并行解析(CPU bound,rayon) ── // 加载 search.db 的 dict 条目(提供 merged_to 别名解析)
let dict_entries = search_db.load_dict_all().await.unwrap_or_default();
// ── Phase 3a:并行解析(CPU bound,rayon) ──
let dirty_albums: Vec<&crate::models::AlbumMeta> = albums.iter() let dirty_albums: Vec<&crate::models::AlbumMeta> = albums.iter()
.filter(|a| dirty_set.contains(&a.id)) .filter(|a| dirty_set.contains(&a.id))
.collect(); .collect();
@@ -354,22 +103,29 @@ pub async fn phase_parse_dirty(db: &Database, dirty_set: &DirtySet) -> (usize, u
.filter_map(|album| { .filter_map(|album| {
let title = album.title.as_deref()?; let title = album.title.as_deref()?;
if title.is_empty() { return None; } if title.is_empty() { return None; }
Some(title_parser::parse_album_title(&album.id, title)) // 使用 dict 优先匹配解析
Some(title_parser::parse_album_title_with_dict(&album.id, title, &dict_entries))
}) })
.collect(); .collect();
let person_count = parsed.iter().filter(|r| r.person_name.is_some()).count(); let person_count = parsed.iter().filter(|r| !r.person_names.is_empty()).count();
let tag_count = parsed.iter().filter(|r| !r.tags.is_empty()).count(); let tag_count = parsed.iter().filter(|r| !r.tags.is_empty()).count();
// ── Phase 1b:批量写入 ── // ── Phase 3b:批量写入 imager.db ──
let _guard = db.write_lock.lock().await; let _guard = db.write_lock.lock().await;
let mut tx = db.pool.begin().await.expect("begin tx"); let mut tx = db.pool.begin().await.expect("begin tx");
db.batch_write_parse_results(&mut tx, &parsed).await.unwrap_or_else(|e| { db.batch_write_parse_results(&mut tx, &parsed).await.unwrap_or_else(|e| {
eprintln!("[管线·Phase1b] 批量写入失败: {}", e); eprintln!("[管线·Phase3b] imager.db 批量写入失败: {}", e);
}); });
tx.commit().await.expect("commit tx"); tx.commit().await.expect("commit tx");
println!("[管线·Phase1] 并行解析+批量写入完成: 脏集 {} 个, 有效 {} 个 (跳过 {} 无标题), 更新人名 {} 个, 更新标签 {} 个", // ── Phase 3c:直接写入 search.db(使用相同解析结果,无需重解析) ──
match search_db.batch_sync_parse_results(&parsed).await {
Ok(n) => println!("[管线·Phase3c] search.db 同步完成:{} 个相册", n),
Err(e) => eprintln!("[管线·Phase3c] search.db 同步失败: {}", e),
}
println!("[管线·Phase3] dict 优先解析+批量写入完成: 脏集 {} 个, 有效 {} 个 (跳过 {} 无标题), 更新人名 {} 个, 更新标签 {} 个",
total, parsed.len(), skipped, person_count, tag_count); total, parsed.len(), skipped, person_count, tag_count);
(person_count, tag_count) (person_count, tag_count)
} }
@@ -403,112 +159,262 @@ pub async fn phase_recount_all(db: &Database) -> usize {
fixed fixed
} }
// ════════════════════════════════════════════════ // ════════════════════════════════════════════════
// Preprocess + Dirty Tracking
// ════════════════════════════════════════════════
pub async fn phase_merge_persons(db: &Database) -> (usize, usize) { /// 合并预处理结果
let result = person_merger::execute_merge(db).await; #[derive(Debug, Clone, Default)]
if result.persons_merged > 0 { struct PreprocessResult {
println!("[管线·Phase2] 人物合并完成:分析 {} 组,合并 {} 人,迁移 {} 个别名", tags_cleaned: usize,
result.groups_analyzed, result.persons_merged, result.aliases_moved); short_tags_removed: usize,
} else { person_like_tags_removed: usize,
println!("[管线·Phase2] 人物合并完成:无需要合并的人物"); new_albums_found: usize,
dirty: DirtySet,
}
/// 合并预处理:只做收集新相册,不再做标签清洗(已迁移到 search.db)
async fn phase_preprocess_combined(db: &Database) -> PreprocessResult {
let mut result = PreprocessResult::default();
let dirty = phase_collect_new_albums(db).await;
result.dirty = dirty;
result.new_albums_found = result.dirty.len();
println!("[管线·Phase①] 合并预处理完成(精简模式):新相册{},脏集合计{}",
result.new_albums_found, result.dirty.len());
result
}
/// 合并人物清理:一次人物遍历完成 2 件事
/// 1. 清理非人物
/// 2. 清理停用词重叠人物
async fn phase_clean_persons_combined(db: &Database) -> (DirtySet, usize, usize) {
let persons = db.get_all_persons_with_counts().await;
let mut dirty = DirtySet::new();
let mut non_persons_deleted = 0usize;
let mut stop_word_persons_removed = 0usize;
for (pid, name, _albums, _images) in &persons {
// 判断是否应该删除
let is_non_person = title_parser::is_excluded_name(name) || !title_parser::is_likely_person_name(name);
let is_stop_word = {
let excluded = tag_dict::get_tag_dict().is_excluded_person(name);
let cn_check = title_parser::extract_cn(name)
.map(|cn| tag_dict::get_tag_dict().is_excluded_person(&cn))
.unwrap_or(false);
excluded || cn_check
};
if !is_non_person && !is_stop_word { continue; }
let album_list = db.get_person_albums(*pid).await;
let album_ids: Vec<String> = album_list.into_iter().map(|a| a.id.to_string()).collect();
for aid in &album_ids { dirty.add(aid); }
if is_stop_word {
println!("[管线·Phase②] 排除人名命中:{} (id={}),释放 {} 个相册", name, pid, album_ids.len());
stop_word_persons_removed += 1;
} else {
println!("[管线·Phase②] 删除非人物:{} (id={}),释放 {} 个相册", name, pid, album_ids.len());
non_persons_deleted += 1;
}
db.update_album_person_by_person_id(*pid).await;
db.delete_person_completely(*pid).await;
} }
(result.persons_merged, result.aliases_moved)
if non_persons_deleted > 0 || stop_word_persons_removed > 0 {
println!("[管线·Phase②] 人物清理完成:删除非人物{},移除停用词人物{},脏相册{}",
non_persons_deleted, stop_word_persons_removed, dirty.len());
} else {
println!("[管线·Phase②] 人物清理完成:无异常");
}
(dirty, non_persons_deleted, stop_word_persons_removed)
} }
// ════════════════════════════════════════════════ // ════════════════════════════════════════════════
// Phase B:后校验标签 — 用合并后的人名检查 // Phase Z0:删除空相册(image_count = 0)
// ════════════════════════════════════════════════ // ════════════════════════════════════════════════
pub async fn phase_clean_tags_after_parse(db: &Database) -> usize { /// 删除所有图片数为 0 的空相册
let albums = db.get_all_albums_full().await; pub async fn phase_delete_empty_albums(db: &Database) -> usize {
let all_person_names: HashSet<String> = db.get_all_person_names().await let empty = db.get_empty_albums().await;
.into_iter().map(|(n, _)| n.to_lowercase()).collect(); let count = empty.len();
let all_aliases: HashSet<String> = db.get_all_aliases().await if count == 0 {
.into_iter().map(|(a, _)| a.to_lowercase()).collect(); println!("[管线·PhaseZ0] 无空相册需要删除");
let person_or_alias: HashSet<String> = all_person_names.into_iter().chain(all_aliases).collect();
if person_or_alias.is_empty() {
println!("[管线·PhaseB] 后校验标签完成:无人物数据,跳过");
return 0; return 0;
} }
let ids: Vec<uuid::Uuid> = empty.iter().map(|a| a.id).collect();
let mut tag_removed = 0usize; let deleted = db.delete_albums_batch(&ids).await;
for album in &albums { println!("[管线·PhaseZ0] 删除 {} 个空相册(无图片)", deleted);
let tags_json = match album.tags.as_deref() { deleted
Some(t) if !t.is_empty() && t != "[]" => t, _ => continue,
};
let old_tags: Vec<String> = match serde_json::from_str(tags_json) { Ok(t) => t, Err(_) => continue, };
let mut album_removed = 0usize;
let good_tags: Vec<String> = old_tags.into_iter().filter(|t| {
if person_or_alias.contains(&t.to_lowercase()) { album_removed += 1; false } else { true }
}).collect();
if album_removed == 0 { continue; }
tag_removed += album_removed;
let all_words_json = album.all_words.as_deref().unwrap_or("[]");
let all_words_new: Vec<[String; 2]> = serde_json::from_str::<Vec<[String; 2]>>(all_words_json)
.unwrap_or_default().into_iter().filter(|pair| !person_or_alias.contains(&pair[0].to_lowercase())).collect();
let tags_json_new = serde_json::to_string(&good_tags).unwrap_or_else(|_| "[]".to_string());
let words_json_new = serde_json::to_string(&all_words_new).unwrap_or_else(|_| "[]".to_string());
db.update_album_tags(&album.id, &tags_json_new, &words_json_new).await;
}
if tag_removed > 0 {
println!("[管线·PhaseB] 后校验标签完成:移除 {} 个人名/别名", tag_removed);
} else {
println!("[管线·PhaseB] 后校验标签完成:无需要修复的标签");
}
tag_removed
} }
// ════════════════════════════════════════════════ // ════════════════════════════════════════════════
// Pipeline 一键执行(7 阶段) // Phase Z1:去重同名相册
// ════════════════════════════════════════════════
/// 查找同名的相册,只保留第一个(最早创建的),删除其余(包括文件夹和 search.db 数据)
pub async fn phase_dedup_albums(db: &Database, search_db: &SearchDb) -> usize {
let dups = db.find_duplicate_albums().await;
let images_dir = &db.config.storage.images_dir;
let mut total_deleted = 0usize;
for (keep_id, keep_document, to_delete) in &dups {
let dup_ids: Vec<uuid::Uuid> = to_delete.iter().map(|(id, _)| *id).collect();
// 删除数据库记录
db.delete_albums_batch(&dup_ids).await;
// 删除 search.db 数据
for (id, _) in to_delete {
search_db.delete_album(&id.to_string()).await.ok();
}
// 删除磁盘文件夹
for (_, doc) in to_delete {
let folder = images_dir.join(doc);
if folder.exists() {
if let Err(e) = std::fs::remove_dir_all(&folder) {
eprintln!("[管线·PhaseZ1] 删除文件夹失败 {}: {}", folder.display(), e);
} else {
println!("[管线·PhaseZ1] 删除文件夹 {}", folder.display());
}
}
}
total_deleted += to_delete.len();
for (id, doc) in to_delete {
println!("[管线·PhaseZ1] 删除重复相册 {} ({}),保留 {} ({})", id, doc, keep_id, keep_document);
}
}
if total_deleted == 0 {
println!("[管线·PhaseZ1] 无重复相册");
} else {
println!("[管线·PhaseZ1] 去重完成:删除 {} 个重复相册", total_deleted);
}
total_deleted
}
// ════════════════════════════════════════════════
// Pipeline 一键执行
// ════════════════════════════════════════════════ // ════════════════════════════════════════════════
#[derive(Debug, Clone, Default)] #[derive(Debug, Clone, Default)]
pub struct PipelineResult { pub struct PipelineResult {
pub tags_cleaned: usize, // Phase 0 pub tags_cleaned: usize, // Phase ①
pub person_like_tags_removed: usize, // Phase A1 pub short_tags_removed: usize, // Phase ①
pub dirty_albums_detected: usize, // A1+A2+A2B+A3 pub person_like_tags_removed: usize, // Phase ①
pub non_persons_deleted: usize, // Phase A2 pub dirty_albums_detected: usize, // 总脏集
pub stop_word_persons_removed: usize, // Phase A2B pub non_persons_deleted: usize, // Phase ②
pub new_albums_found: usize, // Phase A3 pub stop_word_persons_removed: usize, // Phase ②
pub persons_updated: usize, // Phase 1 pub new_albums_found: usize, // Phase ①
pub tags_updated: usize, // Phase 1 pub persons_updated: usize, // Phase ③
pub persons_merged: usize, // Phase 2 pub tags_updated: usize, // Phase ③
pub aliases_moved: usize, // Phase 2 pub empty_albums_deleted: usize, // Phase Z0
pub tags_removed_person: usize, // Phase B pub dup_albums_deleted: usize, // Phase Z1
} }
/// 一键执行完整管线(8 阶段顺序串行) /// 一键执行精简管线(dict 优先匹配)
pub async fn run_pipeline(db: &Database) -> PipelineResult { ///
let tags_cleaned = phase_clean_tags(db).await; /// Phase Z0 删除空相册
let (dirty_a1, person_like_tags_removed) = phase_detect_person_in_tags(db).await; /// Phase Z1 去重同名相册
let (dirty_a2, non_persons_deleted) = phase_clean_persons(db).await; /// Phase ① 收集新相册
let (dirty_a2b, stop_word_persons_removed) = phase_clean_stop_word_persons(db).await; /// Phase ② 合并人物清理(非人物+停用词人物) → 1次人物扫描
let dirty_a3 = phase_collect_new_albums(db).await; /// Phase ③ dict 优先解析脏集 → 只扫脏集
let new_albums_found = dirty_a3.len(); /// Phase C 全量重计
pub async fn run_pipeline(db: &Database, search_db: &SearchDb) -> PipelineResult {
// Phase Z0:删除空相册
let empty_albums_deleted = phase_delete_empty_albums(db).await;
let mut master_dirty = DirtySet::new(); // Phase Z1:去重同名相册(含删除文件夹和 search.db 数据)
master_dirty.extend(dirty_a1.into_inner()); let dup_albums_deleted = phase_dedup_albums(db, search_db).await;
master_dirty.extend(dirty_a2.into_inner());
master_dirty.extend(dirty_a2b.into_inner()); // Phase ①:收集新相册
master_dirty.extend(dirty_a3.into_inner()); let pre = phase_preprocess_combined(db).await;
let tags_cleaned = pre.tags_cleaned;
let short_tags_removed = pre.short_tags_removed;
let person_like_tags_removed = pre.person_like_tags_removed;
let new_albums_found = pre.new_albums_found;
// Phase ②:合并人物清理(1 次人物扫描)
let (dirty_persons, non_persons_deleted, stop_word_persons_removed) =
phase_clean_persons_combined(db).await;
// 合并脏集
let mut master_dirty = pre.dirty;
master_dirty.extend(dirty_persons.into_inner());
let dirty_albums_detected = master_dirty.len(); let dirty_albums_detected = master_dirty.len();
let (persons_updated, tags_updated) = phase_parse_dirty(db, &master_dirty).await; // Phase ③:dict 优先解析脏集
// Phase C:全量重计(在合并前修正所有计数,让合并看到准确数值) let (persons_updated, tags_updated) = phase_parse_dirty(db, search_db, &master_dirty).await;
// Phase C:全量重计(修正计数)
let _recounted = phase_recount_all(db).await; let _recounted = phase_recount_all(db).await;
let (persons_merged, aliases_moved) = phase_merge_persons(db).await;
let tags_removed_person = phase_clean_tags_after_parse(db).await;
PipelineResult { PipelineResult {
tags_cleaned, person_like_tags_removed, dirty_albums_detected, tags_cleaned, short_tags_removed, person_like_tags_removed, dirty_albums_detected,
non_persons_deleted, stop_word_persons_removed, new_albums_found, non_persons_deleted, stop_word_persons_removed, new_albums_found,
persons_updated, tags_updated, persons_merged, persons_updated, tags_updated,
aliases_moved, tags_removed_person, empty_albums_deleted, dup_albums_deleted,
}
}
// ════════════════════════════════════════════════
// Phase S:同步管线结果到 search.db
// 只同步 tags/persons/aliases 到 search.db 的关联表,通过 album_id 关联
// 不同步 albums 表数据(albums 由 imager.db 管理)
// ════════════════════════════════════════════════
/// 全量同步:将所有相册的 tags/persons 解析结果写入 search.db 的关联表(单事务批量)
pub async fn sync_albums_to_search_db(db: &Database, search_db: &SearchDb) -> usize {
let albums = db.get_all_albums_full().await;
// 并行解析所有相册
let parsed: Vec<crate::models::parse::ParseResult> = albums.par_iter()
.filter_map(|album| {
let title = album.title.as_deref()?;
if title.is_empty() { return None; }
Some(title_parser::parse_album_title(&album.id, title))
})
.collect();
// 单事务批量写入 search.db
match search_db.batch_sync_parse_results(&parsed).await {
Ok(n) => {
println!("[Sync->search.db] 全量同步完成:{} 个相册", n);
n
}
Err(e) => {
eprintln!("[Sync->search.db] 批量同步失败: {}", e);
0
}
}
}
/// 增量同步:只处理脏集中的相册 ID(单事务批量)
pub async fn sync_dirty_albums(db: &Database, search_db: &SearchDb, dirty: &DirtySet) -> usize {
if dirty.is_empty() {
println!("[Sync->search.db·增量] 脏集为空,跳过");
return 0;
}
let dirty_ids: Vec<String> = dirty.clone().into_inner().into_iter().collect();
let albums = db.get_albums_by_ids(&dirty_ids).await;
// 并行解析脏集相册
let parsed: Vec<crate::models::parse::ParseResult> = albums.par_iter()
.filter_map(|album| {
let title = album.title.as_deref()?;
if title.is_empty() { return None; }
Some(title_parser::parse_album_title(&album.id, title))
})
.collect();
// 单事务批量写入 search.db
match search_db.batch_sync_parse_results(&parsed).await {
Ok(n) => {
println!("[Sync->search.db·增量] 脏集同步完成:{} 个相册", n);
n
}
Err(e) => {
eprintln!("[Sync->search.db·增量] 批量同步失败: {}", e);
0
}
} }
} }

View File

@@ -5,7 +5,7 @@
//! 2. 人物推荐:基于名称匹配 + 相册数排序 //! 2. 人物推荐:基于名称匹配 + 相册数排序
//! 3. 关联推荐:基于标签共现关系 + 人物共现关系 //! 3. 关联推荐:基于标签共现关系 + 人物共现关系
use crate::db::Database; use crate::search_db::SearchDb;
use crate::models::*; use crate::models::*;
use crate::engine::tag_dict; use crate::engine::tag_dict;
use sqlx::Row; use sqlx::Row;
@@ -14,31 +14,26 @@ use sqlx::Row;
pub struct RecommendEngine; pub struct RecommendEngine;
impl RecommendEngine { impl RecommendEngine {
/// 标签自动补全推荐 /// 标签自动补全推荐(从缓存的热门标签列表匹配)
pub async fn recommend_tags( pub fn recommend_tags(
db: &Database, popular_tags: &[TagStat],
query: &str, query: &str,
limit: usize, limit: usize,
) -> RecommendResponse { ) -> RecommendResponse {
let limit = limit.min(20); let limit = limit.min(20);
let q = query.trim().to_lowercase(); let q = query.trim().to_lowercase();
let tags = db.get_popular_tags(200).await;
let mut items: Vec<RecommendItem> = Vec::new(); let mut items: Vec<RecommendItem> = Vec::new();
for t in &tags { for t in popular_tags {
let tag_lower = t.tag.to_lowercase(); let tag_lower = t.tag.to_lowercase();
let score = if q.is_empty() { let score = if q.is_empty() {
// 无查询时按热门度
t.count as f64 t.count as f64
} else if tag_lower == q { } else if tag_lower == q {
// 精确匹配
1000.0 + t.count as f64 1000.0 + t.count as f64
} else if tag_lower.starts_with(&q) { } else if tag_lower.starts_with(&q) {
// 前缀匹配
500.0 + t.count as f64 500.0 + t.count as f64
} else if tag_lower.contains(&q) { } else if tag_lower.contains(&q) {
// 包含匹配
100.0 + t.count as f64 100.0 + t.count as f64
} else { } else {
continue; continue;
@@ -60,19 +55,18 @@ impl RecommendEngine {
RecommendResponse { items, total, category: "tags".to_string() } RecommendResponse { items, total, category: "tags".to_string() }
} }
/// 人物推荐 /// 人物推荐(从缓存的人物列表匹配)
pub async fn recommend_persons( pub fn recommend_persons(
db: &Database, persons: &[PersonWithCounts],
query: &str, query: &str,
limit: usize, limit: usize,
) -> RecommendResponse { ) -> RecommendResponse {
let limit = limit.min(20); let limit = limit.min(20);
let q = query.trim().to_lowercase(); let q = query.trim().to_lowercase();
let persons = db.get_all_persons_with_aliases().await;
let mut items: Vec<RecommendItem> = Vec::new(); let mut items: Vec<RecommendItem> = Vec::new();
for p in &persons { for p in persons {
let name_lower = p.name.to_lowercase(); let name_lower = p.name.to_lowercase();
let score = if q.is_empty() { let score = if q.is_empty() {
p.total_albums as f64 p.total_albums as f64
@@ -83,7 +77,6 @@ impl RecommendEngine {
} else if name_lower.contains(&q) { } else if name_lower.contains(&q) {
100.0 + p.total_albums as f64 100.0 + p.total_albums as f64
} else { } else {
// 检查别名
let alias_match = p.aliases.iter().any(|a| a.to_lowercase().contains(&q)); let alias_match = p.aliases.iter().any(|a| a.to_lowercase().contains(&q));
if alias_match { 200.0 + p.total_albums as f64 } else { continue } if alias_match { 200.0 + p.total_albums as f64 } else { continue }
}; };
@@ -112,14 +105,13 @@ impl RecommendEngine {
/// 关联推荐(共现标签 + 共现人物) /// 关联推荐(共现标签 + 共现人物)
pub async fn recommend_related( pub async fn recommend_related(
db: &Database, search_db: &SearchDb,
context: &str, // 标签或人名 context: &str,
limit: usize, limit: usize,
) -> TagRecommendation { ) -> TagRecommendation {
let limit = limit.min(15); let limit = limit.min(15);
// 获取共现标签 let co_tags = search_db.get_tag_co_occurrences(context, limit as i64).await;
let co_tags = db.get_tag_co_occurrences(context, limit as i64).await;
let related_tags: Vec<RecommendItem> = co_tags.iter().map(|c| { let related_tags: Vec<RecommendItem> = co_tags.iter().map(|c| {
RecommendItem { RecommendItem {
value: c.co_tag.clone(), value: c.co_tag.clone(),
@@ -130,20 +122,21 @@ impl RecommendEngine {
} }
}).collect(); }).collect();
// 获取相关人物(通过标签) let albums = search_db.search_albums_by_tag(context).await;
let albums = db.search_albums_by_tag(context).await;
let mut person_scores: std::collections::HashMap<String, (i64, f64)> = std::collections::HashMap::new(); let mut person_scores: std::collections::HashMap<String, (i64, f64)> = std::collections::HashMap::new();
let total = albums.len() as f64; let total = albums.len() as f64;
for album in &albums { for album in &albums {
let meta = db.get_all_albums_full().await; let aid = album.id.to_string();
for m in &meta { let person_rows = sqlx::query(
if m.id == album.id.to_string() { r#"SELECT p.name FROM persons p
if let Some(ref name) = m.person_name_cleaned { JOIN album_persons ap ON p.id = ap.person_id
let entry = person_scores.entry(name.clone()).or_insert((0, 0.0)); WHERE ap.album_id = ?"#
entry.0 += 1; ).bind(&aid).fetch_all(&search_db.pool).await.unwrap_or_default();
entry.1 = entry.0 as f64 / total; for row in &person_rows {
} let name: String = row.get("name");
} let entry = person_scores.entry(name).or_insert((0, 0.0));
entry.0 += 1;
entry.1 = entry.0 as f64 / total;
} }
} }
@@ -166,25 +159,23 @@ impl RecommendEngine {
} }
} }
/// 热门人物 /// 热门人物(从缓存的人物列表过滤,top_tags 保留 search.db 查询)
pub async fn popular_persons(db: &Database, limit: usize) -> Vec<PopularPerson> { pub async fn popular_persons(
search_db: &SearchDb,
persons_cache: &[PersonWithCounts],
limit: usize,
) -> Vec<PopularPerson> {
let dict = tag_dict::get_tag_dict(); let dict = tag_dict::get_tag_dict();
let persons = db.get_all_persons_with_aliases().await;
// 收集所有标签分类词(非人名候选)
let all_tag_words: std::collections::HashSet<String> = dict.tag_to_category.keys() let all_tag_words: std::collections::HashSet<String> = dict.tag_to_category.keys()
.map(|k| k.to_lowercase()).collect(); .map(|k| k.to_lowercase()).collect();
// 过滤非人物:三重检查(excluded + is_likely_person_name + 非标签词) let filtered: Vec<_> = persons_cache.iter()
let filtered: Vec<_> = persons.into_iter()
.filter(|p| { .filter(|p| {
// 1. 跳过排除名单中的人物
if dict.is_excluded_person(&p.name) { return false; } if dict.is_excluded_person(&p.name) { return false; }
// 2. 只保留 is_likely_person_name 返回 true 的人名
if !crate::engine::title_parser::is_likely_person_name(&p.name) { if !crate::engine::title_parser::is_likely_person_name(&p.name) {
return false; return false;
} }
// 3. 跳过和标签分类词重叠的非人名(如 "女模特"、"内衣秀")
let name_lower = p.name.to_lowercase(); let name_lower = p.name.to_lowercase();
if all_tag_words.contains(&name_lower) { if all_tag_words.contains(&name_lower) {
return false; return false;
@@ -204,23 +195,10 @@ impl RecommendEngine {
} }
}).collect(); }).collect();
// 为热门人物获取 top tags
// (简化:从 person_albums 查标签)
for rp in &mut results { for rp in &mut results {
if let Some(person) = db.get_person_by_name(&rp.name).await { if let Some(person) = search_db.get_person_by_name(&rp.name).await {
let albums = db.get_person_albums(person.id).await; let top_tags = search_db.get_person_top_tags(&person.id, 5).await;
let mut tag_counts: std::collections::HashMap<String, i64> = std::collections::HashMap::new(); rp.top_tags = top_tags.into_iter().map(|(t, _)| t).collect();
for album in &albums {
let aid = album.id.to_string();
let rows = sqlx::query("SELECT tag FROM album_tags WHERE album_id = ?")
.bind(&aid).fetch_all(&db.pool).await.unwrap_or_default();
for row in &rows {
*tag_counts.entry(row.get::<String, _>("tag")).or_insert(0) += 1;
}
}
let mut tags: Vec<(String, i64)> = tag_counts.into_iter().collect();
tags.sort_by(|a, b| b.1.cmp(&a.1));
rp.top_tags = tags.into_iter().take(5).map(|(t, _)| t).collect();
} }
} }
results results

View File

@@ -531,3 +531,99 @@ pub fn get_tag_dict_stats() -> String {
dict.included_person_names.len(), dict.included_person_names.len(),
) )
} }
// ════════════════════════════════════════════════
// 从 search.db 的 dict 表加载
// ════════════════════════════════════════════════
use crate::search_db::DictEntry;
impl TagDict {
/// 从 search.db 的 dict 表条目加载词典数据
///
/// dict 表条目类型(通过 type 字段区分):
/// - `tag` — word 是标签,category 是分类名 → 加入 keymap
/// - `person` — word 是人名 → 加入 included_person_names
/// - `stop_word` — word 是停用词
/// - `person_prefix` — word 是人物前缀
/// - `excluded_person` — word 是排除人名
///
/// 派生规则:
/// - 所有 tag 类型的 word 自动加入 excluded_person_names
/// - categories 结构基于 metadata(内建)和 keymap(从 tag 条目构建)
pub fn load_from_dict_entries(entries: &[DictEntry]) -> Self {
let mut dict = TagDict::default();
for entry in entries {
match entry.type_.as_str() {
"tag" => {
let cat = entry.category.as_deref().unwrap_or("other");
dict.keymap.insert(entry.word.clone(), cat.to_string());
dict.tag_to_category.insert(entry.word.to_lowercase(), cat.to_string());
dict.excluded_person_names.insert(entry.word.to_lowercase());
}
"person" => {
dict.included_person_names.insert(entry.word.to_lowercase());
}
"stop_word" => {
dict.stop_words.insert(entry.word.to_lowercase());
}
"person_prefix" => {
dict.person_prefixes.push(entry.word.clone());
}
"excluded_person" => {
dict.excluded_person_names.insert(entry.word.to_lowercase());
}
_ => {}
}
}
// ── 构建 categories(基于 metadata + keymap) ──
let mut words_by_cat: HashMap<String, Vec<String>> = HashMap::new();
for (word, cat_name) in &dict.keymap {
words_by_cat.entry(cat_name.clone()).or_default().push(word.clone());
}
for (name, meta) in &dict.metadata {
let words = words_by_cat.remove(name).unwrap_or_default();
dict.categories.insert(name.clone(), CategoryInfo {
name: name.clone(),
label: meta.label.clone(),
color_bg: meta.color_bg.clone(),
color_fg: meta.color_fg.clone(),
words,
});
}
for (cat_name, words) in words_by_cat {
dict.categories.insert(cat_name.clone(), CategoryInfo {
name: cat_name.clone(),
label: cat_name.clone(),
color_bg: "#f1f5f9".to_string(),
color_fg: "#64748b".to_string(),
words,
});
}
println!("[词典] 从 search.db dict 表加载: {} 分类, {} 标签(keymap), {} 停用词, {} 前缀, {} 排除人名, {} 包含人名",
dict.categories.len(), dict.keymap.len(),
dict.stop_words.len(), dict.person_prefixes.len(), dict.excluded_person_names.len(),
dict.included_person_names.len());
dict
}
}
/// 从 search.db 的 dict 表重新加载标签词典
pub async fn reload_from_search_db(search_db: &crate::search_db::SearchDb) -> String {
let entries = match search_db.load_dict_all().await {
Ok(e) => e,
Err(e) => return format!("从 search.db 加载 dict 失败: {}", e),
};
let mut dict = TAG_DICT.write().expect("tag_dict 锁被污染");
*dict = TagDict::load_from_dict_entries(&entries);
format!(
"词典已从 search.db 重载: {} 分类, {} 标签(keymap), {} 停用词, {} 前缀, {} 排除人名, {} 包含人名",
dict.categories.len(), dict.keymap.len(),
dict.stop_words.len(), dict.person_prefixes.len(), dict.excluded_person_names.len(),
dict.included_person_names.len(),
)
}

View File

@@ -1,35 +1,40 @@
//! 标题解析、人名提取、标签提取 //! 标题解析 — 统一最大匹配管线(v5)
//! //!
//! v4 版本 — 基于 keymap 的纯匹配方案,无 jieba 依赖。 //! 核心思路:一次扫描同时识别 person 和 tags,两者互斥,不会混淆。
//! 核心流程:预处理 → token 分割 → 对每个 token 依次检查: //!
//! keymap(person) → 人物 //! 流程:
//! keymap(其他) → 标签 //! 1. 预处理:移除照片数后缀、[工作室]前缀、称呼前缀、编号后缀
//! stopwords → 跳过 //! 2. 切分:中文最大匹配 + 英文按空格切分
//! 人名启发式 → 人物 //! 3. 角色分类:每个片段有明确分类(person / style / outfit / ... / stop / other)
//! 4. 选人名:优先级 = keymap(person) > include 列表 > 启发式
//! 5. 其余分类即为标签
//!
//! 相比 v4 的改进:
//! - 中文连续文本也能正确切分(不再依赖空格)
//! - person 和 tag 在同一 pass 中确定,不会混淆
//! - 最长匹配优先,避免"性感"和"性感女神"都匹配的问题
//! - 英文只按空格切分,不逐字匹配,不移除英文介词等停用词
use regex::Regex; use regex::Regex;
use std::collections::HashSet; use std::collections::HashSet;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use crate::engine::tag_dict; use crate::engine::tag_dict;
use crate::engine::tag_extractor;
// ── 正则 ── // ── 正则 ──
lazy_static! { lazy_static! {
static ref RE_BRACKET_PREFIX: Regex = Regex::new(r"^\[([^\]]+)\]\s*").unwrap(); static ref RE_BRACKET_PREFIX: Regex = Regex::new(r"^\[([^\]]+)\]\s*").unwrap();
static ref RE_NUMBER_SUFFIX: Regex = Regex::new(r"[\s#]*(?:no\.?\s*|vol\.?\s*|#)?\d+[\s]*$").unwrap(); static ref RE_NUMBER_SUFFIX: Regex = Regex::new(r"[\s#]*(?:no\.?\s*|vol\.?\s*|#)?\d+[\s]*$").unwrap();
static ref RE_PAREN_CONTENT: Regex = Regex::new(r"[((]([^))]*)[))]").unwrap();
static ref RE_PHOTOS_SUFFIX: Regex = Regex::new(r"(?i)\s*\d+\s*photos?\s*(?:and\s*\d+\s*videos?)?\s*$").unwrap(); static ref RE_PHOTOS_SUFFIX: Regex = Regex::new(r"(?i)\s*\d+\s*photos?\s*(?:and\s*\d+\s*videos?)?\s*$").unwrap();
static ref RE_CHINESE: Regex = Regex::new(r"[\u{4e00}-\u{9fff}]").unwrap(); static ref RE_CHINESE: Regex = Regex::new(r"[\u{4e00}-\u{9fff}]").unwrap();
static ref RE_ENGLISH_SUFFIX: Regex = Regex::new(r"^([\u{4e00}-\u{9fff}]+)([A-Za-z].*)$").unwrap(); static ref RE_ENGLISH_SUFFIX: Regex = Regex::new(r"^([\u{4e00}-\u{9fff}]+)([A-Za-z].*)$").unwrap();
static ref RE_TRAILING_PUNCT: Regex = Regex::new(r"[\s.,;:,。;:\-–—]+$").unwrap(); static ref RE_TRAILING_PUNCT: Regex = Regex::new(r"[\s.,;:,。;:\-–—]+$").unwrap();
/// 中文词(2-5字) static ref RE_PAREN_CONTENT: Regex = Regex::new(r"[((]([^))]*)[))]").unwrap();
static ref RE_CN_WORD: Regex = Regex::new(r"([\u{4e00}-\u{9fff}]{2,5})").unwrap(); /// 分隔符:空白、常见标点、中英文之间的边界
/// 英文词(2-15字母) static ref RE_SEPARATOR: Regex = Regex::new(r"[\s\-–—_,.;:,。;:、/\\|·]+").unwrap();
static ref RE_EN_WORD: Regex = Regex::new(r"([A-Za-z][A-Za-z]{1,14})").unwrap();
} }
// ── 统一预处理 ── // ── 预处理 ──
/// 统一标题预处理:移除照片数后缀、[工作室] 前缀、称呼前缀、编号后缀 /// 统一标题预处理:移除照片数后缀、[工作室] 前缀、称呼前缀、编号后缀
pub fn preprocess_title(title: &str) -> String { pub fn preprocess_title(title: &str) -> String {
@@ -50,129 +55,150 @@ pub fn preprocess_title(title: &str) -> String {
t t
} }
// ── Token 提取 ── // ── 切分片段:带分类 ──
/// 将标题分割为独立的 token(用于 Key 匹配) /// 一个切分片段及其分类
fn tokenize(title: &str) -> Vec<String> { #[derive(Debug, Clone)]
let mut tokens = Vec::new(); struct Segment {
text: String,
// 先按空白分割(简单 token) category: String,
for segment in title.split_whitespace() {
// 跳过纯标点
if tag_extractor::is_punctuation_only(segment) { continue; }
// 尝试按常见连接符进一步分割(如 "性感女神" 在 keymap 中找不到 → 拆开)
tokens.push(segment.to_string());
}
// 去重
let mut seen = HashSet::new();
tokens.retain(|t| seen.insert(t.to_lowercase()));
tokens
} }
/// 对 token 按长度降序排序(最长匹配优先) // ── 切分核心算法 ──
fn sort_by_length(tokens: &mut Vec<String>) {
tokens.sort_by(|a, b| b.len().cmp(&a.len())); /// 判断字符是否是中文字符
fn is_chinese_char(ch: char) -> bool {
('\u{4e00}'..='\u{9fff}').contains(&ch)
} }
// ── 核心解析:统一入口 ── /// 对标题做切分,返回带分类的片段列表。
/// 统一相册标题解析入口
/// ///
/// 流程:预处理 → token 分割 → 对每个 token: /// 算法分两路:
/// 1. keymap 匹配 → person → 人物;其他 → 标签 /// - 中文:从左到右最大匹配(逐字尝试,最长优先)
/// 2. stopwords → 跳过 /// - 英文/数字:按空格/分隔符直接切分为完整单词,查词典分类
/// 3. 人名启发式 → 人物
/// ///
/// 返回 ParseResult 可直接用于批量写库。 /// 匹配来源优先级:
pub fn parse_album_title(album_id: &str, title: &str) -> crate::models::parse::ParseResult { /// keymap(person) > keymap(其他) > stop_words > include_person
let mut result = crate::models::parse::ParseResult::new(album_id.to_string()); ///
/// 未匹配到的作为 "other" 片段保留。
let title = title.trim(); fn max_match_segment(title: &str) -> Vec<Segment> {
if title.is_empty() { return result; }
let cleaned = preprocess_title(title);
if cleaned.is_empty() { return result; }
let dict = tag_dict::get_tag_dict(); let dict = tag_dict::get_tag_dict();
// ── 收集所有 token(空白分割)── // 收集所有可匹配的词及分类
let raw_tokens = tokenize(&cleaned); let mut all_words: Vec<(String, String)> = Vec::new();
// ── 用于标签提取的已处理 title(移除人名后)── // 1. keymap 中的所有词
let mut person_found: Option<(String, String)> = None; for (word, cat) in dict.get_tag_category_map() {
let mut tag_parts: Vec<String> = Vec::new(); all_words.push((word.clone(), cat.clone()));
}
for token in &raw_tokens { // 2. include 列表中的人名 → "person_include"
let token_lower = token.to_lowercase(); for name in dict.get_included_persons() {
if !dict.get_tag_category_map().contains_key(name) {
all_words.push((name.clone(), "person_include".to_string()));
}
}
// 跳过过短 token // 3. 停用词 → "stop"
if token.len() < 2 { for word in dict.get_stop_words() {
tag_parts.push(token.clone()); all_words.push((word.clone(), "stop".to_string()));
}
// 计算最大词长(中文最大匹配用)
let max_len = all_words.iter().map(|(w, _)| w.chars().count()).max().unwrap_or(8);
// 快速查找函数
let find_category = |word: &str| -> Option<String> {
let word_lower = word.to_lowercase();
for (w, cat) in &all_words {
if w.to_lowercase() == word_lower {
return Some(cat.clone());
}
}
None
};
let mut segments: Vec<Segment> = Vec::new();
let chars: Vec<char> = title.chars().collect();
let n = chars.len();
let mut i = 0;
while i < n {
let ch = chars[i];
// 跳过分隔符
if RE_SEPARATOR.is_match(&ch.to_string()) {
i += 1;
continue; continue;
} }
// 跳过纯数字 // ── 英文/数字:直接按分隔符切分整个单词,不逐字匹配 ──
if token.chars().all(|c| c.is_ascii_digit()) { if ch.is_ascii_alphanumeric() {
let start = i;
while i < n && chars[i].is_ascii_alphanumeric() {
i += 1;
}
let word: String = chars[start..i].iter().collect();
let cat = find_category(&word).unwrap_or_else(|| "other".to_string());
segments.push(Segment { text: word, category: cat });
continue; continue;
} }
// 跳过停用词 // ── 中文:最大匹配 ──
if dict.is_stop_word(&token_lower) { if is_chinese_char(ch) {
continue; let mut found = false;
} let try_max = max_len.min(n - i);
// 检查 keymap(精确匹配) 'outer: for len in (1..=try_max).rev() {
if let Some(category) = dict.match_keymap(&token_lower) { let candidate: String = chars[i..i + len].iter().collect();
if category == "person" && person_found.is_none() { if let Some(cat) = find_category(&candidate) {
person_found = Some((token.clone(), token_lower.clone())); segments.push(Segment { text: candidate, category: cat });
} else if category != "person" { i += len;
tag_parts.push(token.clone()); found = true;
continue; break 'outer;
}
}
if !found {
// 未匹配:收集连续中文字符作为 other
let start = i;
while i < n && is_chinese_char(chars[i]) {
// 前瞻:如果下一个位置开始能匹配词典,就停在这里
if i > start {
let remaining = n - i;
let peek_max = max_len.min(remaining);
let mut matched = false;
for plen in (1..=peek_max).rev() {
let peek: String = chars[i..i + plen].iter().collect();
if find_category(&peek).is_some() {
matched = true;
break;
}
}
if matched { break; }
}
i += 1;
}
if i > start {
let other: String = chars[start..i].iter().collect();
segments.push(Segment { text: other, category: "other".to_string() });
}
} }
continue; continue;
} }
// 检查是否为已知人名(include/启发式) // 其他字符跳过
if person_found.is_none() && is_likely_person_name(token) { i += 1;
person_found = Some((token.clone(), token_lower.clone()));
continue;
}
// 剩余内容放入 tag 池
tag_parts.push(token.clone());
} }
// ── 处理人物 ── segments
if let Some((name, _)) = &person_found {
// include 列表中的最长匹配扩展
let expanded = dict.find_longest_included_match(name)
.filter(|longer| longer.len() > name.len());
let effective_name = expanded.as_deref().unwrap_or(name.as_str());
let (primary, _aliases) = split_person_name_with_aliases(effective_name);
let final_name = if primary.is_empty() { effective_name.to_string() } else { primary };
if final_name.chars().count() > 2 {
result.person_name = Some(final_name);
}
}
// ── 提取标签 ──
let person_exclude = result.person_name.as_deref();
let raw_tags = tag_extractor::extract_tags_from_title(title, person_exclude);
let unique = tag_extractor::unique_tags(raw_tags);
result.tags = unique;
result
} }
// ── 人名启发式判断 ── // ── 人名启发式判断 ──
/// 判断一个词是否"看起来像人名"(v4 简化版,不再查 tag_dict classify,因为 keymap 已覆盖) /// 判断一个词是否"看起来像人名"
/// 返回 true = 像人名;false = 不像 ///
/// 注意:调用方应已排除 keymap 中的非 person 类型词、停用词等。
pub fn is_likely_person_name(name: &str) -> bool { pub fn is_likely_person_name(name: &str) -> bool {
let name = name.trim(); let name = name.trim();
if name.is_empty() { return false; } if name.is_empty() { return false; }
@@ -180,15 +206,18 @@ pub fn is_likely_person_name(name: &str) -> bool {
let dict = tag_dict::get_tag_dict(); let dict = tag_dict::get_tag_dict();
// 强制包含名单优先放行 // 强制包含名单优先放行
if dict.is_included_person(name) || dict.find_longest_included_match(name).is_some() { if dict.is_included_person(name) {
return true; return true;
} }
// 字符数限制 // 字符数限制
if name.chars().count() <= 2 { return false; } let char_count = name.chars().count();
if char_count < 2 { return false; }
// keymap 中的词一定不是人名(已在 parse_album_title 中提前检查过,双保险) // keymap 中的非 person 类型词一定不是人名
if dict.match_keymap(&name.to_lowercase()).is_some() { return false; } if let Some(cat) = dict.classify(name) {
if cat != "person" { return false; }
}
// 排除已知非人名 // 排除已知非人名
if dict.is_excluded_person(name) { return false; } if dict.is_excluded_person(name) { return false; }
@@ -202,7 +231,7 @@ pub fn is_likely_person_name(name: &str) -> bool {
let digit_count = name.chars().filter(|c| c.is_ascii_digit()).count(); let digit_count = name.chars().filter(|c| c.is_ascii_digit()).count();
if digit_count * 2 > name.len() { return false; } if digit_count * 2 > name.len() { return false; }
// 纯英文且长度 > 15 排除 // 纯英文且过长排除
let has_cn = RE_CHINESE.is_match(name); let has_cn = RE_CHINESE.is_match(name);
if !has_cn && name.len() > 15 { return false; } if !has_cn && name.len() > 15 { return false; }
@@ -224,10 +253,122 @@ pub fn is_likely_person_name(name: &str) -> bool {
// 全大写且长度 > 6 排除(缩写/工作室名) // 全大写且长度 > 6 排除(缩写/工作室名)
if name.chars().all(|c| c.is_ascii_uppercase()) && name.len() > 6 { return false; } if name.chars().all(|c| c.is_ascii_uppercase()) && name.len() > 6 { return false; }
// 中文字符数判断:2-5 个中文字符更像人名
let cn_count: usize = name.chars().filter(|c| RE_CHINESE.is_match(&c.to_string())).count();
if has_cn && (cn_count < 2 || cn_count > 5) {
return false;
}
true true
} }
// ── 人名清洗 ── // ── 核心解析入口 ──
/// 统一相册标题解析入口(v5 最大匹配版本)
///
/// 流程:预处理 → 切分 → 选人 → 其余为标签
///
/// 返回 ParseResult 可直接用于批量写库。
pub fn parse_album_title(album_id: &str, title: &str) -> crate::models::parse::ParseResult {
let mut result = crate::models::parse::ParseResult::new(album_id.to_string());
let title = title.trim();
if title.is_empty() { return result; }
let cleaned = preprocess_title(title);
if cleaned.is_empty() { return result; }
// Step 1: 切分
let segments = max_match_segment(&cleaned);
// Step 2: 收集所有人名候选(按优先级排序,全部保留)
let mut person_candidates: Vec<(String, u8)> = Vec::new();
for seg in &segments {
match seg.category.as_str() {
"person" => {
person_candidates.push((seg.text.clone(), 0)); // 优先级 0 = 最高
}
"person_include" => {
person_candidates.push((seg.text.clone(), 1)); // 优先级 1
}
"other" => {
if is_likely_person_name(&seg.text) {
person_candidates.push((seg.text.clone(), 2)); // 优先级 2 = 启发式
}
}
_ => {}
}
}
// 按优先级排序
person_candidates.sort_by_key(|(_, p)| *p);
// 收集最终人名列表(去重)
let mut person_names: Vec<String> = Vec::new();
let mut seen_names: HashSet<String> = HashSet::new();
for (name, _) in &person_candidates {
let (primary, _) = split_person_name_with_aliases(name);
let final_name = if primary.is_empty() { name.clone() } else { primary };
if final_name.chars().count() >= 2 && seen_names.insert(final_name.to_lowercase()) {
person_names.push(final_name);
}
}
result.person_names = person_names;
// Step 3: 收集标签(跳过所有 person 片段)
// 构建所有已识别 person 片段的小写集合(用于过滤 other 类中与 person 重叠的片段)
let person_segment_lower: HashSet<String> = segments.iter()
.filter(|s| s.category == "person" || s.category == "person_include")
.map(|s| s.text.to_lowercase())
.collect();
let person_name_lower: HashSet<String> = result.person_names.iter()
.map(|n| n.to_lowercase())
.collect();
let mut tags: Vec<(String, String)> = Vec::new();
for seg in &segments {
let cat = &seg.category;
// 跳过停用词
if cat == "stop" { continue; }
// 跳过 person 相关片段
if cat == "person" || cat == "person_include" { continue; }
// 如果是 other 类,检查是否与任何人名重叠
if cat == "other" {
let seg_lower = seg.text.to_lowercase();
let overlaps_person = person_segment_lower.iter().any(|pl| {
seg_lower.contains(pl) || pl.contains(&seg_lower)
}) || person_name_lower.iter().any(|pl| {
seg_lower.contains(pl) || pl.contains(&seg_lower)
});
if overlaps_person { continue; }
// other 类也做个简单过滤:太短、纯数字等跳过
if seg.text.chars().count() < 2 { continue; }
if seg.text.chars().all(|c| c.is_ascii_digit()) { continue; }
// 太短的英文 other 也跳过(噪声)
if !RE_CHINESE.is_match(&seg.text) && seg.text.len() < 3 { continue; }
}
// 有效分类标签
let display_cat = if cat == "other" { "other".to_string() } else { cat.clone() };
tags.push((seg.text.clone(), display_cat));
}
// 去重(小写)
let mut seen = HashSet::new();
tags.retain(|(t, _)| seen.insert(t.to_lowercase()));
result.tags = tags;
result
}
// ── 人名清洗工具函数 ──
/// 提取中文核心(开头的连续中文字符) /// 提取中文核心(开头的连续中文字符)
pub fn extract_cn(name: &str) -> Option<String> { pub fn extract_cn(name: &str) -> Option<String> {
@@ -326,17 +467,147 @@ pub fn normalize_tag(tag: &str) -> String {
tag.trim().to_lowercase() tag.trim().to_lowercase()
} }
// ── 兼容函数(供 pipeline / person_merger 调用)── // ── dict 优先匹配 ──
/// 从标题中提取人物名(兼容函数) /// 使用 dict 表优先匹配 + title_parser 回退的混合解析
pub fn extract_person_name_from_title(title: &str) -> Option<String> { ///
parse_album_title("", title).person_name /// 流程:
/// 1. dict 最长匹配提取 person 和 tags(带 merged_to 解析)
/// 2. 从标题移除已匹配的 dict 词
/// 3. 剩余文本走 title_parser 解析(tag_dict 回退)
/// 4. 合并:dict 结果优先,parser 补充
pub fn parse_album_title_with_dict(
album_id: &str,
title: &str,
dict_entries: &[crate::search_db::DictEntry],
) -> crate::models::parse::ParseResult {
let title = title.trim();
if title.is_empty() {
return crate::models::parse::ParseResult::new(album_id.to_string());
}
// Phase 1: dict 优先匹配
let (dict_person, dict_tags, remaining) = extract_with_dict(title, dict_entries);
// Phase 2: title_parser 回退(解析剩余文本)
let parse_result = if remaining.is_empty() {
crate::models::parse::ParseResult::new(album_id.to_string())
} else {
parse_album_title(album_id, &remaining)
};
// Phase 3: 合并结果 — dict 优先,parser 补充
let mut result = crate::models::parse::ParseResult::new(album_id.to_string());
// persons: dict 命中 + parser 结果合并去重
let mut seen_persons = HashSet::new();
for name in dict_person.iter().chain(parse_result.person_names.iter()) {
if seen_persons.insert(name.to_lowercase()) {
result.person_names.push(name.clone());
}
}
// tags: dict 标签优先,parser 标签补充去重
let mut seen = HashSet::new();
for (t, _) in &dict_tags {
seen.insert(t.to_lowercase());
result.tags.push((t.clone(), "other".to_string()));
}
for (t, c) in &parse_result.tags {
if seen.insert(t.to_lowercase()) {
result.tags.push((t.clone(), c.clone()));
}
}
result
}
/// dict 条目按词长降序匹配标题,返回 (persons, tags, 剩余文本)
fn extract_with_dict(
title: &str,
dict_entries: &[crate::search_db::DictEntry],
) -> (Vec<String>, Vec<(String, String)>, String) {
// 按词长降序排列
let mut sorted: Vec<&crate::search_db::DictEntry> = dict_entries.iter().collect();
sorted.sort_by(|a, b| b.word.len().cmp(&a.word.len()));
let title_lower = title.to_lowercase();
let mut matched_ranges: Vec<(usize, usize)> = Vec::new();
let mut persons: Vec<String> = Vec::new();
let mut seen_persons: HashSet<String> = HashSet::new();
let mut tags: Vec<(String, String)> = Vec::new();
let mut seen_tag_words = HashSet::new();
for entry in &sorted {
let word_lower = entry.word.to_lowercase();
// 在当前标题中查找该词(忽略大小写)
let mut search_start = 0;
while let Some(pos) = title_lower[search_start..].find(&word_lower) {
let abs_start = search_start + pos;
let abs_end = abs_start + entry.word.len();
// 检查是否已被更长的 dict 词覆盖
if matched_ranges.iter().any(|&(s, e)| s <= abs_start && abs_end <= e) {
break;
}
matched_ranges.push((abs_start, abs_end));
match entry.type_.as_str() {
"person" => {
let resolved = entry.merged_to.as_ref().unwrap_or(&entry.word).clone();
if seen_persons.insert(resolved.to_lowercase()) {
persons.push(resolved);
}
}
"tag" => {
if seen_tag_words.insert(entry.word.clone()) {
tags.push((entry.word.clone(), entry.category.clone().unwrap_or_default()));
}
}
_ => {}
}
break; // 每个词只匹配一次
}
}
// 构建剩余文本:去掉已匹配的部分
if matched_ranges.is_empty() {
return (persons, tags, title.to_string());
}
matched_ranges.sort_by_key(|&(s, _)| s);
let mut remaining = String::new();
let mut last = 0;
for &(s, e) in &matched_ranges {
if s > last {
remaining.push_str(&title[last..s]);
}
remaining.push(' ');
last = e;
}
if last < title.len() {
remaining.push_str(&title[last..]);
}
// 合并连续空格
let remaining = remaining.split_whitespace().collect::<Vec<_>>().join(" ");
(persons, tags, remaining)
}
// ── 兼容函数(供 pipeline / person_merger 调用) ──
/// 从标题中提取人物名列表(兼容函数)
pub fn extract_person_name_from_title(title: &str) -> Vec<String> {
parse_album_title("", title).person_names
} }
/// 从标题中提取人物名和标签(兼容函数) /// 从标题中提取人物名和标签(兼容函数)
pub fn extract_person_and_tags(title: &str) -> (Option<String>, Vec<(String, String)>) { pub fn extract_person_and_tags(title: &str) -> (Vec<String>, Vec<(String, String)>) {
let result = parse_album_title("", title); let result = parse_album_title("", title);
(result.person_name, result.tags) (result.person_names, result.tags)
} }
#[cfg(test)] #[cfg(test)]
@@ -346,21 +617,38 @@ mod tests {
#[test] #[test]
fn test_parse_album_title_with_person() { fn test_parse_album_title_with_person() {
let r = parse_album_title("id1", "杨晨晨Yome 私房写真"); let r = parse_album_title("id1", "杨晨晨Yome 私房写真");
assert_eq!(r.person_name.as_deref(), Some("杨晨晨")); assert_eq!(r.person_names.first().map(|s| s.as_str()), Some("杨晨晨"));
assert!(!r.tags.is_empty()); assert!(!r.tags.is_empty());
let tag_names: Vec<&str> = r.tags.iter().map(|(t, _)| t.as_str()).collect();
assert!(tag_names.contains(&"私房"), "应包含 '私房' 标签");
assert!(tag_names.contains(&"写真"), "应包含 '写真' 标签");
} }
#[test] #[test]
fn test_parse_album_title_no_person() { fn test_parse_album_title_no_person() {
let r = parse_album_title("id2", "浴室 可爱 性感 写真"); let r = parse_album_title("id2", "浴室 可爱 性感 写真");
assert!(r.person_name.is_none()); assert!(r.person_names.is_empty());
assert!(!r.tags.is_empty()); assert!(!r.tags.is_empty());
let tag_names: Vec<&str> = r.tags.iter().map(|(t, _)| t.as_str()).collect();
assert!(tag_names.contains(&"浴室"));
assert!(tag_names.contains(&"性感"));
assert!(tag_names.contains(&"写真"));
} }
#[test] #[test]
fn test_parse_album_title_with_prefix() { fn test_parse_album_title_with_prefix() {
let r = parse_album_title("id3", "美女模特 杨晨晨 私房"); let r = parse_album_title("id3", "美女模特 杨晨晨 私房");
assert_eq!(r.person_name.as_deref(), Some("杨晨晨")); assert_eq!(r.person_names.first().map(|s| s.as_str()), Some("杨晨晨"));
}
#[test]
fn test_parse_continuous_chinese() {
// 连续中文:杨晨晨私房写真 — 应能切分出人名和标签
let r = parse_album_title("id4", "杨晨晨私房写真");
assert_eq!(r.person_names.first().map(|s| s.as_str()), Some("杨晨晨"));
let tag_names: Vec<&str> = r.tags.iter().map(|(t, _)| t.as_str()).collect();
assert!(tag_names.contains(&"私房"), "应包含 '私房'");
assert!(tag_names.contains(&"写真"), "应包含 '写真'");
} }
#[test] #[test]
@@ -383,4 +671,23 @@ mod tests {
let (name3, _) = split_person_name_with_aliases("Yome"); let (name3, _) = split_person_name_with_aliases("Yome");
assert_eq!(name3, "Yome"); assert_eq!(name3, "Yome");
} }
#[test]
fn test_person_not_in_tags() {
// 人名不应出现在标签中
let r = parse_album_title("id5", "杨晨晨 日系 比基尼");
let tag_names: Vec<&str> = r.tags.iter().map(|(t, _)| t.as_str()).collect();
assert!(!tag_names.contains(&"杨晨晨"), "人名 '杨晨晨' 不应出现在标签中");
assert!(tag_names.contains(&"日系"));
assert!(tag_names.contains(&"比基尼"));
}
#[test]
fn test_stop_words_removed() {
// 停用词不应出现在标签或人名中
let r = parse_album_title("id6", "杨晨晨 photos collection");
let tag_names: Vec<&str> = r.tags.iter().map(|(t, _)| t.as_str()).collect();
assert!(!tag_names.contains(&"photos"), "停用词 'photos' 不应在标签中");
assert!(!tag_names.contains(&"collection"), "停用词 'collection' 不应在标签中");
}
} }

View File

@@ -7,22 +7,30 @@ mod routes;
mod services; mod services;
mod image_processor; mod image_processor;
mod queue; mod queue;
mod search_db;
use crate::cache::AlbumsCache; use crate::cache::AlbumsCache;
use crate::search_db::SearchDb;
use actix_files as afs; use actix_files as afs;
use actix_web::{App, HttpResponse, HttpServer, middleware, web}; use actix_web::{App, HttpResponse, HttpServer, middleware, web};
use std::env;
use std::fs; use std::fs;
use std::sync::Arc; use std::sync::Arc;
use tokio::time::{Duration, interval}; use tokio::time::{Duration, interval};
use tracing::{error, info}; use tracing::{error, info};
#[global_allocator]
static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
#[actix_web::main] #[actix_web::main]
async fn main() -> std::io::Result<()> { async fn main() -> std::io::Result<()> {
tracing_subscriber::fmt::init(); tracing_subscriber::fmt::init();
let args: Vec<String> = env::args().collect();
let export_to_search = args.iter().any(|a| a == "--export-search");
let search_db_cli_path = args.iter().find(|a| a.starts_with("--search-db="))
.map(|s| s.strip_prefix("--search-db=").unwrap_or("search.db"))
.unwrap_or("search.db");
let clear_search = args.iter().any(|a| a == "--clear-search");
let wal_checkpoint = args.iter().any(|a| a == "--wal-checkpoint");
// 加载配置 // 加载配置
let config = match config::Config::load() { let config = match config::Config::load() {
Ok(cfg) => cfg, Ok(cfg) => cfg,
@@ -51,45 +59,99 @@ async fn main() -> std::io::Result<()> {
} }
}; };
if export_to_search {
info!("[搜索导出] 开始将元数据导出到 search.db...");
match services::search_export::export_to_search_db(&db, search_db_cli_path, clear_search).await {
Ok(result) => {
info!("[搜索导出] 导出完成: 相册{}, 标签{}, 人物{}, 别名{}, 关联{}",
result.albums_processed, result.tags_created, result.persons_created,
result.aliases_created, result.album_tags_created + result.album_persons_created);
std::process::exit(0);
}
Err(e) => {
error!("[搜索导出] 导出失败: {}", e);
std::process::exit(1);
}
}
}
if wal_checkpoint {
info!("[WAL合并] 主数据库 WAL checkpoint 已在初始化时完成");
info!("[WAL合并] 正在合并 search.db WAL...");
let search_db = SearchDb::new("data/search.db").await
.expect("search.db 连接失败");
search_db.wal_checkpoint().await;
info!("[WAL合并] 两个数据库均已合并完成");
std::process::exit(0);
}
let image_processor = Arc::new(image_processor::ImageProcessor::new(config.storage.clone())); let image_processor = Arc::new(image_processor::ImageProcessor::new(config.storage.clone()));
// ── 初始化 search.db(运行时搜索专用)──
let search_db_path = "data/search.db";
let search_db = Arc::new(
SearchDb::new(search_db_path).await
.expect("search.db 连接失败")
);
info!("search.db 连接成功");
search_db.wal_checkpoint().await;
// ── 从 search.db 的 dict 表加载标签词典 ──
match engine::tag_dict::reload_from_search_db(&search_db).await {
msg => info!("{}", msg),
}
// ── 内存缓存(必须在管线任务之前创建)── // ── 内存缓存(必须在管线任务之前创建)──
let albums_cache = Arc::new(tokio::sync::RwLock::new(AlbumsCache::new())); let albums_cache = Arc::new(tokio::sync::RwLock::new(AlbumsCache::new()));
let persons_cache = Arc::new(tokio::sync::RwLock::new(cache::PersonCache::default())); let persons_cache = Arc::new(tokio::sync::RwLock::new(cache::PersonCache::default()));
let tags_cache = Arc::new(tokio::sync::RwLock::new(cache::TagCache::default())); let tags_cache = Arc::new(tokio::sync::RwLock::new(cache::TagCache::default()));
// ── 启动管线(单次):导入 → 解析 → 合并 → 缓存刷新 ── // ── 启动管线(单次):导入 → 增量解析 → 条件全量 sync → 缓存刷新 ──
// 不做全量 reparse/merge,只处理新发现的相册
let boot_config = config.clone(); let boot_config = config.clone();
let boot_db = Arc::clone(&db); let boot_db = Arc::clone(&db);
let boot_search_db = Arc::clone(&search_db);
let boot_albums_cache = Arc::clone(&albums_cache); let boot_albums_cache = Arc::clone(&albums_cache);
let boot_persons_cache = Arc::clone(&persons_cache); let boot_persons_cache = Arc::clone(&persons_cache);
let boot_tags_cache = Arc::clone(&tags_cache); let boot_tags_cache = Arc::clone(&tags_cache);
tokio::spawn(async move { tokio::spawn(async move {
// ① 扫描导入新相册 // ① 扫描导入新相册
info!("[启动管线] ① 扫描导入新相册..."); info!("[启动] ① 扫描导入新相册...");
match services::import::import_existing_data(&boot_config, Arc::clone(&boot_db), None).await { match services::import::import_existing_data(&boot_config, Arc::clone(&boot_db), None).await {
Ok(_) => info!("[启动管线] 导入完成"), Ok(_) => info!("[启动] 导入完成"),
Err(e) => error!("[启动管线] 导入失败: {}", e), Err(e) => error!("[启动] 导入失败: {}", e),
} }
// ② 全量解析 + 人物合并 // ② 清理:删除空相册 + 去重
info!("[启动管线] ② 全量解析 + 人物合并..."); info!("[启动] ② 清理空相册和重复相册...");
let result = engine::pipeline::run_pipeline(&boot_db).await; let empty = engine::pipeline::phase_delete_empty_albums(&boot_db).await;
info!("[启动管线] 完成:清洗标点{},检测人名标签{},脏集{}相册,删除非人物{},清除停用词重叠人物{},发现新相册{},更新人名{},更新标签{},合并人物{},迁移别名{},后移除人名标签{}", let dedup = engine::pipeline::phase_dedup_albums(&boot_db, &boot_search_db).await;
result.tags_cleaned, result.person_like_tags_removed, result.dirty_albums_detected, if empty > 0 || dedup > 0 {
result.non_persons_deleted, result.stop_word_persons_removed, result.new_albums_found, info!("[启动] 清理完成:删除空相册 {},去重删除 {}", empty, dedup);
result.persons_updated, result.tags_updated, }
result.persons_merged, result.aliases_moved, result.tags_removed_person);
// ③ 刷新所有内存缓存 // ③ 查找新相册 / 半成品
info!("[启动管线] ③ 刷新所有内存缓存..."); info!("[启动] ③ 查找新相册...");
cache::refresh_all_caches(&boot_db, &boot_albums_cache, &boot_persons_cache, &boot_tags_cache).await; let dirty = engine::pipeline::phase_collect_new_albums(&boot_db).await;
info!("[启动管线] 启动管线执行完毕"); let new_count = dirty.len();
if new_count > 0 {
info!("[启动] 发现 {} 个新相册,同步 tags/persons 到 search.db...", new_count);
let synced = engine::pipeline::sync_dirty_albums(&boot_db, &boot_search_db, &dirty).await;
info!("[启动] 增量同步完成:{} 个相册(仅 tags/persons,不同步 albums 表)", synced);
} else {
info!("[启动] 没有新相册");
}
// ④ 刷新所有内存缓存(从 search.db 读取)
info!("[启动] ④ 刷新所有内存缓存...");
cache::refresh_all_caches(&boot_db, &boot_search_db, &boot_albums_cache, &boot_persons_cache, &boot_tags_cache).await;
info!("[启动] 启动管线执行完毕(新相册={})", new_count);
}); });
// ── 定时管线(每 30 分钟):解析 → 合并 → 缓存刷新 ── // ── 定时管线(每 30 分钟):导入 → 增量解析(有新相册时)→ 缓存刷新(始终执行)──
let timer_cache = Arc::clone(&albums_cache); let timer_cache = Arc::clone(&albums_cache);
let timer_db = Arc::clone(&db); let timer_db = Arc::clone(&db);
let timer_search_db = Arc::clone(&search_db);
let timer_persons_cache = Arc::clone(&persons_cache); let timer_persons_cache = Arc::clone(&persons_cache);
let timer_tags_cache = Arc::clone(&tags_cache); let timer_tags_cache = Arc::clone(&tags_cache);
tokio::spawn(async move { tokio::spawn(async move {
@@ -97,18 +159,23 @@ async fn main() -> std::io::Result<()> {
loop { loop {
interval.tick().await; interval.tick().await;
// ① 全量解析 + 人物合并(不重复 import) // ① 扫描导入新相册
info!("[定时管线] ① 全量解析 + 人物合并..."); info!("[定时] ① 扫描导入新相册...");
let result = engine::pipeline::run_pipeline(&timer_db).await; match services::import::import_existing_data(&timer_db.config, Arc::clone(&timer_db), None).await {
info!("[定时管线] 完成:清洗标点{},检测人名标签{},脏集{}相册,删除非人物{},清除停用词重叠人物{},发现新相册{},更新人名{},更新标签{},合并人物{},迁移别名{},后移除人名标签{}", Ok(_) => {},
result.tags_cleaned, result.person_like_tags_removed, result.dirty_albums_detected, Err(e) => error!("[定时] 导入失败: {}", e),
result.non_persons_deleted, result.stop_word_persons_removed, result.new_albums_found, }
result.persons_updated, result.tags_updated,
result.persons_merged, result.aliases_moved, result.tags_removed_person);
// ② 刷新所有内存缓存 // ② 查找新相册并增量解析
info!("[定时管线] ② 刷新所有内存缓存..."); let new_albums = engine::pipeline::phase_collect_new_albums(&timer_db).await;
cache::refresh_all_caches(&timer_db, &timer_cache, &timer_persons_cache, &timer_tags_cache).await; if !new_albums.is_empty() {
info!("[定时] 发现 {} 个新相册,增量解析(同时写入 imager.db + search.db)...", new_albums.len());
engine::pipeline::phase_parse_dirty(&timer_db, &timer_search_db, &new_albums).await;
}
// ③ 缓存刷新(始终执行)
info!("[定时] 刷新缓存...");
cache::refresh_all_caches(&timer_db, &timer_search_db, &timer_cache, &timer_persons_cache, &timer_tags_cache).await;
} }
}); });
@@ -135,9 +202,11 @@ async fn main() -> std::io::Result<()> {
println!(" - GET /api/people/search?q=关键词 - 搜索人员"); println!(" - GET /api/people/search?q=关键词 - 搜索人员");
println!(" - GET /api/people/{{name}} - 人员详情"); println!(" - GET /api/people/{{name}} - 人员详情");
println!(" - GET /api/people/{{id}}/aliases - 人员别名"); println!(" - GET /api/people/{{id}}/aliases - 人员别名");
println!(" - POST /api/people/delete/{{name}} - 删除人员并重解析受影响相册");
println!(" - GET /api/metadata/stats - 元数据统计"); println!(" - GET /api/metadata/stats - 元数据统计");
println!(" - GET /api/tags/search?tag=标签 - 按标签搜索"); println!(" - GET /api/tags/search?tag=标签 - 按标签搜索");
println!(" - GET /api/tags/popular?limit=50 - 热门标签"); println!(" - GET /api/tags/popular?limit=50 - 热门标签");
println!(" - POST /api/tags/delete/{{name}} - 删除标签并重解析受影响相册");
println!("推荐接口:"); println!("推荐接口:");
println!(" - GET /api/recommend/tags?q=xxx - 标签推荐"); println!(" - GET /api/recommend/tags?q=xxx - 标签推荐");
println!(" - GET /api/recommend/persons?q=xxx - 人物推荐"); println!(" - GET /api/recommend/persons?q=xxx - 人物推荐");
@@ -147,9 +216,17 @@ async fn main() -> std::io::Result<()> {
println!(" - GET /api/migration/stats - 迁移状态"); println!(" - GET /api/migration/stats - 迁移状态");
println!(" - POST /api/migration/run?path=persons.db - 执行迁移"); println!(" - POST /api/migration/run?path=persons.db - 执行迁移");
println!(" - GET /api/queue/stats - 队列状态"); println!(" - GET /api/queue/stats - 队列状态");
println!("管线接口:");
println!(" - POST /api/pipeline/run - 执行管线(增量)");
println!(" - POST /api/pipeline/reparse - 重置并重新解析全部相册(标签+人物)");
println!(" - POST /api/pipeline/reparse-persons - 重置并重新解析全部人物");
println!(" - POST /api/pipeline/reparse-tags - 重置并重新解析全部标签");
println!("词典管理:"); println!("词典管理:");
println!(" - GET /api/dict/stats - 词典状态"); println!(" - GET /api/dict/stats - 词典状态");
println!(" - POST /api/dict/reload - 热重载词典"); println!(" - POST /api/dict/reload - 热重载词典");
println!(" - POST /api/dict/update - 批量更新 dict 表(自动重载内存词典)");
println!("缓存管理:");
println!(" - POST /api/cache/refresh - 手动刷新内存缓存");
println!("按 Ctrl+C 停止服务"); println!("按 Ctrl+C 停止服务");
fs::create_dir_all(&config.storage.images_dir).unwrap_or(()); fs::create_dir_all(&config.storage.images_dir).unwrap_or(());
@@ -161,6 +238,7 @@ async fn main() -> std::io::Result<()> {
.wrap(middleware::Compress::default()) .wrap(middleware::Compress::default())
.wrap(middleware::Logger::default()) .wrap(middleware::Logger::default())
.app_data(web::Data::new(Arc::clone(&db))) .app_data(web::Data::new(Arc::clone(&db)))
.app_data(web::Data::new(Arc::clone(&search_db)))
.app_data(web::Data::new(Arc::clone(&image_processor))) .app_data(web::Data::new(Arc::clone(&image_processor)))
.app_data(web::Data::new(Arc::clone(&albums_cache))) .app_data(web::Data::new(Arc::clone(&albums_cache)))
.app_data(web::Data::new(Arc::clone(&persons_cache))) .app_data(web::Data::new(Arc::clone(&persons_cache)))
@@ -184,10 +262,12 @@ async fn main() -> std::io::Result<()> {
.route("/api/people/search", web::get().to(routes::search_people)) .route("/api/people/search", web::get().to(routes::search_people))
.route("/api/people/{name}", web::get().to(routes::get_person_detail)) .route("/api/people/{name}", web::get().to(routes::get_person_detail))
.route("/api/people/{id}/aliases", web::get().to(routes::get_person_aliases)) .route("/api/people/{id}/aliases", web::get().to(routes::get_person_aliases))
.route("/api/people/delete/{name}", web::post().to(routes::delete_person))
// 标签 API // 标签 API
.route("/api/metadata/stats", web::get().to(routes::get_metadata_stats)) .route("/api/metadata/stats", web::get().to(routes::get_metadata_stats))
.route("/api/tags/search", web::get().to(routes::search_by_tag)) .route("/api/tags/search", web::get().to(routes::search_by_tag))
.route("/api/tags/popular", web::get().to(routes::get_popular_tags)) .route("/api/tags/popular", web::get().to(routes::get_popular_tags))
.route("/api/tags/delete/{name}", web::post().to(routes::delete_tag))
// 推荐 API // 推荐 API
.route("/api/recommend/tags", web::get().to(routes::recommend_tags)) .route("/api/recommend/tags", web::get().to(routes::recommend_tags))
.route("/api/recommend/persons", web::get().to(routes::recommend_persons)) .route("/api/recommend/persons", web::get().to(routes::recommend_persons))
@@ -198,11 +278,17 @@ async fn main() -> std::io::Result<()> {
.route("/api/migration/run", web::post().to(routes::migration_run)) .route("/api/migration/run", web::post().to(routes::migration_run))
// 管线 API // 管线 API
.route("/api/pipeline/run", web::post().to(routes::pipeline_run)) .route("/api/pipeline/run", web::post().to(routes::pipeline_run))
.route("/api/pipeline/reparse", web::post().to(routes::pipeline_reparse))
.route("/api/pipeline/reparse-persons", web::post().to(routes::pipeline_reparse_persons))
.route("/api/pipeline/reparse-tags", web::post().to(routes::pipeline_reparse_tags))
// 队列 API // 队列 API
.route("/api/queue/stats", web::get().to(routes::get_queue_stats)) .route("/api/queue/stats", web::get().to(routes::get_queue_stats))
// 词典 API // 词典 API
.route("/api/dict/stats", web::get().to(routes::dict_stats)) .route("/api/dict/stats", web::get().to(routes::dict_stats))
.route("/api/dict/reload", web::post().to(routes::dict_reload)) .route("/api/dict/reload", web::post().to(routes::dict_reload))
.route("/api/dict/update", web::post().to(routes::dict_update))
// 缓存管理 API
.route("/api/cache/refresh", web::post().to(routes::cache_refresh))
// 静态文件 // 静态文件
.service( .service(
afs::Files::new("/assets", "./assets") afs::Files::new("/assets", "./assets")

View File

@@ -10,10 +10,6 @@ pub struct Album {
pub image_count: i64, pub image_count: i64,
pub created_at: String, pub created_at: String,
pub updated_at: String, pub updated_at: String,
#[serde(default)]
pub person_name_cleaned: Option<String>,
#[serde(default)]
pub tags: Option<String>, // JSON: [tag, ...]
} }
#[derive(Debug, Serialize, Deserialize, Clone)] #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -25,6 +21,8 @@ pub struct AlbumInfo {
pub cover_image_id: Option<String>, pub cover_image_id: Option<String>,
pub image_count: i64, pub image_count: i64,
pub created_at: String, pub created_at: String,
pub tags: Vec<String>,
pub persons: Vec<String>,
} }
#[derive(Debug, Serialize, Deserialize)] #[derive(Debug, Serialize, Deserialize)]
@@ -32,6 +30,8 @@ pub struct AlbumWithImages {
pub album: Album, pub album: Album,
pub images: Vec<super::image::Image>, pub images: Vec<super::image::Image>,
pub image_count: i64, pub image_count: i64,
pub tags: Vec<String>,
pub persons: Vec<String>,
} }
#[derive(Debug, Serialize, Deserialize)] #[derive(Debug, Serialize, Deserialize)]
@@ -47,16 +47,11 @@ pub struct AlbumIndex {
pub images: Vec<String>, pub images: Vec<String>,
} }
/// 相册完整元数据(含扩展字段) /// 相册完整元数据(精简版:仅保留 albums 表原始字段)
#[derive(Debug, Serialize, Deserialize, Clone)] #[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AlbumMeta { pub struct AlbumMeta {
pub id: String, pub id: String,
pub title: Option<String>, pub title: Option<String>,
pub person_name_original: Option<String>, pub cover_image_id: Option<String>,
pub person_name_cleaned: Option<String>,
pub tags: Option<String>,
pub all_words: Option<String>,
pub raw_title: Option<String>,
pub processed_at: Option<String>,
pub image_count: Option<i64>, pub image_count: Option<i64>,
} }

View File

@@ -5,23 +5,21 @@ use serde::{Serialize, Deserialize};
/// 一次 title 解析的完整结果 /// 一次 title 解析的完整结果
/// ///
/// 在一个相册上通过一次 jieba 分词,同时提取: /// 在一个相册上通过一次分词,同时提取:
/// - 人名 + 别名(含 include 扩展、prefix 移除) /// - 人名列表(支持多个)
/// - 标签列表(含分类) /// - 标签列表(含分类)
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ParseResult { pub struct ParseResult {
/// 相册 UUID /// 相册 UUID
pub album_id: String, pub album_id: String,
/// 最终人名 | None = 未找到 /// 最终识别的人名列表 | 空 = 未找到
pub person_name: Option<String>, pub person_names: Vec<String>,
/// 中文主名(split_person_name_with_aliases 后的 primary)
pub person_primary: Option<String>,
/// 标签列表 (tag, category) /// 标签列表 (tag, category)
pub tags: Vec<(String, String)>, pub tags: Vec<(String, String)>,
} }
impl ParseResult { impl ParseResult {
pub fn new(album_id: String) -> Self { pub fn new(album_id: String) -> Self {
Self { album_id, person_name: None, person_primary: None, tags: Vec::new() } Self { album_id, person_names: Vec::new(), tags: Vec::new() }
} }
} }

View File

@@ -3,7 +3,7 @@ use super::album::AlbumInfo;
#[derive(Debug, Serialize, Deserialize, Clone)] #[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Person { pub struct Person {
pub id: i64, pub id: String,
pub name: String, pub name: String,
pub display_name: Option<String>, pub display_name: Option<String>,
pub total_albums: i64, pub total_albums: i64,
@@ -16,7 +16,7 @@ pub struct Person {
#[derive(Debug, Serialize, Deserialize, Clone)] #[derive(Debug, Serialize, Deserialize, Clone)]
pub struct PersonAlias { pub struct PersonAlias {
pub id: i64, pub id: i64,
pub person_id: i64, pub person_id: String,
pub alias_type: String, pub alias_type: String,
pub alias_name: String, pub alias_name: String,
pub created_at: String, pub created_at: String,
@@ -31,7 +31,7 @@ pub struct PersonWithAlbums {
#[derive(Debug, Serialize, Deserialize, Clone)] #[derive(Debug, Serialize, Deserialize, Clone)]
pub struct PersonWithCounts { pub struct PersonWithCounts {
pub id: i64, pub id: String,
pub name: String, pub name: String,
pub display_name: Option<String>, pub display_name: Option<String>,
pub total_albums: i64, pub total_albums: i64,

View File

@@ -20,8 +20,8 @@ pub struct TagListResponse {
pub struct MetadataStats { pub struct MetadataStats {
pub total_persons: i64, pub total_persons: i64,
pub total_aliases: i64, pub total_aliases: i64,
pub total_albums_with_person: i64, pub total_albums: i64,
pub total_albums_without_person: i64, pub total_images: i64,
pub total_tags: i64, pub total_tags: i64,
} }

View File

@@ -1,5 +1,6 @@
use crate::cache::AlbumsCache; use crate::cache::AlbumsCache;
use crate::db::Database; use crate::db::Database;
use crate::search_db::SearchDb;
use crate::models::*; use crate::models::*;
use actix_web::{HttpResponse, Responder, web}; use actix_web::{HttpResponse, Responder, web};
use std::collections::HashMap; use std::collections::HashMap;
@@ -25,7 +26,7 @@ pub async fn get_albums(cache: web::Data<Arc<RwLock<AlbumsCache>>>) -> impl Resp
/// 规则:有任意过滤条件时 → 走 DB 懒加载(只查符合条件的相册) /// 规则:有任意过滤条件时 → 走 DB 懒加载(只查符合条件的相册)
/// 无过滤条件时 → 走缓存全量返回 /// 无过滤条件时 → 走缓存全量返回
pub async fn search_albums( pub async fn search_albums(
db: web::Data<Arc<Database>>, search_db: web::Data<Arc<SearchDb>>,
cache: web::Data<Arc<RwLock<AlbumsCache>>>, cache: web::Data<Arc<RwLock<AlbumsCache>>>,
query: web::Query<HashMap<String, String>>, query: web::Query<HashMap<String, String>>,
) -> impl Responder { ) -> impl Responder {
@@ -50,7 +51,7 @@ pub async fn search_albums(
let person_arg = if person.is_empty() { None } else { Some(person) }; let person_arg = if person.is_empty() { None } else { Some(person) };
let q_arg = if q.is_empty() { None } else { Some(q) }; let q_arg = if q.is_empty() { None } else { Some(q) };
match db.search_albums_with_filters(tag_arg, person_arg, q_arg, limit, offset).await { match search_db.search_albums(tag_arg, person_arg, q_arg, limit, offset).await {
Ok(results) => HttpResponse::Ok().json(results), Ok(results) => HttpResponse::Ok().json(results),
Err(e) => HttpResponse::InternalServerError().json(serde_json::json!({"error": format!("{}", e)})), Err(e) => HttpResponse::InternalServerError().json(serde_json::json!({"error": format!("{}", e)})),
} }
@@ -78,10 +79,30 @@ pub async fn get_random_album(cache: web::Data<Arc<RwLock<AlbumsCache>>>) -> imp
HttpResponse::Ok().json(&c.albums[idx]) HttpResponse::Ok().json(&c.albums[idx])
} }
pub async fn get_album_detail(db: web::Data<Arc<Database>>, path: web::Path<String>) -> impl Responder { pub async fn get_album_detail(
db: web::Data<Arc<Database>>,
cache: web::Data<Arc<RwLock<AlbumsCache>>>,
path: web::Path<String>,
) -> impl Responder {
let id = match Uuid::parse_str(&path.into_inner()) { Ok(id) => id, Err(_) => return HttpResponse::BadRequest().json(serde_json::json!({"error": "无效ID"})) }; let id = match Uuid::parse_str(&path.into_inner()) { Ok(id) => id, Err(_) => return HttpResponse::BadRequest().json(serde_json::json!({"error": "无效ID"})) };
let id_str = id.to_string();
// 从内存缓存查 tags/persons
let (tags, persons) = {
let c = cache.read().await;
let found = c.albums.iter().find(|a| a.id == id);
match found {
Some(a) => (a.tags.clone(), a.persons.clone()),
None => (vec![], vec![]),
}
};
match db.get_album_with_images(id).await { match db.get_album_with_images(id).await {
Ok(Some(album)) => HttpResponse::Ok().json(album), Ok(Some(mut album)) => {
album.tags = tags;
album.persons = persons;
HttpResponse::Ok().json(album)
}
Ok(None) => HttpResponse::NotFound().json(serde_json::json!({"error": "相册不存在"})), Ok(None) => HttpResponse::NotFound().json(serde_json::json!({"error": "相册不存在"})),
Err(e) => HttpResponse::InternalServerError().json(serde_json::json!({"error": format!("{}", e)})), Err(e) => HttpResponse::InternalServerError().json(serde_json::json!({"error": format!("{}", e)})),
} }

27
src/routes/cache.rs Normal file
View File

@@ -0,0 +1,27 @@
use crate::cache;
use crate::db::Database;
use crate::search_db::SearchDb;
use crate::cache::{AlbumsCache, TagCache, PersonCache};
use actix_web::{HttpResponse, Responder, web};
use std::sync::Arc;
use tokio::sync::RwLock;
use tracing::info;
/// POST /api/cache/refresh — 手动刷新所有内存缓存
pub async fn cache_refresh(
db: web::Data<Arc<Database>>,
search_db: web::Data<Arc<SearchDb>>,
albums_cache: web::Data<Arc<RwLock<AlbumsCache>>>,
persons_cache: web::Data<Arc<RwLock<PersonCache>>>,
tags_cache: web::Data<Arc<RwLock<TagCache>>>,
) -> impl Responder {
info!("[API] 手动触发缓存刷新...");
cache::refresh_all_caches(
db.get_ref(),
search_db.get_ref(),
albums_cache.get_ref(),
persons_cache.get_ref(),
tags_cache.get_ref(),
).await;
HttpResponse::Ok().json(serde_json::json!({"success": true, "message": "缓存已刷新"}))
}

View File

@@ -1,8 +1,11 @@
//! 标签词典管理 API — 查看/热重载 //! 标签词典管理 API — 查看/热重载
use actix_web::{HttpResponse, Responder}; use std::sync::Arc;
use actix_web::{HttpResponse, Responder, web};
use crate::engine::tag_dict; use crate::engine::tag_dict;
use crate::search_db::SearchDb;
/// GET /api/dict/stats — 查看词典状态 /// GET /api/dict/stats — 查看词典状态
pub async fn dict_stats() -> impl Responder { pub async fn dict_stats() -> impl Responder {
@@ -30,11 +33,51 @@ pub async fn dict_stats() -> impl Responder {
} }
/// POST /api/dict/reload — 热重载词典 /// POST /api/dict/reload — 热重载词典
pub async fn dict_reload() -> impl Responder { pub async fn dict_reload(search_db: web::Data<Arc<SearchDb>>) -> impl Responder {
let msg = tag_dict::reload_tag_dict(); let msg = tag_dict::reload_from_search_db(search_db.get_ref()).await;
println!("[API] 词典热重载: {}", msg); println!("[API] 词典热重载: {}", msg);
HttpResponse::Ok().json(serde_json::json!({ HttpResponse::Ok().json(serde_json::json!({
"success": true, "success": true,
"message": msg, "message": msg,
})) }))
} }
/// dict 条目请求体
#[derive(serde::Deserialize)]
pub struct DictEntryInput {
pub word: String,
#[serde(rename = "type")]
pub type_: String,
pub category: Option<String>,
pub freq: Option<i64>,
pub merged_to: Option<String>,
}
/// POST /api/dict/update — 更新 dict 表(新增或覆盖条目)
pub async fn dict_update(
search_db: web::Data<Arc<SearchDb>>,
body: web::Json<Vec<DictEntryInput>>,
) -> impl Responder {
let entries = body.into_inner();
let mut inserted = 0usize;
for e in &entries {
match search_db.upsert_dict_entry(
&e.word, &e.type_, e.category.as_deref(), e.freq, e.merged_to.as_deref(),
).await {
Ok(_) => inserted += 1,
Err(err) => {
return HttpResponse::InternalServerError().json(serde_json::json!({
"success": false,
"message": format!("更新词条 '{}' 失败: {}", e.word, err),
}));
}
}
}
// 自动重载内存词典
let msg = tag_dict::reload_from_search_db(search_db.get_ref()).await;
HttpResponse::Ok().json(serde_json::json!({
"success": true,
"message": format!("更新 {} 条字典条目,{}", inserted, msg),
"updated": inserted,
}))
}

View File

@@ -1,6 +1,7 @@
//! API 路由层 — 按领域拆分 //! API 路由层 — 按领域拆分
pub mod album; pub mod album;
pub mod cache;
pub mod image; pub mod image;
pub mod favorite; pub mod favorite;
pub mod person; pub mod person;
@@ -12,6 +13,7 @@ pub mod pipeline;
pub mod dict; pub mod dict;
pub use album::*; pub use album::*;
pub use cache::*;
pub use image::*; pub use image::*;
pub use favorite::*; pub use favorite::*;
pub use person::*; pub use person::*;

View File

@@ -1,22 +1,25 @@
use crate::cache::PersonCache; use crate::cache::{PersonCache, AlbumsCache, TagCache};
use crate::db::Database; use crate::db::Database;
use crate::engine;
use crate::search_db::SearchDb;
use crate::models::*; use crate::models::*;
use actix_web::{HttpResponse, Responder, web}; use actix_web::{HttpResponse, Responder, web};
use sqlx::Row;
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::Arc; use std::sync::Arc;
use tokio::sync::RwLock; use tokio::sync::RwLock;
use uuid::Uuid;
/// GET /api/people — 从缓存获取所有人名列表 /// GET /api/people — 从内存缓存获取所有人名列表
pub async fn get_people(cache: web::Data<Arc<RwLock<PersonCache>>>) -> impl Responder { pub async fn get_people(cache: web::Data<Arc<RwLock<PersonCache>>>) -> impl Responder {
let c = cache.read().await; let c = cache.read().await;
// 缓存中已按 total_albums DESC 排序
HttpResponse::Ok().json(PersonListResponse { HttpResponse::Ok().json(PersonListResponse {
total: c.persons.len(), total: c.persons.len(),
persons: c.persons.clone(), persons: c.persons.clone(),
}) })
} }
/// GET /api/people/search?q=关键词 — 从缓存搜索人名 /// GET /api/people/search?q=关键词 — 从内存缓存搜索人名
pub async fn search_people( pub async fn search_people(
cache: web::Data<Arc<RwLock<PersonCache>>>, cache: web::Data<Arc<RwLock<PersonCache>>>,
query: web::Query<HashMap<String, String>>, query: web::Query<HashMap<String, String>>,
@@ -36,21 +39,53 @@ pub async fn search_people(
}) })
} }
/// GET /api/people/{name} — 从缓存查找人物详情(需要 DB 获取相册列表) /// GET /api/people/{name} — 查找人物详情
/// 人物基本信息从内存缓存获取,相册列表从 imager.db 查询
pub async fn get_person_detail( pub async fn get_person_detail(
db: web::Data<Arc<Database>>, db: web::Data<Arc<Database>>,
search_db: web::Data<Arc<SearchDb>>,
cache: web::Data<Arc<RwLock<PersonCache>>>, cache: web::Data<Arc<RwLock<PersonCache>>>,
path: web::Path<String>, path: web::Path<String>,
) -> impl Responder { ) -> impl Responder {
let name = path.into_inner(); let name = path.into_inner();
let c = cache.read().await; let c = cache.read().await;
// 在缓存中搜索
let found = c.search(&name); let found = c.search(&name);
let p = found.into_iter().find(|p| p.name.to_lowercase() == name.to_lowercase()); let p = found.into_iter().find(|p| p.name.to_lowercase() == name.to_lowercase());
match p { match p {
Some(p) => { Some(p) => {
// 相册列表仍需查 DB // 从 search.db 获取相册 ID 列表
let albums = db.get_person_albums(p.id).await; let album_ids = search_db.get_person_album_ids(&p.id).await;
// 从 imager.db 查询相册详情
let albums = if album_ids.is_empty() {
Vec::new()
} else {
let placeholders: Vec<String> = (0..album_ids.len()).map(|_| "?".to_string()).collect();
let sql = format!(
"SELECT id, title, document, description, cover_image_id, image_count, created_at \
FROM albums WHERE id IN ({}) ORDER BY created_at DESC",
placeholders.join(", ")
);
let mut query = sqlx::query(&sql);
for id in &album_ids {
query = query.bind(id);
}
query.fetch_all(&db.pool).await.unwrap_or_default()
.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: 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()
};
HttpResponse::Ok().json(PersonWithAlbums { HttpResponse::Ok().json(PersonWithAlbums {
album_count: albums.len(), album_count: albums.len(),
person: Person { person: Person {
@@ -70,8 +105,86 @@ pub async fn get_person_detail(
} }
} }
/// GET /api/people/{id}/aliases — 查 DB(别名表记录数可能较大,不适合缓存) /// GET /api/people/{id}/aliases — 从 search.db 查别名
pub async fn get_person_aliases(db: web::Data<Arc<Database>>, path: web::Path<i64>) -> impl Responder { pub async fn get_person_aliases(search_db: web::Data<Arc<SearchDb>>, path: web::Path<String>) -> impl Responder {
let aliases = db.get_person_aliases(path.into_inner()).await; let aliases = search_db.get_person_aliases(&path.into_inner()).await;
HttpResponse::Ok().json(aliases) HttpResponse::Ok().json(aliases)
} }
/// POST /api/people/delete/{name} — 删除 person(从 imager.db + search.db)并重解析受影响的相册
pub async fn delete_person(
db: web::Data<Arc<Database>>,
search_db: web::Data<Arc<SearchDb>>,
albums_cache: web::Data<Arc<RwLock<AlbumsCache>>>,
persons_cache: web::Data<Arc<RwLock<PersonCache>>>,
tags_cache: web::Data<Arc<RwLock<TagCache>>>,
path: web::Path<String>,
) -> impl Responder {
let person_name = path.into_inner().trim().to_string();
if person_name.is_empty() {
return HttpResponse::BadRequest().json(serde_json::json!({
"success": false, "message": "人名不能为空"
}));
}
// 1. 从 search.db 删除并获取受影响 album_ids
let album_ids = match search_db.delete_person_and_get_albums(&person_name).await {
Ok(ids) => ids,
Err(e) => return HttpResponse::InternalServerError().json(serde_json::json!({
"success": false,
"message": format!("从 search.db 删除人物 '{}' 失败: {}", person_name, e),
})),
};
// 2. 从 imager.db 删除(persons + person_aliases + person_albums)
// person.id 来自 imager.db,存储为 i64,模型层转为 String,这里转回 i64
if let Some(person) = db.get_person_by_name(&person_name).await {
if let Ok(pid) = person.id.parse::<i64>() {
db.delete_person_completely(pid).await;
}
}
// 3. 重置受影响相册的 processed_at(触发重新解析)
for aid in &album_ids {
sqlx::query("UPDATE albums SET processed_at = NULL WHERE id = ?")
.bind(aid)
.execute(&db.pool)
.await
.ok();
}
// 4. 重新解析受影响相册,同步到 search.db
if !album_ids.is_empty() {
let mut dirty = engine::pipeline::DirtySet::new();
for aid in &album_ids { dirty.add(aid); }
let (persons_updated, tags_updated) = engine::pipeline::phase_parse_dirty(&db, &search_db, &dirty).await;
// 5. 重载内存词典
engine::tag_dict::reload_from_search_db(&search_db).await;
// 6. 刷新缓存
crate::cache::refresh_all_caches(&db, &search_db, &albums_cache, &persons_cache, &tags_cache).await;
HttpResponse::Ok().json(serde_json::json!({
"success": true,
"person": person_name,
"albums_affected": album_ids.len(),
"persons_updated": persons_updated,
"tags_updated": tags_updated,
"message": format!(
"人物 '{}' 已删除,影响 {} 个相册,重新解析完成(更新人物 {},更新标签 {})",
person_name, album_ids.len(), persons_updated, tags_updated,
)
}))
} else {
// 无受影响相册,只需刷新缓存
crate::cache::refresh_all_caches(&db, &search_db, &albums_cache, &persons_cache, &tags_cache).await;
HttpResponse::Ok().json(serde_json::json!({
"success": true,
"person": person_name,
"albums_affected": 0,
"message": format!("人物 '{}' 已删除,无关联相册", person_name),
}))
}
}

View File

@@ -1,29 +1,144 @@
use crate::db::Database; use crate::db::Database;
use crate::engine::pipeline; use crate::engine;
use crate::search_db::SearchDb;
use actix_web::{HttpResponse, Responder, web}; use actix_web::{HttpResponse, Responder, web};
use std::sync::Arc; use std::sync::Arc;
/// POST /api/pipeline/run — 执行完整管线:清洗→检测→清理→解析→合并→校验 pub async fn pipeline_run(
pub async fn pipeline_run(db: web::Data<Arc<Database>>) -> impl Responder { db: web::Data<Arc<Database>>,
let result = pipeline::run_pipeline(db.get_ref()).await; search_db: web::Data<Arc<SearchDb>>,
) -> impl Responder {
let result = engine::pipeline::run_pipeline(db.get_ref(), search_db.get_ref()).await;
let synced = engine::pipeline::sync_albums_to_search_db(db.get_ref(), search_db.get_ref()).await;
HttpResponse::Ok().json(serde_json::json!({ HttpResponse::Ok().json(serde_json::json!({
"success": true, "success": true,
"tags_cleaned": result.tags_cleaned, "tags_cleaned": result.tags_cleaned,
"short_tags_removed": result.short_tags_removed,
"person_like_tags_removed": result.person_like_tags_removed, "person_like_tags_removed": result.person_like_tags_removed,
"dirty_albums_detected": result.dirty_albums_detected, "dirty_albums_detected": result.dirty_albums_detected,
"non_persons_deleted": result.non_persons_deleted, "non_persons_deleted": result.non_persons_deleted,
"stop_word_persons_removed": result.stop_word_persons_removed,
"new_albums_found": result.new_albums_found, "new_albums_found": result.new_albums_found,
"persons_updated": result.persons_updated, "persons_updated": result.persons_updated,
"tags_updated": result.tags_updated, "tags_updated": result.tags_updated,
"persons_merged": result.persons_merged, "empty_albums_deleted": result.empty_albums_deleted,
"aliases_moved": result.aliases_moved, "dup_albums_deleted": result.dup_albums_deleted,
"tags_removed_person": result.tags_removed_person, "search_db_synced": synced,
"message": format!( "message": format!(
"管线执行完毕:清洗标点{}相册,检测人名标签{},脏集{}相册,删除非人物{},发现新相册{},更新人名{},更新标签{},合并人物{},迁移别名{},后移除人名标签{}", "管线执行完毕:删除空相册{},去重{},清洗标点{}相册,移除短标签{},检测人名标签{},脏集{}相册,删除非人物{},清除停用词重叠人物{},发现新相册{},更新人名{},更新标签{},同步标签/人物到search.db{}",
result.tags_cleaned, result.person_like_tags_removed, result.dirty_albums_detected, result.empty_albums_deleted, result.dup_albums_deleted,
result.non_persons_deleted, result.new_albums_found, result.tags_cleaned, result.short_tags_removed, result.person_like_tags_removed, result.dirty_albums_detected,
result.persons_updated, result.tags_updated, result.non_persons_deleted, result.stop_word_persons_removed, result.new_albums_found,
result.persons_merged, result.aliases_moved, result.tags_removed_person result.persons_updated, result.tags_updated, synced
)
}))
}
/// POST /api/pipeline/reparse — 重置所有相册为未处理状态,重新解析全部标签和人物并同步到 search.db
pub async fn pipeline_reparse(
db: web::Data<Arc<Database>>,
search_db: web::Data<Arc<SearchDb>>,
) -> impl Responder {
// 1. 清除 search.db 中的旧关联(不影响 tags/persons 字典)
sqlx::query("DELETE FROM album_tags").execute(&search_db.pool).await.ok();
sqlx::query("DELETE FROM album_persons").execute(&search_db.pool).await.ok();
// 2. 重置所有相册为未处理
let reset_count = db.reset_all_processed_at().await;
tracing::info!("[reparse] 重置 {} 个相册的 processed_at", reset_count);
// 3. 重新运行完整管线+同步
let result = engine::pipeline::run_pipeline(db.get_ref(), search_db.get_ref()).await;
let synced = engine::pipeline::sync_albums_to_search_db(db.get_ref(), search_db.get_ref()).await;
HttpResponse::Ok().json(serde_json::json!({
"success": true,
"albums_parsed": result.new_albums_found,
"persons_updated": result.persons_updated,
"tags_updated": result.tags_updated,
"synced_to_search_db": synced,
"message": format!(
"重新解析完成:重置{}个相册,解析{}个,更新人物{}个,标签{}个,同步{}个到search.db",
reset_count, result.new_albums_found,
result.persons_updated, result.tags_updated, synced,
)
}))
}
/// POST /api/pipeline/reparse-persons — 重置所有相册,重新解析全部人物
///
/// 流程:
/// 清空 search.db 的 album_persons → 重置所有相册 processed_at →
/// 运行完整管线(人物相关逻辑全部执行)→ 全量同步到 search.db
pub async fn pipeline_reparse_persons(
db: web::Data<Arc<Database>>,
search_db: web::Data<Arc<SearchDb>>,
) -> impl Responder {
// 1. 清空 search.db 中的人物相关表(album_persons + persons + person_aliases)
sqlx::query("DELETE FROM album_persons").execute(&search_db.pool).await.ok();
sqlx::query("DELETE FROM person_aliases").execute(&search_db.pool).await.ok();
sqlx::query("DELETE FROM persons").execute(&search_db.pool).await.ok();
// 2. 重置所有相册为未处理(触发管线重新解析)
let reset_count = db.reset_all_processed_at().await;
tracing::info!("[reparse-persons] 重置 {} 个相册的 processed_at", reset_count);
// 3. 重新运行完整管线(Phase ② 人物清理 + Phase ③ 解析 + Phase ④ 人物合并 + Phase C 重计)
let result = engine::pipeline::run_pipeline(db.get_ref(), search_db.get_ref()).await;
// 4. 全量同步到 search.db(tags 和 persons 都会同步,但 album_persons 已清空确保了干净状态)
let synced = engine::pipeline::sync_albums_to_search_db(db.get_ref(), search_db.get_ref()).await;
HttpResponse::Ok().json(serde_json::json!({
"success": true,
"albums_parsed": result.new_albums_found,
"persons_updated": result.persons_updated,
"non_persons_deleted": result.non_persons_deleted,
"stop_word_persons_removed": result.stop_word_persons_removed,
"synced_to_search_db": synced,
"message": format!(
"人物重新解析完成:重置{}个相册,解析{}个,更新人物{}个,删除非人物{},清除重叠{},同步{}个到search.db",
reset_count, result.new_albums_found,
result.persons_updated,
result.non_persons_deleted, result.stop_word_persons_removed, synced,
)
}))
}
/// POST /api/pipeline/reparse-tags — 重置所有相册,重新解析全部标签
///
/// 流程:
/// 清空 search.db 的 album_tags → 重置所有相册 processed_at →
/// 运行完整管线(标签相关逻辑全部执行)→ 全量同步到 search.db
pub async fn pipeline_reparse_tags(
db: web::Data<Arc<Database>>,
search_db: web::Data<Arc<SearchDb>>,
) -> impl Responder {
// 1. 清空 search.db 中的标签相关表(album_tags + tags)
sqlx::query("DELETE FROM album_tags").execute(&search_db.pool).await.ok();
sqlx::query("DELETE FROM tags").execute(&search_db.pool).await.ok();
// 2. 重置所有相册为未处理(触发管线重新解析)
let reset_count = db.reset_all_processed_at().await;
tracing::info!("[reparse-tags] 重置 {} 个相册的 processed_at", reset_count);
// 3. 重新运行完整管线(Phase ③ 解析会重新提取全部标签)
let result = engine::pipeline::run_pipeline(db.get_ref(), search_db.get_ref()).await;
// 4. 全量同步到 search.db
let synced = engine::pipeline::sync_albums_to_search_db(db.get_ref(), search_db.get_ref()).await;
HttpResponse::Ok().json(serde_json::json!({
"success": true,
"albums_parsed": result.new_albums_found,
"tags_updated": result.tags_updated,
"short_tags_removed": result.short_tags_removed,
"synced_to_search_db": synced,
"message": format!(
"标签重新解析完成:重置{}个相册,解析{}个,更新标签{}个,移除短标签{},同步{}个到search.db",
reset_count, result.new_albums_found,
result.tags_updated, result.short_tags_removed, synced,
) )
})) }))
} }

View File

@@ -1,36 +1,54 @@
use crate::db::Database; use crate::cache::{TagCache, PersonCache};
use crate::search_db::SearchDb;
use crate::engine::RecommendEngine; use crate::engine::RecommendEngine;
#[allow(unused)] use crate::models::*; use crate::models::*;
use actix_web::{HttpResponse, Responder, web}; use actix_web::{HttpResponse, Responder, web};
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::Arc; use std::sync::Arc;
use tokio::sync::RwLock;
/// 标签推荐(自动补全) /// 标签推荐(自动补全)— 从 TagCache 匹配
pub async fn recommend_tags(db: web::Data<Arc<Database>>, query: web::Query<HashMap<String, String>>) -> impl Responder { pub async fn recommend_tags(
cache: web::Data<Arc<RwLock<TagCache>>>,
query: web::Query<HashMap<String, String>>,
) -> impl Responder {
let q = query.get("q").map(|s| s.as_str()).unwrap_or(""); let q = query.get("q").map(|s| s.as_str()).unwrap_or("");
let limit: usize = query.get("limit").and_then(|s| s.parse().ok()).unwrap_or(10); let limit: usize = query.get("limit").and_then(|s| s.parse().ok()).unwrap_or(10);
HttpResponse::Ok().json(RecommendEngine::recommend_tags(&db, q, limit).await) let c = cache.read().await;
HttpResponse::Ok().json(RecommendEngine::recommend_tags(&c.popular_tags, q, limit))
} }
/// 人物推荐(自动补全) /// 人物推荐(自动补全)— 从 PersonCache 匹配
pub async fn recommend_persons(db: web::Data<Arc<Database>>, query: web::Query<HashMap<String, String>>) -> impl Responder { pub async fn recommend_persons(
cache: web::Data<Arc<RwLock<PersonCache>>>,
query: web::Query<HashMap<String, String>>,
) -> impl Responder {
let q = query.get("q").map(|s| s.as_str()).unwrap_or(""); let q = query.get("q").map(|s| s.as_str()).unwrap_or("");
let limit: usize = query.get("limit").and_then(|s| s.parse().ok()).unwrap_or(10); let limit: usize = query.get("limit").and_then(|s| s.parse().ok()).unwrap_or(10);
HttpResponse::Ok().json(RecommendEngine::recommend_persons(&db, q, limit).await) let c = cache.read().await;
HttpResponse::Ok().json(RecommendEngine::recommend_persons(&c.persons, q, limit))
} }
/// 关联推荐(标签共现 + 共现人物) /// 关联推荐(标签共现 + 共现人物)
pub async fn recommend_related(db: web::Data<Arc<Database>>, query: web::Query<HashMap<String, String>>) -> impl Responder { pub async fn recommend_related(
search_db: web::Data<Arc<SearchDb>>,
query: web::Query<HashMap<String, String>>,
) -> impl Responder {
let context = match query.get("context") { let context = match query.get("context") {
Some(c) if !c.is_empty() => c, Some(c) if !c.is_empty() => c,
_ => return HttpResponse::BadRequest().json(serde_json::json!({"error": "请提供context参数"})), _ => return HttpResponse::BadRequest().json(serde_json::json!({"error": "请提供context参数"})),
}; };
let limit: usize = query.get("limit").and_then(|s| s.parse().ok()).unwrap_or(15); let limit: usize = query.get("limit").and_then(|s| s.parse().ok()).unwrap_or(15);
HttpResponse::Ok().json(RecommendEngine::recommend_related(&db, context, limit).await) HttpResponse::Ok().json(RecommendEngine::recommend_related(&search_db, context, limit).await)
} }
/// 热门人物 /// 热门人物 — 从 PersonCache 过滤,top_tags 保留 search.db 查询
pub async fn popular_persons(db: web::Data<Arc<Database>>, query: web::Query<HashMap<String, String>>) -> impl Responder { pub async fn popular_persons(
search_db: web::Data<Arc<SearchDb>>,
cache: web::Data<Arc<RwLock<PersonCache>>>,
query: web::Query<HashMap<String, String>>,
) -> impl Responder {
let limit: usize = query.get("limit").and_then(|s| s.parse().ok()).unwrap_or(20).min(50); let limit: usize = query.get("limit").and_then(|s| s.parse().ok()).unwrap_or(20).min(50);
HttpResponse::Ok().json(RecommendEngine::popular_persons(&db, limit).await) let c = cache.read().await;
HttpResponse::Ok().json(RecommendEngine::popular_persons(&search_db, &c.persons, limit).await)
} }

View File

@@ -1,14 +1,30 @@
use crate::cache::TagCache; use crate::cache::{TagCache, AlbumsCache, PersonCache};
use crate::db::Database; use crate::engine;
use crate::models::*; use crate::models::*;
use crate::search_db::SearchDb;
use actix_web::{HttpResponse, Responder, web}; use actix_web::{HttpResponse, Responder, web};
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::Arc; use std::sync::Arc;
use tokio::sync::RwLock; use tokio::sync::RwLock;
/// GET /api/metadata/stats — 仍查 DB(需要实时统计数据) /// GET /api/metadata/stats — 从内存缓存计算统计数据
pub async fn get_metadata_stats(db: web::Data<Arc<Database>>) -> impl Responder { pub async fn get_metadata_stats(
HttpResponse::Ok().json(db.get_metadata_stats().await) albums_cache: web::Data<Arc<RwLock<AlbumsCache>>>,
persons_cache: web::Data<Arc<RwLock<PersonCache>>>,
tags_cache: web::Data<Arc<RwLock<TagCache>>>,
) -> impl Responder {
let ac = albums_cache.read().await;
let pc = persons_cache.read().await;
let tc = tags_cache.read().await;
let stats = MetadataStats {
total_persons: pc.persons.len() as i64,
total_aliases: pc.persons.iter().map(|p| p.aliases.len() as i64).sum(),
total_albums: ac.albums.len() as i64,
total_images: ac.albums.iter().map(|a| a.image_count).sum(),
total_tags: tc.tag_albums.len() as i64,
};
HttpResponse::Ok().json(stats)
} }
/// GET /api/tags/search?tag=xxx — 从缓存按标签搜索相册 /// GET /api/tags/search?tag=xxx — 从缓存按标签搜索相册
@@ -35,3 +51,61 @@ pub async fn get_popular_tags(
let tags: Vec<TagStat> = c.popular_tags.iter().take(limit).cloned().collect(); let tags: Vec<TagStat> = c.popular_tags.iter().take(limit).cloned().collect();
HttpResponse::Ok().json(TagListResponse { total: tags.len(), tags }) HttpResponse::Ok().json(TagListResponse { total: tags.len(), tags })
} }
/// POST /api/tags/delete/{name} — 删除 tag(从 dict/album_tags/tags)并重解析受影响的相册
pub async fn delete_tag(
db: web::Data<Arc<crate::db::Database>>,
search_db: web::Data<Arc<SearchDb>>,
albums_cache: web::Data<Arc<RwLock<AlbumsCache>>>,
persons_cache: web::Data<Arc<RwLock<PersonCache>>>,
tags_cache: web::Data<Arc<RwLock<TagCache>>>,
path: web::Path<String>,
) -> impl Responder {
let tag_name = path.into_inner().trim().to_string();
if tag_name.is_empty() {
return HttpResponse::BadRequest().json(serde_json::json!({
"success": false, "message": "标签名不能为空"
}));
}
// 1. 删除 tag(dict/album_tags/tags),获取受影响 album_ids
let album_ids = match search_db.delete_tag_and_get_albums(&tag_name).await {
Ok(ids) => ids,
Err(e) => return HttpResponse::InternalServerError().json(serde_json::json!({
"success": false,
"message": format!("删除标签 '{}' 失败: {}", tag_name, e),
})),
};
// 2. 重置受影响相册的 processed_at,触发重新解析
for aid in &album_ids {
sqlx::query("UPDATE albums SET processed_at = NULL WHERE id = ?")
.bind(aid)
.execute(&db.pool)
.await
.ok();
}
// 3. 重新解析受影响相册(同时写入 imager.db + search.db)
let mut dirty = engine::pipeline::DirtySet::new();
for aid in &album_ids { dirty.add(aid); }
let (persons_updated, tags_updated) = engine::pipeline::phase_parse_dirty(&db, &search_db, &dirty).await;
// 4. 重载内存词典(dict 表已更新)
engine::tag_dict::reload_from_search_db(&search_db).await;
// 5. 刷新内存缓存
crate::cache::refresh_all_caches(&db, &search_db, &albums_cache, &persons_cache, &tags_cache).await;
HttpResponse::Ok().json(serde_json::json!({
"success": true,
"tag": tag_name,
"albums_affected": album_ids.len(),
"persons_updated": persons_updated,
"tags_updated": tags_updated,
"message": format!(
"标签 '{}' 已删除,影响 {} 个相册,重新解析完成(更新人物 {},更新标签 {})",
tag_name, album_ids.len(), persons_updated, tags_updated,
)
}))
}

557
src/search_db/mod.rs Normal file
View File

@@ -0,0 +1,557 @@
mod search;
pub use search::*;
use sqlx::{SqlitePool, sqlite::SqlitePoolOptions, Row};
use uuid::Uuid;
/// 从 name 计算确定性 tag UUID(无需查数据库即可得到 id)
pub fn tag_uuid(name: &str) -> String {
Uuid::new_v5(
&Uuid::NAMESPACE_URL,
format!("https://imager.dev/tag/{}", name).as_bytes(),
)
.to_string()
}
/// 从 name 计算确定性 person UUID(无需查数据库即可得到 id)
pub fn person_uuid(name: &str) -> String {
Uuid::new_v5(
&Uuid::NAMESPACE_URL,
format!("https://imager.dev/person/{}", name).as_bytes(),
)
.to_string()
}
#[derive(Debug, Clone)]
pub struct DictEntry {
pub word: String,
pub type_: String,
pub category: Option<String>,
pub freq: Option<i64>,
pub merged_to: Option<String>,
}
pub struct SearchDb {
pub pool: SqlitePool,
}
impl SearchDb {
pub async fn new(db_path: &str) -> Result<Self, sqlx::Error> {
// 确保父目录存在
let path = std::path::Path::new(db_path);
if let Some(parent) = path.parent() {
if !parent.exists() {
std::fs::create_dir_all(parent)?;
}
}
// 转换为绝对路径并创建文件(如果不存在)
let abs_path = std::fs::canonicalize(db_path)
.unwrap_or_else(|_| {
// canonicalize 要求文件存在,所以先创建再转换
std::fs::File::create(db_path).ok();
std::fs::canonicalize(db_path).unwrap_or_else(|_| path.to_path_buf())
});
// 使用 sqlite:/// 前缀 + 绝对路径,避免相对路径解析错误
let url = format!("sqlite:///{}", abs_path.to_string_lossy().replace('\\', "/"));
let pool = SqlitePoolOptions::new()
.max_connections(2)
.connect(&url)
.await?;
sqlx::query("PRAGMA journal_mode=WAL;").execute(&pool).await?;
sqlx::query("PRAGMA synchronous=NORMAL;").execute(&pool).await?;
sqlx::query("PRAGMA busy_timeout=5000;").execute(&pool).await?;
sqlx::query("PRAGMA wal_autocheckpoint=1000;").execute(&pool).await?;
sqlx::query("PRAGMA journal_size_limit=67108864;").execute(&pool).await?;
sqlx::query("PRAGMA cache_size=-256000;").execute(&pool).await?;
sqlx::query("PRAGMA temp_store=MEMORY;").execute(&pool).await?;
sqlx::query("PRAGMA mmap_size=268435456;").execute(&pool).await?;
Self::create_tables(&pool).await?;
Ok(Self { pool })
}
/// 在批量写入前临时调低 synchronous 级别提升性能
pub async fn set_sync_off(&self) {
let _ = sqlx::query("PRAGMA synchronous=OFF;").execute(&self.pool).await;
}
/// 批量写入后恢复 synchronous 级别
pub async fn set_sync_normal(&self) {
let _ = sqlx::query("PRAGMA synchronous=NORMAL;").execute(&self.pool).await;
}
/// 执行 WAL checkpoint(TRUNCATE),将 WAL 完全合并回主文件并清理 -wal / -shm 文件
///
/// 在启动时调用,确保 search.db 文件干净,避免下次启动时 WAL 恢复开销。
pub async fn wal_checkpoint(&self) {
match sqlx::query("PRAGMA wal_checkpoint(TRUNCATE)")
.execute(&self.pool).await
{
Ok(_) => println!("[search.db] WAL checkpoint(TRUNCATE) 完成,数据库文件已合并"),
Err(e) => eprintln!("[search.db] WAL checkpoint 失败: {}", e),
}
}
async fn create_tables(pool: &SqlitePool) -> Result<(), sqlx::Error> {
// ── 迁移检测:如果 tags 表存在且 id 类型是 INTEGER(旧版),重建表 ──
let has_old_schema: bool = sqlx::query(
"SELECT type FROM pragma_table_info('tags') WHERE name = 'id'"
).fetch_optional(pool).await.ok()
.flatten()
.map(|r| {
let t: String = r.get("type");
// 旧版用 INTEGER,新版用 TEXT
t.contains("INTEGER")
})
.unwrap_or(false);
if has_old_schema {
println!("[search.db] 检测到旧版 INTEGER ID 模式,重建表为 TEXT UUID 模式...");
sqlx::query("DROP TABLE IF EXISTS album_tags").execute(pool).await?;
sqlx::query("DROP TABLE IF EXISTS album_persons").execute(pool).await?;
sqlx::query("DROP TABLE IF EXISTS person_aliases").execute(pool).await?;
sqlx::query("DROP TABLE IF EXISTS tags").execute(pool).await?;
sqlx::query("DROP TABLE IF EXISTS persons").execute(pool).await?;
println!("[search.db] 旧表已删除,即将重建");
}
// ── 标签表(TEXT UUID 主键) ──
sqlx::query(r#"
CREATE TABLE IF NOT EXISTS tags (
id TEXT PRIMARY KEY,
name TEXT NOT NULL UNIQUE,
category TEXT,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
)
"#).execute(pool).await?;
// ── 人物表(TEXT UUID 主键) ──
sqlx::query(r#"
CREATE TABLE IF NOT EXISTS persons (
id TEXT PRIMARY KEY,
name TEXT NOT NULL UNIQUE,
display_name TEXT,
total_albums INTEGER DEFAULT 0,
total_images INTEGER DEFAULT 0,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
)
"#).execute(pool).await?;
// ── 人物别名 ──
sqlx::query(r#"
CREATE TABLE IF NOT EXISTS person_aliases (
id INTEGER PRIMARY KEY AUTOINCREMENT,
person_id TEXT NOT NULL,
alias_type TEXT NOT NULL,
alias_name TEXT NOT NULL,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (person_id) REFERENCES persons(id) ON DELETE CASCADE
)
"#).execute(pool).await?;
// ── 相册-标签关联 ──
sqlx::query(r#"
CREATE TABLE IF NOT EXISTS album_tags (
album_id TEXT NOT NULL,
tag_id TEXT NOT NULL,
PRIMARY KEY (album_id, tag_id),
FOREIGN KEY (tag_id) REFERENCES tags(id) ON DELETE CASCADE
)
"#).execute(pool).await?;
// ── 相册-人物关联 ──
sqlx::query(r#"
CREATE TABLE IF NOT EXISTS album_persons (
album_id TEXT NOT NULL,
person_id TEXT NOT NULL,
PRIMARY KEY (album_id, person_id),
FOREIGN KEY (person_id) REFERENCES persons(id) ON DELETE CASCADE
)
"#).execute(pool).await?;
// ── albums 表:搜索返回需要的相册基础信息 ──
sqlx::query(r#"
CREATE TABLE IF NOT EXISTS albums (
id TEXT PRIMARY KEY,
title TEXT NOT NULL DEFAULT '',
cover_image_id TEXT,
image_count INTEGER DEFAULT 0,
created_at TEXT
)
"#).execute(pool).await?;
// ── dict 表 ──
sqlx::query(r#"
CREATE TABLE IF NOT EXISTS dict (
word TEXT NOT NULL PRIMARY KEY,
type TEXT NOT NULL,
category TEXT,
freq INTEGER,
merged_to TEXT,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
)
"#).execute(pool).await?;
// ── 索引 ──
sqlx::query("CREATE INDEX IF NOT EXISTS idx_albums_title ON albums(title)").execute(pool).await?;
sqlx::query("CREATE INDEX IF NOT EXISTS idx_tags_name ON tags(name)").execute(pool).await?;
sqlx::query("CREATE INDEX IF NOT EXISTS idx_persons_name ON persons(name)").execute(pool).await?;
sqlx::query("CREATE INDEX IF NOT EXISTS idx_album_tags_album ON album_tags(album_id)").execute(pool).await?;
sqlx::query("CREATE INDEX IF NOT EXISTS idx_album_tags_tag ON album_tags(tag_id)").execute(pool).await?;
sqlx::query("CREATE INDEX IF NOT EXISTS idx_album_persons_album ON album_persons(album_id)").execute(pool).await?;
sqlx::query("CREATE INDEX IF NOT EXISTS idx_album_persons_person ON album_persons(person_id)").execute(pool).await?;
sqlx::query("CREATE INDEX IF NOT EXISTS idx_person_aliases_name ON person_aliases(alias_name)").execute(pool).await?;
// 兼容旧表:尝试添加 merged_to 列(已有则忽略)
let _ = sqlx::query("ALTER TABLE dict ADD COLUMN merged_to TEXT").execute(pool).await;
Ok(())
}
// ── upsert 写入方法 ──
pub async fn upsert_album(&self, album_id: &str, title: &str,
cover_image_id: Option<&str>, image_count: i64,
created_at: Option<&str>) -> Result<(), sqlx::Error> {
sqlx::query(r#"
INSERT INTO albums (id, title, cover_image_id, image_count, created_at)
VALUES (?, ?, ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET
title = excluded.title,
cover_image_id = excluded.cover_image_id,
image_count = excluded.image_count,
created_at = excluded.created_at
"#)
.bind(album_id).bind(title).bind(cover_image_id)
.bind(image_count).bind(created_at)
.execute(&self.pool).await?;
Ok(())
}
pub async fn delete_album(&self, album_id: &str) -> Result<(), sqlx::Error> {
let mut tx = self.pool.begin().await?;
sqlx::query("DELETE FROM album_tags WHERE album_id = ?").bind(album_id).execute(&mut *tx).await?;
sqlx::query("DELETE FROM album_persons WHERE album_id = ?").bind(album_id).execute(&mut *tx).await?;
sqlx::query("DELETE FROM albums WHERE id = ?").bind(album_id).execute(&mut *tx).await?;
tx.commit().await?;
Ok(())
}
/// 插入标签(使用确定性 UUID,无需 SELECT 回查)
pub async fn insert_tag(&self, name: &str, category: Option<&str>) -> Result<String, sqlx::Error> {
let id = tag_uuid(name);
sqlx::query(r#"INSERT OR IGNORE INTO tags (id, name, category) VALUES (?, ?, ?)"#)
.bind(&id).bind(name).bind(category)
.execute(&self.pool).await?;
Ok(id)
}
/// 插入人物(使用确定性 UUID,无需 SELECT 回查)
pub async fn insert_person(&self, name: &str, display_name: Option<&str>) -> Result<String, sqlx::Error> {
let id = person_uuid(name);
sqlx::query(r#"INSERT OR IGNORE INTO persons (id, name, display_name) VALUES (?, ?, ?)"#)
.bind(&id).bind(name).bind(display_name)
.execute(&self.pool).await?;
Ok(id)
}
pub async fn update_person_counts(&self, person_id: &str, total_albums: i64, total_images: i64) -> Result<(), sqlx::Error> {
sqlx::query("UPDATE persons SET total_albums = ?, total_images = ?, updated_at = datetime('now') WHERE id = ?")
.bind(total_albums).bind(total_images).bind(person_id)
.execute(&self.pool).await?;
Ok(())
}
pub async fn insert_person_alias(&self, person_id: &str, alias_type: &str, alias_name: &str) -> Result<(), sqlx::Error> {
sqlx::query(r#"
INSERT OR IGNORE INTO person_aliases (person_id, alias_type, alias_name) VALUES (?, ?, ?)
"#)
.bind(person_id)
.bind(alias_type)
.bind(alias_name)
.execute(&self.pool)
.await?;
Ok(())
}
pub async fn insert_album_tag(&self, album_id: &str, tag_id: &str) -> Result<(), sqlx::Error> {
sqlx::query(r#"
INSERT OR IGNORE INTO album_tags (album_id, tag_id) VALUES (?, ?)
"#)
.bind(album_id)
.bind(tag_id)
.execute(&self.pool)
.await?;
Ok(())
}
pub async fn insert_album_person(&self, album_id: &str, person_id: &str) -> Result<(), sqlx::Error> {
sqlx::query(r#"
INSERT OR IGNORE INTO album_persons (album_id, person_id) VALUES (?, ?)
"#)
.bind(album_id)
.bind(person_id)
.execute(&self.pool)
.await?;
Ok(())
}
/// 清空某相册的所有关联标签
pub async fn clear_album_tags(&self, album_id: &str) -> Result<(), sqlx::Error> {
sqlx::query("DELETE FROM album_tags WHERE album_id = ?")
.bind(album_id).execute(&self.pool).await?;
Ok(())
}
/// 清空某相册的所有关联人物
pub async fn clear_album_persons(&self, album_id: &str) -> Result<(), sqlx::Error> {
sqlx::query("DELETE FROM album_persons WHERE album_id = ?")
.bind(album_id).execute(&self.pool).await?;
Ok(())
}
pub async fn load_dict(&self) -> Result<Vec<DictEntry>, sqlx::Error> {
let rows = sqlx::query("SELECT word, type, category, freq, merged_to FROM dict")
.fetch_all(&self.pool)
.await?;
let entries = rows.iter().map(|r| DictEntry {
word: r.get("word"),
type_: r.get("type"),
category: r.get("category"),
freq: r.get("freq"),
merged_to: r.get("merged_to"),
}).collect();
Ok(entries)
}
/// 加载 dict 表全部条目(不限类型),用于初始化 TagDict
pub async fn load_dict_all(&self) -> Result<Vec<DictEntry>, sqlx::Error> {
self.load_dict().await
}
/// 插入或更新一条 dict 条目(word 为 PK,相同 word 会覆盖)
pub async fn upsert_dict_entry(&self, word: &str, type_: &str, category: Option<&str>, freq: Option<i64>, merged_to: Option<&str>) -> Result<(), sqlx::Error> {
let rows = sqlx::query(
r#"SELECT COUNT(*) as cnt FROM dict WHERE word = ?"#
).bind(word).fetch_one(&self.pool).await?;
let exists: i64 = rows.get("cnt");
if exists > 0 {
sqlx::query(
"UPDATE dict SET type = ?, category = ?, freq = ?, merged_to = ? WHERE word = ?"
).bind(type_).bind(category).bind(freq).bind(merged_to).bind(word)
.execute(&self.pool).await?;
} else {
sqlx::query(
"INSERT INTO dict (word, type, category, freq, merged_to) VALUES (?, ?, ?, ?, ?)"
).bind(word).bind(type_).bind(category).bind(freq).bind(merged_to)
.execute(&self.pool).await?;
}
Ok(())
}
/// 删除 tag:从 dict/album_tags/tags 表中删除,返回受影响的 album_id 列表
pub async fn delete_tag_and_get_albums(&self, tag_name: &str) -> Result<Vec<String>, sqlx::Error> {
// 1. 计算确定性 tag UUID
let tag_id = tag_uuid(tag_name);
// 2. 查找关联 album_ids
let album_ids: Vec<String> = sqlx::query_scalar::<_, String>(
"SELECT DISTINCT album_id FROM album_tags WHERE tag_id = ?"
).bind(&tag_id).fetch_all(&self.pool).await.unwrap_or_default();
// 3. 删除 album_tags 关联
sqlx::query("DELETE FROM album_tags WHERE tag_id = ?")
.bind(&tag_id).execute(&self.pool).await?;
// 4. 删除 tags 表条目
sqlx::query("DELETE FROM tags WHERE id = ?").bind(&tag_id).execute(&self.pool).await?;
// 5. 删除 dict 表条目
sqlx::query("DELETE FROM dict WHERE word = ? AND type = 'tag'").bind(tag_name).execute(&self.pool).await?;
Ok(album_ids)
}
/// 删除 person:从 search.db 的 album_persons/persons/person_aliases 中删除,返回受影响的 album_id 列表
pub async fn delete_person_and_get_albums(&self, person_name: &str) -> Result<Vec<String>, sqlx::Error> {
// 1. 计算确定性 person UUID
let person_id = person_uuid(person_name);
// 2. 查找关联 album_ids
let album_ids: Vec<String> = sqlx::query_scalar::<_, String>(
"SELECT DISTINCT album_id FROM album_persons WHERE person_id = ?"
).bind(&person_id).fetch_all(&self.pool).await.unwrap_or_default();
// 3. 删除关联表
sqlx::query("DELETE FROM album_persons WHERE person_id = ?")
.bind(&person_id).execute(&self.pool).await?;
sqlx::query("DELETE FROM person_aliases WHERE person_id = ?")
.bind(&person_id).execute(&self.pool).await?;
sqlx::query("DELETE FROM persons WHERE id = ?")
.bind(&person_id).execute(&self.pool).await?;
// 4. 删除 dict 表中的对应条目(如果存在)
sqlx::query("DELETE FROM dict WHERE word = ? AND type = 'person'")
.bind(person_name).execute(&self.pool).await?;
Ok(album_ids)
}
/// 批量同步解析结果到 search.db(单事务 + 预计算 UUID + 批量操作)
///
/// 核心优化:
/// 1. 预加载全部 tags/persons 到 HashMap(仅 2 次 SELECT)
/// 2. 预计算所有 tag/person 的 UUID(零数据库查询得到 ID)
/// 3. 全量 `DELETE WHERE album_id IN (...)` 代替逐条 DELETE
/// 4. 逐条 INSERT 但无需 SELECT 查 ID(UUID 直接写入)
/// 5. 每事务一次 person counts 刷新
pub async fn batch_sync_parse_results(&self, results: &[crate::models::parse::ParseResult]) -> Result<usize, sqlx::Error> {
use std::collections::HashMap;
let mut tx = self.pool.begin().await?;
// 1. 预加载现有 tags/persons(仅 2 次 SELECT)
let existing_tags: HashMap<String, String> = sqlx::query_as::<_, (String, String)>(
"SELECT name, id FROM tags"
).fetch_all(&mut *tx).await?.into_iter().collect();
let existing_persons: HashMap<String, String> = sqlx::query_as::<_, (String, String)>(
"SELECT name, id FROM persons"
).fetch_all(&mut *tx).await?.into_iter().collect();
// 2. 收集所有相册 ID,用于批量 DELETE
let album_ids: Vec<&str> = results.iter().map(|r| r.album_id.as_str()).collect();
if !album_ids.is_empty() {
let ph: Vec<String> = album_ids.iter().map(|_| "?".to_string()).collect();
let sql = format!("DELETE FROM album_tags WHERE album_id IN ({})", ph.join(","));
let mut q = sqlx::query(&sql);
for id in &album_ids { q = q.bind(id); }
q.execute(&mut *tx).await?;
let ph2: Vec<String> = album_ids.iter().map(|_| "?".to_string()).collect();
let sql2 = format!("DELETE FROM album_persons WHERE album_id IN ({})", ph2.join(","));
let mut q2 = sqlx::query(&sql2);
for id in &album_ids { q2 = q2.bind(id); }
q2.execute(&mut *tx).await?;
}
// 3. 收集去重后的 tag 和 person 名称
let mut unique_tags: Vec<(String, Option<String>)> = Vec::new();
let mut seen_tags = std::collections::HashSet::new();
let mut unique_persons: Vec<String> = Vec::new();
let mut seen_persons = std::collections::HashSet::new();
for result in results {
for (tag_name, category) in &result.tags {
if seen_tags.insert(tag_name.clone()) {
unique_tags.push((tag_name.clone(), Some(category.clone())));
}
}
for person_name in &result.person_names {
if seen_persons.insert(person_name.clone()) {
unique_persons.push(person_name.clone());
}
}
}
// 4a. 写入标签:对不存在的标签 INSERT(使用预计算 UUID)
for (tag_name, category) in &unique_tags {
if !existing_tags.contains_key(tag_name) {
let id = tag_uuid(tag_name);
sqlx::query("INSERT OR IGNORE INTO tags (id, name, category) VALUES (?, ?, ?)")
.bind(&id).bind(tag_name).bind(category)
.execute(&mut *tx).await?;
}
}
// 4b. 写入人物:对不存在的人物 INSERT(使用预计算 UUID)
for person_name in &unique_persons {
if !existing_persons.contains_key(person_name) {
let id = person_uuid(person_name);
sqlx::query("INSERT OR IGNORE INTO persons (id, name) VALUES (?, ?)")
.bind(&id).bind(person_name)
.execute(&mut *tx).await?;
}
}
// 5. 写入批量关联数据(无 SELECT 查找,直接使用预计算的 UUID)
let mut tag_id_cache: HashMap<String, String> = existing_tags.clone();
let mut person_id_cache: HashMap<String, String> = existing_persons.clone();
for result in results {
let album_id = &result.album_id;
// ── album_tags ──
for (tag_name, _category) in &result.tags {
let tid = tag_id_cache.get(tag_name.as_str())
.cloned()
.unwrap_or_else(|| tag_uuid(tag_name));
// 缓存新写入的 tag(即使上一个缓存中已更新,这里确保缓存完整)
tag_id_cache.entry(tag_name.clone()).or_insert_with(|| tid.clone());
sqlx::query("INSERT OR IGNORE INTO album_tags (album_id, tag_id) VALUES (?, ?)")
.bind(album_id).bind(&tid).execute(&mut *tx).await?;
}
// ── album_persons ──
for person_name in &result.person_names {
let pid = person_id_cache.get(person_name.as_str())
.cloned()
.unwrap_or_else(|| person_uuid(person_name));
person_id_cache.entry(person_name.clone()).or_insert_with(|| pid.clone());
sqlx::query("INSERT OR IGNORE INTO album_persons (album_id, person_id) VALUES (?, ?)")
.bind(album_id).bind(&pid).execute(&mut *tx).await?;
// 别名写入
let (primary, aliases) = crate::engine::title_parser::split_person_name_with_aliases(person_name);
if !aliases.is_empty() {
for (alias_type, alias_name) in &aliases {
if alias_name != person_name {
sqlx::query("INSERT OR IGNORE INTO person_aliases (person_id, alias_type, alias_name) VALUES (?, ?, ?)")
.bind(&pid).bind(alias_type).bind(alias_name).execute(&mut *tx).await?;
}
}
if primary != person_name.as_str() && !primary.is_empty() {
sqlx::query("INSERT OR IGNORE INTO person_aliases (person_id, alias_type, alias_name) VALUES (?, ?, ?)")
.bind(&pid).bind("primary").bind(&primary).execute(&mut *tx).await?;
}
}
}
}
// 6. 更新 person counts(一次批量)
for (_name, pid) in &person_id_cache {
let count: i64 = sqlx::query_scalar(
"SELECT COUNT(*) FROM album_persons WHERE person_id = ?"
).bind(pid).fetch_one(&mut *tx).await.unwrap_or(0);
sqlx::query("UPDATE persons SET total_albums = ?, total_images = 0 WHERE id = ?")
.bind(count).bind(pid).execute(&mut *tx).await?;
}
tx.commit().await?;
let total = results.len();
println!("[batch_sync] 单事务同步完成:{} 个相册,{} 个标签(key),{} 个人物(key)",
total, tag_id_cache.len(), person_id_cache.len());
Ok(total)
}
pub async fn clear_all(&self) -> Result<(), sqlx::Error> {
let mut tx = self.pool.begin().await?;
sqlx::query("DELETE FROM album_tags").execute(&mut *tx).await?;
sqlx::query("DELETE FROM album_persons").execute(&mut *tx).await?;
sqlx::query("DELETE FROM person_aliases").execute(&mut *tx).await?;
sqlx::query("DELETE FROM tags").execute(&mut *tx).await?;
sqlx::query("DELETE FROM persons").execute(&mut *tx).await?;
sqlx::query("DELETE FROM albums").execute(&mut *tx).await?;
sqlx::query("DELETE FROM dict").execute(&mut *tx).await?;
tx.commit().await?;
Ok(())
}
}

350
src/search_db/search.rs Normal file
View File

@@ -0,0 +1,350 @@
//! 搜索读取方法 — 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"),
tags: vec![],
persons: vec![],
}
}).collect())
}
/// 获取全量相册列表(缓存烘焙用,含 tags 和 persons)
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?;
// 批量获取所有 album-tag 关系
let tag_rows = sqlx::query(
r#"SELECT at.album_id, t.name FROM album_tags at JOIN tags t ON at.tag_id = t.id"#
).fetch_all(&self.pool).await?;
let mut album_tags: std::collections::HashMap<String, Vec<String>> = std::collections::HashMap::new();
for r in &tag_rows {
let aid: String = r.get("album_id");
let name: String = r.get("name");
album_tags.entry(aid).or_default().push(name);
}
// 批量获取所有 album-person 关系
let person_rows = sqlx::query(
r#"SELECT ap.album_id, p.name FROM album_persons ap JOIN persons p ON ap.person_id = p.id"#
).fetch_all(&self.pool).await?;
let mut album_persons: std::collections::HashMap<String, Vec<String>> = std::collections::HashMap::new();
for r in &person_rows {
let aid: String = r.get("album_id");
let name: String = r.get("name");
album_persons.entry(aid).or_default().push(name);
}
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"),
tags: album_tags.remove(&id_str).unwrap_or_default(),
persons: album_persons.remove(&id_str).unwrap_or_default(),
}
}).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: r.get("cnt"),
}).collect()
}
/// 按标签搜索相册
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"),
tags: vec![],
persons: vec![],
}
}).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: &str) -> 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: String = 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: String = 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,
})
}
/// 获取人物的所有相册 ID(从 search.db 的 album_persons 关联表查询)
pub async fn get_person_album_ids(&self, person_id: &str) -> Vec<String> {
sqlx::query_scalar::<_, String>(
"SELECT album_id FROM album_persons WHERE person_id = ?"
).bind(person_id).fetch_all(&self.pool).await.unwrap_or_default()
}
/// 获取人物的 top 标签(用于详情页)
pub async fn get_person_top_tags(&self, person_id: &str, 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.clone()) {
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,
}
}
}

View File

@@ -1,5 +1,7 @@
//! 服务层 — 导入、处理等业务逻辑 //! 服务层 — 导入、处理等业务逻辑
pub mod import; pub mod import;
pub mod search_export;
#[allow(unused)] pub use import::*; #[allow(unused)] pub use import::*;
#[allow(unused)] pub use search_export::*;

View File

@@ -0,0 +1,192 @@
use crate::db::Database;
use crate::engine::title_parser;
use crate::search_db::SearchDb;
use std::collections::HashMap;
pub struct SearchExportResult {
pub albums_processed: usize,
pub tags_created: usize,
pub persons_created: usize,
pub aliases_created: usize,
pub album_tags_created: usize,
pub album_persons_created: usize,
pub dict_matched_persons: usize,
pub dict_matched_tags: usize,
pub dict_resolved_aliases: usize,
}
impl Default for SearchExportResult {
fn default() -> Self {
Self {
albums_processed: 0,
tags_created: 0,
persons_created: 0,
aliases_created: 0,
album_tags_created: 0,
album_persons_created: 0,
dict_matched_persons: 0,
dict_matched_tags: 0,
dict_resolved_aliases: 0,
}
}
}
pub async fn export_to_search_db(
source_db: &Database,
search_db_path: &str,
clear_existing: bool,
) -> Result<SearchExportResult, String> {
let search_db = SearchDb::new(search_db_path).await.map_err(|e| format!("创建 search.db 失败: {}", e))?;
if clear_existing {
search_db.clear_all().await.map_err(|e| format!("清空 search.db 失败: {}", e))?;
println!("[搜索导出] 已清空 search.db 现有数据");
}
// ── 加载 dict 表 ──
let dict_entries = search_db
.load_dict()
.await
.map_err(|e| format!("加载 dict 表失败: {}", e))?;
let person_count = dict_entries.iter().filter(|e| e.type_ == "person").count();
let tag_count = dict_entries.iter().filter(|e| e.type_ == "tag").count();
let alias_count = dict_entries.iter().filter(|e| e.merged_to.is_some()).count();
println!(
"[搜索导出] dict 表加载完成: {} 条 (person={}, tag={}, 别名映射={})",
dict_entries.len(),
person_count,
tag_count,
alias_count,
);
let albums = source_db.get_all_albums().await.map_err(|e| format!("读取相册列表失败: {}", e))?;
println!("[搜索导出] 共读取 {} 个相册(来自 imager.db)", albums.len());
let mut tag_cache: HashMap<String, String> = HashMap::new();
let mut person_cache: HashMap<String, String> = HashMap::new();
let mut result = SearchExportResult::default();
for album in &albums {
let album_id = album.id.to_string();
let title = &album.title;
// ── 1. dict 优先解析(dict 优先匹配 → tag_dict 回退 → 合并) ──
let parse_result = title_parser::parse_album_title_with_dict(&album_id, title, &dict_entries);
// 统计 dict 命中
let dict_matched_person = parse_result.person_names.iter().any(|pn| {
dict_entries.iter().any(|e| {
e.type_ == "person"
&& (e.word.to_lowercase() == pn.to_lowercase()
|| e.merged_to.as_ref().map_or(false, |m| m.to_lowercase() == pn.to_lowercase()))
})
});
if dict_matched_person {
result.dict_matched_persons += 1;
}
// ── 2. 写入 search.db ──
for (tag_name, category) in &parse_result.tags {
// 检查是否是 dict 命中的 tag
let from_dict = dict_entries.iter().any(|e| {
e.type_ == "tag" && e.word.to_lowercase() == tag_name.to_lowercase()
});
if from_dict {
result.dict_matched_tags += 1;
}
// 使用确定性 UUID,无需查数据库得到 id
let tag_id = match tag_cache.get(tag_name) {
Some(id) => id.clone(),
None => {
let id = search_db
.insert_tag(tag_name, Some(category))
.await
.map_err(|e| format!("插入标签 {} 失败: {}", tag_name, e))?;
tag_cache.insert(tag_name.clone(), id.clone());
result.tags_created += 1;
id
}
};
search_db
.insert_album_tag(&album_id, &tag_id)
.await
.map_err(|e| format!("关联相册标签 {} → {} 失败: {}", album_id, tag_name, e))?;
result.album_tags_created += 1;
}
for person_name in &parse_result.person_names {
// 检查是否有 merged_to 别名解析
let resolved_from = dict_entries.iter().find(|e| {
e.type_ == "person"
&& e.merged_to.as_ref().map_or(false, |m| m.to_lowercase() == person_name.to_lowercase())
});
if resolved_from.is_some() {
result.dict_resolved_aliases += 1;
}
// 使用确定性 UUID,无需查数据库得到 id
let person_id = match person_cache.get(person_name) {
Some(id) => id.clone(),
None => {
let id = search_db
.insert_person(person_name, None)
.await
.map_err(|e| format!("插入人物 {} 失败: {}", person_name, e))?;
person_cache.insert(person_name.clone(), id.clone());
result.persons_created += 1;
id
}
};
search_db
.insert_album_person(&album_id, &person_id)
.await
.map_err(|e| format!("关联相册人物 {} → {} 失败: {}", album_id, person_name, e))?;
result.album_persons_created += 1;
// 同步别名
let (primary, aliases) = title_parser::split_person_name_with_aliases(person_name);
if !aliases.is_empty() {
for (alias_type, alias_name) in &aliases {
if alias_name != person_name {
search_db
.insert_person_alias(&person_id, alias_type, alias_name)
.await
.map_err(|e| format!("插入别名 {} → {} 失败: {}", person_name, alias_name, e))?;
result.aliases_created += 1;
}
}
if primary != person_name.as_str() && !primary.is_empty() {
search_db
.insert_person_alias(&person_id, "primary", &primary)
.await
.map_err(|e| format!("插入别名 {} → {} 失败: {}", person_name, primary, e))?;
result.aliases_created += 1;
}
}
}
result.albums_processed += 1;
if result.albums_processed % 100 == 0 {
println!("[搜索导出] 已处理 {} / {} 相册", result.albums_processed, albums.len());
}
}
println!("[搜索导出] 完成:");
println!(" - 相册: {}", result.albums_processed);
println!(" - 标签: {}", result.tags_created);
println!(" - 人物: {}", result.persons_created);
println!(" - 别名: {}", result.aliases_created);
println!(" - 相册标签关联: {}", result.album_tags_created);
println!(" - 相册人物关联: {}", result.album_persons_created);
println!(" - dict 命中 person: {}", result.dict_matched_persons);
println!(" - dict 命中 tag: {}", result.dict_matched_tags);
println!(" - dict 别名解析: {}", result.dict_resolved_aliases);
Ok(result)
}