Enum ForgeConn 

pub enum ForgeConn<'a> {
    Pool(PoolConnection<Postgres>),
    Tx(MutexGuard<'a, Transaction<'static, Postgres>>),
}

Connection wrapper that implements sqlx’s Executor trait with automatic db.query tracing spans.

Obtain via ctx.conn().await? in mutation handlers. Works with compile-time checked macros via &mut conn.

let mut conn = ctx.conn().await?;
sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", id)
    .fetch_one(&mut *conn)
    .await?

Variants

Pool(PoolConnection<Postgres>)

Tx(MutexGuard<'a, Transaction<'static, Postgres>>)

Methods from Deref<Target = PgConnection>

pub fn server_version_num(&self) -> Option<u32>

the version number of the server in libpq format

pub async fn copy_in_raw( &mut self, statement: &str, ) -> Result<PgCopyIn<&mut PgConnection>, Error>

Issue a COPY FROM STDIN statement and transition the connection to streaming data to Postgres. This is a more efficient way to import data into Postgres as compared to INSERT but requires one of a few specific data formats (text/CSV/binary).

If statement is anything other than a COPY ... FROM STDIN ... command, an error is returned.

Command examples and accepted formats for COPY data are shown here: https://www.postgresql.org/docs/current/sql-copy.html

Note

PgCopyIn::finish or PgCopyIn::abort must be called when finished or the connection will return an error the next time it is used.

pub async fn copy_out_raw<'c>( &'c mut self, statement: &str, ) -> Result<Pin<Box<dyn Stream<Item = Result<Bytes, Error>> + Send + 'c>>, Error>

Issue a COPY TO STDOUT statement and transition the connection to streaming data from Postgres. This is a more efficient way to export data from Postgres but arrives in chunks of one of a few data formats (text/CSV/binary).

If statement is anything other than a COPY ... TO STDOUT ... command, an error is returned.

Note that once this process has begun, unless you read the stream to completion, it can only be canceled in two ways:

1. by closing the connection, or:
2. by using another connection to kill the server process that is sending the data as shown in this StackOverflow answer.

If you don’t read the stream to completion, the next time the connection is used it will need to read and discard all the remaining queued data, which could take some time.

Command examples and accepted formats for COPY data are shown here: https://www.postgresql.org/docs/current/sql-copy.html

Trait Implementations

impl Debug for ForgeConn<'_>

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

Formats the value using the given formatter.

impl Deref for ForgeConn<'_>

type Target = PgConnection

The resulting type after dereferencing.

fn deref(&self) -> &PgConnection

Dereferences the value.

impl DerefMut for ForgeConn<'_>

fn deref_mut(&mut self) -> &mut PgConnection

Mutably dereferences the value.

impl<'c> Executor<'c> for &'c mut ForgeConn<'_>

type Database = Postgres

fn fetch_many<'e, 'q: 'e, E>( self, query: E, ) -> BoxStream<'e, Result<Either<PgQueryResult, PgRow>, Error>>

where E: Execute<'q, Postgres> + 'q, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.

fn fetch_optional<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<Option<PgRow>, Error>>

where E: Execute<'q, Postgres> + 'q, 'c: 'e,

Execute the query and returns at most one row.

fn execute<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<PgQueryResult, Error>>

where E: Execute<'q, Postgres> + 'q, 'c: 'e,

Execute the query and return the total number of rows affected.

fn fetch_all<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<Vec<PgRow>, Error>>

where E: Execute<'q, Postgres> + 'q, 'c: 'e,

Execute the query and return all the generated results, collected into a Vec.

fn fetch_one<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<PgRow, Error>>

where E: Execute<'q, Postgres> + 'q, 'c: 'e,

Execute the query and returns exactly one row.

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [<Postgres as Database>::TypeInfo], ) -> BoxFuture<'e, Result<<Postgres as Database>::Statement<'q>, Error>>

where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results.

fn execute_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute multiple queries and return the rows affected from each query, in a stream.

fn fetch<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the generated results as a stream.

fn prepare<'e, 'q>( self, query: &'q str, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Statement<'q>, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results.