Struct diesel::prelude::PgConnection

pub struct PgConnection { /* private fields */ }

The connection string expected by PgConnection::establish should be a PostgreSQL connection string, as documented at https://www.postgresql.org/docs/9.4/static/libpq-connect.html#LIBPQ-CONNSTRING

Supported loading model implementations

• DefaultLoadingMode
• PgRowByRowLoadingMode

If you are unsure which loading mode is the correct one for your application, you likely want to use the DefaultLoadingMode as that one offers generally better performance.

Due to the fact that PgConnection supports multiple loading modes it is required to always specify the used loading mode when calling RunQueryDsl::load_iter

DefaultLoadingMode

By using this mode PgConnection defaults to loading all response values at once and only performs deserialization afterward for the DefaultLoadingMode. Generally this mode will be more performant as it.

This loading mode allows users to perform hold more than one iterator at once using the same connection:

use diesel::connection::DefaultLoadingMode;

let iter1 = users::table.load_iter::<(i32, String), DefaultLoadingMode>(connection)?;
let iter2 = users::table.load_iter::<(i32, String), DefaultLoadingMode>(connection)?;

for r in iter1 {
    let (id, name) = r?;
    println!("Id: {} Name: {}", id, name);
}

for r in iter2 {
    let (id, name) = r?;
    println!("Id: {} Name: {}", id, name);
}

PgRowByRowLoadingMode

By using this mode PgConnection defaults to loading each row of the result set sepreatly. This might be desired for huge result sets.

This loading mode prevents creating more than one iterator at once using the same connection. The following code is not allowed:

use diesel::pg::PgRowByRowLoadingMode;

let iter1 = users::table.load_iter::<(i32, String), PgRowByRowLoadingMode>(connection)?;
// creating a second iterator generates an compiler error
let iter2 = users::table.load_iter::<(i32, String), PgRowByRowLoadingMode>(connection)?;

for r in iter1 {
    let (id, name) = r?;
    println!("Id: {} Name: {}", id, name);
}

for r in iter2 {
    let (id, name) = r?;
    println!("Id: {} Name: {}", id, name);
}

Implementations

impl PgConnection

pub fn build_transaction(&mut self) -> TransactionBuilder<'_, Self>

Build a transaction, specifying additional details such as isolation level

See TransactionBuilder for more examples.

conn.build_transaction()
    .read_only()
    .serializable()
    .deferrable()
    .run(|conn| Ok(()))

Trait Implementations

impl Connection for PgConnection

type Backend = Pg

The backend this type connects to

type TransactionManager = AnsiTransactionManager

The transaction manager implementation used by this connection

fn establish(database_url: &str) -> ConnectionResult<PgConnection>

Establishes a new connection to the database

fn execute_returning_count<T>(&mut self, source: &T) -> QueryResult<usize>

where T: QueryFragment<Pg> + QueryId,

Execute a single SQL statements given by a query and return number of affected rows

fn transaction_state(&mut self) -> &mut AnsiTransactionManager

where Self: Sized,

Get access to the current transaction state of this connection

fn transaction<T, E, F>(&mut self, f: F) -> Result<T, E>

where F: FnOnce(&mut Self) -> Result<T, E>, E: From<Error>,

Executes the given function inside of a database transaction

fn begin_test_transaction(&mut self) -> QueryResult<()>

Creates a transaction that will never be committed. This is useful for tests. Panics if called while inside of a transaction or if called with a connection containing a broken transaction

fn test_transaction<T, E, F>(&mut self, f: F) -> T

where F: FnOnce(&mut Self) -> Result<T, E>, E: Debug,

Executes the given function inside a transaction, but does not commit it. Panics if the given function returns an error.

impl<'conn, 'query> ConnectionGatWorkaround<'conn, 'query, Pg> for PgConnection

type Cursor = Cursor

The cursor type returned by LoadConnection::load

type Row = PgRow

The row type used as Iterator::Item for the iterator implementation of ConnectionGatWorkaround::Cursor

impl<'conn, 'query> ConnectionGatWorkaround<'conn, 'query, Pg, PgRowByRowLoadingMode> for PgConnection

type Cursor = RowByRowCursor<'conn>

The cursor type returned by LoadConnection::load

type Row = PgRow

The row type used as Iterator::Item for the iterator implementation of ConnectionGatWorkaround::Cursor

impl GetPgMetadataCache for PgConnection

fn get_metadata_cache(&mut self) -> &mut PgMetadataCache

Get the PgMetadataCache

impl<B> LoadConnection<B> for PgConnection

where Self: PgLoadingMode<B>,

fn load<'conn, 'query, T>( &'conn mut self, source: T, ) -> QueryResult<LoadRowIter<'conn, 'query, Self, Self::Backend, B>>

where T: Query + QueryFragment<Self::Backend> + QueryId + 'query, Self::Backend: QueryMetadata<T::SqlType>,

Executes a given query and returns any requested values

impl MigrationConnection for PgConnection

fn setup(&mut self) -> QueryResult<usize>

Setup the following table:

impl SimpleConnection for PgConnection

fn batch_execute(&mut self, query: &str) -> QueryResult<()>

Execute multiple SQL statements within the same string.

impl<'b, Changes, Output> UpdateAndFetchResults<Changes, Output> for PgConnection

where Changes: Copy + AsChangeset<Target = <Changes as HasTable>::Table> + IntoUpdateTarget, Update<Changes, Changes>: LoadQuery<'b, PgConnection, Output>, <Changes::Table as Table>::AllColumns: ValidGrouping<()>, <<Changes::Table as Table>::AllColumns as ValidGrouping<()>>::IsAggregate: MixedAggregates<No, Output = No>,

fn update_and_fetch(&mut self, changeset: Changes) -> QueryResult<Output>

See the traits documentation.

impl Send for PgConnection