Struct PgStorage 

pub struct PgStorage { /* private fields */ }

Implementations

impl PgStorage

pub async fn connect(database_url: &str) -> Result<Self, Error>

Connect and apply this crate’s migrations (src/migrations/), the behaviour every release before 1.1.0 had. Equivalent to connect_with(database_url, true).

pub async fn connect_with( database_url: &str, migrate: bool, ) -> Result<Self, Error>

Connect, applying the migrations only if migrate is true.

migrate = false is for deployments where something else owns the schema — typednotes-infra applies src/migrations/ as a declared history, so the SQL is reviewed in a plan before it runs and the serving identity needs no DDL rights. The schema is then checked rather than assumed: a missing kv_store fails here, at startup, naming the cause, instead of as a confusing error on the first request. Note that the two modes do not mix on one database: sqlx records what it applied in _sqlx_migrations, an external runner does not, so switching an existing database from one to the other means reconciling that bookkeeping first.

Trait Implementations

impl StorageBackend for PgStorage

fn list_expired<'life0, 'life1, 'async_trait>( &'life0 self, prefix: &'life1 str, now: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = StorageResult<Vec<String>>> + Send + 'async_trait>>

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

Served by the partial index on expires_at from the initial migration, so the reaper no longer reads every lease to find the few that expired.

fn replace_if_unchanged<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, path: &'life1 str, expected: &'life2 [u8], entry: StorageEntry, ) -> Pin<Box<dyn Future<Output = StorageResult<bool>> + Send + 'async_trait>>

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

One statement, so the comparison and the write cannot be interleaved.

fn get<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, ) -> Pin<Box<dyn Future<Output = StorageResult<Option<StorageEntry>>> + Send + 'async_trait>>

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

fn put<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, entry: StorageEntry, ) -> Pin<Box<dyn Future<Output = StorageResult<()>> + Send + 'async_trait>>

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

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, ) -> Pin<Box<dyn Future<Output = StorageResult<()>> + Send + 'async_trait>>

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

fn ping<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = StorageResult<()>> + Send + 'async_trait>>

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

Cheap liveness probe for the health endpoint. It must stay cheap: a load balancer calls it constantly, against every replica, forever.

fn try_acquire_lock<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = StorageResult<bool>> + Send + 'async_trait>>

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

Best-effort cross-process mutual exclusion, so exactly one replica runs a singleton background task. Granting unconditionally is correct for a single-node or in-memory backend, which is why that is the default.

fn list<'life0, 'life1, 'async_trait>( &'life0 self, prefix: &'life1 str, ) -> Pin<Box<dyn Future<Output = StorageResult<Vec<String>>> + Send + 'async_trait>>

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