use std::collections::{BTreeMap, BTreeSet};
use anyhow::{Result, bail};
use chrono::Utc;
use rusqlite::{Connection, OptionalExtension, Transaction, params};
use serde::Serialize;
use uuid::Uuid;
use super::authored_order::{self, Tombstone};
use super::sessions::session_of;
use super::{SqliteStore, blocklist, delete_status, settled, sync_dedup};
use crate::schema::{AGENT_NOTE_SOURCE, Conversation, Memory, SyncNodeType, SyncOp};
const PURGE_REQUESTED: &str = "delete_purge_requested";
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DeleteScope {
Memory(Uuid),
Session(String),
Project(String),
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize)]
pub struct DeleteCounts {
pub memories: u64,
pub distillates: u64,
pub chunks: u64,
pub relations: u64,
pub markers: u64,
pub conversations: u64,
pub vector_keys: u64,
pub chunk_vector_keys: u64,
pub bm25: u64,
pub cold_records: u64,
pub restored: u64,
pub log_records: u64,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct DeleteReport {
pub counts: DeleteCounts,
pub memory_ids: Vec<Uuid>,
pub sessions: Vec<String>,
pub conversations: Vec<Uuid>,
pub delete_id: Option<Uuid>,
pub seq: Option<u64>,
}
impl DeleteReport {
pub fn is_empty(&self) -> bool {
self.memory_ids.is_empty() && self.sessions.is_empty() && self.conversations.is_empty()
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize)]
pub struct ColdPurge {
pub retired: u64,
pub rewritten: u64,
pub removed_files: u64,
}
struct Target {
id: String,
distillate: bool,
}
struct Plan {
targets: Vec<Target>,
markers: BTreeSet<String>,
repoint: BTreeMap<String, Uuid>,
restored: Vec<Uuid>,
conversations: BTreeSet<Uuid>,
sessions: BTreeSet<String>,
}
struct Matched {
source: String,
source_id: String,
conversation: Option<String>,
}
const MEMORY_COLUMNS: &str = "SELECT id, source, source_id, conversation_id FROM memories";
impl SqliteStore {
pub fn delete_scope(
&self,
scope: &DeleteScope,
archived_sessions: &[String],
) -> Result<DeleteReport> {
check_scope(scope)?;
self.with_txn(|tx| {
let plan = plan(tx, scope, archived_sessions)?;
let mut report = self.execute(tx, &plan)?;
if !report.is_empty() {
let (id, seq) = delete_status::record(tx, scope)?;
report.delete_id = Some(id);
report.seq = Some(seq);
}
Ok(report)
})
}
fn execute(&self, tx: &Transaction<'_>, plan: &Plan) -> Result<DeleteReport> {
let mut report = counted(tx, plan)?;
if report.is_empty() {
return Ok(report);
}
for raw in &plan.markers {
let Ok(raw_id) = Uuid::parse_str(raw) else {
continue;
};
if let Some(member) = plan.repoint.get(raw) {
self.repoint_marker_on_tx(tx, raw_id, *member)?;
} else if self.drop_marker_on_tx(tx, raw_id)? {
report.counts.markers += 1;
}
}
for id in &plan.restored {
self.restore_superseded_on_tx(tx, *id)?;
}
for target in &plan.targets {
report.counts.log_records += erase_memory_traces(tx, &target.id)?;
blocklist::block_row(tx, &target.id, None)?;
tx.execute("DELETE FROM memories WHERE id = ?1", params![target.id])?;
let authored = self.authored_now(tx)?;
Self::upsert_tombstone(tx, &target.id, "memory", &self.machine_id, authored)?;
if let Ok(id) = Uuid::parse_str(&target.id) {
Self::append_outbox(tx, id, "delete")?;
}
self.append_local_log_at(
tx,
SyncOp::Delete,
SyncNodeType::Memory,
&target.id,
None,
authored,
)?;
}
for id in &plan.conversations {
let id = id.to_string();
report.counts.log_records += erase_conversation_traces(tx, &id)?;
let removed = tx.execute("DELETE FROM conversations WHERE id = ?1", params![id])?;
if removed > 0 {
tx.execute("DELETE FROM relations WHERE to_id = ?1", params![id])?;
}
let authored = self.authored_now(tx)?;
let tombstone = Tombstone {
deleted_at: authored.timestamp_micros(),
origin: self.machine_id.clone(),
};
authored_order::record_tombstone(tx, "conversation", &id, &tombstone)?;
let data = authored_order::data_with_updated_by(
&serde_json::json!({ "id": id }),
&self.machine_id,
)?;
self.append_local_log_at(
tx,
SyncOp::Delete,
SyncNodeType::Conversation,
&id,
Some(&data),
authored,
)?;
}
Ok(report)
}
pub(super) fn cascade_conversation_delete(
&self,
tx: &Transaction<'_>,
conversation_id: &str,
) -> Result<()> {
let Ok(id) = Uuid::parse_str(conversation_id) else {
return Ok(());
};
let mut matched: BTreeMap<String, Matched> = matching(
tx,
&format!("{MEMORY_COLUMNS} WHERE conversation_id = ?1"),
conversation_id,
)?
.into_iter()
.collect();
let mut sessions = BTreeSet::new();
for m in matched.values() {
if let Some(session) = session_source(&m.source, &m.source_id)
&& Conversation::claude_code_id(&session) == id
{
sessions.insert(session);
}
}
for key in ingested_session_keys(tx)? {
let base = key.split('/').next().unwrap_or(&key);
if Conversation::claude_code_id(&key) == id || Conversation::claude_code_id(base) == id
{
sessions.insert(base.to_string());
}
}
for session in &sessions {
matched.extend(session_rows(tx, session)?);
}
if matched.is_empty() {
return Ok(());
}
let conversations = scope_conversations(&matched, &sessions);
let plan = plan_of(tx, matched, conversations, sessions)?;
self.execute(tx, &plan)?;
Ok(())
}
fn repoint_marker_on_tx(&self, tx: &Transaction<'_>, raw: Uuid, member: Uuid) -> Result<()> {
let Some((marker, _)) = authored_order::marker_stamp(tx, raw)? else {
return Ok(());
};
let model = marker.model.clone().unwrap_or_default();
self.mark_distillation_on_tx(tx, raw, member, &model, &marker.status)
}
fn restore_superseded_on_tx(&self, tx: &Transaction<'_>, id: Uuid) -> Result<()> {
let changed = tx.execute(
"UPDATE memories SET superseded_by = NULL, updated_at = ?2 \
WHERE id = ?1 AND superseded_by IS NOT NULL",
params![id.to_string(), Utc::now().to_rfc3339()],
)?;
if changed == 0 {
return Ok(());
}
Self::append_outbox(tx, id, "upsert")?;
if let Some(memory) = Self::memory_on_tx(tx, id)? {
self.log_memory_update(tx, &memory)?;
}
Ok(())
}
pub fn delete_purge_requested(&self) -> Result<Option<String>> {
Ok(self
.reader()
.query_row(
"SELECT value FROM index_meta WHERE key = ?1",
params![PURGE_REQUESTED],
|r| r.get(0),
)
.optional()?)
}
pub fn delete_purge_done(&self, token: &str) -> Result<()> {
self.conn().execute(
"DELETE FROM index_meta WHERE key = ?1 AND value = ?2",
params![PURGE_REQUESTED, token],
)?;
Ok(())
}
pub fn preview_delete(
&self,
scope: &DeleteScope,
archived_sessions: &[String],
) -> Result<DeleteReport> {
check_scope(scope)?;
let conn = self.reader();
let plan = plan(&conn, scope, archived_sessions)?;
let mut report = counted(&conn, &plan)?;
report.counts.markers = (plan.markers.len() - plan.repoint.len()) as u64;
Ok(report)
}
pub fn conversation_deleted(&self, id: Uuid) -> Result<bool> {
conversation_tombstoned(&self.reader(), id)
}
pub fn session_deleted(&self, path: &str) -> Result<bool> {
let Some(session) = session_of(path) else {
return Ok(false);
};
self.conversation_deleted(Conversation::claude_code_id(&session))
}
pub fn purge_cold_segments(&self) -> Result<ColdPurge> {
let Some(tier) = self.cold_tier() else {
return Ok(ColdPurge::default());
};
let _pass = tier.pass_guard();
let (retired, rewritten) = self.retire_dead_records(tier)?;
let (removed_files, _) = self.sweep_cold_files(tier)?;
Ok(ColdPurge {
retired,
rewritten,
removed_files,
})
}
}
fn matching(conn: &Connection, sql: &str, value: &str) -> Result<Vec<(String, Matched)>> {
let mut stmt = conn.prepare(sql)?;
let rows = stmt.query_map(params![value], |r| {
Ok((
r.get::<_, String>(0)?,
Matched {
source: r.get(1)?,
source_id: r.get(2)?,
conversation: r.get(3)?,
},
))
})?;
Ok(rows.collect::<rusqlite::Result<_>>()?)
}
fn check_scope(scope: &DeleteScope) -> Result<()> {
match scope {
DeleteScope::Session(key) if key.trim().is_empty() => {
bail!("a session delete needs a session id")
}
DeleteScope::Project(path) if path.trim().is_empty() => {
bail!("a project delete needs a project")
}
_ => Ok(()),
}
}
fn session_source(source: &str, source_id: &str) -> Option<String> {
let transcript =
matches!(source, "claude-code" | "consolidation") && source_id.ends_with(".jsonl");
if transcript || source == AGENT_NOTE_SOURCE {
session_of(source_id)
} else {
None
}
}
pub(super) fn in_deleted_session(conn: &Connection, memory: &Memory) -> Result<bool> {
if let Some(c) = memory.conversation_id
&& conversation_tombstoned(conn, c)?
{
return Ok(true);
}
match session_source(&memory.source, &memory.source_id) {
Some(session) => conversation_tombstoned(conn, Conversation::claude_code_id(&session)),
None => Ok(false),
}
}
pub(super) fn request_purge(tx: &Transaction<'_>) -> Result<()> {
tx.execute(
"INSERT INTO index_meta (key, value) VALUES (?1, '1') \
ON CONFLICT(key) DO UPDATE SET value = CAST(value AS INTEGER) + 1",
params![PURGE_REQUESTED],
)?;
Ok(())
}
fn ingested_session_keys(conn: &Connection) -> Result<Vec<String>> {
let mut stmt =
conn.prepare("SELECT DISTINCT session_key FROM ingest_log WHERE session_key IS NOT NULL")?;
let keys = stmt
.query_map([], |r| r.get(0))?
.collect::<rusqlite::Result<_>>()?;
Ok(keys)
}
fn session_rows(conn: &Connection, key: &str) -> Result<Vec<(String, Matched)>> {
let mut rows = matching(
conn,
&format!("{MEMORY_COLUMNS} WHERE instr(source_id, ?1) > 0"),
key,
)?;
rows.retain(|(_, m)| session_source(&m.source, &m.source_id).as_deref() == Some(key));
rows.extend(matching(
conn,
&format!("{MEMORY_COLUMNS} WHERE conversation_id = ?1"),
&Conversation::claude_code_id(key).to_string(),
)?);
Ok(rows)
}
fn versions_of(conn: &Connection, id: Uuid) -> Result<BTreeMap<String, Matched>> {
let mut found = BTreeMap::new();
let mut frontier = vec![id.to_string()];
let mut older = conn.prepare("SELECT id FROM memories WHERE superseded_by = ?1")?;
while let Some(id) = frontier.pop() {
if found.contains_key(&id) {
continue;
}
let Some((_, m)) = matching(conn, &format!("{MEMORY_COLUMNS} WHERE id = ?1"), &id)?
.into_iter()
.next()
else {
continue;
};
for prior in older.query_map(params![id], |r| r.get::<_, String>(0))? {
frontier.push(prior?);
}
found.insert(id, m);
}
Ok(found)
}
fn plan(conn: &Connection, scope: &DeleteScope, archived_sessions: &[String]) -> Result<Plan> {
let matched: BTreeMap<String, Matched> = match scope {
DeleteScope::Memory(id) => versions_of(conn, *id)?,
DeleteScope::Session(key) => session_rows(conn, key)?.into_iter().collect(),
DeleteScope::Project(path) => {
let mut rows = matching(
conn,
&format!("{MEMORY_COLUMNS} WHERE project_path = ?1"),
path,
)?;
for session in archived_sessions {
rows.extend(session_rows(conn, session)?);
}
rows.into_iter().collect()
}
};
let sessions = scope_sessions(scope, &matched, archived_sessions);
let mut conversations = BTreeSet::new();
match scope {
DeleteScope::Memory(_) => {}
DeleteScope::Session(_) => conversations = scope_conversations(&matched, &sessions),
DeleteScope::Project(path) => {
conversations = scope_conversations(&matched, &sessions);
let mut stmt = conn.prepare("SELECT id FROM conversations WHERE project_path = ?1")?;
for id in stmt.query_map(params![path], |r| r.get::<_, String>(0))? {
if let Ok(id) = Uuid::parse_str(&id?) {
conversations.insert(id);
}
}
}
}
plan_of(conn, matched, conversations, sessions)
}
fn scope_conversations(
matched: &BTreeMap<String, Matched>,
sessions: &BTreeSet<String>,
) -> BTreeSet<Uuid> {
let mut conversations: BTreeSet<Uuid> = matched
.values()
.filter_map(|m| m.conversation.as_deref())
.filter_map(|c| Uuid::parse_str(c).ok())
.collect();
conversations.extend(sessions.iter().map(|s| Conversation::claude_code_id(s)));
conversations
}
fn plan_of(
conn: &Connection,
matched: BTreeMap<String, Matched>,
conversations: BTreeSet<Uuid>,
sessions: BTreeSet<String>,
) -> Result<Plan> {
let mut distilled_into = BTreeSet::new();
let mut markers = BTreeSet::new();
{
let mut by_raw =
conn.prepare("SELECT distilled_id FROM distillation_log WHERE memory_id = ?1")?;
let mut onto =
conn.prepare("SELECT memory_id FROM distillation_log WHERE distilled_id = ?1")?;
for id in matched.keys() {
for distilled in by_raw.query_map(params![id], |r| r.get::<_, Option<String>>(0))? {
if let Some(distilled) = distilled? {
distilled_into.insert(distilled);
}
markers.insert(id.clone());
}
}
for id in matched.keys().chain(distilled_into.iter()) {
for raw in onto.query_map(params![id], |r| r.get::<_, String>(0))? {
markers.insert(raw?);
}
}
}
let mut targets = Vec::new();
let mut exists = conn.prepare("SELECT EXISTS (SELECT 1 FROM memories WHERE id = ?1)")?;
let mut is_distillate =
conn.prepare("SELECT EXISTS (SELECT 1 FROM distillation_log WHERE distilled_id = ?1)")?;
let extra = distilled_into
.iter()
.filter(|d| !matched.contains_key(d.as_str()));
for id in matched.keys().chain(extra) {
if !exists.query_row(params![id], |r| r.get::<_, bool>(0))? {
continue;
}
targets.push(Target {
id: id.clone(),
distillate: is_distillate.query_row(params![id], |r| r.get::<_, bool>(0))?,
});
}
let doomed: BTreeSet<String> = targets.iter().map(|t| t.id.clone()).collect();
let revived = restore_plan(conn, &doomed, &markers)?;
for id in revived.derived {
targets.push(Target {
id: id.to_string(),
distillate: true,
});
}
let (restored, repoint) = (revived.restored, revived.repoint);
let mut pending = BTreeSet::new();
for id in conversations {
let held: bool = conn.query_row(
"SELECT EXISTS (SELECT 1 FROM conversations WHERE id = ?1)",
params![id.to_string()],
|r| r.get(0),
)?;
if held || !conversation_tombstoned(conn, id)? {
pending.insert(id);
}
}
Ok(Plan {
targets,
markers,
repoint,
restored,
conversations: pending,
sessions,
})
}
struct Revived {
restored: Vec<Uuid>,
derived: Vec<Uuid>,
repoint: BTreeMap<String, Uuid>,
}
#[derive(Clone)]
struct Superseded {
id: String,
source: String,
source_id: String,
}
struct SupersedeTree<'c> {
older: rusqlite::Statement<'c>,
doomed: &'c BTreeSet<String>,
fed_sessions: &'c BTreeSet<String>,
tainted: BTreeMap<String, bool>,
}
impl<'c> SupersedeTree<'c> {
fn new(
conn: &'c Connection,
doomed: &'c BTreeSet<String>,
fed_sessions: &'c BTreeSet<String>,
) -> Result<Self> {
Ok(Self {
older: conn
.prepare("SELECT id, source, source_id FROM memories WHERE superseded_by = ?1")?,
doomed,
fed_sessions,
tainted: BTreeMap::new(),
})
}
fn children(&mut self, id: &str) -> Result<Vec<Superseded>> {
let rows = self.older.query_map(params![id], |r| {
Ok(Superseded {
id: r.get(0)?,
source: r.get(1)?,
source_id: r.get(2)?,
})
})?;
Ok(rows.collect::<rusqlite::Result<_>>()?)
}
fn tainted(&mut self, node: &Superseded) -> Result<bool> {
if let Some(known) = self.tainted.get(&node.id) {
return Ok(*known);
}
self.tainted.insert(node.id.clone(), false);
let tainted = if node.source != "consolidation" {
false
} else if session_source(&node.source, &node.source_id)
.is_some_and(|s| self.fed_sessions.contains(&s))
{
true
} else {
let mut any = false;
for child in self.children(&node.id)? {
if self.doomed.contains(&child.id) || self.tainted(&child)? {
any = true;
break;
}
}
any
};
self.tainted.insert(node.id.clone(), tainted);
Ok(tainted)
}
}
fn restore_plan(
conn: &Connection,
doomed: &BTreeSet<String>,
markers: &BTreeSet<String>,
) -> Result<Revived> {
let mut marker = conn.prepare(
"SELECT d.distilled_id, m.source, m.source_id FROM distillation_log d \
JOIN memories m ON m.id = d.memory_id WHERE d.memory_id = ?1",
)?;
let mut marker_of = |raw: &str| -> Result<Option<(Option<String>, String, String)>> {
Ok(marker
.query_row(params![raw], |r| {
Ok((
r.get::<_, Option<String>>(0)?,
r.get::<_, String>(1)?,
r.get::<_, String>(2)?,
))
})
.optional()?)
};
let mut fed_sessions = BTreeSet::new();
for id in doomed {
if let Some((Some(distilled), source, source_id)) = marker_of(id)?
&& distilled != *id
&& doomed.contains(&distilled)
&& let Some(session) = session_source(&source, &source_id)
{
fed_sessions.insert(session);
}
}
let mut tree = SupersedeTree::new(conn, doomed, &fed_sessions)?;
let mut restored: BTreeMap<Uuid, Option<String>> = BTreeMap::new();
let mut derived = Vec::new();
let mut frontier: Vec<String> = doomed.iter().cloned().collect();
let mut visited = BTreeSet::new();
while let Some(parent) = frontier.pop() {
for child in tree.children(&parent)? {
if doomed.contains(&child.id) || !visited.insert(child.id.clone()) {
continue;
}
let Ok(id) = Uuid::parse_str(&child.id) else {
continue;
};
if tree.tainted(&child)? {
derived.push(id);
frontier.push(child.id);
} else {
restored.insert(id, session_source(&child.source, &child.source_id));
}
}
}
let mut repoint = BTreeMap::new();
if !restored.is_empty() {
for raw in markers {
if doomed.contains(raw) {
continue;
}
let Some((distilled, source, source_id)) = marker_of(raw)? else {
continue;
};
if !distilled.is_some_and(|d| doomed.contains(&d)) {
continue;
}
let Some(session) = session_source(&source, &source_id) else {
continue;
};
if let Some((member, _)) = restored
.iter()
.find(|(_, s)| s.as_deref() == Some(session.as_str()))
{
repoint.insert(raw.clone(), *member);
}
}
}
derived.sort();
derived.dedup();
Ok(Revived {
restored: restored.into_keys().collect(),
derived,
repoint,
})
}
fn scope_sessions(
scope: &DeleteScope,
matched: &BTreeMap<String, Matched>,
archived_sessions: &[String],
) -> BTreeSet<String> {
match scope {
DeleteScope::Memory(_) => BTreeSet::new(),
DeleteScope::Session(key) => {
if matched.is_empty() && archived_sessions.is_empty() {
BTreeSet::new()
} else {
BTreeSet::from([key.clone()])
}
}
DeleteScope::Project(_) => {
let mut sessions: BTreeSet<String> = archived_sessions.iter().cloned().collect();
for m in matched.values() {
if let Some(session) = session_source(&m.source, &m.source_id) {
sessions.insert(session);
}
}
sessions
}
}
}
fn conversation_tombstoned(conn: &Connection, id: Uuid) -> Result<bool> {
Ok(conn.query_row(
"SELECT EXISTS (SELECT 1 FROM type_tombstones \
WHERE node_type = 'conversation' AND node_id = ?1)",
params![id.to_string()],
|r| r.get(0),
)?)
}
fn count(conn: &Connection, sql: &str, id: &str) -> Result<u64> {
Ok(conn.query_row(sql, params![id], |r| r.get::<_, i64>(0))? as u64)
}
fn counted(conn: &Connection, plan: &Plan) -> Result<DeleteReport> {
let mut counts = DeleteCounts::default();
let mut memory_ids = Vec::new();
let mut relations = BTreeSet::new();
let mut related = conn.prepare(
"SELECT from_id || ':' || to_id || ':' || relation_type FROM relations \
WHERE from_id = ?1 OR to_id = ?1",
)?;
for target in &plan.targets {
let id = target.id.as_str();
if target.distillate {
counts.distillates += 1;
} else {
counts.memories += 1;
}
counts.chunks += count(
conn,
"SELECT COUNT(*) FROM memory_chunks WHERE memory_id = ?1",
id,
)?;
counts.vector_keys += count(
conn,
"SELECT COUNT(*) FROM vec_keys WHERE memory_id = ?1",
id,
)?;
counts.chunk_vector_keys += count(
conn,
"SELECT COUNT(*) FROM chunk_vec_keys WHERE memory_id = ?1",
id,
)?;
counts.bm25 += count(
conn,
"SELECT COUNT(*) FROM memories WHERE id = ?1 AND tier = 'hot' AND superseded_by IS NULL",
id,
)?;
counts.cold_records += count(
conn,
"SELECT COUNT(*) FROM memories WHERE id = ?1 AND archived_segment IS NOT NULL",
id,
)?;
for key in related.query_map(params![id], |r| r.get::<_, String>(0))? {
relations.insert(key?);
}
if let Ok(uuid) = Uuid::parse_str(id) {
memory_ids.push(uuid);
}
}
for id in &plan.conversations {
counts.conversations += count(
conn,
"SELECT COUNT(*) FROM conversations WHERE id = ?1",
&id.to_string(),
)?;
}
counts.relations = relations.len() as u64;
counts.restored = plan.restored.len() as u64;
Ok(DeleteReport {
counts,
memory_ids,
sessions: plan.sessions.iter().cloned().collect(),
conversations: plan.conversations.iter().copied().collect(),
delete_id: None,
seq: None,
})
}
pub(super) fn erase_memory_traces(tx: &Transaction<'_>, memory_id: &str) -> Result<u64> {
tx.execute(
"DELETE FROM memory_chunks WHERE memory_id = ?1",
params![memory_id],
)?;
let relation_keys: Vec<String> = {
let mut stmt = tx.prepare(
"SELECT from_id || ':' || to_id || ':' || relation_type FROM relations \
WHERE from_id = ?1 OR to_id = ?1",
)?;
stmt.query_map(params![memory_id], |r| r.get(0))?
.collect::<rusqlite::Result<_>>()?
};
tx.execute(
"DELETE FROM relations WHERE from_id = ?1 OR to_id = ?1",
params![memory_id],
)?;
let mut reclaimed = reclaim_writes(tx, "memory", memory_id)?;
settled::drop_failed_of(tx, memory_id)?;
for key in &relation_keys {
reclaimed += reclaim_writes(tx, "relation", key)?;
settled::drop_failed_of(tx, key)?;
}
Ok(reclaimed)
}
pub(super) fn erase_conversation_traces(
tx: &Transaction<'_>,
conversation_id: &str,
) -> Result<u64> {
tx.execute(
"DELETE FROM distillates WHERE conversation_id = ?1",
params![conversation_id],
)?;
settled::drop_failed_of(tx, conversation_id)?;
reclaim_writes(tx, "conversation", conversation_id)
}
fn reclaim_writes(tx: &Transaction<'_>, node_type: &str, node_id: &str) -> Result<u64> {
let seqs: Vec<i64> = {
let mut stmt = tx.prepare(
"SELECT local_seq FROM sync_log \
WHERE node_type = ?1 AND node_id = ?2 AND op IN ('create', 'update')",
)?;
stmt.query_map(params![node_type, node_id], |r| r.get(0))?
.collect::<rusqlite::Result<_>>()?
};
if seqs.is_empty() {
return Ok(0);
}
sync_dedup::keep_keys_of(tx, &seqs)?;
let mut removed = 0;
for seq in &seqs {
removed += tx.execute("DELETE FROM sync_log WHERE local_seq = ?1", params![seq])? as u64;
}
Ok(removed)
}