Struct sparkle_cache_postgres::Cache

pub struct Cache(_);

The Discord cache

This is a wrapper over PgPool, you can use Cache::pg to get the inner PgPool, see its documentation for more info

Indexing

Most ID and name columns are indexed, you can inspect the database to see which columns are indexed, you can also create your own indexes using the inner PgPool, if you think there’s a missing index, please create an issue

Implementations

impl Cache

pub async fn new(url: &str) -> Result<Self, Error>

Create a new cache using the given URL

Refer to [sqlx::postgres::PgConnectOptions] for the URL format

This only clears the tables about Sparkle Cache, meaning any other custom tables are persistent

Errors

Returns the error SQLx returns when the database connection failed or the init.sql script failed to run

pub const fn pg(&self) -> &PgPool

Return a reference to the inner PgPool for the cache, so that you can use it in custom queries

Make sure the names of tables or indexes you create don’t collide with the ones created by this crate

Example

use sparkle_cache_postgres::Cache;
use sqlx::query;
query!("CREATE TABLE IF NOT EXISTS members_ext (id bigint, age smallint)")
    .execute(cache.pg())
    .await?;

Trait Implementations

impl Backend for Cache

type Error = Error

The error type the backend returns, for example sqlx::Error

fn set_current_user<'life0, 'async_trait>(
    &'life0 self,
    current_user: CurrentUser
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Set or replace the current user information of the bot

fn upsert_channel<'life0, 'async_trait>(
    &'life0 self,
    channel: CachedChannel
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add or replace a channel in the cache

fn delete_channel<'life0, 'async_trait>(
    &'life0 self,
    channel_id: Id<ChannelMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a channel from the cache

fn delete_guild_channels<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a guild’s channels from the cache

fn upsert_permission_overwrite<'life0, 'async_trait>(
    &'life0 self,
    permission_overwrite: CachedPermissionOverwrite
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add a permission overwrite to the cache

fn delete_channel_permission_overwrites<'life0, 'async_trait>(
    &'life0 self,
    channel_id: Id<ChannelMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a channel’s permission overwrites from the cache

fn upsert_message<'life0, 'async_trait>(
    &'life0 self,
    message: CachedMessage
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add or replace a message in the cache

fn delete_message<'life0, 'async_trait>(
    &'life0 self,
    message_id: Id<MessageMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a message from the cache

fn upsert_embed<'life0, 'async_trait>(
    &'life0 self,
    embed: CachedEmbed
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add an embed to the cache

fn delete_embed<'life0, 'async_trait>(
    &'life0 self,
    embed_id: Id<GenericMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove an embed from the cache

fn upsert_embed_field<'life0, 'async_trait>(
    &'life0 self,
    embed_field: CachedEmbedField
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add an embed field to the cache

fn delete_embed_fields<'life0, 'async_trait>(
    &'life0 self,
    embed_id: Id<GenericMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove an embed’s fields from the cache

fn select_message_embeds<'life0, 'async_trait>(
    &'life0 self,
    message_id: Id<MessageMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedEmbed>, Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get embeds of a message by its ID

fn select_embed_fields<'life0, 'async_trait>(
    &'life0 self,
    embed_id: Id<GenericMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedEmbedField>, Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get fields of an embed by its ID

fn upsert_attachment<'life0, 'async_trait>(
    &'life0 self,
    attachment: CachedAttachment
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add an attachment to the cache

fn delete_message_attachments<'life0, 'async_trait>(
    &'life0 self,
    message_id: Id<MessageMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a message’s attachments from the cache

fn upsert_reaction<'life0, 'async_trait>(
    &'life0 self,
    reaction: CachedReaction
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add a reaction to the cache

fn delete_reaction<'life0, 'async_trait>(
    &'life0 self,
    message_id: Id<MessageMarker>,
    user_id: Id<UserMarker>,
    emoji: String
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a reaction from the cache

fn delete_message_reactions_by_emoji<'life0, 'async_trait>(
    &'life0 self,
    message_id: Id<MessageMarker>,
    emoji: String
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a message’s reactions of the given emoji from the cache

fn delete_message_reactions<'life0, 'async_trait>(
    &'life0 self,
    message_id: Id<MessageMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a message’s reactions from the cache

fn upsert_member<'life0, 'async_trait>(
    &'life0 self,
    member: CachedMember
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add or replace a member in the cache

fn delete_member<'life0, 'async_trait>(
    &'life0 self,
    user_id: Id<UserMarker>,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a member from the cache

fn delete_guild_members<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a guild’s members from the cache

fn upsert_presence<'life0, 'async_trait>(
    &'life0 self,
    presence: CachedPresence
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add or replace a presence in the cache

fn delete_presence<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>,
    user_id: Id<UserMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a presence from the cache

fn delete_guild_presences<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a guild’s presences from the cache

fn upsert_activity<'life0, 'async_trait>(
    &'life0 self,
    activity: CachedActivity
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add an activity to the cache

fn delete_user_activities<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>,
    user_id: Id<UserMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a user’s activities from the cache

fn upsert_guild<'life0, 'async_trait>(
    &'life0 self,
    guild: CachedGuild
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add or replace a guild in the cache

fn delete_guild<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a channel from the cache

fn insert_role<'life0, 'async_trait>(
    &'life0 self,
    role: CachedRole
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add a role to the cache

fn update_roles<'life0, 'async_trait>(
    &'life0 self,
    role: CachedRole
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Update roles in the cache

fn delete_role<'life0, 'async_trait>(
    &'life0 self,
    role_id: Id<RoleMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a role from the cache

fn delete_guild_roles<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a guild’s roles from the cache

fn delete_member_roles<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>,
    user_id: Id<UserMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a member’s roles from the cache

fn upsert_emoji<'life0, 'async_trait>(
    &'life0 self,
    emoji: CachedEmoji
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add or replace an emoji in the cache

fn delete_emoji<'life0, 'async_trait>(
    &'life0 self,
    emoji_id: Id<EmojiMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove an emoji from the cache

fn delete_guild_emojis<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a guild’s emojis from the cache

fn upsert_sticker<'life0, 'async_trait>(
    &'life0 self,
    sticker: CachedSticker
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add or replace a sticker in the cache

fn delete_message_stickers<'life0, 'async_trait>(
    &'life0 self,
    message_id: Id<MessageMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a message’s stickers from the cache

fn delete_guild_stickers<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a guild’s stickers from the cache

fn upsert_stage_instance<'life0, 'async_trait>(
    &'life0 self,
    stage: StageInstance
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add or replace a stage instance in the cache

fn delete_stage_instance<'life0, 'async_trait>(
    &'life0 self,
    stage_id: Id<StageMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a stage instance from the cache

fn delete_guild_stage_instances<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Remove a guild’s stage instance from the cache

impl Cache for Cache

fn current_user<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<CurrentUser, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get the current user information of the bot

fn channel<'life0, 'async_trait>(
    &'life0 self,
    channel_id: Id<ChannelMarker>
) -> Pin<Box<dyn Future<Output = Result<Option<CachedChannel>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a cached channel or thread by its ID

fn permission_overwrites<'life0, 'async_trait>(
    &'life0 self,
    channel_id: Id<ChannelMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedPermissionOverwrite>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a cached permission overwrites of a channel by its ID

fn guild_channels<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedChannel>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a guild’s channels and threads by its ID

fn message<'life0, 'async_trait>(
    &'life0 self,
    message_id: Id<MessageMarker>
) -> Pin<Box<dyn Future<Output = Result<Option<CachedMessage>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a cached message by its ID

fn attachments<'life0, 'async_trait>(
    &'life0 self,
    message_id: Id<MessageMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedAttachment>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get cached attachments of a message by its ID

fn reactions<'life0, 'async_trait>(
    &'life0 self,
    message_id: Id<MessageMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedReaction>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get cached reactions of a message by its ID

fn stickers<'life0, 'async_trait>(
    &'life0 self,
    message_id: Id<MessageMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedSticker>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get cached stickers of a message by its ID

fn channel_messages<'life0, 'async_trait>(
    &'life0 self,
    channel_id: Id<ChannelMarker>,
    limit: u16
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedMessage>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a channel’s most recent limit messages by its ID

fn member<'life0, 'async_trait>(
    &'life0 self,
    user_id: Id<UserMarker>,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<Option<CachedMember>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a cached member by its guild ID and user ID

fn member_roles<'life0, 'async_trait>(
    &'life0 self,
    user_id: Id<UserMarker>,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedRole>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get cached roles of a member by their ID

fn presence<'life0, 'async_trait>(
    &'life0 self,
    user_id: Id<UserMarker>
) -> Pin<Box<dyn Future<Output = Result<Option<CachedPresence>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get cached presence of a member by their ID

fn member_activities<'life0, 'async_trait>(
    &'life0 self,
    user_id: Id<UserMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedActivity>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get cached activities of a member by their ID

fn guild_members<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedMember>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a guild’s members by its ID

fn guild<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<Option<CachedGuild>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a cached guild by its ID

fn role<'life0, 'async_trait>(
    &'life0 self,
    role_id: Id<RoleMarker>
) -> Pin<Box<dyn Future<Output = Result<Option<CachedRole>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a cached role by its ID

fn guild_roles<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedRole>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a guild’s roles by its ID

fn emoji<'life0, 'async_trait>(
    &'life0 self,
    emoji_id: Id<EmojiMarker>
) -> Pin<Box<dyn Future<Output = Result<Option<CachedEmoji>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a cached emoji by its ID

fn guild_emojis<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedEmoji>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a guild’s emojis by its ID

fn sticker<'life0, 'async_trait>(
    &'life0 self,
    sticker_id: Id<StickerMarker>
) -> Pin<Box<dyn Future<Output = Result<Option<CachedSticker>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a cached sticker by its ID

fn guild_stickers<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<CachedSticker>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a guild’s stickers by its ID

fn stage_instance<'life0, 'async_trait>(
    &'life0 self,
    stage_id: Id<StageMarker>
) -> Pin<Box<dyn Future<Output = Result<Option<StageInstance>, Error<Self::Error>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get a cached stage instance by its ID

fn update<'life0, 'life1, 'async_trait>(
    &'life0 self,
    event: &'life1 Event
) -> Pin<Box<dyn Future<Output = Result<(), Error<Self::Error>>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait + Sync,

Update the cache with the given event, should be called for every event to keep the cache valid

fn self_channel_permissions<'life0, 'async_trait>(
    &'life0 self,
    channel_id: Id<ChannelMarker>
) -> Pin<Box<dyn Future<Output = Result<Permissions, Error<Self::Error>>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait + Sync,

Get permissions of the current user in the given channel

fn self_guild_permissions<'life0, 'async_trait>(
    &'life0 self,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<Permissions, Error<Self::Error>>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait + Sync,

Get permissions of the current user in the given guild

fn channel_permissions<'life0, 'async_trait>(
    &'life0 self,
    user_id: Id<UserMarker>,
    channel_id: Id<ChannelMarker>
) -> Pin<Box<dyn Future<Output = Result<Permissions, Error<Self::Error>>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait + Sync,

Get the permissions of the given user and channel

fn guild_permissions<'life0, 'async_trait>(
    &'life0 self,
    user_id: Id<UserMarker>,
    guild_id: Id<GuildMarker>
) -> Pin<Box<dyn Future<Output = Result<Permissions, Error<Self::Error>>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait + Sync,

Get the permissions of the given user and guild

fn embeds<'life0, 'async_trait>(
    &'life0 self,
    message_id: Id<MessageMarker>
) -> Pin<Box<dyn Future<Output = Result<Vec<(CachedEmbed, Vec<CachedEmbedField, Global>), Global>, Error<Self::Error>>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait + Sync,

Get cached embeds of a message by its ID

impl Debug for Cache

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

Formats the value using the given formatter.