Struct DbConnection 

pub struct DbConnection<C> { /* private fields */ }

A wrapper for RawDbConnection that houses all XMTP DB operations.

Implementations

impl<C> DbConnection<C>

pub fn new(conn: C) -> Self

impl<C> DbConnection<C>

where C: ConnectionExt,

pub fn raw_query_read<T, F>(&self, fun: F) -> Result<T, ConnectionError>

where F: FnOnce(&mut SqliteConnection) -> Result<T, Error>,

pub fn raw_query_write<T, F>(&self, fun: F) -> Result<T, ConnectionError>

where F: FnOnce(&mut SqliteConnection) -> Result<T, Error>,

impl<C: ConnectionExt> DbConnection<C>

pub fn register_triggers(&self)

Create a new table and register triggers for tracking column updates

pub fn disable_memory_security(&self)

Disable sqlcipher memory security

pub fn intents_published(&self) -> i32

pub fn intents_processed(&self) -> i32

pub fn intents_deleted(&self) -> i32

pub fn intent_payloads_deleted(&self) -> Vec<Vec<u8>>

pub fn intents_created(&self) -> i32

pub fn missing_messages(&self, sequence_ids: &[u64]) -> Vec<StoredGroupMessage>

pub fn key_package_rotation_history(&self) -> Vec<(i64, i64)>

pub fn print_db(&self)

print refresh state, group messages, and icebox tables of the database to stdout in column format.

Trait Implementations

impl<C: Clone> Clone for DbConnection<C>

fn clone(&self) -> DbConnection<C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C> ConnectionExt for DbConnection<C>

where C: ConnectionExt,

fn raw_query_read<T, F>(&self, fun: F) -> Result<T, ConnectionError>

where F: FnOnce(&mut SqliteConnection) -> Result<T, Error>, Self: Sized,

in order to track transaction context

fn raw_query_write<T, F>(&self, fun: F) -> Result<T, ConnectionError>

where F: FnOnce(&mut SqliteConnection) -> Result<T, Error>, Self: Sized,

Run a scoped write-only query in order to track transaction context

fn disconnect(&self) -> Result<(), ConnectionError>

fn reconnect(&self) -> Result<(), ConnectionError>

impl<C> Debug for DbConnection<C>

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

Formats the value using the given formatter.

impl<C: ConnectionExt> Delete<StoredGroupIntent> for DbConnection<C>

type Key = i32

fn delete(&self, key: ID) -> Result<usize, StorageError>

impl<C: ConnectionExt> Delete<StoredKeyStoreEntry> for DbConnection<C>

type Key = Vec<u8>

fn delete(&self, key: Vec<u8>) -> Result<usize, StorageError>

impl<C: ConnectionExt> From<DbConnection<C>> for XmtpOpenMlsProvider<SqlKeyStore<C>>

fn from(db: DbConnection<C>) -> XmtpOpenMlsProvider<SqlKeyStore<C>>

Converts to this type from the input type.

impl<C: ConnectionExt> IntoConnection for DbConnection<C>

type Connection = C

fn into_connection(self) -> Self::Connection

impl<C: ConnectionExt> Pragmas for DbConnection<C>

fn busy_timeout(&self) -> Result<i32, ConnectionError>

Check the busy timeout value

fn set_sqlcipher_log<S: AsRef<str>>( &self, level: S, ) -> Result<(), ConnectionError>

impl<C: ConnectionExt> QueryAssociationStateCache for DbConnection<C>

fn write_to_cache( &self, inbox_id: String, sequence_id: i64, state: AssociationStateProto, ) -> Result<(), StorageError>

fn read_from_cache<A: AsRef<str>>( &self, inbox_id: A, sequence_id: i64, ) -> Result<Option<AssociationStateProto>, StorageError>

fn batch_read_from_cache( &self, identifiers: Vec<(String, i64)>, ) -> Result<Vec<AssociationStateProto>, StorageError>

impl<C: ConnectionExt> QueryConsentRecord for DbConnection<C>

fn get_consent_record( &self, entity: String, entity_type: ConsentType, ) -> Result<Option<StoredConsentRecord>, ConnectionError>

Returns the consent_records for the given entity up

fn insert_or_replace_consent_records( &self, records: &[StoredConsentRecord], ) -> Result<Vec<StoredConsentRecord>, ConnectionError>

Insert consent_records, and replace existing entries, returns records that are new or changed

fn consent_records(&self) -> Result<Vec<StoredConsentRecord>, ConnectionError>

fn consent_records_paged( &self, limit: i64, offset: i64, ) -> Result<Vec<StoredConsentRecord>, ConnectionError>

fn insert_newer_consent_record( &self, record: StoredConsentRecord, ) -> Result<bool, ConnectionError>

Returns true if newer

fn maybe_insert_consent_record_return_existing( &self, record: &StoredConsentRecord, ) -> Result<Option<StoredConsentRecord>, ConnectionError>

fn find_consent_by_dm_id( &self, dm_id: &str, ) -> Result<Vec<StoredConsentRecord>, ConnectionError>

impl<C: ConnectionExt> QueryConversationList for DbConnection<C>

fn fetch_conversation_list<A: AsRef<GroupQueryArgs>>( &self, args: A, ) -> Result<Vec<ConversationListItem>, StorageError>

impl<C: ConnectionExt> QueryDeviceSyncMessages for DbConnection<C>

fn unprocessed_sync_group_messages( &self, ) -> Result<Vec<StoredGroupMessage>, StorageError>

fn sync_group_messages_paged( &self, offset: i64, limit: i64, ) -> Result<Vec<StoredGroupMessage>, StorageError>

fn mark_device_sync_msg_as_processed( &self, message_id: &[u8], ) -> Result<(), StorageError>

Marks a device sync message as processed.

fn increment_device_sync_msg_attempt( &self, message_id: &[u8], max_attempts: i32, ) -> Result<i32, StorageError>

Increments the attempt count for a device sync message. If the attempt count reaches max_attempts, the state is set to Failed. Returns the new attempt count.

impl<C: ConnectionExt> QueryDms for DbConnection<C>

fn fetch_stitched( &self, key: &[u8], ) -> Result<Option<StoredGroup>, ConnectionError>

Same behavior as fetched, but will stitch DM groups

fn other_dms( &self, group_id: &[u8], ) -> Result<Vec<StoredGroup>, ConnectionError>

Load the other DMs that are stitched into this group

fn find_active_dm_group<M>( &self, members: M, ) -> Result<Option<StoredGroup>, ConnectionError>

where M: Display,

impl<C: ConnectionExt> QueryGroup for DbConnection<C>

fn find_groups<A: AsRef<GroupQueryArgs>>( &self, args: A, ) -> Result<Vec<StoredGroup>, ConnectionError>

Return regular Purpose::Conversation groups with additional optional filters

fn update_group_membership<GroupId: AsRef<[u8]>>( &self, group_id: GroupId, state: GroupMembershipState, ) -> Result<(), ConnectionError>

Updates group membership state

fn find_group(&self, id: &[u8]) -> Result<Option<StoredGroup>, ConnectionError>

Return a single group that matches the given ID

fn find_group_by_sequence_id( &self, cursor: Cursor, ) -> Result<Option<StoredGroup>, ConnectionError>

Return a single group that matches the given welcome ID

fn update_rotated_at_ns(&self, group_id: Vec<u8>) -> Result<(), StorageError>

Updates the ‘last time checked’ we checked for new installations.

fn update_installations_time_checked( &self, group_id: Vec<u8>, ) -> Result<(), StorageError>

Updates the ‘last time checked’ we checked for new installations.

fn group_cursors(&self) -> Result<Vec<Cursor>, ConnectionError>

Get all the welcome ids turned into groups

fn get_conversation_ids_for_remote_log_publish( &self, ) -> Result<Vec<StoredGroupCommitLogPublicKey>, ConnectionError>

Get conversation IDs for all conversations that require a remote commit log publish (DMs and groups where user is super admin, excluding sync groups and rejected groups)

fn find_groups_by_id_paged<A: AsRef<GroupQueryArgs>>( &self, args: A, offset: i64, ) -> Result<Vec<StoredGroup>, ConnectionError>

fn all_sync_groups(&self) -> Result<Vec<StoredGroup>, ConnectionError>

fn find_sync_group( &self, id: &[u8], ) -> Result<Option<StoredGroup>, ConnectionError>

fn primary_sync_group(&self) -> Result<Option<StoredGroup>, ConnectionError>

fn get_rotated_at_ns(&self, group_id: Vec<u8>) -> Result<i64, StorageError>

fn get_installations_time_checked( &self, group_id: Vec<u8>, ) -> Result<i64, StorageError>

fn update_message_disappearing_from_ns( &self, group_id: Vec<u8>, from_ns: Option<i64>, ) -> Result<(), StorageError>

fn update_message_disappearing_in_ns( &self, group_id: Vec<u8>, in_ns: Option<i64>, ) -> Result<(), StorageError>

fn insert_or_replace_group( &self, group: StoredGroup, ) -> Result<StoredGroup, StorageError>

fn mark_group_as_maybe_forked( &self, group_id: &[u8], fork_details: String, ) -> Result<(), StorageError>

fn clear_fork_flag_for_group( &self, group_id: &[u8], ) -> Result<(), ConnectionError>

fn has_duplicate_dm(&self, group_id: &[u8]) -> Result<bool, ConnectionError>

fn get_conversation_ids_for_remote_log_download( &self, ) -> Result<Vec<StoredGroupCommitLogPublicKey>, ConnectionError>

Get conversations for all conversations that require a remote commit log download (DMs and groups that are not sync groups)

fn get_conversation_ids_for_fork_check( &self, ) -> Result<Vec<Vec<u8>>, ConnectionError>

Get conversation IDs for fork checking (excludes already forked conversations and sync groups)

fn get_conversation_ids_for_requesting_readds( &self, ) -> Result<Vec<StoredGroupForReaddRequest>, ConnectionError>

Get conversation IDs for conversations that are forked and need readd requests

fn get_conversation_ids_for_responding_readds( &self, ) -> Result<Vec<StoredGroupForRespondingReadds>, ConnectionError>

Get conversation IDs for conversations that need to respond to readd requests

fn get_conversation_type( &self, group_id: &[u8], ) -> Result<ConversationType, ConnectionError>

fn set_group_commit_log_public_key( &self, group_id: &[u8], public_key: &[u8], ) -> Result<(), StorageError>

Updates the commit log public key for a group

fn set_group_commit_log_forked_status( &self, group_id: &[u8], is_forked: Option<bool>, ) -> Result<(), StorageError>

Updates the is_commit_log_forked status for a group

fn get_group_commit_log_forked_status( &self, group_id: &[u8], ) -> Result<Option<bool>, StorageError>

Gets the is_commit_log_forked status for a group

fn set_group_has_pending_leave_request_status( &self, group_id: &[u8], has_pending_leave_request: Option<bool>, ) -> Result<(), StorageError>

Updates the has_pending_leave_request status for a group

fn get_groups_have_pending_leave_request( &self, ) -> Result<Vec<Vec<u8>>, ConnectionError>

impl<C: ConnectionExt> QueryGroupIntent for DbConnection<C>

fn set_group_intent_error(&self, intent_id: ID) -> Result<(), StorageError>

Set the intent with the given ID to Error

fn find_dependant_commits<P: AsRef<[u8]>>( &self, payload_hashes: &[P], ) -> Result<HashMap<PayloadHash, IntentDependency>, StorageError>

Find the commit message refresh state for each intent by payload hash. Returns a map from payload hash to a vector of dependencies (one per originator).

fn insert_group_intent( &self, to_save: NewGroupIntent, ) -> Result<StoredGroupIntent, ConnectionError>

fn find_group_intents<Id: AsRef<[u8]>>( &self, group_id: Id, allowed_states: Option<Vec<IntentState>>, allowed_kinds: Option<Vec<IntentKind>>, ) -> Result<Vec<StoredGroupIntent>, ConnectionError>

fn set_group_intent_published( &self, intent_id: ID, payload_hash: &[u8], post_commit_data: Option<Vec<u8>>, staged_commit: Option<Vec<u8>>, published_in_epoch: i64, ) -> Result<(), StorageError>

fn set_group_intent_committed( &self, intent_id: ID, cursor: Cursor, ) -> Result<(), StorageError>

fn set_group_intent_processed(&self, intent_id: ID) -> Result<(), StorageError>

fn set_group_intent_to_publish(&self, intent_id: ID) -> Result<(), StorageError>

fn find_group_intent_by_payload_hash( &self, payload_hash: &[u8], ) -> Result<Option<StoredGroupIntent>, StorageError>

fn increment_intent_publish_attempt_count( &self, intent_id: ID, ) -> Result<(), StorageError>

fn set_group_intent_error_and_fail_msg( &self, intent: &StoredGroupIntent, msg_id: Option<Vec<u8>>, ) -> Result<(), StorageError>

impl<C: ConnectionExt> QueryGroupMessage for DbConnection<C>

fn get_group_messages( &self, group_id: &[u8], args: &MsgQueryArgs, ) -> Result<Vec<StoredGroupMessage>, ConnectionError>

Query for group messages

fn count_group_messages( &self, group_id: &[u8], args: &MsgQueryArgs, ) -> Result<i64, ConnectionError>

Count group messages matching the given criteria

fn get_group_messages_with_reactions( &self, group_id: &[u8], args: &MsgQueryArgs, ) -> Result<Vec<StoredGroupMessageWithReactions>, ConnectionError>

Query for group messages with their reactions

fn get_group_message<MessageId: AsRef<[u8]>>( &self, id: MessageId, ) -> Result<Option<StoredGroupMessage>, ConnectionError>

Get a particular group message

fn write_conn_get_group_message<MessageId: AsRef<[u8]>>( &self, id: MessageId, ) -> Result<Option<StoredGroupMessage>, ConnectionError>

Get a particular group message using the write connection

fn group_messages_paged( &self, args: &MsgQueryArgs, offset: i64, ) -> Result<Vec<StoredGroupMessage>, ConnectionError>

fn get_inbound_relations( &self, group_id: &[u8], message_ids: &[&[u8]], relation_query: RelationQuery, ) -> Result<InboundRelations, ConnectionError>

fn get_outbound_relations( &self, group_id: &[u8], reference_ids: &[&[u8]], ) -> Result<OutboundRelations, ConnectionError>

fn get_inbound_relation_counts( &self, group_id: &[u8], message_ids: &[&[u8]], relation_query: RelationQuery, ) -> Result<RelationCounts, ConnectionError>

fn get_latest_message_times_by_sender<GroupId: AsRef<[u8]>>( &self, group_id: GroupId, allowed_content_types: &[ContentType], ) -> Result<LatestMessageTimeBySender, ConnectionError>

fn get_group_message_by_timestamp<GroupId: AsRef<[u8]>>( &self, group_id: GroupId, timestamp: i64, ) -> Result<Option<StoredGroupMessage>, ConnectionError>

fn get_group_message_by_cursor<GroupId: AsRef<[u8]>>( &self, group_id: GroupId, cursor: Cursor, ) -> Result<Option<StoredGroupMessage>, ConnectionError>

fn set_delivery_status_to_published<MessageId: AsRef<[u8]>>( &self, msg_id: &MessageId, timestamp: u64, cursor: Cursor, message_expire_at_ns: Option<i64>, ) -> Result<usize, ConnectionError>

fn set_delivery_status_to_failed<MessageId: AsRef<[u8]>>( &self, msg_id: &MessageId, ) -> Result<usize, ConnectionError>

fn delete_expired_messages( &self, ) -> Result<Vec<StoredGroupMessage>, ConnectionError>

fn delete_message_by_id<MessageId: AsRef<[u8]>>( &self, message_id: MessageId, ) -> Result<usize, ConnectionError>

fn messages_newer_than( &self, cursors_by_group: &HashMap<Vec<u8>, GlobalCursor>, ) -> Result<Vec<Cursor>, ConnectionError>

fn clear_messages( &self, group_ids: Option<&[Vec<u8>]>, retention_days: Option<u32>, ) -> Result<usize, ConnectionError>

Clear messages from the database with optional filtering.

impl<C: ConnectionExt> QueryGroupVersion for DbConnection<C>

fn set_group_paused( &self, group_id: &[u8], min_version: &str, ) -> Result<(), StorageError>

fn unpause_group(&self, group_id: &[u8]) -> Result<(), StorageError>

fn get_group_paused_version( &self, group_id: &[u8], ) -> Result<Option<String>, StorageError>

impl<C: ConnectionExt> QueryIcebox for DbConnection<C>

fn past_dependents( &self, cursors: &[Cursor], ) -> Result<Vec<OrphanedEnvelope>, ConnectionError>

Returns the envelopes (if they exist) plus all their dependencies, and dependencies of dependencies, along with each envelope’s own dependencies. This could be useful for resolving issues where a commit that could have been processed, was accidentally committed to the icebox. Generally, if an envelope has a dependency on something in the icebox already it means its dependency could not be processed, so it must also be iceboxed.

fn future_dependents( &self, cursors: &[Cursor], ) -> Result<Vec<OrphanedEnvelope>, ConnectionError>

Returns envelopes that depend on any of the specified cursors, along with each envelope’s own dependencies. Does not return the cursors themselves, if they exist in the chain.

fn ice(&self, orphans: Vec<OrphanedEnvelope>) -> Result<usize, ConnectionError>

cache the orphans until its parent(s) may be found.

fn prune_icebox(&self) -> Result<usize, ConnectionError>

Removes icebox entries that have been processed according to refresh_state. Deletes entries where the refresh_state cursor for the group is at or beyond the icebox entry’s sequence_id, indicating the envelope has been processed.

impl<C: ConnectionExt> QueryIdentity for DbConnection<C>

fn queue_key_package_rotation(&self) -> Result<(), StorageError>

fn reset_key_package_rotation_queue( &self, rotation_interval_ns: i64, ) -> Result<(), StorageError>

fn is_identity_needs_rotation(&self) -> Result<bool, StorageError>

impl<C: ConnectionExt> QueryIdentityCache for DbConnection<C>

fn fetch_cached_inbox_ids<T>( &self, identifiers: &[T], ) -> Result<HashMap<String, String>, StorageError>

where T: Display, for<'a> &'a T: Into<StoredIdentityKind>,

Returns a HashMap of WalletAddress -> InboxId

fn cache_inbox_id<T, S>( &self, identifier: &T, inbox_id: S, ) -> Result<(), StorageError>

where T: Display, S: ToString, for<'a> &'a T: Into<StoredIdentityKind>,

impl<C: ConnectionExt> QueryIdentityUpdates for DbConnection<C>

fn get_identity_updates<InboxId: AsRef<str>>( &self, inbox_id: InboxId, from_sequence_id: Option<i64>, to_sequence_id: Option<i64>, ) -> Result<Vec<StoredIdentityUpdate>, ConnectionError>

Returns all identity updates for the given inbox ID up to the provided sequence_id. Returns updates greater than from_sequence_id and less than or equal to to_sequence_id

fn insert_or_ignore_identity_updates( &self, updates: &[StoredIdentityUpdate], ) -> Result<(), ConnectionError>

Batch insert identity updates, ignoring duplicates.

fn get_latest_sequence_id( &self, inbox_ids: &[&str], ) -> Result<HashMap<String, i64>, ConnectionError>

Given a list of inbox_ids return a HashMap of each inbox ID -> highest known sequence ID

fn get_latest_sequence_id_for_inbox( &self, inbox_id: &str, ) -> Result<i64, ConnectionError>

fn count_inbox_updates( &self, inbox_ids: &[&str], ) -> Result<HashMap<String, i64>, ConnectionError>

Returns the count of identity updates for inbox_ids

impl<C: ConnectionExt> QueryKeyPackageHistory for DbConnection<C>

fn store_key_package_history_entry( &self, key_package_hash_ref: Vec<u8>, post_quantum_public_key: Option<Vec<u8>>, ) -> Result<StoredKeyPackageHistoryEntry, StorageError>

fn find_key_package_history_entry_by_hash_ref( &self, hash_ref: Vec<u8>, ) -> Result<StoredKeyPackageHistoryEntry, StorageError>

fn find_key_package_history_entries_before_id( &self, id: i32, ) -> Result<Vec<StoredKeyPackageHistoryEntry>, StorageError>

fn mark_key_package_before_id_to_be_deleted( &self, id: i32, ) -> Result<(), StorageError>

fn get_expired_key_packages( &self, ) -> Result<Vec<StoredKeyPackageHistoryEntry>, StorageError>

fn delete_key_package_history_up_to_id( &self, id: i32, ) -> Result<(), StorageError>

fn delete_key_package_entry_with_id(&self, id: i32) -> Result<(), StorageError>

impl<C: ConnectionExt> QueryKeyStoreEntry for DbConnection<C>

fn insert_or_update_key_store_entry( &self, key: Vec<u8>, value: Vec<u8>, ) -> Result<(), StorageError>

impl<C: ConnectionExt> QueryLocalCommitLog for DbConnection<C>

fn get_group_logs( &self, group_id: &[u8], ) -> Result<Vec<LocalCommitLog>, ConnectionError>

fn get_local_commit_log_after_cursor( &self, group_id: &[u8], after_cursor: i64, order: LocalCommitLogOrder, ) -> Result<Vec<LocalCommitLog>, ConnectionError>

fn get_latest_log_for_group( &self, group_id: &[u8], ) -> Result<Option<LocalCommitLog>, ConnectionError>

fn get_local_commit_log_cursor( &self, group_id: &[u8], ) -> Result<Option<i32>, ConnectionError>

impl<C: ConnectionExt> QueryMessageDeletion for DbConnection<C>

fn get_message_deletion( &self, id: &[u8], ) -> Result<Option<StoredMessageDeletion>, ConnectionError>

Get a deletion record by the DeleteMessage ID

fn get_deletion_by_deleted_message_id( &self, deleted_message_id: &[u8], ) -> Result<Option<StoredMessageDeletion>, ConnectionError>

Get deletion record for a specific deleted message

fn get_deletions_for_messages( &self, message_ids: Vec<Vec<u8>>, ) -> Result<Vec<StoredMessageDeletion>, ConnectionError>

Get all deletions for a list of message IDs

fn get_group_deletions( &self, group_id: &[u8], ) -> Result<Vec<StoredMessageDeletion>, ConnectionError>

Get all deletions in a group

fn is_message_deleted(&self, message_id: &[u8]) -> Result<bool, ConnectionError>

Check if a message has been deleted

impl<C: ConnectionExt> QueryMigrations for DbConnection<C>

fn applied_migrations(&self) -> Result<Vec<String>, ConnectionError>

Returns a list of all applied migration versions, most recent first.

fn available_migrations(&self) -> Result<Vec<String>, ConnectionError>

Returns a list of all available (embedded) migration names.

fn rollback_to_version( &self, version: &str, ) -> Result<Vec<String>, ConnectionError>

Rollback all migrations after and including the specified version.

fn run_migration(&self, name: &str) -> Result<(), ConnectionError>

Run a specific migration by name.

fn revert_migration(&self, name: &str) -> Result<(), ConnectionError>

Revert a specific migration by name.

fn run_pending_migrations(&self) -> Result<Vec<String>, ConnectionError>

Run all pending migrations.

impl<C: ConnectionExt> QueryPendingRemove for DbConnection<C>

fn get_pending_remove_users( &self, group_id: &[u8], ) -> Result<Vec<String>, ConnectionError>

fn get_user_pending_remove_status( &self, group_id: &[u8], inbox_id: &str, ) -> Result<bool, ConnectionError>

fn delete_pending_remove_users( &self, group_id: &[u8], inbox_ids: Vec<String>, ) -> Result<usize, ConnectionError>

impl<C: ConnectionExt> QueryReaddStatus for DbConnection<C>

fn get_readd_status( &self, group_id: &[u8], installation_id: &[u8], ) -> Result<Option<ReaddStatus>, ConnectionError>

fn is_awaiting_readd( &self, group_id: &[u8], installation_id: &[u8], ) -> Result<bool, ConnectionError>

fn update_requested_at_sequence_id( &self, group_id: &[u8], installation_id: &[u8], sequence_id: i64, ) -> Result<(), ConnectionError>

Update the requested_at_sequence_id for a given group_id and installation_id, provided it is higher than the current value. Inserts the row if it doesn’t exist.

fn update_responded_at_sequence_id( &self, group_id: &[u8], installation_id: &[u8], sequence_id: i64, ) -> Result<(), ConnectionError>

Update the responded_at_sequence_id for a given group_id and installation_id, provided it is higher than the current value. Inserts the row if it doesn’t exist.

fn delete_other_readd_statuses( &self, group_id: &[u8], self_installation_id: &[u8], ) -> Result<(), ConnectionError>

fn delete_readd_statuses( &self, group_id: &[u8], installation_ids: HashSet<Vec<u8>>, ) -> Result<(), ConnectionError>

fn get_readds_awaiting_response( &self, group_id: &[u8], self_installation_id: &[u8], ) -> Result<Vec<ReaddStatus>, ConnectionError>

impl<C: ConnectionExt> QueryRefreshState for DbConnection<C>

fn get_refresh_state<EntityId: AsRef<[u8]>>( &self, entity_id: EntityId, entity_kind: EntityKind, originator_id: u32, ) -> Result<Option<RefreshState>, StorageError>

fn get_last_cursor_for_originators<Id: AsRef<[u8]>>( &self, id: Id, entity_kind: EntityKind, originator_ids: &[u32], ) -> Result<Vec<Cursor>, StorageError>

fn get_last_cursor_for_ids<Id: AsRef<[u8]>>( &self, ids: &[Id], entities: &[EntityKind], ) -> Result<HashMap<Vec<u8>, GlobalCursor>, StorageError>

fn update_cursor<Id: AsRef<[u8]>>( &self, entity_id: Id, entity_kind: EntityKind, cursor: Cursor, ) -> Result<bool, StorageError>

fn get_remote_log_cursors( &self, conversation_ids: &[&Vec<u8>], ) -> Result<HashMap<Vec<u8>, Cursor>, ConnectionError>

fn lowest_common_cursor( &self, topics: &[&Topic], ) -> Result<GlobalCursor, StorageError>

fn lowest_common_cursor_combined( &self, topics: &[&Topic], ) -> Result<GlobalCursor, StorageError>

fn latest_cursor_for_id<Id: AsRef<[u8]>>( &self, entity_id: Id, entities: &[EntityKind], originators: Option<&[&OriginatorId]>, ) -> Result<GlobalCursor, StorageError>

fn latest_cursor_combined<Id: AsRef<[u8]>>( &self, entity_id: Id, entities: &[EntityKind], originators: Option<&[&OriginatorId]>, ) -> Result<GlobalCursor, StorageError>

fn get_last_cursor_for_originator<Id: AsRef<[u8]>>( &self, id: Id, entity_kind: EntityKind, originator_id: u32, ) -> Result<Cursor, StorageError>

impl<C: ConnectionExt> QueryRemoteCommitLog for DbConnection<C>

fn get_latest_remote_log_for_group( &self, group_id: &[u8], ) -> Result<Option<RemoteCommitLog>, ConnectionError>

fn get_remote_commit_log_after_cursor( &self, group_id: &[u8], after_cursor: i64, order: RemoteCommitLogOrder, ) -> Result<Vec<RemoteCommitLog>, ConnectionError>

impl<C: ConnectionExt> QueryTasks for DbConnection<C>

fn create_task(&self, task: NewTask) -> Result<Task, StorageError>

fn get_tasks(&self) -> Result<Vec<Task>, StorageError>

fn get_next_task(&self) -> Result<Option<Task>, StorageError>

fn update_task( &self, id: i32, attempts: i32, last_attempted_at_ns: i64, next_attempt_at_ns: i64, ) -> Result<Task, StorageError>

fn delete_task(&self, id: i32) -> Result<bool, StorageError>

impl<C: ConnectionExt> ReadOnly for DbConnection<C>

fn enable_readonly(&self) -> Result<(), StorageError>

fn disable_readonly(&self) -> Result<(), StorageError>

impl<T, C> Store<DbConnection<C>> for Vec<T>

where T: Store<DbConnection<C>>,

type Output = ()

fn store(&self, into: &DbConnection<C>) -> Result<Self::Output, StorageError>