mod chunks;
mod compaction;
mod correct;
mod ddl;
mod ingest_window;
mod note_cover;
mod notes;
mod payload_redaction;
pub(crate) mod pool;
mod raw_sources;
mod rewrite;
mod sessions;
mod stored_redaction;
mod sync_apply;
#[cfg(any(test, feature = "test-support"))]
pub mod test_support;
mod transcript_backfill;
pub use chunks::{ChunkWork, MemoryChunk};
pub use compaction::VacuumSpace;
pub use correct::{CorrectRefusal, Corrected};
pub use ddl::{BASELINE_VERSION, SCHEMA_VERSION};
pub use ingest_window::IngestedSession;
pub use note_cover::NOTE_COVERED;
pub use notes::{AgentNote, NoteKind};
pub use pool::ReadDeadline;
pub use raw_sources::{ArchivedRaws, RawMemoryState};
pub use rewrite::RewriteOutcome;
pub use sessions::ActiveSession;
pub use stored_redaction::{KindCounts, RedactionPhase, RedactionReport, RedactionRun, SkippedRow};
use std::collections::HashSet;
use std::path::Path;
use std::sync::{Mutex, MutexGuard};
use anyhow::Result;
use chrono::{DateTime, Utc};
use rusqlite::{Connection, OptionalExtension, Row, Transaction, params};
use uuid::Uuid;
use crate::schema::{
Conversation, Distillation, Entity, Memory, MemoryType, Relation, RelationType, SyncNodeType,
SyncOp, Tier,
};
use crate::store::Store;
pub(crate) const MEMORY_COLS: &str = "id, content, context, memory_type, confidence, created_at, updated_at, \
last_accessed, access_count, source, source_id, project_path, machine_id, conversation_id, \
tier, archived_segment, superseded_by, retired_reason, session_at";
pub const TRAVERSE_MAX_RESULTS: usize = 50;
const TRAVERSE_MAX_WALK: i64 = 2000;
const DEDUP_TRIM_SET: &str = "char(9, 10, 11, 12, 13, 32, 133, 160, 5760, 8192, 8193, 8194, 8195, \
8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232, 8233, 8239, 8287, 12288)";
fn dedup_query(with_project: bool, excluding_source: bool) -> String {
let project = if with_project {
" AND +project_path = ?2"
} else {
""
};
let source = match (excluding_source, with_project) {
(false, _) => "",
(true, true) => " AND source <> ?3",
(true, false) => " AND source <> ?2",
};
format!(
"SELECT {MEMORY_COLS} FROM memories \
WHERE substr(lower(trim(content, {DEDUP_TRIM_SET})), 1, 128) = substr(?1, 1, 128) \
AND lower(trim(content, {DEDUP_TRIM_SET})) = ?1 \
AND tier = 'hot' AND superseded_by IS NULL{project}{source} \
ORDER BY rowid LIMIT 1"
)
}
pub struct SqliteStore {
writer: Mutex<Connection>,
readers: ReadBackend,
machine_id: String,
}
enum ReadBackend {
Pooled(pool::ReaderPool),
SameAsWriter,
}
#[allow(private_interfaces)]
pub(crate) enum ReaderGuard<'a> {
Pooled(pool::PooledConn<'a>),
Writer(MutexGuard<'a, Connection>),
}
impl std::ops::Deref for ReaderGuard<'_> {
type Target = Connection;
fn deref(&self) -> &Connection {
match self {
ReaderGuard::Pooled(p) => p,
ReaderGuard::Writer(g) => g,
}
}
}
impl SqliteStore {
pub fn open(path: &Path, machine_id: String) -> Result<Self> {
Self::open_with_pool_size(path, machine_id, pool::default_pool_size())
}
pub fn open_with_pool_size(
path: &Path,
machine_id: String,
reader_pool_size: usize,
) -> Result<Self> {
let writer = pool::open_connection(path)?;
ddl::init_schema(&writer)?;
let readers = pool::ReaderPool::open(path, reader_pool_size.max(1))?;
Ok(Self {
writer: Mutex::new(writer),
readers: ReadBackend::Pooled(readers),
machine_id,
})
}
pub fn in_memory(machine_id: String) -> Result<Self> {
let conn = Connection::open_in_memory()?;
ddl::init_schema(&conn)?;
Ok(Self {
writer: Mutex::new(conn),
readers: ReadBackend::SameAsWriter,
machine_id,
})
}
pub fn machine_id(&self) -> &str {
&self.machine_id
}
pub(crate) fn conn(&self) -> MutexGuard<'_, Connection> {
self.writer.lock().unwrap()
}
pub(crate) fn reader(&self) -> ReaderGuard<'_> {
match &self.readers {
ReadBackend::Pooled(pool) => ReaderGuard::Pooled(pool.checkout()),
ReadBackend::SameAsWriter => ReaderGuard::Writer(self.writer.lock().unwrap()),
}
}
pub(crate) fn with_txn<T>(&self, f: impl FnOnce(&Transaction<'_>) -> Result<T>) -> Result<T> {
let mut conn = self.conn();
let tx = conn.transaction()?;
let value = f(&tx)?;
tx.commit()?;
Ok(value)
}
pub fn tombstone_exists(&self, id: Uuid) -> Result<bool> {
let conn = self.reader();
let hit: Option<i64> = conn
.query_row(
"SELECT 1 FROM tombstones WHERE node_id = ?1",
params![id.to_string()],
|r| r.get(0),
)
.optional()?;
Ok(hit.is_some())
}
pub fn memory_content_exists(&self, content_prefix: &str) -> Result<bool> {
let conn = self.reader();
let hit: Option<i64> = conn
.query_row(
"SELECT 1 FROM memories WHERE substr(content, 1, length(?1)) = ?1 LIMIT 1",
params![content_prefix],
|r| r.get(0),
)
.optional()?;
Ok(hit.is_some())
}
pub fn max_sync_seq(&self) -> Result<u64> {
let conn = self.reader();
let max: i64 = conn.query_row(
"SELECT COALESCE(MAX(local_seq), 0) FROM sync_log",
[],
|r| r.get(0),
)?;
Ok(max as u64)
}
pub fn schema_version(&self) -> Result<i64> {
ddl::schema_version(&self.reader())
}
pub fn get_conversation(&self, id: Uuid) -> Result<Option<Conversation>> {
let conn = self.reader();
conn.query_row(
"SELECT id, source, machine_id, started_at, project_path FROM conversations WHERE id = ?1",
params![id.to_string()],
|r| {
Ok(Conversation {
id: parse_uuid(&r.get::<_, String>(0)?)?,
source: r.get(1)?,
machine_id: r.get(2)?,
started_at: parse_dt(&r.get::<_, String>(3)?)?,
project_path: r.get(4)?,
})
},
)
.optional()
.map_err(Into::into)
}
fn insert_memory(tx: &Transaction<'_>, memory: &Memory) -> Result<()> {
let embedding = if memory.embedding.is_empty() {
None
} else {
Some(embedding_to_blob(&memory.embedding))
};
tx.execute(
&format!(
"INSERT OR REPLACE INTO memories ({MEMORY_COLS}, embedding) \
VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?15,?16,?17,?18,?19,?20)"
),
params![
memory.id.to_string(),
memory.content,
memory.context,
memory_type_to_str(memory.memory_type),
memory.confidence as f64,
memory.created_at.to_rfc3339(),
memory.updated_at.to_rfc3339(),
memory.last_accessed.to_rfc3339(),
memory.access_count as i64,
memory.source,
memory.source_id,
memory.project_path,
memory.machine_id,
memory.conversation_id.map(|u| u.to_string()),
tier_to_str(memory.tier),
memory.archived_segment,
memory.superseded_by.map(|u| u.to_string()),
memory.retired_reason,
memory.session_at.map(|t| t.to_rfc3339()),
embedding,
],
)?;
Ok(())
}
pub(crate) fn append_outbox(tx: &Transaction<'_>, memory_id: Uuid, op: &str) -> Result<()> {
tx.execute(
"INSERT INTO index_outbox (memory_id, op) VALUES (?1, ?2)",
params![memory_id.to_string(), op],
)?;
Ok(())
}
fn tombstoned(tx: &Transaction<'_>, id: Uuid) -> Result<bool> {
Self::tombstone_row_exists(tx, &id.to_string())
}
fn tombstone_row_exists(tx: &Transaction<'_>, node_id: &str) -> Result<bool> {
let hit: Option<i64> = tx
.query_row(
"SELECT 1 FROM tombstones WHERE node_id = ?1",
params![node_id],
|r| r.get(0),
)
.optional()?;
Ok(hit.is_some())
}
fn upsert_tombstone(
tx: &Transaction<'_>,
node_id: &str,
node_type: &str,
machine_id: &str,
) -> Result<()> {
tx.execute(
"INSERT INTO tombstones (node_id, node_type, deleted_at, machine_id) VALUES (?1,?2,?3,?4) \
ON CONFLICT(node_id) DO UPDATE SET node_type = excluded.node_type, \
deleted_at = excluded.deleted_at, machine_id = excluded.machine_id",
params![node_id, node_type, Utc::now().to_rfc3339(), machine_id],
)?;
Ok(())
}
fn insert_distillation(tx: &Transaction<'_>, entry: &Distillation) -> Result<()> {
tx.execute(
"INSERT OR REPLACE INTO distillation_log \
(memory_id, distilled_id, distilled_at, model, status) VALUES (?1,?2,?3,?4,?5)",
params![
entry.memory_id.to_string(),
entry.distilled_id.map(|v| v.to_string()),
entry.distilled_at.map(|v| v.to_rfc3339()),
entry.model,
entry.status,
],
)?;
Ok(())
}
pub(crate) fn append_sync_log(
tx: &Transaction<'_>,
op: SyncOp,
node_type: SyncNodeType,
node_id: &str,
data: Option<&str>,
origin_machine_id: &str,
origin_seq: Option<i64>,
) -> Result<()> {
let local_seq: i64 = tx.query_row(
"SELECT COALESCE(MAX(local_seq), 0) + 1 FROM sync_log",
[],
|r| r.get(0),
)?;
let origin_seq = origin_seq.unwrap_or(local_seq);
let id = format!("{origin_machine_id}:{origin_seq}");
let duplicate: Option<i64> = tx
.query_row("SELECT 1 FROM sync_log WHERE id = ?1", params![id], |r| {
r.get(0)
})
.optional()?;
if duplicate.is_some() {
return Ok(());
}
tx.execute(
"INSERT INTO sync_log (id, local_seq, origin_machine_id, origin_seq, op, node_type, \
node_id, timestamp, data) VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9)",
params![
id,
local_seq,
origin_machine_id,
origin_seq,
sync_op_to_str(op),
sync_node_type_to_str(node_type),
node_id,
Utc::now().to_rfc3339(),
data,
],
)?;
Ok(())
}
}
impl SqliteStore {
pub(crate) fn store_memory_on_tx(&self, tx: &Transaction<'_>, memory: &Memory) -> Result<bool> {
if Self::tombstoned(tx, memory.id)? {
return Ok(false);
}
let data = serde_json::to_string(memory).ok();
Self::insert_memory(tx, memory)?;
Self::append_outbox(tx, memory.id, "upsert")?;
Self::append_sync_log(
tx,
SyncOp::Create,
SyncNodeType::Memory,
&memory.id.to_string(),
data.as_deref(),
&self.machine_id,
None,
)?;
Ok(true)
}
pub fn store_memory_if_absent(&self, memory: &Memory) -> Result<bool> {
self.with_txn(|tx| {
if Self::memory_on_tx(tx, memory.id)?.is_some() {
return Ok(false);
}
self.store_memory_on_tx(tx, memory)
})
}
pub(crate) fn delete_relation_on_tx(
&self,
tx: &Transaction<'_>,
relation: &Relation,
) -> Result<bool> {
let rel_type = relation_type_to_str(relation.relation_type);
let changed = tx.execute(
"DELETE FROM relations WHERE from_id = ?1 AND to_id = ?2 AND relation_type = ?3",
params![
relation.from_id.to_string(),
relation.to_id.to_string(),
rel_type,
],
)?;
if changed == 0 {
return Ok(false);
}
let node_id = format!("{}:{}:{}", relation.from_id, relation.to_id, rel_type);
let data = serde_json::to_string(relation).ok();
Self::append_sync_log(
tx,
SyncOp::Delete,
SyncNodeType::Relation,
&node_id,
data.as_deref(),
&self.machine_id,
None,
)?;
Ok(true)
}
pub(crate) fn store_entity_on_tx(
&self,
tx: &Transaction<'_>,
entity: &Entity,
op: SyncOp,
) -> Result<()> {
let data = serde_json::to_string(entity).ok();
let embedding = if entity.embedding.is_empty() {
None
} else {
Some(embedding_to_blob(&entity.embedding))
};
tx.execute(
"INSERT OR REPLACE INTO entities (id, name, entity_type, embedding, aliases) \
VALUES (?1,?2,?3,?4,?5)",
params![
entity.id.to_string(),
entity.name,
entity.entity_type,
embedding,
serde_json::to_string(&entity.aliases)?,
],
)?;
Self::append_sync_log(
tx,
op,
SyncNodeType::Entity,
&entity.id.to_string(),
data.as_deref(),
&self.machine_id,
None,
)
}
pub(crate) fn store_relation_on_tx(
&self,
tx: &Transaction<'_>,
relation: &Relation,
) -> Result<()> {
let rel_type = relation_type_to_str(relation.relation_type);
let node_id = format!("{}:{}:{}", relation.from_id, relation.to_id, rel_type);
let data = serde_json::to_string(relation).ok();
tx.execute(
"INSERT INTO relations (from_id, to_id, relation_type, strength, context, created_at) \
VALUES (?1,?2,?3,?4,?5,?6) \
ON CONFLICT(from_id, to_id, relation_type) DO UPDATE SET \
strength = excluded.strength, context = excluded.context",
params![
relation.from_id.to_string(),
relation.to_id.to_string(),
rel_type,
relation.strength as f64,
relation.context,
Utc::now().to_rfc3339(),
],
)?;
Self::append_sync_log(
tx,
SyncOp::Create,
SyncNodeType::Relation,
&node_id,
data.as_deref(),
&self.machine_id,
None,
)
}
}
impl Store for SqliteStore {
fn store_memory(&self, memory: &Memory) -> Result<()> {
self.with_txn(|tx| self.store_memory_on_tx(tx, memory).map(|_| ()))
}
fn get_memory(&self, id: Uuid) -> Result<Option<Memory>> {
let conn = self.reader();
conn.query_row(
&format!("SELECT {MEMORY_COLS} FROM memories WHERE id = ?1"),
params![id.to_string()],
|r| row_to_memory(r, false),
)
.optional()
.map_err(Into::into)
}
fn get_memory_with_embedding(&self, id: Uuid) -> Result<Option<Memory>> {
let conn = self.reader();
conn.query_row(
&format!("SELECT {MEMORY_COLS}, embedding FROM memories WHERE id = ?1"),
params![id.to_string()],
|r| row_to_memory(r, true),
)
.optional()
.map_err(Into::into)
}
fn delete_memory(&self, id: Uuid) -> Result<()> {
self.remove_memory(id).map(|_| ())
}
fn remove_memory(&self, id: Uuid) -> Result<bool> {
let id_string = id.to_string();
self.with_txn(|tx| {
let removed = tx.execute("DELETE FROM memories WHERE id = ?1", params![id_string])?;
if removed == 0 {
return Ok(false);
}
tx.execute(
"DELETE FROM relations WHERE from_id = ?1 OR to_id = ?1",
params![id_string],
)?;
Self::upsert_tombstone(tx, &id_string, "memory", &self.machine_id)?;
Self::append_outbox(tx, id, "delete")?;
Self::append_sync_log(
tx,
SyncOp::Delete,
SyncNodeType::Memory,
&id_string,
None,
&self.machine_id,
None,
)?;
Ok(true)
})
}
fn store_entity(&self, entity: &Entity) -> Result<()> {
self.with_txn(|tx| self.store_entity_on_tx(tx, entity, SyncOp::Create))
}
fn get_entity(&self, id: Uuid) -> Result<Option<Entity>> {
let conn = self.reader();
conn.query_row(
"SELECT id, name, entity_type, embedding, aliases FROM entities WHERE id = ?1",
params![id.to_string()],
row_to_entity,
)
.optional()
.map_err(Into::into)
}
fn find_entity_by_name(&self, name: &str) -> Result<Option<Entity>> {
let conn = self.reader();
conn.query_row(
"SELECT id, name, entity_type, embedding, aliases FROM entities WHERE name = ?1 LIMIT 1",
params![name],
row_to_entity,
)
.optional()
.map_err(Into::into)
}
fn store_conversation(&self, conversation: &Conversation) -> Result<()> {
let data = serde_json::to_string(conversation).ok();
self.with_txn(|tx| {
tx.execute(
"INSERT OR REPLACE INTO conversations (id, source, machine_id, started_at, project_path) \
VALUES (?1,?2,?3,?4,?5)",
params![
conversation.id.to_string(),
conversation.source,
conversation.machine_id,
conversation.started_at.to_rfc3339(),
conversation.project_path,
],
)?;
Self::append_sync_log(
tx,
SyncOp::Create,
SyncNodeType::Conversation,
&conversation.id.to_string(),
data.as_deref(),
&self.machine_id,
None,
)
})
}
fn store_relation(&self, relation: &Relation) -> Result<()> {
self.with_txn(|tx| self.store_relation_on_tx(tx, relation))
}
fn get_relations(
&self,
node_id: Uuid,
relation_type: Option<RelationType>,
) -> Result<Vec<Relation>> {
let conn = self.reader();
let collect = |sql: &str, p: &[&dyn rusqlite::ToSql]| -> Result<Vec<Relation>> {
let mut stmt = conn.prepare(sql)?;
let rows = stmt.query_map(p, |r| {
let to_id = parse_uuid(&r.get::<_, String>(0)?)?;
let rt = parse_relation_type(&r.get::<_, String>(1)?)?;
Ok(Relation {
from_id: node_id,
to_id,
relation_type: rt,
strength: 1.0,
context: None,
})
})?;
Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)
};
match relation_type {
Some(rt) => collect(
"SELECT to_id, relation_type FROM relations WHERE from_id = ?1 AND relation_type = ?2",
&[&node_id.to_string(), &relation_type_to_str(rt)],
),
None => collect(
"SELECT to_id, relation_type FROM relations WHERE from_id = ?1",
&[&node_id.to_string()],
),
}
}
fn vector_search(&self, embedding: &[f32], limit: usize) -> Result<Vec<(Memory, f32)>> {
let conn = self.reader();
let mut stmt = conn.prepare(&format!(
"SELECT {MEMORY_COLS}, embedding FROM memories \
WHERE embedding IS NOT NULL AND tier = 'hot' AND superseded_by IS NULL"
))?;
let rows = stmt.query_map([], |r| row_to_memory(r, true))?;
let mut scored: Vec<(Memory, f32)> = Vec::new();
for row in rows {
let mut memory = row?;
let similarity = cosine(embedding, &memory.embedding);
memory.embedding = Vec::new();
scored.push((memory, similarity));
}
scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
scored.truncate(limit);
Ok(scored)
}
fn filtered_vector_search(
&self,
embedding: &[f32],
source: Option<&str>,
memory_type: Option<MemoryType>,
project_path: Option<&str>,
limit: usize,
) -> Result<Vec<(Memory, f32)>> {
if limit == 0 {
return Ok(Vec::new());
}
let (predicate, args) = Self::scope_predicate(source, memory_type, project_path);
let mut top: Vec<(f32, Uuid)> = Vec::with_capacity(limit + 1);
{
let conn = self.reader();
let mut stmt = conn.prepare(&format!(
"SELECT id, embedding FROM memories \
WHERE embedding IS NOT NULL AND tier = 'hot' AND superseded_by IS NULL{predicate}"
))?;
let bound: Vec<&dyn rusqlite::ToSql> =
args.iter().map(|a| a as &dyn rusqlite::ToSql).collect();
let query_norm = embedding.iter().map(|x| x * x).sum::<f32>().sqrt();
let mut rows = stmt.query(bound.as_slice())?;
let mut floor = f32::NEG_INFINITY;
while let Some(row) = rows.next()? {
let Some(blob) = row.get_ref(1)?.as_blob_or_null()? else {
continue;
};
let similarity = cosine_blob(embedding, query_norm, blob);
if top.len() == limit && similarity <= floor {
continue;
}
let id = parse_uuid(row.get_ref(0)?.as_str()?)?;
let at = top.partition_point(|(s, _)| *s >= similarity);
top.insert(at, (similarity, id));
top.truncate(limit);
if top.len() == limit {
floor = top[limit - 1].0;
}
}
}
let mut out = Vec::with_capacity(top.len());
for (similarity, id) in top {
if let Some(memory) = self.get_memory(id)? {
out.push((memory, similarity));
}
}
Ok(out)
}
fn traverse(&self, start_id: Uuid, depth: u32) -> Result<Vec<(Memory, Vec<Relation>)>> {
let conn = self.reader();
let mut stmt = conn.prepare(&format!(
"WITH RECURSIVE walk(id, d) AS ( \
SELECT ?1, 0 \
UNION \
SELECT r.to_id, w.d + 1 FROM walk w \
JOIN relations r ON r.from_id = w.id \
WHERE w.d < ?2 AND r.relation_type <> 'mentions' \
UNION \
SELECT r.from_id, w.d + 1 FROM walk w \
JOIN relations r ON r.to_id = w.id \
WHERE w.d < ?2 AND r.relation_type <> 'mentions' \
UNION \
SELECT peer.from_id, w.d + 1 FROM walk w \
JOIN relations own ON own.from_id = w.id AND own.relation_type = 'mentions' \
JOIN relations peer ON peer.to_id = own.to_id AND peer.relation_type = 'mentions' \
WHERE w.d < ?2 \
UNION \
SELECT peer.id, w.d + 1 FROM walk w \
JOIN memories own ON own.id = w.id \
JOIN memories peer ON peer.conversation_id = own.conversation_id \
WHERE w.d < ?2 AND own.conversation_id IS NOT NULL \
LIMIT ?3 \
) \
SELECT {MEMORY_COLS} FROM memories \
WHERE id IN (SELECT id FROM walk WHERE d > 0) AND id <> ?1 \
AND tier = 'hot' AND superseded_by IS NULL \
ORDER BY created_at DESC LIMIT ?4"
))?;
let rows = stmt.query_map(
params![
start_id.to_string(),
depth as i64,
TRAVERSE_MAX_WALK,
TRAVERSE_MAX_RESULTS as i64
],
|r| row_to_memory(r, false),
)?;
let mut results = Vec::new();
for row in rows {
results.push((row?, Vec::new()));
}
Ok(results)
}
fn memories_by_source(&self, source: &str) -> Result<Vec<Memory>> {
self.memories_where("source = ?1", params![source])
}
fn source_admits(&self, memory: &Memory, source: &str) -> Result<bool> {
if memory.source == source {
return Ok(true);
}
let conn = self.reader();
let descends: bool = conn.query_row(
&format!(
"SELECT EXISTS (SELECT 1 FROM ({}) d WHERE d.distilled_id = ?)",
Self::DISTILLED_FROM_SOURCE
),
params![source, memory.id.to_string()],
|r| r.get(0),
)?;
Ok(descends)
}
fn memories_by_type(&self, memory_type: MemoryType) -> Result<Vec<Memory>> {
self.memories_where("memory_type = ?1", params![memory_type_to_str(memory_type)])
}
fn chunk_window(&self, memory_id: Uuid, ord: usize) -> Result<Option<String>> {
self.chunk_window_text(memory_id, ord)
}
fn update_memory(&self, memory: &Memory) -> Result<()> {
let data = serde_json::to_string(memory).ok();
self.with_txn(|tx| {
tx.execute(
"UPDATE memories SET confidence = ?2, last_accessed = ?3, access_count = ?4, \
project_path = ?5, updated_at = ?6, machine_id = ?7 WHERE id = ?1",
params![
memory.id.to_string(),
memory.confidence as f64,
memory.last_accessed.to_rfc3339(),
memory.access_count as i64,
memory.project_path,
memory.updated_at.to_rfc3339(),
memory.machine_id,
],
)?;
Self::append_outbox(tx, memory.id, "upsert")?;
Self::append_sync_log(
tx,
SyncOp::Update,
SyncNodeType::Memory,
&memory.id.to_string(),
data.as_deref(),
&self.machine_id,
None,
)
})
}
fn record_access(&self, memory: &Memory) -> Result<()> {
let conn = self.conn();
conn.execute(
"UPDATE memories SET last_accessed = ?2, access_count = ?3, confidence = ?4 WHERE id = ?1",
params![
memory.id.to_string(),
memory.last_accessed.to_rfc3339(),
memory.access_count as i64,
memory.confidence as f64,
],
)?;
Ok(())
}
fn record_accesses(&self, ids: &[Uuid]) -> Result<()> {
if ids.is_empty() {
return Ok(());
}
let now = Utc::now().to_rfc3339();
self.with_txn(|tx| {
let mut stmt = tx.prepare_cached(
"UPDATE memories SET last_accessed = ?2, access_count = access_count + 1 \
WHERE id = ?1",
)?;
for id in ids {
stmt.execute(params![id.to_string(), now])?;
}
Ok(())
})
}
fn bm25_search(&self, query: &str, limit: usize) -> Result<Vec<Memory>> {
self.scoped_text_search(query, None, None, None, limit)
}
fn memory_count(&self) -> Result<usize> {
let conn = self.reader();
let count: i64 = conn.query_row("SELECT COUNT(*) FROM memories", [], |r| r.get(0))?;
Ok(count as usize)
}
fn all_memory_ids(&self) -> Result<Vec<Uuid>> {
let conn = self.reader();
let mut stmt = conn.prepare("SELECT id FROM memories")?;
let rows = stmt.query_map([], |r| parse_uuid(&r.get::<_, String>(0)?))?;
Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)
}
fn all_relations(&self) -> Result<Vec<Relation>> {
let conn = self.reader();
let mut stmt = conn.prepare("SELECT from_id, to_id, relation_type FROM relations")?;
let rows = stmt.query_map([], |r| {
Ok(Relation {
from_id: parse_uuid(&r.get::<_, String>(0)?)?,
to_id: parse_uuid(&r.get::<_, String>(1)?)?,
relation_type: parse_relation_type(&r.get::<_, String>(2)?)?,
strength: 1.0,
context: None,
})
})?;
Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)
}
}
impl SqliteStore {
fn memories_where(&self, predicate: &str, p: impl rusqlite::Params) -> Result<Vec<Memory>> {
let conn = self.reader();
let mut stmt = conn.prepare(&format!(
"SELECT {MEMORY_COLS} FROM memories WHERE {predicate}"
))?;
let rows = stmt.query_map(p, |r| row_to_memory(r, false))?;
Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)
}
}
pub(crate) fn embedding_to_blob(embedding: &[f32]) -> Vec<u8> {
embedding.iter().flat_map(|f| f.to_le_bytes()).collect()
}
pub(crate) fn cosine_blob(query: &[f32], query_norm: f32, blob: &[u8]) -> f32 {
let mut dot = 0.0_f32;
let mut norm = 0.0_f32;
for (i, chunk) in blob.as_chunks::<4>().0.iter().enumerate() {
let y = f32::from_le_bytes(*chunk);
norm += y * y;
if let Some(x) = query.get(i) {
dot += x * y;
}
}
let norm = norm.sqrt();
if query_norm == 0.0 || norm == 0.0 {
return 0.0;
}
dot / (query_norm * norm)
}
pub(crate) fn blob_to_embedding(blob: &[u8]) -> Vec<f32> {
blob.as_chunks::<4>()
.0
.iter()
.map(|c| f32::from_le_bytes(*c))
.collect()
}
fn cosine(a: &[f32], b: &[f32]) -> f32 {
let dot: f32 = a.iter().zip(b).map(|(x, y)| x * y).sum();
let na: f32 = a.iter().map(|x| x * x).sum::<f32>().sqrt();
let nb: f32 = b.iter().map(|x| x * x).sum::<f32>().sqrt();
if na == 0.0 || nb == 0.0 {
return 0.0;
}
dot / (na * nb)
}
fn conversion_err(err: impl std::error::Error + Send + Sync + 'static) -> rusqlite::Error {
rusqlite::Error::FromSqlConversionFailure(0, rusqlite::types::Type::Text, Box::new(err))
}
pub(crate) fn parse_dt(s: &str) -> rusqlite::Result<DateTime<Utc>> {
DateTime::parse_from_rfc3339(s)
.map(|d| d.with_timezone(&Utc))
.map_err(conversion_err)
}
pub(crate) fn parse_uuid(s: &str) -> rusqlite::Result<Uuid> {
Uuid::parse_str(s).map_err(conversion_err)
}
fn memory_type_to_str(t: MemoryType) -> &'static str {
match t {
MemoryType::Episodic => "episodic",
MemoryType::Semantic => "semantic",
MemoryType::Procedural => "procedural",
MemoryType::Decision => "decision",
MemoryType::Architecture => "architecture",
MemoryType::Debugging => "debugging",
MemoryType::Task => "task",
MemoryType::Question => "question",
}
}
fn parse_memory_type(s: &str) -> rusqlite::Result<MemoryType> {
match s {
"episodic" => Ok(MemoryType::Episodic),
"semantic" => Ok(MemoryType::Semantic),
"procedural" => Ok(MemoryType::Procedural),
"decision" => Ok(MemoryType::Decision),
"architecture" => Ok(MemoryType::Architecture),
"debugging" => Ok(MemoryType::Debugging),
"task" => Ok(MemoryType::Task),
"question" => Ok(MemoryType::Question),
other => Err(conversion_err(std::io::Error::other(format!(
"unknown memory_type: {other}"
)))),
}
}
fn relation_type_to_str(t: RelationType) -> &'static str {
match t {
RelationType::RelatesTo => "relates_to",
RelationType::Mentions => "mentions",
RelationType::DerivedFrom => "derived_from",
RelationType::Contradicts => "contradicts",
RelationType::Reinforces => "reinforces",
RelationType::Supersedes => "supersedes",
RelationType::DistilledFrom => "distilled_from",
}
}
fn parse_relation_type(s: &str) -> rusqlite::Result<RelationType> {
match s {
"relates_to" => Ok(RelationType::RelatesTo),
"mentions" => Ok(RelationType::Mentions),
"derived_from" => Ok(RelationType::DerivedFrom),
"contradicts" => Ok(RelationType::Contradicts),
"reinforces" => Ok(RelationType::Reinforces),
"supersedes" => Ok(RelationType::Supersedes),
"distilled_from" => Ok(RelationType::DistilledFrom),
other => Err(conversion_err(std::io::Error::other(format!(
"unknown relation_type: {other}"
)))),
}
}
fn tier_to_str(t: Tier) -> &'static str {
match t {
Tier::Hot => "hot",
Tier::Archived => "archived",
}
}
fn parse_tier(s: &str) -> rusqlite::Result<Tier> {
match s {
"hot" => Ok(Tier::Hot),
"archived" => Ok(Tier::Archived),
other => Err(conversion_err(std::io::Error::other(format!(
"unknown tier: {other}"
)))),
}
}
fn sync_op_to_str(op: SyncOp) -> &'static str {
match op {
SyncOp::Create => "create",
SyncOp::Update => "update",
SyncOp::Delete => "delete",
}
}
fn sync_node_type_to_str(t: SyncNodeType) -> &'static str {
match t {
SyncNodeType::Memory => "memory",
SyncNodeType::Entity => "entity",
SyncNodeType::Conversation => "conversation",
SyncNodeType::Relation => "relation",
SyncNodeType::Distillation => "distillation",
}
}
pub(crate) fn row_to_memory(r: &Row<'_>, with_embedding: bool) -> rusqlite::Result<Memory> {
let embedding = if with_embedding {
r.get::<_, Option<Vec<u8>>>(19)?
.map(|b| blob_to_embedding(&b))
.unwrap_or_default()
} else {
Vec::new()
};
Ok(Memory {
id: parse_uuid(&r.get::<_, String>(0)?)?,
content: r.get(1)?,
context: r.get(2)?,
embedding,
memory_type: parse_memory_type(&r.get::<_, String>(3)?)?,
confidence: r.get::<_, f64>(4)? as f32,
created_at: parse_dt(&r.get::<_, String>(5)?)?,
updated_at: parse_dt(&r.get::<_, String>(6)?)?,
last_accessed: parse_dt(&r.get::<_, String>(7)?)?,
access_count: r.get::<_, i64>(8)? as u32,
source: r.get(9)?,
source_id: r.get(10)?,
project_path: r.get(11)?,
machine_id: r.get(12)?,
conversation_id: r
.get::<_, Option<String>>(13)?
.map(|s| parse_uuid(&s))
.transpose()?,
tier: parse_tier(&r.get::<_, String>(14)?)?,
archived_segment: r.get(15)?,
superseded_by: r
.get::<_, Option<String>>(16)?
.map(|s| parse_uuid(&s))
.transpose()?,
retired_reason: r.get(17)?,
session_at: r
.get::<_, Option<String>>(18)?
.map(|s| parse_dt(&s))
.transpose()?,
})
}
fn row_to_entity(r: &Row<'_>) -> rusqlite::Result<Entity> {
Ok(Entity {
id: parse_uuid(&r.get::<_, String>(0)?)?,
name: r.get(1)?,
entity_type: r.get(2)?,
embedding: r
.get::<_, Option<Vec<u8>>>(3)?
.map(|b| blob_to_embedding(&b))
.unwrap_or_default(),
aliases: serde_json::from_str(&r.get::<_, String>(4)?).map_err(conversion_err)?,
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RetireOutcome {
Retired,
AlreadyRetired,
NotFound,
}
pub struct IndexableMemory {
pub embedding: Vec<f32>,
pub body: String,
pub hot: bool,
pub content_hash: String,
}
pub struct OutboxRow {
pub seq: i64,
pub memory_id: Uuid,
pub op: String,
}
pub(crate) fn body_of(context: Option<String>, content: String) -> String {
match context {
Some(c) if !c.is_empty() => format!("{c}\n{content}"),
_ => content,
}
}
impl SqliteStore {
pub fn index_watermark(&self) -> Result<i64> {
let conn = self.reader();
let value: Option<String> = conn
.query_row(
"SELECT value FROM index_meta WHERE key = 'watermark'",
[],
|r| r.get(0),
)
.optional()?;
Ok(value.and_then(|v| v.parse().ok()).unwrap_or(0))
}
pub fn set_index_watermark(&self, seq: i64) -> Result<()> {
let conn = self.conn();
conn.execute(
"INSERT OR REPLACE INTO index_meta (key, value) VALUES ('watermark', ?1)",
params![seq.to_string()],
)?;
Ok(())
}
pub fn outbox_after(&self, seq: i64) -> Result<Vec<OutboxRow>> {
let conn = self.reader();
let mut stmt = conn
.prepare("SELECT seq, memory_id, op FROM index_outbox WHERE seq > ?1 ORDER BY seq")?;
let rows = stmt.query_map(params![seq], |r| {
Ok(OutboxRow {
seq: r.get(0)?,
memory_id: parse_uuid(&r.get::<_, String>(1)?)?,
op: r.get(2)?,
})
})?;
Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)
}
pub fn prune_outbox(&self, upto: i64) -> Result<()> {
let conn = self.conn();
conn.execute("DELETE FROM index_outbox WHERE seq <= ?1", params![upto])?;
Ok(())
}
pub fn max_outbox_seq(&self) -> Result<i64> {
let conn = self.reader();
Ok(
conn.query_row("SELECT COALESCE(MAX(seq), 0) FROM index_outbox", [], |r| {
r.get(0)
})?,
)
}
pub fn vec_key(&self, memory_id: Uuid) -> Result<u64> {
let conn = self.conn();
conn.execute(
"INSERT OR IGNORE INTO vec_keys (memory_id) VALUES (?1)",
params![memory_id.to_string()],
)?;
let key: i64 = conn.query_row(
"SELECT key FROM vec_keys WHERE memory_id = ?1",
params![memory_id.to_string()],
|r| r.get(0),
)?;
Ok(key as u64)
}
pub fn existing_vec_key(&self, memory_id: Uuid) -> Result<Option<u64>> {
let conn = self.reader();
let key: Option<i64> = conn
.query_row(
"SELECT key FROM vec_keys WHERE memory_id = ?1",
params![memory_id.to_string()],
|r| r.get(0),
)
.optional()?;
Ok(key.map(|k| k as u64))
}
pub fn delete_vec_key(&self, memory_id: Uuid) -> Result<()> {
let conn = self.conn();
conn.execute(
"DELETE FROM vec_keys WHERE memory_id = ?1",
params![memory_id.to_string()],
)?;
Ok(())
}
pub fn find_exact_duplicate(
&self,
content: &str,
project_path: Option<&str>,
) -> Result<Option<Memory>> {
self.exact_duplicate(content, project_path, None)
}
pub fn find_exact_duplicate_outside_source(
&self,
content: &str,
project_path: Option<&str>,
source: &str,
) -> Result<Option<Memory>> {
self.exact_duplicate(content, project_path, Some(source))
}
fn exact_duplicate(
&self,
content: &str,
project_path: Option<&str>,
excluded_source: Option<&str>,
) -> Result<Option<Memory>> {
let key = content.trim().to_lowercase();
let conn = self.reader();
let mut stmt = conn.prepare(&dedup_query(
project_path.is_some(),
excluded_source.is_some(),
))?;
let mut bound: Vec<&dyn rusqlite::ToSql> = vec![&key];
if let Some(p) = project_path.as_ref() {
bound.push(p);
}
if let Some(s) = excluded_source.as_ref() {
bound.push(s);
}
let found = stmt
.query_row(bound.as_slice(), |r| row_to_memory(r, false))
.optional()?;
Ok(found)
}
const DISTILLED_FROM_SOURCE: &str = "SELECT dl.distilled_id FROM distillation_log dl JOIN memories raw ON raw.id = dl.memory_id WHERE raw.source = ?";
pub(crate) fn scope_predicate(
source: Option<&str>,
memory_type: Option<MemoryType>,
project_path: Option<&str>,
) -> (String, Vec<String>) {
let mut predicate = String::new();
let mut args = Vec::new();
if let Some(s) = source {
predicate.push_str(&format!(
" AND (source = ? OR id IN ({}))",
Self::DISTILLED_FROM_SOURCE
));
args.push(s.to_string());
args.push(s.to_string());
}
if let Some(t) = memory_type {
predicate.push_str(" AND memory_type = ?");
args.push(memory_type_to_str(t).to_string());
}
if let Some(p) = project_path {
predicate.push_str(" AND project_path = ?");
args.push(p.to_string());
}
(predicate, args)
}
pub fn scoped_text_search(
&self,
query: &str,
source: Option<&str>,
memory_type: Option<MemoryType>,
project_path: Option<&str>,
limit: usize,
) -> Result<Vec<Memory>> {
let (predicate, args) = Self::scope_predicate(source, memory_type, project_path);
let needle = query.to_lowercase();
let limit = limit as i64;
let bound: Vec<&dyn rusqlite::ToSql> = std::iter::once(&needle as &dyn rusqlite::ToSql)
.chain(args.iter().map(|a| a as &dyn rusqlite::ToSql))
.chain(std::iter::once(&limit as &dyn rusqlite::ToSql))
.collect();
let conn = self.reader();
let mut stmt = conn.prepare(&format!(
"SELECT {MEMORY_COLS} FROM memories \
WHERE instr(lower(content), ?) > 0 AND tier = 'hot' AND superseded_by IS NULL\
{predicate} ORDER BY created_at DESC LIMIT ?"
))?;
let rows = stmt.query_map(bound.as_slice(), |r| row_to_memory(r, false))?;
Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)
}
pub fn scoped_count(
&self,
source: Option<&str>,
memory_type: Option<MemoryType>,
project_path: Option<&str>,
) -> Result<usize> {
let (predicate, args) = Self::scope_predicate(source, memory_type, project_path);
let conn = self.reader();
let bound: Vec<&dyn rusqlite::ToSql> =
args.iter().map(|a| a as &dyn rusqlite::ToSql).collect();
let count: i64 = conn.query_row(
&format!(
"SELECT COUNT(*) FROM memories \
WHERE tier = 'hot' AND superseded_by IS NULL{predicate}"
),
bound.as_slice(),
|r| r.get(0),
)?;
Ok(count as usize)
}
pub fn retain_in_scope(
&self,
ids: &[Uuid],
source: Option<&str>,
memory_type: Option<MemoryType>,
project_path: Option<&str>,
) -> Result<HashSet<Uuid>> {
const BATCH: usize = 400;
let (predicate, args) = Self::scope_predicate(source, memory_type, project_path);
let mut kept = HashSet::new();
let conn = self.reader();
for chunk in ids.chunks(BATCH) {
let holes = std::iter::repeat_n("?", chunk.len())
.collect::<Vec<_>>()
.join(",");
let mut stmt = conn.prepare(&format!(
"SELECT id FROM memories \
WHERE tier = 'hot' AND superseded_by IS NULL{predicate} AND id IN ({holes})"
))?;
let texts: Vec<String> = chunk.iter().map(|id| id.to_string()).collect();
let bound: Vec<&dyn rusqlite::ToSql> = args
.iter()
.map(|a| a as &dyn rusqlite::ToSql)
.chain(texts.iter().map(|t| t as &dyn rusqlite::ToSql))
.collect();
let rows = stmt.query_map(bound.as_slice(), |r| parse_uuid(&r.get::<_, String>(0)?))?;
for id in rows {
kept.insert(id?);
}
}
Ok(kept)
}
pub fn memory_id_for_vec_key(&self, key: u64) -> Result<Option<Uuid>> {
let conn = self.reader();
let id: Option<String> = conn
.query_row(
"SELECT memory_id FROM vec_keys WHERE key = ?1",
params![key as i64],
|r| r.get(0),
)
.optional()?;
Ok(id.as_deref().map(Uuid::parse_str).transpose()?)
}
pub fn memory_for_indexing(&self, memory_id: Uuid) -> Result<Option<IndexableMemory>> {
let conn = self.reader();
conn.query_row(
"SELECT content, context, embedding, tier, superseded_by FROM memories WHERE id = ?1",
params![memory_id.to_string()],
|r| {
let content: String = r.get(0)?;
let context: Option<String> = r.get(1)?;
let embedding = r
.get::<_, Option<Vec<u8>>>(2)?
.map(|b| blob_to_embedding(&b))
.unwrap_or_default();
let tier: String = r.get(3)?;
let superseded_by: Option<String> = r.get(4)?;
Ok(IndexableMemory {
embedding,
content_hash: crate::chunk::content_hash(&content),
body: body_of(context, content),
hot: tier == "hot" && superseded_by.is_none(),
})
},
)
.optional()
.map_err(Into::into)
}
pub fn all_indexable(&self) -> Result<Vec<(Uuid, Vec<f32>, String)>> {
let conn = self.reader();
let mut stmt = conn.prepare(
"SELECT id, content, context, embedding FROM memories \
WHERE tier = 'hot' AND superseded_by IS NULL",
)?;
let rows = stmt.query_map([], |r| {
let id = parse_uuid(&r.get::<_, String>(0)?)?;
let content: String = r.get(1)?;
let context: Option<String> = r.get(2)?;
let embedding = r
.get::<_, Option<Vec<u8>>>(3)?
.map(|b| blob_to_embedding(&b))
.unwrap_or_default();
Ok((id, embedding, body_of(context, content)))
})?;
Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)
}
pub fn vector_indexable_count(&self, dim: usize) -> Result<usize> {
let conn = self.reader();
let count: i64 = conn.query_row(
"SELECT COUNT(*) FROM memories WHERE tier = 'hot' AND superseded_by IS NULL \
AND embedding IS NOT NULL AND length(embedding) = ?1",
params![(dim * 4) as i64],
|r| r.get(0),
)?;
Ok(count as usize)
}
pub fn indexable_count(&self) -> Result<usize> {
let conn = self.reader();
let count: i64 = conn.query_row(
"SELECT COUNT(*) FROM memories WHERE tier = 'hot' AND superseded_by IS NULL",
[],
|r| r.get(0),
)?;
Ok(count as usize)
}
pub(crate) fn memory_on_tx(tx: &Transaction<'_>, id: Uuid) -> Result<Option<Memory>> {
tx.query_row(
&format!("SELECT {MEMORY_COLS}, embedding FROM memories WHERE id = ?1"),
params![id.to_string()],
|r| row_to_memory(r, true),
)
.optional()
.map_err(Into::into)
}
pub(crate) fn log_memory_update(&self, tx: &Transaction<'_>, memory: &Memory) -> Result<()> {
let data = serde_json::to_string(memory)?;
Self::append_sync_log(
tx,
SyncOp::Update,
SyncNodeType::Memory,
&memory.id.to_string(),
Some(&data),
&self.machine_id,
None,
)
}
pub fn supersede_memory(&self, memory_id: Uuid, by: Uuid) -> Result<()> {
self.with_txn(|tx| self.supersede_on_tx(tx, memory_id, by).map(|_| ()))
}
pub(crate) fn supersede_on_tx(
&self,
tx: &Transaction<'_>,
memory_id: Uuid,
by: Uuid,
) -> Result<bool> {
let changed = tx.execute(
"UPDATE memories SET superseded_by = ?2, updated_at = ?3 \
WHERE id = ?1 AND superseded_by IS NULL",
params![
memory_id.to_string(),
by.to_string(),
Utc::now().to_rfc3339()
],
)?;
if changed == 0 {
return Ok(false);
}
Self::append_outbox(tx, memory_id, "upsert")?;
if let Some(memory) = Self::memory_on_tx(tx, memory_id)? {
self.log_memory_update(tx, &memory)?;
}
Ok(true)
}
pub fn archive_memory(&self, memory_id: Uuid) -> Result<()> {
self.with_txn(|tx| self.archive_on_tx(tx, memory_id).map(|_| ()))
}
pub(crate) fn archive_on_tx(&self, tx: &Transaction<'_>, memory_id: Uuid) -> Result<bool> {
let changed = tx.execute(
"UPDATE memories SET tier = 'archived', updated_at = ?2 \
WHERE id = ?1 AND tier <> 'archived'",
params![memory_id.to_string(), Utc::now().to_rfc3339()],
)?;
if changed == 0 {
return Ok(false);
}
Self::append_outbox(tx, memory_id, "delete")?;
if let Some(memory) = Self::memory_on_tx(tx, memory_id)? {
self.log_memory_update(tx, &memory)?;
}
Ok(true)
}
pub fn retire_memory(&self, memory_id: Uuid, reason: &str) -> Result<RetireOutcome> {
self.with_txn(|tx| {
let changed = tx.execute(
"UPDATE memories SET tier = 'archived', retired_reason = ?2, updated_at = ?3 \
WHERE id = ?1 AND retired_reason IS NULL",
params![memory_id.to_string(), reason, Utc::now().to_rfc3339()],
)?;
if changed == 0 {
return Ok(match Self::memory_on_tx(tx, memory_id)? {
Some(_) => RetireOutcome::AlreadyRetired,
None => RetireOutcome::NotFound,
});
}
Self::append_outbox(tx, memory_id, "delete")?;
if let Some(memory) = Self::memory_on_tx(tx, memory_id)? {
self.log_memory_update(tx, &memory)?;
}
Ok(RetireOutcome::Retired)
})
}
pub fn mark_archived(&self, memory_id: Uuid, segment: &str) -> Result<()> {
self.with_txn(|tx| {
tx.execute(
"UPDATE memories SET tier = 'archived', archived_segment = ?2, \
embedding = NULL, content = substr(content, 1, 200) WHERE id = ?1",
params![memory_id.to_string(), segment],
)?;
Self::append_outbox(tx, memory_id, "delete")
})
}
}
#[cfg(test)]
mod tests {
use super::*;
fn plan(store: &SqliteStore, with_project: bool, excluding_source: bool) -> Vec<String> {
let conn = store.reader();
let mut stmt = conn
.prepare(&format!(
"EXPLAIN QUERY PLAN {}",
dedup_query(with_project, excluding_source)
))
.unwrap();
let mut bound: Vec<&dyn rusqlite::ToSql> = vec![&"k"];
if with_project {
bound.push(&"/p");
}
if excluding_source {
bound.push(&"markdown");
}
stmt.query_map(bound.as_slice(), |r: &Row<'_>| r.get::<_, String>(3))
.unwrap()
.collect::<rusqlite::Result<Vec<_>>>()
.unwrap()
}
#[test]
fn the_dedup_lookup_reads_the_dedup_key_index() {
let store = SqliteStore::in_memory("m".to_string()).unwrap();
for (with_project, excluding_source) in
[(false, false), (true, false), (false, true), (true, true)]
{
let plan = plan(&store, with_project, excluding_source);
assert!(
plan.iter().any(|d| d.contains("idx_memories_dedup_key")),
"with_project={with_project} excluding_source={excluding_source}: {plan:?}"
);
}
}
#[test]
fn the_dedup_trim_set_is_exactly_what_str_trim_strips() {
let listed: Vec<u32> = DEDUP_TRIM_SET
.trim_start_matches("char(")
.trim_end_matches(')')
.split(", ")
.map(|n| n.parse().unwrap())
.collect();
let rust: Vec<u32> = (0..=char::MAX as u32)
.filter_map(char::from_u32)
.filter(|c| c.is_whitespace())
.map(u32::from)
.collect();
assert_eq!(listed, rust);
}
}