Skip to main content

mneme/store/
db.rs

1use rusqlite::Connection;
2use std::path::Path;
3use std::sync::{Arc, Mutex};
4
5/// Conexión gestionada a la base de datos SQLite.
6#[derive(Debug, Clone)]
7pub struct Database {
8    conn: Arc<Mutex<Connection>>,
9    crypto: Option<Arc<Mutex<crate::crypto::CryptoEngine>>>,
10}
11
12impl Database {
13    /// Abre o crea la base de datos en la ruta indicada y aplica migraciones.
14    pub fn open(path: &Path) -> crate::error::Result<Self> {
15        let mut conn = Connection::open(path)?;
16
17        conn.pragma_update(None, "journal_mode", "WAL")?;
18        conn.pragma_update(None, "synchronous", "NORMAL")?;
19        conn.pragma_update(None, "foreign_keys", "ON")?;
20        conn.pragma_update(None, "cache_size", -64000)?;
21        conn.pragma_update(None, "temp_store", "MEMORY")?;
22        conn.pragma_update(None, "busy_timeout", 5000)?;
23
24        crate::store::migrations::run_migrations(&mut conn)?;
25
26        Ok(Self {
27            conn: Arc::new(Mutex::new(conn)),
28            crypto: None,
29        })
30    }
31
32    /// Asigna el motor de encriptación.
33    pub fn with_crypto(mut self, crypto: Arc<Mutex<crate::crypto::CryptoEngine>>) -> Self {
34        self.crypto = Some(crypto);
35        self
36    }
37
38    /// Retorna un store de memorias.
39    pub fn memories(&self) -> crate::store::memory::MemoryStore {
40        let store = crate::store::memory::MemoryStore::new(self.conn.clone());
41        match &self.crypto {
42            Some(crypto) => store.with_crypto(Arc::clone(crypto)),
43            None => store,
44        }
45    }
46
47    /// Retorna un store de sesiones.
48    pub fn sessions(&self) -> crate::store::memory::SessionStore {
49        crate::store::memory::SessionStore::new(self.conn.clone())
50    }
51
52    /// Retorna un store de embeddings.
53    pub fn embeddings(&self) -> crate::embeddings::store::EmbeddingStore {
54        crate::embeddings::store::EmbeddingStore::new(self.conn.clone())
55    }
56
57    /// Retorna un store de entidades extraídas.
58    pub fn entities(&self) -> crate::store::entities::EntityStore {
59        crate::store::entities::EntityStore::new(self.conn.clone())
60    }
61
62    /// Retorna un store de peers.
63    pub fn peers(&self) -> crate::sync::peer::PeerStore {
64        crate::sync::peer::PeerStore::new(self.conn.clone())
65    }
66
67    /// Retorna una copia del Arc de conexion.
68    pub fn get_conn(&self) -> Arc<Mutex<Connection>> {
69        self.conn.clone()
70    }
71
72    /// Ejecuta PRAGMA optimize para mejorar el rendimiento del query planner.
73    pub fn optimize(&self) -> crate::error::Result<()> {
74        let conn = self
75            .conn
76            .lock()
77            .map_err(|_| crate::error::MnemeError::Config("mutex poisoned".into()))?;
78        conn.execute("PRAGMA optimize", [])?;
79        Ok(())
80    }
81}