Struct MySqlSessionStore 

pub struct MySqlSessionStore(/* private fields */);

A server-side session store using MySQL as its backend.

Implementation details

This store uses sqlx to interact with MySQL. All session records are stored in a single table. You can use migrate to create the table and index required by the store in the database. Alternatively, you can use migration_query to get the SQL query that creates the table and index in order to run it yourself (e.g. as part of your database migration scripts).

MySQL version requirements

This implementation requires MySQL 5.7.8+ or MariaDB 10.2+ for JSON support. For optimal performance with JSON operations, MySQL 8.0+ is recommended.

Implementations

impl MySqlSessionStore

pub fn new(pool: MySqlPool) -> Self

Creates a new MySQL session store instance.

It requires a pool of MySQL connections to interact with the database where the session records are stored.

pub fn migration_query() -> &'static str

Return the query used to create the sessions table and index.

Implementation details

The query is designed to be idempotent, meaning it can be run multiple times without causing any issues. If the table and index already exist, the query does nothing.

MySQL version requirements

This query requires MySQL 5.7.8+ or MariaDB 10.2+ for JSON column support.

Alternatives

You can use this method to add the query to your database migration scripts. Alternatively, you can use migrate to run the query directly on the database.

pub async fn migrate(&self) -> Result<(), Error>

Create the sessions table and index in the database.

This method is idempotent, meaning it can be called multiple times without causing any issues. If the table and index already exist, this method does nothing.

If you prefer to run the query yourself, rely on migration_query to get the SQL that’s being executed.

Trait Implementations

impl Clone for MySqlSessionStore

fn clone(&self) -> MySqlSessionStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MySqlSessionStore

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

Formats the value using the given formatter.

impl From<MySqlSessionStore> for SessionStore

fn from(value: MySqlSessionStore) -> Self

Converts to this type from the input type.

impl SessionStorageBackend for MySqlSessionStore

fn create<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 SessionId, record: SessionRecordRef<'life2>, ) -> Pin<Box<dyn Future<Output = Result<(), CreateError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Creates a new session record in the store using the provided ID. When a conflicting session id is present, we perform a simple upsert. This is a deliberate decision given we can’t return an error and keep atomicity at the same time.

Even when using a guard clause, which we’d expect to amount to a noop:

ON DUPLICATE KEY UPDATE deadline = IF(sessions.deadline < UNIX_TIMESTAMP(), VALUES(deadline), sessions.deadline), state = IF(sessions.deadline < UNIX_TIMESTAMP(), VALUES(state), sessions.state)

affected_rows() is still non-zero. This seems to be a kink in MySQL.

fn update<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 SessionId, record: SessionRecordRef<'life2>, ) -> Pin<Box<dyn Future<Output = Result<(), UpdateError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update the state of an existing session in the store.

It overwrites the existing record with the provided one.

fn update_ttl<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 SessionId, ttl: Duration, ) -> Pin<Box<dyn Future<Output = Result<(), UpdateTtlError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update the TTL of an existing session record in the store.

It leaves the session state unchanged.

fn load<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, ) -> Pin<Box<dyn Future<Output = Result<Option<SessionRecord>, LoadError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads an existing session record from the store using the provided ID.

If a session with the given ID exists, it is returned. If the session does not exist or has been invalidated (e.g., expired), None is returned.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 SessionId, ) -> Pin<Box<dyn Future<Output = Result<(), DeleteError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Deletes a session record from the store using the provided ID.

If the session exists, it is removed from the store.

fn change_id<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, old_id: &'life1 SessionId, new_id: &'life2 SessionId, ) -> Pin<Box<dyn Future<Output = Result<(), ChangeIdError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Change the session id associated with an existing session record.

The server-side state is left unchanged.

fn delete_expired<'life0, 'async_trait>( &'life0 self, batch_size: Option<NonZeroUsize>, ) -> Pin<Box<dyn Future<Output = Result<usize, DeleteExpiredError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete expired sessions from the database.

If batch_size is provided, the query will delete at most batch_size expired sessions. In either case, if successful, the method returns the number of expired sessions that have been deleted.

When should you delete in batches?

If there are a lot of expired sessions in the database, deleting them all at once can cause performance issues. By deleting in batches, you can limit the number of sessions deleted in a single query, reducing the impact.

Example

Delete expired sessions in batches of 1000:

use pavex_session::SessionStore;
use pavex_session_sqlx::MySqlSessionStore;
use pavex_tracing::fields::{
    error_details,
    error_message,
    ERROR_DETAILS,
    ERROR_MESSAGE
};
use std::time::Duration;

let backend = MySqlSessionStore::new(pool);
let store = SessionStore::new(backend);
let batch_size = Some(1000.try_into().unwrap());
let batch_sleep = Duration::from_secs(60);
loop {
    if let Err(e) = store.delete_expired(batch_size).await {
        tracing::event!(
            tracing::Level::ERROR,
            { ERROR_MESSAGE } = error_message(&e),
            { ERROR_DETAILS } = error_details(&e),
            "Failed to delete a batch of expired sessions",
        );
    }
    tokio::time::sleep(batch_sleep).await;
}