Struct ChatToHandle 

pub struct ChatToHandle { /* private fields */ }

Represents a single row in the chat_handle_join table.

Implementations

impl ChatToHandle

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

Get the chat lookup map from the database, if it exists

This is used to map chat IDs that are split across services to a canonical chat ID for deduplication purposes.

Example:

use imessage_database::util::dirs::default_db_path;
use imessage_database::tables::table::{Diagnostic, 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>

Given the initial set of duplicated chats, deduplicate them based on the participants

This returns a new hashmap that maps the real chat ID to a new deduplicated unique chat ID that represents a single chat for all of the same participants, even if they have multiple handles.

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, Deduplicate, 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>

Generate a hashmap containing each chatroom’s ID pointing to a HashSet of participant handle IDs

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

The key type for the cache HashMap

type V = BTreeSet<i32>

The value type for the cache HashMap

impl Diagnostic for ChatToHandle

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

Emit diagnostic data for the Chat to Handle join table

Get the number of chats referenced in the messages table that do not exist in this join table:

Example:

use imessage_database::util::dirs::default_db_path;
use imessage_database::tables::table::{Diagnostic, 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 Table for ChatToHandle

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

Deserialize a single row into Self, returning a rusqlite::Result

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

Prepare SELECT * statement

fn extract( chat_to_handle: Result<Result<Self, Error>, Error>, ) -> Result<Self, TableError>

Map a rusqlite::Result<Self> into our TableError

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

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

Process all rows from the table using a callback. This is the most memory-efficient approach for large tables.

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

Get a BLOB from the table

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

Check if a BLOB exists in the table