Struct Chat 

pub struct Chat {
    pub rowid: i32,
    pub chat_identifier: String,
    pub service_name: Option<String>,
    pub display_name: Option<String>,
}

Represents a single row in the chat table.

Fields

rowid: i32

The unique identifier for the chat in the database

chat_identifier: String

The identifier for the chat, typically a phone number, email, or group chat ID

service_name: Option<String>

The service the chat used, i.e. iMessage, SMS, IRC, etc.

display_name: Option<String>

Optional custom name created for the chat

Implementations

impl Chat

pub fn name(&self) -> &str

Generate a name for a chat, falling back to the default if a custom one is not set

pub fn display_name(&self) -> Option<&str>

Get the current display name for the chat, if it exists.

pub fn service(&self) -> Service<'_>

Get the service used by the chat, i.e. iMessage, SMS, IRC, etc.

pub fn properties(&self, db: &Connection) -> Option<Properties>

Get the Properties for the chat, if they exist

Calling this hits the database, so it is expensive and should only get invoked when needed.

Trait Implementations

impl Cacheable for Chat

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

Generate a hashmap containing each chatroom’s ID pointing to the chatroom’s metadata.

These chatroom ID’s contain duplicates and must be deduped later once we have all of the participants parsed out. On its own this data is not useful.

Example:

use imessage_database::util::dirs::default_db_path;
use imessage_database::tables::table::{Cacheable, get_connection};
use imessage_database::tables::chat::Chat;

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

type K = i32

The key type for the cache HashMap

type V = Chat

The value type for the cache HashMap

impl Debug for Chat

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

Formats the value using the given formatter.

impl Table for Chat

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

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

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