1457 lines
58 KiB
Rust
1457 lines
58 KiB
Rust
//! 笔记索引:SQLite + FTS5 全文检索、标签、双链。
|
||
//!
|
||
//! # 索引不是真相
|
||
//!
|
||
//! 真相永远是库根下的 `.md` 文件(见 `library.rs`)。本模块只是**可随时丢弃重建**
|
||
//! 的加速层:删掉 `{库根}/.editor/editor.db` 的唯一后果是下次搜索前要做一次全量扫描。
|
||
//! 因此这里不写「强一致」逻辑,只保证「一次同步之后索引与文件一致」——
|
||
//! 增量同步靠 `(mtime, size)` 快速筛掉未变文件,变了才读内容算 hash。
|
||
//!
|
||
//! # 为什么索引放在库根里(而不是 app_data)
|
||
//!
|
||
//! 库是可切换的(设置里的自定义目录)。索引跟库走有两个好处:换库自然换索引,
|
||
//! 不需要维护「库 → 索引文件」的映射;把整个库目录拷走时索引一起走,新机器上
|
||
//! 第一次搜索只做增量校验而不是全量重建。
|
||
//!
|
||
//! 代价是「数据库落在用户看得见的目录里」,所以目录名用点号前缀 `.editor/`:
|
||
//! 库扫描(`library::scan`)本来就跳过点号开头的目录,它不会出现在侧栏树里;
|
||
//! P2 的 WebDAV 同步也会按约定排除它。
|
||
//!
|
||
//! # 分词器为什么选 trigram
|
||
//!
|
||
//! 笔记正文以中文为主,而 FTS5 默认的 `unicode61` 分词器把连续汉字切成**一整个**
|
||
//! 词元:搜「会议」匹配不到「周会议纪要」。`trigram` 按 3 字符 n-gram 建索引,
|
||
//! 中文任意子串(≥3 字)都能命中;代价是**查询词短于 3 字符时静默返回空**,
|
||
//! 所以 [`FTS_MIN_CHARS`] 以下的词回退到 `LIKE` 扫描(笔记库规模下完全够用)。
|
||
//! 这与 `terminal/history.rs` 的取舍同源。
|
||
|
||
use std::path::{Path, PathBuf};
|
||
use std::time::UNIX_EPOCH;
|
||
|
||
use rusqlite::{params, Connection, OptionalExtension};
|
||
use serde::{Deserialize, Serialize};
|
||
use specta::Type;
|
||
use sha2::{Digest, Sha256};
|
||
use walkdir::WalkDir;
|
||
|
||
use super::library::{self, ASSETS_DIR};
|
||
|
||
/// 库结构版本(与 `PRAGMA user_version` 对应)。
|
||
///
|
||
/// 索引全部可由文件重建,因此迁移策略取最简的一种:**版本不等就整库 DROP 重建**
|
||
/// (与 `translate/history.rs` 同一取舍,而未采用 `terminal/history.rs` 的增量迁移——
|
||
/// 那里一条记录是用户敲过的命令,丢了就没了;这里一条记录是 `.md` 文件的投影,
|
||
/// 文件还在就什么都没丢)。
|
||
const SCHEMA_VERSION: i64 = 1;
|
||
|
||
/// 走 FTS 索引所需的最小字符数(trigram 的 3 字符下限,见模块头)。
|
||
const FTS_MIN_CHARS: usize = 3;
|
||
|
||
/// 正文入库上限(字节)。
|
||
///
|
||
/// 索引里的正文只服务于「生成高亮片段」,不用于回显全文。超大文件(用户把日志
|
||
/// 改名成 `.md` 之类)截断存储,避免数据库被单篇笔记撑爆;`notes` 表仍记录真实
|
||
/// 的 size/hash,改动检测不受影响。
|
||
const MAX_BODY_BYTES: usize = 512 * 1024;
|
||
|
||
/// 单次搜索返回条数上限(前端分页步长 30,500 已远超一屏)。
|
||
const MAX_SEARCH_LIMIT: i64 = 200;
|
||
|
||
/// 高亮片段的分隔标记。
|
||
///
|
||
/// **刻意不用 `<b>`**:片段要在前端渲染,而笔记正文是用户内容,回传 HTML 就等于
|
||
/// 把 XSS 风险引进渲染路径(P2 的导出链路才需要真正的 HTML 渲染 + 消毒)。
|
||
/// 用两个 ASCII 控制字符当定界符,前端在文本层切分即可,注入无从发生。
|
||
const HL_OPEN: char = '\u{2}';
|
||
const HL_CLOSE: char = '\u{3}';
|
||
|
||
// ===== 对外数据结构 =====
|
||
|
||
/// 单篇笔记的索引记录(返回给前端的搜索结果项)。
|
||
#[derive(Debug, Clone, Serialize, Type)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct NoteSearchHit {
|
||
/// 稳定 ID(front-matter 的 `id`;缺失时为空串)
|
||
pub id: String,
|
||
/// 相对库根的路径(`/` 分隔)
|
||
pub rel_path: String,
|
||
/// 显示标题(front-matter 的 `title`,缺失时取首个一级标题,再缺则取文件名)
|
||
pub title: String,
|
||
/// 命中片段(含 [`HL_OPEN`] / [`HL_CLOSE`] 定界符;无关键词搜索时为空)
|
||
pub snippet: String,
|
||
/// 标签
|
||
pub tags: Vec<String>,
|
||
/// 最后修改时间(Unix 毫秒)
|
||
pub modified: u64,
|
||
}
|
||
|
||
/// 一次搜索的结果(含总数,供「共 N 条」显示)。
|
||
///
|
||
/// 名字带 `Note` 前缀不是啰嗦:`tauri-specta` 的类型注册表按**类型名全局唯一**,
|
||
/// 重名会让 `export_bindings()` 直接 panic(`terminal/history.rs` 的
|
||
/// `TerminalHistoryPage` 就是为这个改的名)。
|
||
#[derive(Debug, Clone, Serialize, Type)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct NoteSearchPage {
|
||
pub items: Vec<NoteSearchHit>,
|
||
/// 满足条件的总条数(**不受 limit/offset 影响**)
|
||
pub total: i64,
|
||
}
|
||
|
||
/// 标签及其笔记数。
|
||
#[derive(Debug, Clone, Serialize, Type)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct NoteTagCount {
|
||
pub tag: String,
|
||
pub count: i64,
|
||
}
|
||
|
||
/// 一条链接(出链或入链)。
|
||
///
|
||
/// 出链与入链共用同一个结构,因为面板里展示的信息完全一样(标题 + 路径 + 原始目标)。
|
||
/// `resolved` 区分「已解析到库内某篇笔记」与「未解析」(`[[不存在的笔记]]`)——
|
||
/// 后者不是错误,而是反链面板里最有价值的提示:用户点一下就能建那篇笔记。
|
||
#[derive(Debug, Clone, Serialize, Type)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct NoteLink {
|
||
/// 原始写法(`[[会议纪要]]` 里的 `会议纪要`,或 `[x](notes/a.md)` 里的 `notes/a.md`)
|
||
pub target: String,
|
||
/// 解析出的库内相对路径(未解析时为空串)
|
||
pub rel_path: String,
|
||
/// 目标笔记的标题(未解析时为原始 target)
|
||
pub title: String,
|
||
/// 是否已解析到库内笔记
|
||
pub resolved: bool,
|
||
/// `wiki` | `md` | `url`
|
||
pub kind: String,
|
||
}
|
||
|
||
/// 一篇笔记的链接关系(出链 + 入链)。
|
||
#[derive(Debug, Clone, Serialize, Type)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct NoteBacklinks {
|
||
/// 本篇指向别处的链接
|
||
pub outgoing: Vec<NoteLink>,
|
||
/// 别处指向本篇的链接
|
||
pub incoming: Vec<NoteLink>,
|
||
/// 入链去重后的来源笔记数(面板标题显示「被 N 篇引用」)
|
||
pub incoming_sources: u32,
|
||
}
|
||
|
||
/// 索引状态(设置页展示 / 诊断用)。
|
||
#[derive(Debug, Clone, Serialize, Type)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct NoteIndexStats {
|
||
/// 索引中的笔记数
|
||
pub note_count: i64,
|
||
/// 库中实际存在的 `.md` 文件数
|
||
pub file_count: i64,
|
||
/// 标签数
|
||
pub tag_count: i64,
|
||
/// 库结构版本
|
||
pub schema_version: i64,
|
||
/// 索引文件路径
|
||
pub db_path: String,
|
||
}
|
||
|
||
/// 搜索筛选条件。
|
||
///
|
||
/// 用结构体而不是一长串位置参数:命令层把前端 payload 原样转发,而多个同类型
|
||
/// 位置参数在调用点顺序写错时编译器不会报错(`terminal/history.rs` 同一理由)。
|
||
#[derive(Debug, Clone, Default, Deserialize, Type)]
|
||
#[serde(rename_all = "camelCase", default)]
|
||
pub struct NoteSearchQuery {
|
||
/// 关键词(空格分隔的多个词按 AND 处理;空串 = 只按标签/目录筛选)
|
||
pub keyword: String,
|
||
/// 只看带该标签的笔记(空 = 不筛选)
|
||
pub tag: String,
|
||
/// 只看该目录(含子目录)下的笔记(空 = 全库)
|
||
pub dir: String,
|
||
/// 分页偏移
|
||
pub offset: i64,
|
||
/// 分页大小
|
||
pub limit: i64,
|
||
}
|
||
|
||
impl NoteSearchQuery {
|
||
fn normalized(mut self) -> Self {
|
||
if self.limit <= 0 {
|
||
self.limit = 50;
|
||
}
|
||
if self.limit > MAX_SEARCH_LIMIT {
|
||
self.limit = MAX_SEARCH_LIMIT;
|
||
}
|
||
if self.offset < 0 {
|
||
self.offset = 0;
|
||
}
|
||
self
|
||
}
|
||
}
|
||
|
||
// ===== front-matter 解析 =====
|
||
|
||
/// 一篇笔记解析出的元数据(不落盘,只用于写索引)。
|
||
struct NoteMeta {
|
||
id: String,
|
||
title: String,
|
||
tags: Vec<String>,
|
||
created: String,
|
||
updated: String,
|
||
body: String,
|
||
links: Vec<String>,
|
||
}
|
||
|
||
/// 拆出 front-matter 与正文。
|
||
///
|
||
/// 只认「文件第一行就是 `---`」的形式(标准 front-matter)。未闭合的 `---` 一律
|
||
/// 当作正文:把一篇以 `---` 开头的普通笔记误判成「全是元数据」会让整篇内容从索引里
|
||
/// 消失,而反过来只是标题退化成文件名 —— 两种误判代价不对称,这里选代价小的。
|
||
fn split_front_matter(content: &str) -> (Option<&str>, &str) {
|
||
let normalized = content.strip_prefix('\u{feff}').unwrap_or(content);
|
||
let mut lines = normalized.split_inclusive('\n');
|
||
let Some(first) = lines.next() else {
|
||
return (None, normalized);
|
||
};
|
||
if first.trim_end() != "---" {
|
||
return (None, normalized);
|
||
}
|
||
|
||
let mut offset = first.len();
|
||
for line in lines {
|
||
let trimmed = line.trim_end();
|
||
if trimmed == "---" || trimmed == "..." {
|
||
let fm = &normalized[first.len()..offset];
|
||
let body = &normalized[offset + line.len()..];
|
||
return (Some(fm), body);
|
||
}
|
||
offset += line.len();
|
||
}
|
||
(None, normalized)
|
||
}
|
||
|
||
/// 从 YAML 值里取字符串(容忍被引号包住、或写成数字/布尔的情况)。
|
||
fn yaml_str(value: &serde_yaml::Value) -> String {
|
||
match value {
|
||
serde_yaml::Value::String(s) => s.trim().to_string(),
|
||
serde_yaml::Value::Number(n) => n.to_string(),
|
||
serde_yaml::Value::Bool(b) => b.to_string(),
|
||
_ => String::new(),
|
||
}
|
||
}
|
||
|
||
/// 解析 `tags` 字段:YAML 里它可能是列表、逗号分隔串、或单个标签。
|
||
fn parse_tags(value: Option<&serde_yaml::Value>) -> Vec<String> {
|
||
let mut out: Vec<String> = Vec::new();
|
||
let mut push = |raw: &str| {
|
||
for part in raw.split([',', ',']) {
|
||
let tag = part.trim().trim_matches(['[', ']', '"', '\''].as_ref()).trim();
|
||
if !tag.is_empty() && !out.iter().any(|t| t == tag) {
|
||
out.push(tag.to_string());
|
||
}
|
||
}
|
||
};
|
||
match value {
|
||
Some(serde_yaml::Value::Sequence(items)) => {
|
||
for item in items {
|
||
push(&yaml_str(item));
|
||
}
|
||
}
|
||
Some(serde_yaml::Value::String(s)) => push(s),
|
||
Some(other) => push(&yaml_str(other)),
|
||
None => {}
|
||
}
|
||
out
|
||
}
|
||
|
||
/// 首个**一级**标题的文本(front-matter 没写 title 时的兜底)。
|
||
///
|
||
/// 只认 `# `:把第一个碰到的任意级别标题当书名号会让「## 小节」抢走标题位
|
||
/// (一篇笔记往往先写小节、再补一级标题)。
|
||
fn first_h1(body: &str) -> Option<String> {
|
||
body.lines().find_map(|line| {
|
||
let trimmed = line.trim_end().trim_start();
|
||
// 用 `strip_prefix` 而不是「算 `#` 个数再切片」:后者是字节索引,缩进或多字节
|
||
// 字符时容易切到非字符边界上。`?` 在闭包里是「这一行不是 H1」而不是「整篇结束」
|
||
// —— `find_map` 的闭包返回 `Option`,`?` 只会让当次迭代返回 `None`。
|
||
let title = trimmed.strip_prefix("# ")?.trim();
|
||
if title.is_empty() {
|
||
None
|
||
} else {
|
||
Some(title.to_string())
|
||
}
|
||
})
|
||
}
|
||
|
||
/// 收集正文里的链接目标:`[[wikilink]]` 与 `[text](target)`。
|
||
fn collect_links(body: &str) -> Vec<String> {
|
||
let mut out: Vec<String> = Vec::new();
|
||
let bytes = body.as_bytes();
|
||
let mut i = 0usize;
|
||
while i < bytes.len() {
|
||
// [[wiki]] —— 忽略后面紧跟 `(` 的 `[[`(那是 `[[]](...)` 的少见写法)
|
||
if bytes[i] == b'[' && i + 1 < bytes.len() && bytes[i + 1] == b'[' {
|
||
if let Some(end) = body[i + 2..].find("]]") {
|
||
let target = body[i + 2..i + 2 + end].split('|').next().unwrap_or("").trim();
|
||
if !target.is_empty() {
|
||
out.push(target.to_string());
|
||
}
|
||
i += 2 + end + 2;
|
||
continue;
|
||
}
|
||
}
|
||
// [text](target)
|
||
if bytes[i] == b']' && i + 1 < bytes.len() && bytes[i + 1] == b'(' {
|
||
if let Some(end) = body[i + 2..].find(')') {
|
||
let target = body[i + 2..i + 2 + end].trim();
|
||
let target = target.split_whitespace().next().unwrap_or("");
|
||
if !target.is_empty() && !target.starts_with('#') {
|
||
out.push(target.to_string());
|
||
}
|
||
i += 2 + end + 1;
|
||
continue;
|
||
}
|
||
}
|
||
i += 1;
|
||
}
|
||
out
|
||
}
|
||
|
||
/// 解析一篇笔记的元数据与正文(不读磁盘,输入是文件内容)。
|
||
fn parse_note(rel_path: &str, content: &str) -> NoteMeta {
|
||
let (front, body) = split_front_matter(content);
|
||
let mut id = String::new();
|
||
let mut title = String::new();
|
||
let mut tags: Vec<String> = Vec::new();
|
||
let mut created = String::new();
|
||
let mut updated = String::new();
|
||
|
||
if let Some(front) = front {
|
||
if let Ok(serde_yaml::Value::Mapping(map)) = serde_yaml::from_str::<serde_yaml::Value>(front)
|
||
{
|
||
let get = |keys: &[&str]| -> Option<&serde_yaml::Value> {
|
||
map.iter().find_map(|(k, v)| {
|
||
let key = yaml_str(k);
|
||
if keys.iter().any(|want| key.eq_ignore_ascii_case(want)) {
|
||
Some(v)
|
||
} else {
|
||
None
|
||
}
|
||
})
|
||
};
|
||
id = get(&["id", "uuid"]).map(yaml_str).unwrap_or_default();
|
||
title = get(&["title"]).map(yaml_str).unwrap_or_default();
|
||
tags = parse_tags(get(&["tags", "tag"]));
|
||
created = get(&["created", "date", "created_at"])
|
||
.map(yaml_str)
|
||
.unwrap_or_default();
|
||
updated = get(&["updated", "modified", "updated_at"])
|
||
.map(yaml_str)
|
||
.unwrap_or_default();
|
||
}
|
||
}
|
||
|
||
if title.trim().is_empty() {
|
||
title = first_h1(body).unwrap_or_else(|| {
|
||
Path::new(rel_path)
|
||
.file_stem()
|
||
.map(|s| s.to_string_lossy().to_string())
|
||
.unwrap_or_else(|| rel_path.to_string())
|
||
});
|
||
}
|
||
|
||
NoteMeta {
|
||
id,
|
||
title,
|
||
tags,
|
||
created,
|
||
updated,
|
||
body: body.to_string(),
|
||
links: collect_links(body),
|
||
}
|
||
}
|
||
|
||
/// 文件内容 hash(用于「mtime 未变但内容确实变了」之外的改动判定,
|
||
/// 以及同步(P2)时的清单比对基准)。取前 16 字节十六进制即可。
|
||
pub fn content_hash(bytes: &[u8]) -> String {
|
||
let mut hasher = Sha256::new();
|
||
hasher.update(bytes);
|
||
let digest = hasher.finalize();
|
||
let mut out = String::with_capacity(32);
|
||
for byte in digest.iter().take(16) {
|
||
out.push_str(&format!("{byte:02x}"));
|
||
}
|
||
out
|
||
}
|
||
|
||
// ===== 索引本体 =====
|
||
|
||
/// 一次同步的统计结果。
|
||
#[derive(Debug, Clone, Default, Serialize, Type)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct NoteSyncReport {
|
||
/// 本次新索引(或内容变化后重索引)的笔记数
|
||
pub indexed: i64,
|
||
/// 本次从索引中移除的笔记数(文件已删除/改名)
|
||
pub removed: i64,
|
||
/// 因 (mtime, size) 未变而跳过的笔记数
|
||
pub skipped: i64,
|
||
}
|
||
|
||
/// 笔记索引(持有 SQLite 连接 + 当前库根)。
|
||
pub struct EditorIndex {
|
||
conn: Connection,
|
||
/// 索引所属的库根(库切换时整个索引实例被替换)
|
||
root: PathBuf,
|
||
/// 索引文件绝对路径(诊断展示用)
|
||
db_path: PathBuf,
|
||
}
|
||
|
||
impl EditorIndex {
|
||
/// 打开(或创建)某个库根对应的索引。
|
||
///
|
||
/// 库根切换后由命令层用新库根调用本函数重建实例 —— 索引与库一一对应,
|
||
/// 不做「一份索引服务多个库」的多态(那需要为每张表加 root 列,得不偿失)。
|
||
pub fn open(root: &Path) -> Result<Self, String> {
|
||
// 惰性迁移旧私有目录(幂等):索引可重建,但同步基线要跟着搬过去
|
||
library::migrate_private_dir(root);
|
||
let dir = root.join(library::PRIVATE_DIR);
|
||
std::fs::create_dir_all(&dir).map_err(|e| format!("创建索引目录失败: {e}"))?;
|
||
let db_path = dir.join("editor.db");
|
||
let conn = Connection::open(&db_path).map_err(|e| format!("打开笔记索引失败: {e}"))?;
|
||
conn.busy_timeout(std::time::Duration::from_secs(3))
|
||
.map_err(|e| format!("设置索引超时失败: {e}"))?;
|
||
// WAL:读(搜索)与写(索引同步)互不阻塞,与 terminal / translate 的历史库一致
|
||
let _ = conn.pragma_update(None, "journal_mode", "WAL");
|
||
let _ = conn.pragma_update(None, "synchronous", "NORMAL");
|
||
|
||
let mut index = Self {
|
||
conn,
|
||
root: root.to_path_buf(),
|
||
db_path,
|
||
};
|
||
index.ensure_schema()?;
|
||
Ok(index)
|
||
}
|
||
|
||
/// 库根(供调用方判断是否需要换库)。
|
||
pub fn root(&self) -> &Path {
|
||
&self.root
|
||
}
|
||
|
||
/// 索引文件路径。
|
||
pub fn db_path(&self) -> &Path {
|
||
&self.db_path
|
||
}
|
||
|
||
/// 建表 + 版本检查(版本不等则整库重建,见 [`SCHEMA_VERSION`])。
|
||
fn ensure_schema(&mut self) -> Result<(), String> {
|
||
let version: i64 = self
|
||
.conn
|
||
.query_row("PRAGMA user_version", [], |row| row.get(0))
|
||
.unwrap_or(0);
|
||
|
||
if version != 0 && version != SCHEMA_VERSION {
|
||
crate::logger::log_warn(
|
||
"editor",
|
||
&format!("索引结构版本 {version} → {SCHEMA_VERSION},按文件重建索引"),
|
||
);
|
||
self.drop_all()?;
|
||
}
|
||
|
||
self.conn
|
||
.execute_batch(
|
||
"
|
||
CREATE TABLE IF NOT EXISTS notes (
|
||
rel_path TEXT PRIMARY KEY,
|
||
id TEXT NOT NULL DEFAULT '',
|
||
title TEXT NOT NULL DEFAULT '',
|
||
tags TEXT NOT NULL DEFAULT '',
|
||
created TEXT NOT NULL DEFAULT '',
|
||
updated TEXT NOT NULL DEFAULT '',
|
||
mtime INTEGER NOT NULL DEFAULT 0,
|
||
size INTEGER NOT NULL DEFAULT 0,
|
||
hash TEXT NOT NULL DEFAULT '',
|
||
body TEXT NOT NULL DEFAULT ''
|
||
);
|
||
CREATE INDEX IF NOT EXISTS idx_notes_mtime ON notes(mtime DESC);
|
||
|
||
-- 外部内容表:索引只存倒排表,正文只在 notes 里一份。
|
||
-- 代价是不会自动感知主表变化,靠下面三个触发器同步。
|
||
CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(
|
||
title, body,
|
||
content='notes', content_rowid='rowid',
|
||
tokenize='trigram'
|
||
);
|
||
|
||
CREATE TRIGGER IF NOT EXISTS notes_fts_ai AFTER INSERT ON notes BEGIN
|
||
INSERT INTO notes_fts(rowid, title, body) VALUES (new.rowid, new.title, new.body);
|
||
END;
|
||
CREATE TRIGGER IF NOT EXISTS notes_fts_ad AFTER DELETE ON notes BEGIN
|
||
INSERT INTO notes_fts(notes_fts, rowid, title, body)
|
||
VALUES ('delete', old.rowid, old.title, old.body);
|
||
END;
|
||
CREATE TRIGGER IF NOT EXISTS notes_fts_au AFTER UPDATE ON notes BEGIN
|
||
INSERT INTO notes_fts(notes_fts, rowid, title, body)
|
||
VALUES ('delete', old.rowid, old.title, old.body);
|
||
INSERT INTO notes_fts(rowid, title, body) VALUES (new.rowid, new.title, new.body);
|
||
END;
|
||
|
||
CREATE TABLE IF NOT EXISTS tags (
|
||
name TEXT PRIMARY KEY
|
||
);
|
||
CREATE TABLE IF NOT EXISTS note_tags (
|
||
rel_path TEXT NOT NULL,
|
||
tag TEXT NOT NULL,
|
||
PRIMARY KEY (rel_path, tag)
|
||
);
|
||
CREATE INDEX IF NOT EXISTS idx_note_tags_tag ON note_tags(tag);
|
||
|
||
-- 双链 / 未解析链接。dst_path 为解析出的库内相对路径(尽力而为),
|
||
-- 解析不到时只留原始 target —— 「未解析链接」本身就是反链面板要展示的信息。
|
||
CREATE TABLE IF NOT EXISTS links (
|
||
src_path TEXT NOT NULL,
|
||
target TEXT NOT NULL,
|
||
dst_path TEXT NOT NULL DEFAULT '',
|
||
kind TEXT NOT NULL DEFAULT 'md'
|
||
);
|
||
CREATE INDEX IF NOT EXISTS idx_links_src ON links(src_path);
|
||
CREATE INDEX IF NOT EXISTS idx_links_dst ON links(dst_path);
|
||
",
|
||
)
|
||
.map_err(|e| format!("初始化笔记索引表失败: {e}"))?;
|
||
|
||
self.conn
|
||
.pragma_update(None, "user_version", SCHEMA_VERSION)
|
||
.map_err(|e| format!("写入索引版本失败: {e}"))?;
|
||
Ok(())
|
||
}
|
||
|
||
/// 清空全部索引结构(版本迁移用;文件不受影响)。
|
||
fn drop_all(&mut self) -> Result<(), String> {
|
||
self.conn
|
||
.execute_batch(
|
||
"DROP TABLE IF EXISTS notes_fts;
|
||
DROP TABLE IF EXISTS note_tags;
|
||
DROP TABLE IF EXISTS tags;
|
||
DROP TABLE IF EXISTS links;
|
||
DROP TABLE IF EXISTS notes;",
|
||
)
|
||
.map_err(|e| format!("重建索引表失败: {e}"))
|
||
}
|
||
|
||
/// 全量重建:清空索引后重新扫描整个库。
|
||
pub fn rebuild(&mut self) -> Result<NoteSyncReport, String> {
|
||
self.drop_all()?;
|
||
self.conn
|
||
.pragma_update(None, "user_version", 0)
|
||
.map_err(|e| format!("重置索引版本失败: {e}"))?;
|
||
self.ensure_schema()?;
|
||
self.sync()
|
||
}
|
||
|
||
/// 增量同步:扫描库根,只对「mtime/size 变化或索引里没有」的文件重新解析。
|
||
pub fn sync(&mut self) -> Result<NoteSyncReport, String> {
|
||
let mut report = NoteSyncReport::default();
|
||
let root = self.root.clone();
|
||
|
||
// 1) 先收集磁盘现状(顺带拿到 (mtime, size) 用于快速筛)
|
||
let mut seen: Vec<(String, u64, u64, PathBuf)> = Vec::new();
|
||
for entry in WalkDir::new(&root)
|
||
.max_depth(library::MAX_DEPTH)
|
||
.into_iter()
|
||
.filter_map(Result::ok)
|
||
{
|
||
if !entry.file_type().is_file() {
|
||
continue;
|
||
}
|
||
let path = entry.path();
|
||
// 跳过点号目录(含 `.editor/` 自身)与根级 assets/
|
||
if skip_path(&root, path) {
|
||
continue;
|
||
}
|
||
let name = entry.file_name().to_string_lossy().to_string();
|
||
if !name.to_ascii_lowercase().ends_with(".md") {
|
||
continue;
|
||
}
|
||
let Ok(meta) = entry.metadata() else { continue };
|
||
let rel = library::rel_string(&root, path);
|
||
seen.push((rel, modified_ms(&meta), meta.len(), path.to_path_buf()));
|
||
}
|
||
|
||
// 2) 文件名 → 相对路径映射(wikilink 按名解析用,见 resolve_link)
|
||
let mut stems: std::collections::HashMap<String, String> = std::collections::HashMap::new();
|
||
for (rel, ..) in &seen {
|
||
if let Some(stem) = Path::new(rel).file_stem() {
|
||
stems
|
||
.entry(stem.to_string_lossy().to_ascii_lowercase())
|
||
.or_insert_with(|| rel.clone());
|
||
}
|
||
}
|
||
|
||
// 3) 索引里有、磁盘上没有的 → 删
|
||
let existing: Vec<String> = {
|
||
let mut stmt = self
|
||
.conn
|
||
.prepare("SELECT rel_path FROM notes")
|
||
.map_err(|e| format!("读取索引清单失败: {e}"))?;
|
||
let rows = stmt
|
||
.query_map([], |row| row.get::<_, String>(0))
|
||
.map_err(|e| format!("读取索引清单失败: {e}"))?;
|
||
rows.filter_map(Result::ok).collect()
|
||
};
|
||
for rel in existing {
|
||
if !seen.iter().any(|(path, ..)| *path == rel) {
|
||
self.remove_note(&rel)?;
|
||
report.removed += 1;
|
||
}
|
||
}
|
||
|
||
// 4) 逐个文件:未变跳过,变了重解析
|
||
for (rel, mtime, size, path) in seen {
|
||
let cached: Option<(i64, i64)> = self
|
||
.conn
|
||
.query_row(
|
||
"SELECT mtime, size FROM notes WHERE rel_path = ?1",
|
||
params![rel],
|
||
|row| Ok((row.get(0)?, row.get(1)?)),
|
||
)
|
||
.optional()
|
||
.map_err(|e| format!("查询笔记索引失败: {e}"))?;
|
||
if let Some((cached_mtime, cached_size)) = cached {
|
||
if cached_mtime as u64 == mtime && cached_size as u64 == size {
|
||
report.skipped += 1;
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// 读文件:非 UTF-8 按有损解码 —— 索引里出现替换字符好过整库索引失败
|
||
let bytes = match std::fs::read(&path) {
|
||
Ok(b) => b,
|
||
Err(e) => {
|
||
crate::logger::log_warn("editor", &format!("索引读取失败 {rel}: {e}"));
|
||
continue;
|
||
}
|
||
};
|
||
let content = String::from_utf8_lossy(&bytes);
|
||
self.upsert_note(&rel, &content, mtime, size, &content_hash(&bytes), &stems)?;
|
||
report.indexed += 1;
|
||
}
|
||
|
||
Ok(report)
|
||
}
|
||
|
||
/// 写入/更新一篇笔记的索引(含标签与链接)。
|
||
///
|
||
/// `stems` 供 wikilink 按文件名解析;单篇保存时调用方若不想扫全库,
|
||
/// 可以先 `list_notes` 现搭一份小映射(见 `commands.rs`),或传空表退化为
|
||
/// 「按相对路径解析」。
|
||
pub fn upsert_note(
|
||
&mut self,
|
||
rel_path: &str,
|
||
content: &str,
|
||
mtime: u64,
|
||
size: u64,
|
||
hash: &str,
|
||
stems: &std::collections::HashMap<String, String>,
|
||
) -> Result<(), String> {
|
||
let meta = parse_note(rel_path, content);
|
||
let body: String = {
|
||
let mut body = meta.body.clone();
|
||
if body.len() > MAX_BODY_BYTES {
|
||
// 按字符边界截断,避免切出半个 UTF-8 序列
|
||
let mut cut = MAX_BODY_BYTES;
|
||
while cut > 0 && !body.is_char_boundary(cut) {
|
||
cut -= 1;
|
||
}
|
||
body.truncate(cut);
|
||
}
|
||
body
|
||
};
|
||
|
||
let tx = self
|
||
.conn
|
||
.transaction()
|
||
.map_err(|e| format!("开启索引事务失败: {e}"))?;
|
||
tx.execute(
|
||
"INSERT INTO notes (rel_path, id, title, tags, created, updated, mtime, size, hash, body)
|
||
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)
|
||
ON CONFLICT(rel_path) DO UPDATE SET
|
||
id = excluded.id, title = excluded.title, tags = excluded.tags,
|
||
created = excluded.created, updated = excluded.updated,
|
||
mtime = excluded.mtime, size = excluded.size, hash = excluded.hash,
|
||
body = excluded.body",
|
||
params![
|
||
rel_path,
|
||
meta.id,
|
||
meta.title,
|
||
meta.tags.join(","),
|
||
meta.created,
|
||
meta.updated,
|
||
mtime as i64,
|
||
size as i64,
|
||
hash,
|
||
body
|
||
],
|
||
)
|
||
.map_err(|e| format!("写入笔记索引失败: {e}"))?;
|
||
|
||
// 标签:先删后插(改标签是最常见的编辑动作之一,diff 不值得)
|
||
tx.execute("DELETE FROM note_tags WHERE rel_path = ?1", params![rel_path])
|
||
.map_err(|e| format!("清理标签失败: {e}"))?;
|
||
for tag in &meta.tags {
|
||
tx.execute("INSERT OR IGNORE INTO tags (name) VALUES (?1)", params![tag])
|
||
.map_err(|e| format!("写入标签失败: {e}"))?;
|
||
tx.execute(
|
||
"INSERT OR REPLACE INTO note_tags (rel_path, tag) VALUES (?1, ?2)",
|
||
params![rel_path, tag],
|
||
)
|
||
.map_err(|e| format!("关联标签失败: {e}"))?;
|
||
}
|
||
|
||
// 链接:同样先删后插
|
||
tx.execute("DELETE FROM links WHERE src_path = ?1", params![rel_path])
|
||
.map_err(|e| format!("清理链接失败: {e}"))?;
|
||
for link in &meta.links {
|
||
let (dst, kind) = resolve_link(rel_path, link, stems);
|
||
tx.execute(
|
||
"INSERT INTO links (src_path, target, dst_path, kind) VALUES (?1, ?2, ?3, ?4)",
|
||
params![rel_path, link, dst, kind],
|
||
)
|
||
.map_err(|e| format!("写入链接失败: {e}"))?;
|
||
}
|
||
|
||
tx.commit().map_err(|e| format!("提交索引事务失败: {e}"))
|
||
}
|
||
|
||
/// 从索引里移除一篇笔记(文件被删除/改名)。
|
||
pub fn remove_note(&mut self, rel_path: &str) -> Result<(), String> {
|
||
let tx = self
|
||
.conn
|
||
.transaction()
|
||
.map_err(|e| format!("开启索引事务失败: {e}"))?;
|
||
tx.execute("DELETE FROM notes WHERE rel_path = ?1", params![rel_path])
|
||
.map_err(|e| format!("删除索引项失败: {e}"))?;
|
||
tx.execute("DELETE FROM note_tags WHERE rel_path = ?1", params![rel_path])
|
||
.map_err(|e| format!("清理标签失败: {e}"))?;
|
||
tx.execute("DELETE FROM links WHERE src_path = ?1", params![rel_path])
|
||
.map_err(|e| format!("清理链接失败: {e}"))?;
|
||
// 顺手清掉「已无人引用」的标签,避免标签云里堆着一堆 0 计数条目
|
||
tx.execute(
|
||
"DELETE FROM tags WHERE name NOT IN (SELECT DISTINCT tag FROM note_tags)",
|
||
[],
|
||
)
|
||
.map_err(|e| format!("清理空标签失败: {e}"))?;
|
||
tx.commit().map_err(|e| format!("提交索引事务失败: {e}"))
|
||
}
|
||
|
||
/// 全文检索 / 筛选。
|
||
pub fn search(&self, query: NoteSearchQuery) -> Result<NoteSearchPage, String> {
|
||
let query = query.normalized();
|
||
let keyword = query.keyword.trim();
|
||
let tag = query.tag.trim();
|
||
let dir = query.dir.trim().trim_matches('/');
|
||
|
||
// 关键词走 FTS 时额外套一层子查询,便于把「筛选条件」与「命中排序」解耦
|
||
let use_fts = keyword.chars().count() >= FTS_MIN_CHARS;
|
||
let mut joins = String::new();
|
||
let mut wheres: Vec<String> = Vec::new();
|
||
let mut args: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();
|
||
|
||
if use_fts {
|
||
joins.push_str(" JOIN notes_fts f ON f.rowid = notes.rowid");
|
||
wheres.push("notes_fts MATCH ?".to_string());
|
||
args.push(Box::new(fts_query(keyword)));
|
||
}
|
||
if !keyword.is_empty() && !use_fts {
|
||
// 短词回退:trigram 对 <3 字符的查询静默返回空,这里退化成子串匹配
|
||
wheres.push("(notes.title LIKE ? OR notes.body LIKE ?)".to_string());
|
||
let like = format!("%{keyword}%");
|
||
args.push(Box::new(like.clone()));
|
||
args.push(Box::new(like));
|
||
}
|
||
if !tag.is_empty() {
|
||
wheres.push("EXISTS (SELECT 1 FROM note_tags nt WHERE nt.rel_path = notes.rel_path AND nt.tag = ?)".to_string());
|
||
args.push(Box::new(tag.to_string()));
|
||
}
|
||
if !dir.is_empty() {
|
||
// 目录筛选含子目录:'dir/%' 前缀匹配;根目录(空串)已在上面归一化掉
|
||
wheres.push("notes.rel_path LIKE ?".to_string());
|
||
args.push(Box::new(format!("{dir}/%")));
|
||
}
|
||
|
||
let where_sql = if wheres.is_empty() {
|
||
String::new()
|
||
} else {
|
||
format!(" WHERE {}", wheres.join(" AND "))
|
||
};
|
||
|
||
let total: i64 = {
|
||
let sql = format!("SELECT COUNT(*) FROM notes{joins}{where_sql}");
|
||
let refs: Vec<&dyn rusqlite::ToSql> = args.iter().map(|b| b.as_ref()).collect();
|
||
self.conn
|
||
.query_row(&sql, refs.as_slice(), |row| row.get(0))
|
||
.map_err(|e| format!("统计检索结果失败: {e}"))?
|
||
};
|
||
|
||
// 片段:走 FTS 时用 snippet()(列索引 `-1` = **让 FTS 自己挑最佳列**)。
|
||
//
|
||
// 不写死列号的原因:关键词常常命中**标题**(中文笔记尤其如此 —— 「周会」就在
|
||
// 标题「周会纪要」里),写死正文列会得到一个与命中位置无关的片段。
|
||
// 短词回退 LIKE 时另有 Rust 侧生成的片段(见 `make_snippet`),这里留空。
|
||
let snippet_expr = if use_fts {
|
||
format!(
|
||
"snippet(notes_fts, -1, '{}', '{}', '…', 18)",
|
||
HL_OPEN, HL_CLOSE
|
||
)
|
||
} else {
|
||
"''".to_string()
|
||
};
|
||
let order = if use_fts {
|
||
"bm25(notes_fts, 8.0, 1.0)".to_string()
|
||
} else {
|
||
"notes.mtime DESC".to_string()
|
||
};
|
||
// 短词回退时一并取回正文,用于生成片段(正文列已在写索引时截断过长度)
|
||
let body_expr = if use_fts { "''" } else { "notes.body" };
|
||
|
||
let sql = format!(
|
||
"SELECT notes.rel_path, notes.id, notes.title, notes.tags, notes.mtime, {snippet_expr}, {body_expr}
|
||
FROM notes{joins}{where_sql} ORDER BY {order} LIMIT ? OFFSET ?"
|
||
);
|
||
let mut stmt = self
|
||
.conn
|
||
.prepare(&sql)
|
||
.map_err(|e| format!("准备检索语句失败: {e}"))?;
|
||
|
||
let mut all: Vec<Box<dyn rusqlite::ToSql>> = args;
|
||
all.push(Box::new(query.limit));
|
||
all.push(Box::new(query.offset));
|
||
let refs: Vec<&dyn rusqlite::ToSql> = all.iter().map(|b| b.as_ref()).collect();
|
||
|
||
let rows = stmt
|
||
.query_map(refs.as_slice(), |row| {
|
||
let tags: String = row.get(3)?;
|
||
Ok((
|
||
NoteSearchHit {
|
||
rel_path: row.get(0)?,
|
||
id: row.get(1)?,
|
||
title: row.get(2)?,
|
||
tags: tags
|
||
.split(',')
|
||
.filter(|s| !s.is_empty())
|
||
.map(|s| s.to_string())
|
||
.collect(),
|
||
modified: row.get::<_, i64>(4)? as u64,
|
||
snippet: row.get(5)?,
|
||
},
|
||
row.get::<_, String>(6)?,
|
||
))
|
||
})
|
||
.map_err(|e| format!("检索失败: {e}"))?;
|
||
|
||
let mut items: Vec<NoteSearchHit> = Vec::new();
|
||
for row in rows.filter_map(Result::ok) {
|
||
let (mut hit, body) = row;
|
||
if hit.snippet.is_empty() && !keyword.is_empty() {
|
||
// 短词回退(LIKE)路径:FTS 不给片段,这里自己截
|
||
hit.snippet = make_snippet(&hit.title, &body, keyword);
|
||
}
|
||
items.push(hit);
|
||
}
|
||
Ok(NoteSearchPage { items, total })
|
||
}
|
||
|
||
/// 查询一篇笔记的链接关系(出链 + 入链)。
|
||
///
|
||
/// # 入链为什么按 `dst_path` 匹配
|
||
///
|
||
/// 写索引时已经把链接目标**尽力解析**成库内相对路径(含 Obsidian 式「全库按名解析」)。
|
||
/// 因此「谁引用了我」只需要 `links.dst_path = 本篇路径`。未解析的链接
|
||
/// (`dst_path = ''`)自然不会被算作任何一篇的入链 —— 这正是期望行为:
|
||
/// 指向不存在笔记的链接不该在别处显示成反链。
|
||
///
|
||
/// # 出链为什么用 LEFT JOIN
|
||
///
|
||
/// 出链里既有已解析的(`dst_path` 命中 `notes`)也有未解析的(空串或指向不存在的
|
||
/// 目标)。用 LEFT JOIN 一次取回,未解析的那些 `rel_path` 为空、`title` 回退成原始
|
||
/// target —— 前端据此把它们渲染成「点一下就能新建」的入口。
|
||
pub fn backlinks(&self, rel_path: &str) -> Result<NoteBacklinks, String> {
|
||
let outgoing = {
|
||
let mut stmt = self
|
||
.conn
|
||
.prepare(
|
||
"SELECT links.target, links.kind,
|
||
COALESCE(notes.rel_path, ''), COALESCE(notes.title, '')
|
||
FROM links LEFT JOIN notes ON notes.rel_path = links.dst_path
|
||
WHERE links.src_path = ?1
|
||
ORDER BY links.target",
|
||
)
|
||
.map_err(|e| format!("准备出链语句失败: {e}"))?;
|
||
let rows = stmt
|
||
.query_map(params![rel_path], |row| {
|
||
let target: String = row.get(0)?;
|
||
let kind: String = row.get(1)?;
|
||
let dst: String = row.get(2)?;
|
||
let title: String = row.get(3)?;
|
||
Ok(NoteLink {
|
||
title: if title.is_empty() {
|
||
target.clone()
|
||
} else {
|
||
title
|
||
},
|
||
resolved: !dst.is_empty(),
|
||
rel_path: dst,
|
||
target,
|
||
kind,
|
||
})
|
||
})
|
||
.map_err(|e| format!("查询出链失败: {e}"))?;
|
||
rows.filter_map(Result::ok).collect::<Vec<_>>()
|
||
};
|
||
|
||
let incoming = {
|
||
let mut stmt = self
|
||
.conn
|
||
.prepare(
|
||
"SELECT links.target, links.kind, links.src_path, COALESCE(notes.title, '')
|
||
FROM links LEFT JOIN notes ON notes.rel_path = links.src_path
|
||
WHERE links.dst_path = ?1
|
||
ORDER BY links.src_path",
|
||
)
|
||
.map_err(|e| format!("准备入链语句失败: {e}"))?;
|
||
let rows = stmt
|
||
.query_map(params![rel_path], |row| {
|
||
let target: String = row.get(0)?;
|
||
let kind: String = row.get(1)?;
|
||
let src: String = row.get(2)?;
|
||
let title: String = row.get(3)?;
|
||
Ok(NoteLink {
|
||
title: if title.is_empty() {
|
||
src.clone()
|
||
} else {
|
||
title
|
||
},
|
||
// 入链的「目标」就是来源笔记本身
|
||
resolved: true,
|
||
rel_path: src,
|
||
target,
|
||
kind,
|
||
})
|
||
})
|
||
.map_err(|e| format!("查询入链失败: {e}"))?;
|
||
rows.filter_map(Result::ok).collect::<Vec<_>>()
|
||
};
|
||
|
||
let incoming_sources = {
|
||
let mut set: Vec<&str> = incoming.iter().map(|l| l.rel_path.as_str()).collect();
|
||
set.sort_unstable();
|
||
set.dedup();
|
||
set.len() as u32
|
||
};
|
||
|
||
Ok(NoteBacklinks {
|
||
outgoing,
|
||
incoming,
|
||
incoming_sources,
|
||
})
|
||
}
|
||
|
||
/// 全库链接图(`{ 源路径: [目标路径] }`,只含已解析的内部链接)。
|
||
///
|
||
/// 供「双链图谱」用。只返回已解析的边:指向不存在笔记的链接在图上没有节点可连。
|
||
pub fn link_graph(&self) -> Result<Vec<(String, String)>, String> {
|
||
let mut stmt = self
|
||
.conn
|
||
.prepare(
|
||
"SELECT src_path, dst_path FROM links
|
||
WHERE dst_path <> '' AND kind <> 'url'
|
||
ORDER BY src_path, dst_path",
|
||
)
|
||
.map_err(|e| format!("准备图谱语句失败: {e}"))?;
|
||
let rows = stmt
|
||
.query_map([], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)))
|
||
.map_err(|e| format!("查询图谱失败: {e}"))?;
|
||
Ok(rows.filter_map(Result::ok).collect())
|
||
}
|
||
|
||
/// 快速打开用的轻量清单(只取路径/标题/时间,不带正文与片段)。
|
||
pub fn list_notes(&self, limit: i64) -> Result<Vec<NoteSearchHit>, String> {
|
||
let limit = limit.clamp(1, 2000);
|
||
let mut stmt = self
|
||
.conn
|
||
.prepare(
|
||
"SELECT rel_path, id, title, tags, mtime FROM notes ORDER BY mtime DESC LIMIT ?1",
|
||
)
|
||
.map_err(|e| format!("准备清单语句失败: {e}"))?;
|
||
let rows = stmt
|
||
.query_map(params![limit], |row| {
|
||
let tags: String = row.get(3)?;
|
||
Ok(NoteSearchHit {
|
||
rel_path: row.get(0)?,
|
||
id: row.get(1)?,
|
||
title: row.get(2)?,
|
||
tags: tags
|
||
.split(',')
|
||
.filter(|s| !s.is_empty())
|
||
.map(|s| s.to_string())
|
||
.collect(),
|
||
modified: row.get::<_, i64>(4)? as u64,
|
||
snippet: String::new(),
|
||
})
|
||
})
|
||
.map_err(|e| format!("读取笔记清单失败: {e}"))?;
|
||
Ok(rows.filter_map(Result::ok).collect())
|
||
}
|
||
|
||
/// 标签及计数(按计数降序、同计数按名称)。
|
||
pub fn tags(&self) -> Result<Vec<NoteTagCount>, String> { let mut stmt = self
|
||
.conn
|
||
.prepare(
|
||
"SELECT tag, COUNT(*) AS n FROM note_tags GROUP BY tag ORDER BY n DESC, tag ASC",
|
||
)
|
||
.map_err(|e| format!("准备标签语句失败: {e}"))?;
|
||
let rows = stmt
|
||
.query_map([], |row| {
|
||
Ok(NoteTagCount {
|
||
tag: row.get(0)?,
|
||
count: row.get(1)?,
|
||
})
|
||
})
|
||
.map_err(|e| format!("读取标签失败: {e}"))?;
|
||
Ok(rows.filter_map(Result::ok).collect())
|
||
}
|
||
|
||
/// 索引状态。
|
||
pub fn stats(&self) -> Result<NoteIndexStats, String> {
|
||
let note_count: i64 = self
|
||
.conn
|
||
.query_row("SELECT COUNT(*) FROM notes", [], |row| row.get(0))
|
||
.unwrap_or(0);
|
||
let tag_count: i64 = self
|
||
.conn
|
||
.query_row("SELECT COUNT(*) FROM tags", [], |row| row.get(0))
|
||
.unwrap_or(0);
|
||
let file_count = WalkDir::new(&self.root)
|
||
.max_depth(library::MAX_DEPTH)
|
||
.into_iter()
|
||
.filter_map(Result::ok)
|
||
.filter(|e| {
|
||
e.file_type().is_file()
|
||
&& !skip_path(&self.root, e.path())
|
||
&& e.file_name()
|
||
.to_string_lossy()
|
||
.to_ascii_lowercase()
|
||
.ends_with(".md")
|
||
})
|
||
.count() as i64;
|
||
Ok(NoteIndexStats {
|
||
note_count,
|
||
file_count,
|
||
tag_count,
|
||
schema_version: SCHEMA_VERSION,
|
||
db_path: self.db_path.to_string_lossy().to_string(),
|
||
})
|
||
}
|
||
}
|
||
|
||
// ===== 辅助 =====
|
||
|
||
fn modified_ms(meta: &std::fs::Metadata) -> u64 {
|
||
meta.modified()
|
||
.ok()
|
||
.and_then(|t| t.duration_since(UNIX_EPOCH).ok())
|
||
.map(|d| d.as_millis() as u64)
|
||
.unwrap_or(0)
|
||
}
|
||
|
||
/// 该绝对路径是否应当排除在索引之外(点号目录 / 根级 assets)。
|
||
fn skip_path(root: &Path, path: &Path) -> bool {
|
||
let rel = library::rel_string(root, path);
|
||
if rel.is_empty() {
|
||
return false;
|
||
}
|
||
let parts: Vec<&str> = rel.split('/').collect();
|
||
// 任何一层是点号开头 → 排除(`.editor/` 索引自身、`.git/` 等)
|
||
if parts.iter().any(|p| p.starts_with('.')) {
|
||
return true;
|
||
}
|
||
// 根级 assets/ 是图片仓库,不是笔记(与 library::scan 的口径一致)
|
||
parts.first() == Some(&ASSETS_DIR)
|
||
}
|
||
|
||
/// 为「短词回退 LIKE」路径生成命中片段。
|
||
///
|
||
/// FTS 的 `snippet()` 只服务于 FTS 查询;短于 3 字符的关键词走 LIKE(trigram 的
|
||
/// 下限),那条路径没有片段可拿。若就此返回空片段,用户在结果列表里只看到一个标题、
|
||
/// 不知道为什么会命中 —— 于是这里自己截一段上下文。
|
||
///
|
||
/// # 顺序
|
||
///
|
||
/// 优先在**正文**里找关键词(正文命中才是「检索」的价值所在),找不到再看标题。
|
||
/// 命中处两侧各留 [`SNIPPET_CONTEXT`] 个**字符**(`chars` 而不是字节:中文笔记里按
|
||
/// 字节截会切出乱码),并加上高亮定界符。
|
||
fn make_snippet(title: &str, body: &str, keyword: &str) -> String {
|
||
const SNIPPET_CONTEXT: usize = 24;
|
||
if keyword.is_empty() {
|
||
return String::new();
|
||
}
|
||
let Some((source, at)) = find_ci(body, keyword)
|
||
.map(|at| (body, at))
|
||
.or_else(|| find_ci(title, keyword).map(|at| (title, at)))
|
||
else {
|
||
return String::new();
|
||
};
|
||
|
||
// 归一化换行:片段是单行展示的,正文里的 `\n` 会让它断成两截
|
||
let flat = source.replace(['\n', '\r'], " ");
|
||
let chars: Vec<char> = flat.chars().collect();
|
||
let keyword_chars = keyword.chars().count();
|
||
let at_chars = source[..at].chars().count().min(chars.len());
|
||
let start = at_chars.saturating_sub(SNIPPET_CONTEXT);
|
||
let end = (at_chars + keyword_chars + SNIPPET_CONTEXT).min(chars.len());
|
||
|
||
let mut out = String::new();
|
||
if start > 0 {
|
||
out.push('…');
|
||
}
|
||
out.extend(&chars[start..at_chars]);
|
||
out.push(HL_OPEN);
|
||
out.extend(&chars[at_chars..(at_chars + keyword_chars).min(chars.len())]);
|
||
out.push(HL_CLOSE);
|
||
out.extend(&chars[(at_chars + keyword_chars).min(chars.len())..end]);
|
||
if end < chars.len() {
|
||
out.push('…');
|
||
}
|
||
out
|
||
}
|
||
|
||
/// 大小写无关的字节查找(返回字节下标;找不到返回 None)。
|
||
fn find_ci(haystack: &str, needle: &str) -> Option<usize> {
|
||
haystack
|
||
.to_lowercase()
|
||
.find(&needle.to_lowercase())
|
||
}
|
||
|
||
/// 把 FTS5 查询串安全地转成「多个短语的 AND」。
|
||
/// FTS5 的 `MATCH` 有自己一套查询语法(`-` `*` `(` `^` `"` `:` `+` 都是操作符)。
|
||
/// 用户输入是笔记标题里的普通词,直接塞进去轻则语义错、重则整个查询报语法错误。
|
||
/// 做法与 `terminal/history.rs` 一致:每个词包成双引号短语、内部引号翻倍,
|
||
/// 词与词之间用空格(FTS5 的空格即 AND)。
|
||
fn fts_query(keyword: &str) -> String {
|
||
keyword
|
||
.split_whitespace()
|
||
.map(|word| format!("\"{}\"", word.replace('"', "\"\"")))
|
||
.collect::<Vec<_>>()
|
||
.join(" ")
|
||
}
|
||
|
||
/// 把链接目标尽力解析成「库内相对路径」。
|
||
///
|
||
/// 解析不了就返回空串 —— 这不是失败,而是「未解析链接」,反链面板要靠它提示用户
|
||
/// 目标不存在(`[[不存在的笔记]]` 在 Obsidian 里正是「新建入口」)。
|
||
///
|
||
/// `stems` 是「文件名(不含扩展名)→ 库内相对路径」的全库映射,专治 `[[笔记名]]`
|
||
/// 这种**不带目录**的写法:Obsidian 的 wikilink 语义是「全库按名查」,只按相对路径
|
||
/// 猜会把 `[[周会]]` 解析到错的目录去(或干脆解析不到)。
|
||
fn resolve_link(
|
||
src_rel: &str,
|
||
target: &str,
|
||
stems: &std::collections::HashMap<String, String>,
|
||
) -> (String, String) {
|
||
let is_wiki = target.ends_with(".md") || !target.contains('.');
|
||
if target.contains("://") {
|
||
return (String::new(), "url".to_string());
|
||
}
|
||
let clean = target.split('#').next().unwrap_or("").trim();
|
||
let kind = if is_wiki { "wiki" } else { "md" };
|
||
if clean.is_empty() {
|
||
return (String::new(), kind.to_string());
|
||
}
|
||
|
||
// wikilink 优先按「全库文件名」解析(Obsidian 语义),命中即用
|
||
if is_wiki && !clean.contains('/') {
|
||
if let Some(hit) = stems.get(&clean.to_ascii_lowercase()) {
|
||
return (hit.clone(), kind.to_string());
|
||
}
|
||
}
|
||
|
||
// 相对当前笔记所在目录解析
|
||
let base = Path::new(src_rel).parent().unwrap_or(Path::new(""));
|
||
let joined = if clean.starts_with('/') {
|
||
clean.trim_start_matches('/').to_string()
|
||
} else {
|
||
let mut parts: Vec<String> = Vec::new();
|
||
for part in base.to_string_lossy().replace('\\', "/").split('/') {
|
||
if !part.is_empty() {
|
||
parts.push(part.to_string());
|
||
}
|
||
}
|
||
for part in clean.replace('\\', "/").split('/') {
|
||
match part {
|
||
"" | "." => {}
|
||
".." => {
|
||
parts.pop();
|
||
}
|
||
other => parts.push(other.to_string()),
|
||
}
|
||
}
|
||
parts.join("/")
|
||
};
|
||
|
||
let with_ext = if joined.to_ascii_lowercase().ends_with(".md") {
|
||
joined
|
||
} else {
|
||
format!("{joined}.md")
|
||
};
|
||
(with_ext, kind.to_string())
|
||
}
|
||
|
||
// ===== 测试 =====
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn front_matter_split_and_parse() {
|
||
let content = "---\nid: abc\ntitle: 会议纪要\ntags: [工作, 周会]\n---\n\n# 会议纪要\n\n正文\n";
|
||
let meta = parse_note("2026/09/meeting.md", content);
|
||
assert_eq!(meta.id, "abc");
|
||
assert_eq!(meta.title, "会议纪要");
|
||
assert_eq!(meta.tags, vec!["工作", "周会"]);
|
||
assert!(meta.body.contains("正文"));
|
||
assert!(!meta.body.contains("id: abc"));
|
||
}
|
||
|
||
#[test]
|
||
fn unterminated_front_matter_is_body() {
|
||
// 未闭合的 `---` 必须当正文:宁可标题退化,也不能让整篇内容从索引里消失
|
||
let content = "---\n这不是元数据\n\n# 标题\n";
|
||
let meta = parse_note("a.md", content);
|
||
assert!(meta.body.contains("这不是元数据"));
|
||
assert_eq!(meta.title, "标题");
|
||
}
|
||
|
||
#[test]
|
||
fn title_falls_back_to_h1_then_filename() {
|
||
let meta = parse_note("dir/无元数据.md", "## 二级\n\n# 一级标题\n");
|
||
assert_eq!(meta.title, "一级标题");
|
||
let meta = parse_note("dir/只有文件名.md", "普通正文\n");
|
||
assert_eq!(meta.title, "只有文件名");
|
||
}
|
||
|
||
#[test]
|
||
fn tags_accept_three_shapes() {
|
||
let list = parse_note("a.md", "---\ntags: [a, b]\n---\nx");
|
||
assert_eq!(list.tags, vec!["a", "b"]);
|
||
let csv = parse_note("a.md", "---\ntags: a, b\n---\nx");
|
||
assert_eq!(csv.tags, vec!["a", "b"]);
|
||
let one = parse_note("a.md", "---\ntag: 单个\n---\nx");
|
||
assert_eq!(one.tags, vec!["单个"]);
|
||
}
|
||
|
||
#[test]
|
||
fn links_parsed_from_both_syntaxes() {
|
||
let meta = parse_note("notes/a.md", "见 [[另一篇]] 与 [名](notes/b.md#小节)\n");
|
||
assert!(meta.links.contains(&"另一篇".to_string()));
|
||
assert!(meta.links.contains(&"notes/b.md#小节".to_string()));
|
||
}
|
||
|
||
#[test]
|
||
fn resolve_link_uses_source_dir() {
|
||
let stems = std::collections::HashMap::new();
|
||
let (dst, kind) = resolve_link("notes/2026/a.md", "b", &stems);
|
||
assert_eq!(dst, "notes/2026/b.md");
|
||
assert_eq!(kind, "wiki");
|
||
let (dst, _) = resolve_link("notes/a.md", "../assets/x.png", &stems);
|
||
assert_eq!(dst, "assets/x.png.md");
|
||
let (dst, kind) = resolve_link("a.md", "https://example.com/x", &stems);
|
||
assert!(dst.is_empty());
|
||
assert_eq!(kind, "url");
|
||
}
|
||
|
||
#[test]
|
||
fn resolve_link_prefers_library_wide_stem() {
|
||
// Obsidian 的 wikilink 语义是全库按名查:`[[周会]]` 应当落到真实所在目录,
|
||
// 而不是被硬按「相对当前目录」猜错位置
|
||
let mut stems = std::collections::HashMap::new();
|
||
stems.insert("周会".to_string(), "archive/2025/周会.md".to_string());
|
||
let (dst, kind) = resolve_link("notes/today.md", "周会", &stems);
|
||
assert_eq!(dst, "archive/2025/周会.md");
|
||
assert_eq!(kind, "wiki");
|
||
}
|
||
|
||
#[test]
|
||
fn fts_query_neutralizes_operators() {
|
||
// 每个词都被包成短语,`-` `*` 这类操作符不会再被解释
|
||
assert_eq!(fts_query("a-b"), "\"a-b\"");
|
||
assert_eq!(fts_query("会议 纪要"), "\"会议\" \"纪要\"");
|
||
assert_eq!(fts_query("he said \"hi\""), "\"he\" \"said\" \"\"\"hi\"\"\"");
|
||
}
|
||
|
||
/// 端到端:真的建一个临时库,落盘 `.md`,同步索引,然后检索。
|
||
///
|
||
/// 覆盖的是「单测覆盖不到的那一层」:建表语句、触发器、FTS5 MATCH 语法、
|
||
/// trigram 中文子串匹配、标签 JOIN —— 这些只有真跑一次 SQLite 才能确认。
|
||
#[test]
|
||
fn index_roundtrip_search_tags_and_rebuild() {
|
||
let root = std::env::temp_dir().join(format!(
|
||
"thing-editor-index-test-{}",
|
||
std::process::id()
|
||
));
|
||
let _ = std::fs::remove_dir_all(&root);
|
||
std::fs::create_dir_all(root.join("notes")).unwrap();
|
||
std::fs::create_dir_all(root.join("assets")).unwrap();
|
||
|
||
std::fs::write(
|
||
root.join("notes/会议纪要.md"),
|
||
"---\ntitle: 周会纪要\ntags: [工作, 周会]\n---\n\n本周讨论了三件事,其中一件是检索。\n",
|
||
)
|
||
.unwrap();
|
||
std::fs::write(
|
||
root.join("notes/随手记.md"),
|
||
"# 随手记\n\n买牛奶。参见 [[会议纪要]] 与 [外链](https://example.com)。\n",
|
||
)
|
||
.unwrap();
|
||
// 非 .md 与点号目录都不该被索引
|
||
std::fs::write(root.join("notes/notes.txt"), "不该被索引").unwrap();
|
||
|
||
// 先打开索引(顺带创建 `.editor/` 目录),再往里塞一个「不该被索引」的 .md
|
||
let mut index = EditorIndex::open(&root).unwrap();
|
||
std::fs::write(root.join(".editor/ignored.md"), "也不该被索引").unwrap();
|
||
|
||
let report = index.sync().unwrap();
|
||
assert_eq!(report.indexed, 2, "只应索引两篇 .md");
|
||
assert_eq!(report.removed, 0);
|
||
|
||
// 第二次同步:没有任何变化 → 全部跳过
|
||
let again = index.sync().unwrap();
|
||
assert_eq!(again.indexed, 0);
|
||
assert_eq!(again.skipped, 2);
|
||
|
||
// 中文子串检索(trigram 的价值所在:「周会」要能命中「周会纪要」)
|
||
let page = index
|
||
.search(NoteSearchQuery {
|
||
keyword: "周会".to_string(),
|
||
..Default::default()
|
||
})
|
||
.unwrap();
|
||
assert_eq!(page.total, 1, "{:?}", page.items);
|
||
assert_eq!(page.items[0].title, "周会纪要");
|
||
// 2 字符关键词在 trigram 下**不命中 FTS**(3 字符下限),走 LIKE 回退;
|
||
// 片段由 Rust 侧 make_snippet 生成,同样带高亮定界符
|
||
assert!(
|
||
page.items[0].snippet.contains(HL_OPEN),
|
||
"短词命中也应有高亮片段: {:?}",
|
||
page.items[0].snippet
|
||
);
|
||
|
||
// 3 字符关键词走 FTS,片段由 snippet() 生成
|
||
let fts_page = index
|
||
.search(NoteSearchQuery {
|
||
keyword: "周会纪".to_string(),
|
||
..Default::default()
|
||
})
|
||
.unwrap();
|
||
assert_eq!(fts_page.total, 1);
|
||
assert!(
|
||
fts_page.items[0].snippet.contains(HL_OPEN),
|
||
"FTS 命中的片段应带高亮: {:?}",
|
||
fts_page.items[0].snippet
|
||
);
|
||
|
||
// 正文命中(关键词只出现在 body)
|
||
let body_hit = index
|
||
.search(NoteSearchQuery {
|
||
keyword: "检索".to_string(),
|
||
..Default::default()
|
||
})
|
||
.unwrap();
|
||
assert_eq!(body_hit.total, 1);
|
||
|
||
// 短词回退 LIKE(trigram 对 <3 字符静默返回空,必须走 LIKE)
|
||
let short = index
|
||
.search(NoteSearchQuery {
|
||
keyword: "牛奶".to_string(),
|
||
..Default::default()
|
||
})
|
||
.unwrap();
|
||
assert_eq!(short.total, 1, "两字关键词应能命中");
|
||
assert!(
|
||
short.items[0].snippet.contains(HL_OPEN) && short.items[0].snippet.contains("牛奶"),
|
||
"短词片段应包含关键词并带高亮: {:?}",
|
||
short.items[0].snippet
|
||
);
|
||
|
||
// 标签筛选
|
||
let tagged = index
|
||
.search(NoteSearchQuery {
|
||
tag: "工作".to_string(),
|
||
..Default::default()
|
||
})
|
||
.unwrap();
|
||
assert_eq!(tagged.total, 1);
|
||
let tag_names: Vec<String> = index.tags().unwrap().into_iter().map(|t| t.tag).collect();
|
||
assert!(tag_names.contains(&"工作".to_string()), "{tag_names:?}");
|
||
assert!(tag_names.contains(&"周会".to_string()), "{tag_names:?}");
|
||
|
||
// wikilink 解析:[[会议纪要]] 应解析到真实路径
|
||
let dst: String = index
|
||
.conn
|
||
.query_row(
|
||
"SELECT dst_path FROM links WHERE src_path LIKE '%随手记%' AND kind = 'wiki'",
|
||
[],
|
||
|row| row.get(0),
|
||
)
|
||
.unwrap();
|
||
assert_eq!(dst, "notes/会议纪要.md");
|
||
|
||
// 删除文件后同步 → 索引里也应消失(含标签清理)
|
||
std::fs::remove_file(root.join("notes/随手记.md")).unwrap();
|
||
let after_delete = index.sync().unwrap();
|
||
assert_eq!(after_delete.removed, 1);
|
||
assert_eq!(index.stats().unwrap().note_count, 1);
|
||
|
||
// 全量重建:索引数应与文件数一致
|
||
let rebuilt = index.rebuild().unwrap();
|
||
assert_eq!(rebuilt.indexed, 1);
|
||
let stats = index.stats().unwrap();
|
||
assert_eq!(stats.note_count, 1);
|
||
assert_eq!(stats.file_count, 1);
|
||
|
||
let _ = std::fs::remove_dir_all(&root);
|
||
}
|
||
|
||
/// 诊断用的探针已删除:它验证的结论是「trigram 下 2 字符关键词不命中 FTS」,
|
||
/// 该结论现已固化到 [`make_snippet`] 的存在理由里(短词回退 LIKE + 自建片段)。
|
||
|
||
/// front-matter 里的 `id` / `created` 也要进索引(P2 同步靠它做稳定标识)。
|
||
#[test]
|
||
fn front_matter_id_and_dates_are_indexed() {
|
||
let root = std::env::temp_dir().join(format!(
|
||
"thing-editor-index-fm-{}",
|
||
std::process::id()
|
||
));
|
||
let _ = std::fs::remove_dir_all(&root);
|
||
std::fs::create_dir_all(root.join("notes")).unwrap();
|
||
std::fs::write(
|
||
root.join("notes/a.md"),
|
||
"---\nid: 01J9Z8\ntitle: 标题\ncreated: 2026-09-30T10:00:00+08:00\nupdated: 2026-09-30T11:20:00+08:00\ntags: 单独\n---\n\n正文\n",
|
||
)
|
||
.unwrap();
|
||
|
||
let mut index = EditorIndex::open(&root).unwrap();
|
||
index.sync().unwrap();
|
||
let page = index
|
||
.search(NoteSearchQuery {
|
||
keyword: "标题".to_string(),
|
||
..Default::default()
|
||
})
|
||
.unwrap();
|
||
assert_eq!(page.items.len(), 1);
|
||
assert_eq!(page.items[0].id, "01J9Z8");
|
||
assert_eq!(page.items[0].tags, vec!["单独"]);
|
||
let _ = std::fs::remove_dir_all(&root);
|
||
}
|
||
}
|