Struct PostgresOptions 

pub struct PostgresOptions { /* private fields */ }

Where the store keeps its tables and how it talks to the database.

The defaults are what PostgresStore::connect uses: tables found through search_path, migration history in _sqlx_migrations, prepared statements cached per connection, and 10 connections.

Implementations

impl PostgresOptions

pub fn new() -> Self

The defaults.

pub fn schema(self, schema: impl Into<String>) -> Self

Keeps the store’s tables in schema and names it in every query, so search_path does not matter. The migration history goes in schema._sqlx_migrations, apart from any other sqlx migrations in the database.

schema is a name, used exactly as written (case included), not SQL. migrate creates it if it does not exist.

pub fn transaction_pooling(self, enabled: bool) -> Self

For a pool that reaches Postgres through PgBouncer, or another pooler, in transaction mode.

Such a pooler may hand each transaction, and each statement outside one, to a different server connection. So no statement is prepared for reuse, and every store operation runs inside a transaction, so that a statement’s parse, bind and execution all reach the same server. Reads that would otherwise run alone cost a BEGIN and a COMMIT more.

The pool is the application’s, so its connect options are too. Two of sqlx’s matter behind a pooler: turn off the extra_float_digits startup parameter (PgConnectOptions::extra_float_digits(None)) unless the pooler ignores it, and do not set search_path through PgConnectOptions::options, which a pooler does not pass on; use schema instead. The store has no float columns, so it does not depend on extra_float_digits.

pub fn max_connections(self, max: u32) -> Self

The size of the pool connect and connect_with open; 10 by default. attach uses the pool it is given as it is.

pub async fn connect(&self, url: &str) -> Result<PostgresStore, StoreError>

Connects to url, applies migrations, and attaches.

Migrating needs a direct connection (see migrate), so url must not go through a pooler in transaction mode; for that, migrate directly and attach to the pooled pool.

Errors

StoreError::Backend if connecting or migrating fails.

pub async fn connect_with( &self, options: PgConnectOptions, ) -> Result<PostgresStore, StoreError>

Connects with options, applies migrations, and attaches. Like connect, it needs a direct connection.

Errors

StoreError::Backend if connecting or migrating fails.

pub async fn migrate(&self, pool: &PgPool) -> Result<(), StoreError>

Applies the store’s migrations through pool.

pool must reach Postgres directly, not through a pooler in transaction mode: migrations hold a session-level advisory lock, so concurrent callers are safe. Through such a pooler the lock can be left held on a server connection, blocking every later migration in the database, the application’s included. With a schema, the connection used is closed afterwards instead of going back to the pool, so pool keeps its own search_path.

Errors

StoreError::Backend if migrating fails, or if the history table holds a different migration under one of the store’s versions (as when it is shared with an application’s migrations; give the store a schema of its own).

pub async fn attach(&self, pool: PgPool) -> Result<PostgresStore, StoreError>

Uses pool without migrating; pool may go through a pooler (see transaction_pooling for its connect options).

Checks that every migration this version needs has been applied, so a missing migrate fails here rather than on the first effect.

Errors

StoreError::Backend if the database is unreachable or a migration is missing or not the store’s own.

Trait Implementations

impl Clone for PostgresOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PostgresOptions

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

Formats the value using the given formatter.

impl Default for PostgresOptions

fn default() -> Self

Returns the “default value” for a type.