Struct ChatToHandle 

pub struct ChatToHandle { /* private fields */ }

Row from the chat_handle_join table.

Implementations

impl ChatToHandle

pub fn run_diagnostic( db: &Connection, ) -> Result<ChatHandleDiagnostic, TableError>

Compute diagnostic data for the chat_handle_join table.

Counts chats referenced by messages but missing from this join table.

Example:

use imessage_database::util::dirs::default_db_path;
use imessage_database::tables::table::get_connection;
use imessage_database::tables::chat_handle::ChatToHandle;

let db_path = default_db_path();
let conn = get_connection(&db_path).unwrap();
ChatToHandle::run_diagnostic(&conn);

impl ChatToHandle

pub fn get_chat_lookup_map( conn: &Connection, ) -> Result<HashMap<i32, i32>, TableError>

Load the chat_lookup canonical chat map when the table exists.

The map links chat IDs split across services to a canonical chat ID for deduplication.

Example:

use imessage_database::util::dirs::default_db_path;
use imessage_database::tables::table::get_connection;
use imessage_database::tables::chat_handle::ChatToHandle;

let db_path = default_db_path();
let conn = get_connection(&db_path).unwrap();
ChatToHandle::get_chat_lookup_map(&conn);

pub fn dedupe( duplicated_data: &HashMap<i32, BTreeSet<i32>>, chat_lookup_map: &HashMap<i32, i32>, ) -> Result<HashMap<i32, i32>, TableError>

Assign stable deduplicated IDs to chats.

Chats merge when they have the same participant set or are linked by chat_lookup.

Assuming no new chat-handle relationships have been written to the database, deduplicated data is deterministic across runs.

Example:

use std::collections::HashMap;

use imessage_database::util::dirs::default_db_path;
use imessage_database::tables::table::{Cacheable, get_connection};
use imessage_database::tables::chat_handle::ChatToHandle;

let db_path = default_db_path();
let conn = get_connection(&db_path).unwrap();
let chatrooms = ChatToHandle::cache(&conn).unwrap();
let deduped_chatrooms = ChatToHandle::dedupe(&chatrooms, &HashMap::new());

Trait Implementations

impl Cacheable for ChatToHandle

fn cache(db: &Connection) -> Result<HashMap<Self::K, Self::V>, TableError>

Cache participant handle IDs by chat row ID.

Example:

use imessage_database::util::dirs::default_db_path;
use imessage_database::tables::table::{Cacheable, get_connection};
use imessage_database::tables::chat_handle::ChatToHandle;

let db_path = default_db_path();
let conn = get_connection(&db_path).unwrap();
let chatrooms = ChatToHandle::cache(&conn);

type K = i32

Key type for the cache map.

type V = BTreeSet<i32>

Value type for the cache map.

impl Debug for ChatToHandle

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Table for ChatToHandle

fn from_row(row: &Row<'_>) -> Result<ChatToHandle>

Deserialize a single row into Self. Returns rusqlite::Result for direct use inside rusqlite::query_map / query_row callbacks. For high-level iteration, prefer Table::rows or Table::row.

fn get(db: &Connection) -> Result<CachedStatement<'_>, TableError>

Prepare the table’s default SELECT * statement.

fn rows<'stmt, P: Params>( stmt: &'stmt mut Statement<'_>, params: P, ) -> Result<impl Iterator<Item = Result<Self, TableError>> + 'stmt, TableError>

where Self: 'stmt,

Iterate over rows produced by stmt, deserializing each via from_row. Errors at row-fetch or row-deserialize time are surfaced uniformly as TableError. Accepts both rusqlite::Statement and rusqlite::CachedStatement (the latter via deref coercion).

fn row<P: Params>( stmt: &mut Statement<'_>, params: P, ) -> Result<Self, TableError>

Fetch exactly one row from stmt. Returns TableError::QueryError if the row is missing or fails to deserialize. Accepts both rusqlite::Statement and rusqlite::CachedStatement (the latter via deref coercion).

fn stream<F, E>(db: &Connection, callback: F) -> Result<(), E>

where E: From<TableError>, F: FnMut(Result<Self, TableError>) -> Result<(), E>,

Process every row from the table’s default SELECT * query using a callback. Builds and discards the prepared statement internally, so the caller never sees it.

fn get_blob<'a>( &self, db: &'a Connection, table: &str, column: &str, rowid: i64, ) -> Option<Blob<'a>>

Open a BLOB column for the supplied rowid.

fn has_blob( &self, db: &Connection, table: &str, column: &str, rowid: i64, ) -> bool

Return whether a BLOB column is non-null for the supplied rowid.