pub struct SqliteStore { /* private fields */ }Expand description
Every write (via with_txn or a direct execute) goes through writer,
the single connection WAL reserves for the one process-wide writer. Reads
go through readers: a pool of separate connections in file-backed mode,
or the same connection as the writer for in_memory, where a second
connection would just see an empty, unrelated database.
Implementations§
Source§impl SqliteStore
impl SqliteStore
pub fn live_counts(&self) -> Result<LiveCounts>
Sourcepub fn outbox_pending(&self) -> Result<u64>
pub fn outbox_pending(&self) -> Result<u64>
Outbox rows the index drain has not applied yet. While any are pending the index counts lag the store by design, so a count mismatch then is not drift.
pub fn integrity_report( &self, indexes: Option<&Indexes>, ) -> Result<IntegrityReport>
Sourcepub fn repair(
&self,
indexes: Option<&mut Indexes>,
embed: Option<EmbedFn<'_>>,
dry_run: bool,
) -> Result<RepairStats>
pub fn repair( &self, indexes: Option<&mut Indexes>, embed: Option<EmbedFn<'_>>, dry_run: bool, ) -> Result<RepairStats>
Restores every invariant in IntegrityReport::drift, each step in
its own transactions so a failure part-way leaves earlier steps
committed. With indexes, the outbox is drained before the key
garbage collection and before the consistency check, so one pass
leaves nothing for the next. dry_run counts without writing.
Sourcepub fn backfill_embeddings(
&self,
embed: EmbedFn<'_>,
dry_run: bool,
) -> Result<(u64, u64)>
pub fn backfill_embeddings( &self, embed: EmbedFn<'_>, dry_run: bool, ) -> Result<(u64, u64)>
Embeds hot rows that have none, over the same context-plus-content
body the ingest path embeds. updated_at is bumped so the peer’s
last-writer-wins check accepts the row that now carries a vector.
Runs only this step of repair, so a caller that must not merge or
retire rows can fill vectors on its own schedule. Returns (rows
embedded, rows whose embedding failed or had the wrong dimension);
with dry_run it counts rows awaiting a vector and writes nothing.
Sourcepub fn backfill_chunk_embeddings(
&self,
embed: EmbedBatchFn<'_>,
max_memories: usize,
budget: Duration,
) -> Result<ChunkBackfill>
pub fn backfill_chunk_embeddings( &self, embed: EmbedBatchFn<'_>, max_memories: usize, budget: Duration, ) -> Result<ChunkBackfill>
Embeds the chunk sets of up to max_memories memories that need
them and stores each set whole via store_chunks, which queues the
index upsert. Texts go to embed in batches of at most 16 (a padded
ONNX batch of 64 held about 2.4 GB of arena, past the Pi’s cap), whole
memories per batch; once budget has elapsed no further batch
starts, so a caller on a shared thread gets it back promptly. A
memory any of whose vectors fails or has the wrong dimension counts
as failed and is left for a later call. Records the remaining
pending count for chunk_progress.
Sourcepub fn vacuum(&self) -> Result<(u64, u64)>
pub fn vacuum(&self) -> Result<(u64, u64)>
VACUUM cannot run inside a transaction and needs the writer alone;
returns (bytes before, bytes after).
Sourcepub fn sync_log_row_exists(&self, local_seq: u64) -> Result<bool>
pub fn sync_log_row_exists(&self, local_seq: u64) -> Result<bool>
Whether a sync_log row with this local_seq still exists; a test and diagnostic hook for the sync log garbage collector.
Source§impl SqliteStore
impl SqliteStore
Sourcepub fn near_duplicate_groups(
&self,
indexes: &Indexes,
threshold: f32,
limit: usize,
) -> Result<NearDupListing>
pub fn near_duplicate_groups( &self, indexes: &Indexes, threshold: f32, limit: usize, ) -> Result<NearDupListing>
Groups of live distillates sharing a project and type whose cosine is
at least threshold, closest group first, at most limit, with the
total number of groups.
pub fn near_duplicate_group_count( &self, indexes: &Indexes, threshold: f32, ) -> Result<usize>
Sourcepub fn check_merge(
&self,
member_ids: &[Uuid],
) -> Result<Result<(), MergeRefusal>>
pub fn check_merge( &self, member_ids: &[Uuid], ) -> Result<Result<(), MergeRefusal>>
The member checks merge_distillates makes, read-only, so a caller
can refuse a doomed merge before paying for its embedding.
Sourcepub fn merge_distillates(
&self,
member_ids: &[Uuid],
content: &str,
embedding: Vec<f32>,
model: &str,
) -> Result<Result<MergeReport, MergeRefusal>>
pub fn merge_distillates( &self, member_ids: &[Uuid], content: &str, embedding: Vec<f32>, model: &str, ) -> Result<Result<MergeReport, MergeRefusal>>
One transaction: store content as a distillate of the members’
project and type, supersede every member by it and move each raw’s
distillation marker onto it. Refused without writing anything unless
the members are 2 to 4 distinct live distillates of one project and
type.
Sourcepub fn record_near_duplicate_review(
&self,
member_ids: &[Uuid],
verdict: ReviewVerdict,
) -> Result<Result<u64, MergeRefusal>>
pub fn record_near_duplicate_review( &self, member_ids: &[Uuid], verdict: ReviewVerdict, ) -> Result<Result<u64, MergeRefusal>>
Links every pair of member_ids with the verdict’s relation and
context (see ReviewVerdict::relation); returns how many links were
new. A pair holds one edge per relation type, so a later separate
or unmerged verdict replaces the earlier one.
Sourcepub fn reopen_near_duplicate_reviews(
&self,
verdicts: &[ReviewVerdict],
) -> Result<u64>
pub fn reopen_near_duplicate_reviews( &self, verdicts: &[ReviewVerdict], ) -> Result<u64>
Deletes the review edges of verdicts, replicated as relation
deletes, so their pairs are grouped again on every peer. Returns how
many edges were removed; a rerun removes nothing.
Source§impl SqliteStore
impl SqliteStore
Sourcepub fn backfill_session_at(
&self,
evidence: &dyn SessionEvidence,
dry_run: bool,
reemit: bool,
) -> Result<SessionBackfillReport>
pub fn backfill_session_at( &self, evidence: &dyn SessionEvidence, dry_run: bool, reemit: bool, ) -> Result<SessionBackfillReport>
Fills a NULL session_at from the strongest evidence each memory has
(see SessionTier) and logs a sync Update per row, without touching
updated_at: peers merge the date apart from last-write-wins, so the
Update never beats a newer edit made elsewhere. A date already set is
never replaced, so a second run writes nothing. reemit also relogs
every date set before this run, for a peer that upgraded late.
Source§impl SqliteStore
impl SqliteStore
Sourcepub fn chunks_needing_embedding(&self, limit: usize) -> Result<Vec<ChunkWork>>
pub fn chunks_needing_embedding(&self, limit: usize) -> Result<Vec<ChunkWork>>
Live memories that split into two or more chunks and whose stored set is absent or was split from other content, oldest first. Splitting happens here in Rust, so every candidate row is split on each call; the length floor only skips rows too short to yield two chunks.
Sourcepub fn scan_chunk_work(&self, limit: usize) -> Result<(Vec<ChunkWork>, usize)>
pub fn scan_chunk_work(&self, limit: usize) -> Result<(Vec<ChunkWork>, usize)>
chunks_needing_embedding, plus the total number of memories needing
chunks. Counting past limit keeps scanning the whole table but
holds on to nothing beyond the first limit.
Sourcepub fn chunk_progress(&self) -> Result<(usize, Option<usize>)>
pub fn chunk_progress(&self) -> Result<(usize, Option<usize>)>
(live memories holding a chunk set, memories still needing one as of the last chunk backfill). The second is None before any backfill has run, because counting it fresh means splitting every live row.
Sourcepub fn store_chunks(
&self,
memory_id: Uuid,
content_hash: &str,
chunks: &[(usize, String, Vec<f32>)],
) -> Result<bool>
pub fn store_chunks( &self, memory_id: Uuid, content_hash: &str, chunks: &[(usize, String, Vec<f32>)], ) -> Result<bool>
Replaces the memory’s whole chunk set and queues an index upsert for
it, in one transaction. Returns false, writing nothing, when the
memory is no longer live or its content no longer hashes to
content_hash. Chunks are derived locally on every peer, so nothing
here touches sync_log.
pub fn chunks_for(&self, memory_id: Uuid) -> Result<Vec<MemoryChunk>>
pub fn delete_chunks(&self, memory_id: Uuid) -> Result<()>
Sourcepub fn chunk_vec_key(&self, memory_id: Uuid, ord: usize) -> Result<u64>
pub fn chunk_vec_key(&self, memory_id: Uuid, ord: usize) -> Result<u64>
Stable u64 key in chunks.usearch for one chunk, allocated on first
use, mirroring vec_key.
Sourcepub fn chunk_vec_keys_for(&self, memory_id: Uuid) -> Result<Vec<(usize, u64)>>
pub fn chunk_vec_keys_for(&self, memory_id: Uuid) -> Result<Vec<(usize, u64)>>
(ord, key) pairs allocated for the memory, by ord.
Sourcepub fn delete_chunk_vec_key(&self, memory_id: Uuid, ord: usize) -> Result<()>
pub fn delete_chunk_vec_key(&self, memory_id: Uuid, ord: usize) -> Result<()>
Drops the key row once its vector is gone from chunks.usearch, so
chunk_vec_keys only holds keys the index can still resolve.
pub fn chunk_for_vec_key(&self, key: u64) -> Result<Option<(Uuid, usize)>>
Sourcepub fn embedded_chunk_count(&self, dim: usize) -> Result<usize>
pub fn embedded_chunk_count(&self, dim: usize) -> Result<usize>
Chunk rows of live memories whose embedding has exactly dim
components: what chunks.usearch should hold once drained.
Sourcepub fn live_chunked_memories(&self) -> Result<Vec<(Uuid, String)>>
pub fn live_chunked_memories(&self) -> Result<Vec<(Uuid, String)>>
Live memories holding a chunk set, each with the hash of its current content, which the set must match to still be indexed.
Sourcepub fn purge_chunks_outside_live_set(&self) -> Result<()>
pub fn purge_chunks_outside_live_set(&self) -> Result<()>
Deletes chunk rows and chunk keys of every memory outside the live set. Only a full rebuild calls this, because it resets the chunk index first and so has no vectors to remove per key.
Sourcepub fn filtered_chunk_search(
&self,
embedding: &[f32],
source: Option<&str>,
memory_type: Option<MemoryType>,
project_path: Option<&str>,
limit: usize,
) -> Result<Vec<(Uuid, f32, usize)>>
pub fn filtered_chunk_search( &self, embedding: &[f32], source: Option<&str>, memory_type: Option<MemoryType>, project_path: Option<&str>, limit: usize, ) -> Result<Vec<(Uuid, f32, usize)>>
The scoped counterpart of Indexes::chunk_search: a brute-force
cosine scan of the embedded chunks of live in-scope memories,
returning each memory’s best (memory id, cosine, ord) for the top
limit memories, best first. Rows arrive grouped by memory (the
primary key’s order), so only the running best of one memory and the
top limit are ever held, however wide the scope.
Source§impl SqliteStore
impl SqliteStore
Sourcepub fn restore_explicit_memories(&self) -> Result<ExplicitRestoreStats>
pub fn restore_explicit_memories(&self) -> Result<ExplicitRestoreStats>
Undoes what consolidation did to explicit memories before
EXPLICIT_SOURCES was excluded from it: every archived explicit raw
returns to the hot tier and the indexes, every marker on an explicit
raw is dropped so no later pass retires it again, and a distillate
whose raws were all explicit is superseded by the oldest of them,
since nothing it summarised is missing from recall any more. A
distillate that also stands in for transcript raws stays live.
Every change replicates the way consolidation’s own writes do.
Sourcepub fn refile_nested_transcript_projects(&self) -> Result<u64>
pub fn refile_nested_transcript_projects(&self) -> Result<u64>
Re-files memories that an older adapter filed under the directory
holding the transcript file (subagents, agent-transcripts) rather
than the project directory under the projects root. Raws re-file
from their own source_id; a distillate re-files to the project most
of its raws now carry, because a consolidation batch is grouped by
conversation and one project is the only value that fits a row with a
single project_path, or to the project in its own source_id when
no raw is left to vote. Every changed row is replicated as an Update
and queued for the indexes, exactly as update_memory does.
Sourcepub fn refile_stray_project_slugs(&self) -> Result<StraySlugReport>
pub fn refile_stray_project_slugs(&self) -> Result<StraySlugReport>
Re-files explicit memories that an earlier remember filed under the
bare directory name it was given (wardrobe) instead of the slug
ingest stores for that directory (-mnt-data-wardrobe). A bare name
resolves to the stored slugs ending in -<name>, with name encoded
the way Claude Code encodes a path; the two spellings Claude Code and
Cursor give one directory (with and without the leading -) count as
one project. A name matching more than one project is reported, never
guessed, and transcript rows under a bare slug are left alone because
an adapter filed them there on purpose.
Source§impl SqliteStore
impl SqliteStore
pub fn open(path: &Path, machine_id: String) -> Result<Self>
Sourcepub fn open_with_pool_size(
path: &Path,
machine_id: String,
reader_pool_size: usize,
) -> Result<Self>
pub fn open_with_pool_size( path: &Path, machine_id: String, reader_pool_size: usize, ) -> Result<Self>
Same as open, with an explicit reader pool size instead of the
parallelism-derived default. reader_pool_size is clamped to at
least 1 so a caller passing 0 still gets a working store.
pub fn in_memory(machine_id: String) -> Result<Self>
pub fn machine_id(&self) -> &str
pub fn tombstone_exists(&self, id: Uuid) -> Result<bool>
pub fn memory_content_exists(&self, content_prefix: &str) -> Result<bool>
pub fn max_sync_seq(&self) -> Result<u64>
pub fn get_conversation(&self, id: Uuid) -> Result<Option<Conversation>>
Source§impl SqliteStore
impl SqliteStore
pub fn index_watermark(&self) -> Result<i64>
pub fn set_index_watermark(&self, seq: i64) -> Result<()>
pub fn outbox_after(&self, seq: i64) -> Result<Vec<OutboxRow>>
pub fn prune_outbox(&self, upto: i64) -> Result<()>
pub fn max_outbox_seq(&self) -> Result<i64>
Sourcepub fn vec_key(&self, memory_id: Uuid) -> Result<u64>
pub fn vec_key(&self, memory_id: Uuid) -> Result<u64>
Stable u64 usearch key for a memory id, allocated on first use.
pub fn existing_vec_key(&self, memory_id: Uuid) -> Result<Option<u64>>
Sourcepub fn delete_vec_key(&self, memory_id: Uuid) -> Result<()>
pub fn delete_vec_key(&self, memory_id: Uuid) -> Result<()>
Drops the key row once the vector is gone from usearch, so vec_keys
only ever holds keys the index can still resolve.
Sourcepub fn find_exact_duplicate(
&self,
content: &str,
project_path: Option<&str>,
) -> Result<Option<Memory>>
pub fn find_exact_duplicate( &self, content: &str, project_path: Option<&str>, ) -> Result<Option<Memory>>
The live memory content duplicates under remember’s rule: equal
once surrounding whitespace is trimmed and both sides are lowercased.
With project_path, only memories filed under that project count;
among several matches the oldest wins. SQLite’s lower() folds ASCII
only, so a stored memory that differs from content just in the case
of a non-ASCII letter is not found, which the substring shortlist this
replaces could not find either.
Sourcepub fn scoped_text_search(
&self,
query: &str,
source: Option<&str>,
memory_type: Option<MemoryType>,
project_path: Option<&str>,
limit: usize,
) -> Result<Vec<Memory>>
pub fn scoped_text_search( &self, query: &str, source: Option<&str>, memory_type: Option<MemoryType>, project_path: Option<&str>, limit: usize, ) -> Result<Vec<Memory>>
bm25_search’s match with a source/type/project scope inside the
query, so limit counts only rows the scope admits instead of cutting
before a caller’s filter could run. The match is a substring test over
content on hot, unsuperseded rows, with no relevance score to order
by (tantivy, not SQLite, holds the text index), so matches come back
newest first. Case folding is SQLite’s lower(), which is ASCII only.
Sourcepub fn scoped_count(
&self,
source: Option<&str>,
memory_type: Option<MemoryType>,
project_path: Option<&str>,
) -> Result<usize>
pub fn scoped_count( &self, source: Option<&str>, memory_type: Option<MemoryType>, project_path: Option<&str>, ) -> Result<usize>
How many live memories a source/type/project scope holds. Answered by COUNT off the source, memory_type, and project_path indexes, so it stays O(1) in memory however large the scope grows.
Sourcepub fn retain_in_scope(
&self,
ids: &[Uuid],
source: Option<&str>,
memory_type: Option<MemoryType>,
project_path: Option<&str>,
) -> Result<HashSet<Uuid>>
pub fn retain_in_scope( &self, ids: &[Uuid], source: Option<&str>, memory_type: Option<MemoryType>, project_path: Option<&str>, ) -> Result<HashSet<Uuid>>
Which of ids fall inside a source/type/project scope.
Asks the database about the candidates in hand rather than reading the scope out to test membership locally, so the cost tracks the caller’s list and not the scope. Batched because SQLite caps how many bound parameters one statement may carry.
pub fn memory_id_for_vec_key(&self, key: u64) -> Result<Option<Uuid>>
pub fn memory_for_indexing( &self, memory_id: Uuid, ) -> Result<Option<IndexableMemory>>
pub fn all_indexable(&self) -> Result<Vec<(Uuid, Vec<f32>, String)>>
Sourcepub fn vector_indexable_count(&self, dim: usize) -> Result<usize>
pub fn vector_indexable_count(&self, dim: usize) -> Result<usize>
Hot rows whose stored embedding has exactly dim components: the
only rows the vector index can hold, so a row still waiting for an
embedding does not read as index drift.
pub fn indexable_count(&self) -> Result<usize>
Sourcepub fn supersede_memory(&self, memory_id: Uuid, by: Uuid) -> Result<()>
pub fn supersede_memory(&self, memory_id: Uuid, by: Uuid) -> Result<()>
Zep-style soft invalidation: the row stays, the indexes drop it via the outbox, and peers learn of it through a sync Update carrying the row.
Sourcepub fn archive_memory(&self, memory_id: Uuid) -> Result<()>
pub fn archive_memory(&self, memory_id: Uuid) -> Result<()>
Local cold tier: the row keeps its content and embedding but leaves
both retrieval indexes and every recall predicate. archived_segment
stays NULL, which is what distinguishes this from mark_archived’s
uploaded-segment stub. Replicated as an Update so peers retire the
same row instead of keeping it hot beside the distillate.
Sourcepub fn retire_memory(
&self,
memory_id: Uuid,
reason: &str,
) -> Result<RetireOutcome>
pub fn retire_memory( &self, memory_id: Uuid, reason: &str, ) -> Result<RetireOutcome>
forget’s default: archives the row as archive_memory does and
records why, so the memory leaves recall on every peer while its
content stays recoverable. Nothing is tombstoned, and an id this store
does not hold changes nothing.
Trait Implementations§
Source§impl Store for SqliteStore
impl Store for SqliteStore
Source§fn traverse(
&self,
start_id: Uuid,
depth: u32,
) -> Result<Vec<(Memory, Vec<Relation>)>>
fn traverse( &self, start_id: Uuid, depth: u32, ) -> Result<Vec<(Memory, Vec<Relation>)>>
Live memories within depth hops of start_id, newest first, capped
at TRAVERSE_MAX_RESULTS. Ingest writes no memory-to-memory edges
(only mentions, derived_from and distilled_from), so a hop is any of:
a memory-to-memory relation in either direction, a shared mentioned
entity, or a shared conversation.
fn store_memory(&self, memory: &Memory) -> Result<()>
fn get_memory(&self, id: Uuid) -> Result<Option<Memory>>
fn get_memory_with_embedding(&self, id: Uuid) -> Result<Option<Memory>>
fn delete_memory(&self, id: Uuid) -> Result<()>
Source§fn remove_memory(&self, id: Uuid) -> Result<bool>
fn remove_memory(&self, id: Uuid) -> Result<bool>
delete_memory that also reports whether a row was there to remove,
so a forget of an unknown id can be answered as such instead of
silently succeeding.fn store_entity(&self, entity: &Entity) -> Result<()>
fn get_entity(&self, id: Uuid) -> Result<Option<Entity>>
fn find_entity_by_name(&self, name: &str) -> Result<Option<Entity>>
fn store_conversation(&self, conversation: &Conversation) -> Result<()>
fn store_relation(&self, relation: &Relation) -> Result<()>
fn get_relations( &self, node_id: Uuid, relation_type: Option<RelationType>, ) -> Result<Vec<Relation>>
fn vector_search( &self, embedding: &[f32], limit: usize, ) -> Result<Vec<(Memory, f32)>>
Source§fn filtered_vector_search(
&self,
embedding: &[f32],
source: Option<&str>,
memory_type: Option<MemoryType>,
project_path: Option<&str>,
limit: usize,
) -> Result<Vec<(Memory, f32)>>
fn filtered_vector_search( &self, embedding: &[f32], source: Option<&str>, memory_type: Option<MemoryType>, project_path: Option<&str>, limit: usize, ) -> Result<Vec<(Memory, f32)>>
source, memory_type,
and/or project_path, scanned exhaustively over that subset. Read morefn memories_by_source(&self, source: &str) -> Result<Vec<Memory>>
Source§fn source_admits(&self, memory: &Memory, source: &str) -> Result<bool>
fn source_admits(&self, memory: &Memory, source: &str) -> Result<bool>
memory answers a recall scoped to source. Consolidation
leaves the raws archived and the distillate tagged ‘consolidation’, so
a store that tracks distillation must let a distillate answer for the
sources of its raws, or a source filter finds nothing once its raws
are consolidated. The default is the plain column comparison for
stores that never consolidate.fn memories_by_type(&self, memory_type: MemoryType) -> Result<Vec<Memory>>
Source§fn chunk_window(&self, memory_id: Uuid, ord: usize) -> Result<Option<String>>
fn chunk_window(&self, memory_id: Uuid, ord: usize) -> Result<Option<String>>
ord: that chunk joined with one
neighbour on each side. None for a store that keeps no chunks.fn update_memory(&self, memory: &Memory) -> Result<()>
fn record_access(&self, memory: &Memory) -> Result<()>
Source§fn record_accesses(&self, ids: &[Uuid]) -> Result<()>
fn record_accesses(&self, ids: &[Uuid]) -> Result<()>
ids and stamp them with the current
time; confidence is left alone. A recall touches every result it
returns, so an implementation should batch these into one write
rather than take the writer lock per row. Ids the store does not
hold are ignored.fn bm25_search(&self, query: &str, limit: usize) -> Result<Vec<Memory>>
fn memory_count(&self) -> Result<usize>
fn all_memory_ids(&self) -> Result<Vec<Uuid>>
fn all_relations(&self) -> Result<Vec<Relation>>
Source§impl StoreAdmin for SqliteStore
impl StoreAdmin for SqliteStore
fn register_machine(&self, identity: &MachineIdentity) -> Result<()>
fn get_all_machines(&self) -> Result<HashMap<String, String>>
fn diagnostic(&self) -> Result<String>
fn find_or_create_entity(&self, name: &str, entity_type: &str) -> Result<Entity>
fn memory_content_exists(&self, content_prefix: &str) -> Result<bool>
fn is_file_changed(&self, file_path: &str, file_hash: &str) -> Result<bool>
fn mark_ingested( &self, file_path: &str, file_hash: &str, memory_count: usize, source: &str, ) -> Result<()>
fn ingested_file_count(&self) -> Result<usize>
fn clear_ingest_log(&self) -> Result<usize>
fn delete_memories_by_source(&self, source: &str) -> Result<usize>
fn delete_memories_by_source_id(&self, source_id: &str) -> Result<usize>
fn rebuild_vector_index(&self) -> Result<()>
fn backfill_project_paths(&self) -> Result<u64>
fn backfill_sync_log(&self) -> Result<u64>
fn backfill_tombstones(&self) -> Result<u64>
fn prune_dangling_relations(&self) -> Result<u64>
Source§fn compact_sync_log(
&self,
ops: &[SyncOp],
dry_run: bool,
) -> Result<CompactStats>
fn compact_sync_log( &self, ops: &[SyncOp], dry_run: bool, ) -> Result<CompactStats>
sync_log rows down to one per
(node_type, node_id, op), keeping the highest local_seq in each
group since the counter is derived as MAX(local_seq)+1 on every
write: dropping the row holding the true max would let the next
write reuse a sequence a peer already considers seen.fn memories_by_project_path(&self, project_path: &str) -> Result<Vec<Memory>>
Source§fn distinct_project_paths(&self) -> Result<Vec<(String, u64)>>
fn distinct_project_paths(&self) -> Result<Vec<(String, u64)>>
project_path value with its live memory
count, so a caller can discover the real slug recall’s project
scope expects instead of guessing.fn all_memories_with_embeddings(&self) -> Result<Vec<Memory>>
fn consolidation_stats(&self) -> Result<ConsolidationStats>
Source§fn unconsolidated_memories(&self, limit: usize) -> Result<Vec<Memory>>
fn unconsolidated_memories(&self, limit: usize) -> Result<Vec<Memory>>
fn mark_consolidated( &self, raw_id: Uuid, distilled_id: Uuid, model: &str, ) -> Result<()>
Source§fn retire_consolidated_raws(&self) -> Result<usize>
fn retire_consolidated_raws(&self) -> Result<usize>
fn memories_created_between( &self, start: &DateTime<Utc>, end: &DateTime<Utc>, ) -> Result<Vec<Memory>>
fn sync_log_since(&self, after_seq: u64) -> Result<Vec<SyncEntry>>
fn sync_log_page( &self, after_seq: u64, limit: Option<usize>, ) -> Result<Vec<SyncEntry>>
fn max_sync_seq(&self) -> Result<u64>
fn get_sync_state(&self, peer_id: &str) -> Result<Option<SyncState>>
fn set_sync_state(&self, state: &SyncState) -> Result<()>
fn get_all_sync_states(&self) -> Result<Vec<SyncState>>
fn tombstone_exists(&self, id: Uuid) -> Result<bool>
Source§fn apply_record(&self, record: &SyncRecord) -> Result<ApplyOutcome>
fn apply_record(&self, record: &SyncRecord) -> Result<ApplyOutcome>
Source§fn apply_batch(&self, records: &[SyncRecord]) -> Result<Vec<ApplyOutcome>>
fn apply_batch(&self, records: &[SyncRecord]) -> Result<Vec<ApplyOutcome>>
Auto Trait Implementations§
impl !Freeze for SqliteStore
impl RefUnwindSafe for SqliteStore
impl Send for SqliteStore
impl Sync for SqliteStore
impl Unpin for SqliteStore
impl UnsafeUnpin for SqliteStore
impl UnwindSafe for SqliteStore
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be
downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.Source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further
downcast into Rc<ConcreteType> where ConcreteType implements Trait.Source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &Any’s vtable from &Trait’s.Source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &mut Any’s vtable from &mut Trait’s.Source§impl<T> DowncastSend for T
impl<T> DowncastSend for T
Source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
impl<T> Fruit for T
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
Source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more