Struct InnerPool 

struct InnerPool {
    connections: Mutex<Vec<Connection>>,
    semaphore: Arc<Semaphore>,
    pub(crate) write_mutex: Arc<Mutex<()>>,
    wal_checkpoint_mutex: Mutex<()>,
}

Inner connection pool.

Fields

connections: Mutex<Vec<Connection>>

Available connections.

semaphore: Arc<Semaphore>

Counts the number of available connections.

write_mutex: Arc<Mutex<()>>

Write mutex.

This mutex ensures there is at most one write connection with query_only=0.

This mutex is locked when write connection is outside the pool.

wal_checkpoint_mutex: Mutex<()>

WAL checkpointing mutex.

This mutex ensures that no more than one thread runs WAL checkpointing at the same time.

Normal procedures acquire either one read connection or one write connection with a write mutex, and return the resources without trying to acquire more connections or trying to acquire write mutex without returning the read connection first. WAL checkpointing is special, it tries to acquire all connections and the write mutex, so two threads doing this at the same time may result in a deadlock with one thread waiting for a write lock and the other thread waiting for a connection.

Implementations

impl InnerPool

fn put(&self, connection: Connection)

Puts a connection into the pool.

The connection could be new or returned back.

pub async fn get(self: Arc<Self>, query_only: bool) -> Result<PooledConnection>

Retrieves a connection from the pool.

Sets query_only pragma to the provided value to prevent accidental misuse of connection for writing when reading is intended. Only pass query_only=false if you want to use the connection for writing.

Trait Implementations

impl Debug for InnerPool

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

Formats the value using the given formatter.