feat(chat): implement search functionality for chat sessions

- Added search capability to the chat interface, allowing users to find sessions by title or message content.
- Integrated debounce logic for search input to enhance performance and user experience.
- Updated the sidebar to include a search input field and loading indicator during search operations.
- Implemented full-text search in the database for efficient session retrieval based on user queries.
- Enhanced session management by filtering out orphan sessions during search results.
This commit is contained in:
Evandro Fonseca Junior committed 2025-11-27 17:58:33 -03:00
1 parent 8c546f6474
commit 6a7eeaf7af
5 files changed
+589 -12

No files matched your search

+235
View File
@@ -108,6 +108,140 @@ impl Database {
[],
)?;
// Índice para ordenação por updated_at
self.conn.execute(
"CREATE INDEX IF NOT EXISTS idx_sessions_updated_at ON sessions(updated_at DESC)",
[],
)?;
// Inicializar FTS (Full-Text Search)
self.init_fts_schema()?;
Ok(())
}
/// Inicializa tabelas FTS5 para busca de texto completo
fn init_fts_schema(&self) -> SqliteResult<()> {
// Tabela FTS para títulos de sessões
self.conn.execute(
"CREATE VIRTUAL TABLE IF NOT EXISTS sessions_fts USING fts5(
id UNINDEXED,
title,
content='sessions',
content_rowid='rowid'
)",
[],
)?;
// Tabela FTS para conteúdo de mensagens
self.conn.execute(
"CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
session_id UNINDEXED,
content,
content='messages',
content_rowid='rowid'
)",
[],
)?;
// Triggers para manter FTS sincronizado com tabelas principais
self.create_fts_triggers()?;
// Popular tabelas FTS com dados existentes (se necessário)
self.populate_fts_tables()?;
Ok(())
}
/// Cria triggers para manter tabelas FTS sincronizadas
fn create_fts_triggers(&self) -> SqliteResult<()> {
// Trigger para inserir em sessions_fts quando nova sessão é criada
self.conn.execute(
"CREATE TRIGGER IF NOT EXISTS sessions_fts_insert AFTER INSERT ON sessions BEGIN
INSERT INTO sessions_fts(rowid, id, title) VALUES (new.rowid, new.id, new.title);
END",
[],
)?;
// Trigger para atualizar sessions_fts quando sessão é atualizada
self.conn.execute(
"CREATE TRIGGER IF NOT EXISTS sessions_fts_update AFTER UPDATE ON sessions BEGIN
INSERT INTO sessions_fts(sessions_fts, rowid, id, title) VALUES ('delete', old.rowid, old.id, old.title);
INSERT INTO sessions_fts(rowid, id, title) VALUES (new.rowid, new.id, new.title);
END",
[],
)?;
// Trigger para deletar de sessions_fts quando sessão é deletada
self.conn.execute(
"CREATE TRIGGER IF NOT EXISTS sessions_fts_delete AFTER DELETE ON sessions BEGIN
INSERT INTO sessions_fts(sessions_fts, rowid, id, title) VALUES ('delete', old.rowid, old.id, old.title);
END",
[],
)?;
// Trigger para inserir em messages_fts quando nova mensagem é criada
self.conn.execute(
"CREATE TRIGGER IF NOT EXISTS messages_fts_insert AFTER INSERT ON messages BEGIN
INSERT INTO messages_fts(rowid, session_id, content) VALUES (new.rowid, new.session_id, new.content);
END",
[],
)?;
// Trigger para atualizar messages_fts quando mensagem é atualizada
self.conn.execute(
"CREATE TRIGGER IF NOT EXISTS messages_fts_update AFTER UPDATE ON messages BEGIN
INSERT INTO messages_fts(messages_fts, rowid, session_id, content) VALUES ('delete', old.rowid, old.session_id, old.content);
INSERT INTO messages_fts(rowid, session_id, content) VALUES (new.rowid, new.session_id, new.content);
END",
[],
)?;
// Trigger para deletar de messages_fts quando mensagem é deletada
self.conn.execute(
"CREATE TRIGGER IF NOT EXISTS messages_fts_delete AFTER DELETE ON messages BEGIN
INSERT INTO messages_fts(messages_fts, rowid, session_id, content) VALUES ('delete', old.rowid, old.session_id, old.content);
END",
[],
)?;
Ok(())
}
/// Popula tabelas FTS com dados existentes
fn populate_fts_tables(&self) -> SqliteResult<()> {
// Verificar se sessions_fts já tem dados
let count: i64 = self.conn.query_row(
"SELECT COUNT(*) FROM sessions_fts",
[],
|row| row.get(0),
).unwrap_or(0);
// Se vazio, popular com dados existentes
if count == 0 {
self.conn.execute(
"INSERT INTO sessions_fts(rowid, id, title)
SELECT rowid, id, title FROM sessions",
[],
)?;
}
// Verificar se messages_fts já tem dados
let count: i64 = self.conn.query_row(
"SELECT COUNT(*) FROM messages_fts",
[],
|row| row.get(0),
).unwrap_or(0);
// Se vazio, popular com dados existentes
if count == 0 {
self.conn.execute(
"INSERT INTO messages_fts(rowid, session_id, content)
SELECT rowid, session_id, content FROM messages",
[],
)?;
}
Ok(())
}
@@ -172,6 +306,11 @@ impl Database {
}
}
/// Salva uma sessão (create ou update)
pub fn save_session(&self, session: &ChatSession) -> SqliteResult<()> {
self.create_session(session)
}
/// Lista todas as sessões ordenadas por updated_at DESC
pub fn list_sessions(&self) -> SqliteResult<Vec<ChatSession>> {
let mut stmt = self.conn.prepare(
@@ -304,5 +443,101 @@ impl Database {
}
Ok(docs)
}
/// Busca sessões por query (título ou conteúdo de mensagens)
/// Retorna resultados ordenados por relevância (match no título > match no conteúdo)
pub fn search_sessions(&self, query: &str, limit: usize) -> SqliteResult<Vec<ChatSession>> {
if query.trim().is_empty() {
// Se query vazia, retornar todas as sessões ordenadas por updated_at
return self.list_sessions();
}
// Escapar caracteres especiais para FTS5
let escaped_query = query.replace('"', "\"\"");
let fts_query = format!("\"{}\"", escaped_query);
// Busca combinada: título (peso 1.0) + conteúdo (peso 0.5)
let mut stmt = self.conn.prepare(
"WITH title_matches AS (
SELECT s.id, s.title, s.emoji, s.created_at, s.updated_at,
bm25(sessions_fts) as rank
FROM sessions s
JOIN sessions_fts ON s.rowid = sessions_fts.rowid
WHERE sessions_fts MATCH ?1
ORDER BY rank
LIMIT ?2
),
content_matches AS (
SELECT DISTINCT s.id, s.title, s.emoji, s.created_at, s.updated_at,
bm25(messages_fts) * 0.5 as rank
FROM sessions s
JOIN messages m ON s.id = m.session_id
JOIN messages_fts ON m.rowid = messages_fts.rowid
WHERE messages_fts MATCH ?1
ORDER BY rank
LIMIT ?2
)
SELECT id, title, emoji, created_at, updated_at
FROM (
SELECT * FROM title_matches
UNION
SELECT * FROM content_matches
)
ORDER BY rank DESC, updated_at DESC
LIMIT ?2"
)?;
let rows = stmt.query_map(params![fts_query, limit], |row| {
Ok(ChatSession {
id: row.get(0)?,
title: row.get(1)?,
emoji: row.get(2)?,
created_at: DateTime::parse_from_rfc3339(&row.get::<_, String>(3)?)
.map_err(|_| rusqlite::Error::InvalidColumnType(3, "TEXT".to_string(), rusqlite::types::Type::Text))?
.with_timezone(&Utc),
updated_at: DateTime::parse_from_rfc3339(&row.get::<_, String>(4)?)
.map_err(|_| rusqlite::Error::InvalidColumnType(4, "TEXT".to_string(), rusqlite::types::Type::Text))?
.with_timezone(&Utc),
})
})?;
let mut sessions = Vec::new();
for row in rows {
sessions.push(row?);
}
// Se não encontrou resultados com FTS, tentar busca simples com LIKE (fallback)
if sessions.is_empty() {
let mut stmt = self.conn.prepare(
"SELECT DISTINCT s.id, s.title, s.emoji, s.created_at, s.updated_at
FROM sessions s
LEFT JOIN messages m ON s.id = m.session_id
WHERE s.title LIKE ?1 OR m.content LIKE ?1
ORDER BY s.updated_at DESC
LIMIT ?2"
)?;
let like_query = format!("%{}%", query);
let rows = stmt.query_map(params![like_query, limit], |row| {
Ok(ChatSession {
id: row.get(0)?,
title: row.get(1)?,
emoji: row.get(2)?,
created_at: DateTime::parse_from_rfc3339(&row.get::<_, String>(3)?)
.map_err(|_| rusqlite::Error::InvalidColumnType(3, "TEXT".to_string(), rusqlite::types::Type::Text))?
.with_timezone(&Utc),
updated_at: DateTime::parse_from_rfc3339(&row.get::<_, String>(4)?)
.map_err(|_| rusqlite::Error::InvalidColumnType(4, "TEXT".to_string(), rusqlite::types::Type::Text))?
.with_timezone(&Utc),
})
})?;
for row in rows {
sessions.push(row?);
}
}
Ok(sessions)
}
}