Skip to main content

PoolConnection

sqlx_oldapi::pool

Struct PoolConnection 

Source 
pub struct PoolConnection<DB>
where
    DB: Database,
{ /* private fields */ }
Expand description

A connection managed by a Pool.

Will be returned to the pool on-drop.

Implementations§

Source§

impl<DB> PoolConnection<DB>
where DB: Database,

Source

pub fn detach(self) -> <DB as Database>::Connection

Detach this connection from the pool, allowing it to open a replacement.

Note that if your application uses a single shared pool, this effectively lets the application exceed the max_connections setting.

If min_connections is nonzero, a task will be spawned to replace this connection.

If you want the pool to treat this connection as permanently checked-out, use .leak() instead.

Source

pub fn leak(self) -> <DB as Database>::Connection

Detach this connection from the pool, treating it as permanently checked-out.

This effectively will reduce the maximum capacity of the pool by 1 every time it is used.

If you don’t want to impact the pool’s capacity, use .detach() instead.

Trait Implementations§

Source§

impl<'c> Acquire<'c> for &'c mut PoolConnection<Any>

Source§

type Database = Any

Source§

type Connection = &'c mut <Any as Database>::Connection

Source§

fn acquire( self, ) -> Pin<Box<dyn Future<Output = Result<<&'c mut PoolConnection<Any> as Acquire<'c>>::Connection, Error>> + Send + 'c>>

Source§

fn begin( self, ) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, Any>, Error>> + Send + 'c>>

Source§

impl<'c> Acquire<'c> for &'c mut PoolConnection<Mssql>

Source§

type Database = Mssql

Source§

type Connection = &'c mut <Mssql as Database>::Connection

Source§

fn acquire( self, ) -> Pin<Box<dyn Future<Output = Result<<&'c mut PoolConnection<Mssql> as Acquire<'c>>::Connection, Error>> + Send + 'c>>

Source§

fn begin( self, ) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, Mssql>, Error>> + Send + 'c>>

Source§

impl<'c> Acquire<'c> for &'c mut PoolConnection<MySql>

Source§

type Database = MySql

Source§

type Connection = &'c mut <MySql as Database>::Connection

Source§

fn acquire( self, ) -> Pin<Box<dyn Future<Output = Result<<&'c mut PoolConnection<MySql> as Acquire<'c>>::Connection, Error>> + Send + 'c>>

Source§

fn begin( self, ) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, MySql>, Error>> + Send + 'c>>

Source§

impl<'c> Acquire<'c> for &'c mut PoolConnection<Odbc>

Source§

type Database = Odbc

Source§

type Connection = &'c mut <Odbc as Database>::Connection

Source§

fn acquire( self, ) -> Pin<Box<dyn Future<Output = Result<<&'c mut PoolConnection<Odbc> as Acquire<'c>>::Connection, Error>> + Send + 'c>>

Source§

fn begin( self, ) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, Odbc>, Error>> + Send + 'c>>

Source§

impl<'c> Acquire<'c> for &'c mut PoolConnection<Postgres>

Source§

type Database = Postgres

Source§

type Connection = &'c mut <Postgres as Database>::Connection

Source§

fn acquire( self, ) -> Pin<Box<dyn Future<Output = Result<<&'c mut PoolConnection<Postgres> as Acquire<'c>>::Connection, Error>> + Send + 'c>>

Source§

fn begin( self, ) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, Postgres>, Error>> + Send + 'c>>

Source§

impl<'c> Acquire<'c> for &'c mut PoolConnection<Sqlite>

Source§

type Database = Sqlite

Source§

type Connection = &'c mut <Sqlite as Database>::Connection

Source§

fn acquire( self, ) -> Pin<Box<dyn Future<Output = Result<<&'c mut PoolConnection<Sqlite> as Acquire<'c>>::Connection, Error>> + Send + 'c>>

Source§

fn begin( self, ) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, Sqlite>, Error>> + Send + 'c>>

Source§

impl<DB> AsMut<<DB as Database>::Connection> for PoolConnection<DB>
where DB: Database,

Source§

fn as_mut(&mut self) -> &mut <DB as Database>::Connection

Converts this type into a mutable reference of the (usually inferred) input type.
Source§

impl<DB> AsRef<<DB as Database>::Connection> for PoolConnection<DB>
where DB: Database,

Source§

fn as_ref(&self) -> &<DB as Database>::Connection

Converts this type into a shared reference of the (usually inferred) input type.
Source§

impl<DB> Debug for PoolConnection<DB>
where DB: Database,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<DB> Deref for PoolConnection<DB>
where DB: Database,

Source§

type Target = <DB as Database>::Connection

The resulting type after dereferencing.
Source§

fn deref(&self) -> &<PoolConnection<DB> as Deref>::Target

Dereferences the value.
Source§

impl<DB> DerefMut for PoolConnection<DB>
where DB: Database,

Source§

fn deref_mut(&mut self) -> &mut <PoolConnection<DB> as Deref>::Target

Mutably dereferences the value.
Source§

impl<DB> Drop for PoolConnection<DB>
where DB: Database,

Returns the connection to the Pool it was checked-out from.

Source§

fn drop(&mut self)

Executes the destructor for this type. Read more
Source§

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)
Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned. Read more
Source§

impl<'c> Executor<'c> for &'c mut PoolConnection<Any>

Source§

type Database = Any

Source§

fn fetch_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<Either<<Any as Database>::QueryResult, AnyRow>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Any> + 'q,

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

fn fetch_optional<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Option<AnyRow>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Any> + 'q,

Execute the query and returns at most one row.
Source§

fn prepare_with<'e, 'q>( self, sql: &'q str, parameters: &'e [<Any as Database>::TypeInfo], ) -> Pin<Box<dyn Future<Output = Result<<Any as HasStatement<'q>>::Statement, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e,

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

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

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

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: Execute<'q, Self::Database> + 'q,

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

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: Execute<'q, Self::Database> + 'q,

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

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

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

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

Execute the query and returns exactly one row.
Source§

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

Prepare the SQL query to inspect the type information of its parameters and results. Read more
Source§

impl<'c> Executor<'c> for &'c mut PoolConnection<Mssql>

Source§

type Database = Mssql

Source§

fn fetch_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<Either<<Mssql as Database>::QueryResult, MssqlRow>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Mssql> + 'q,

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

fn fetch_optional<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Option<MssqlRow>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Mssql> + 'q,

Execute the query and returns at most one row.
Source§

fn prepare_with<'e, 'q>( self, sql: &'q str, parameters: &'e [<Mssql as Database>::TypeInfo], ) -> Pin<Box<dyn Future<Output = Result<<Mssql as HasStatement<'q>>::Statement, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e,

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

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

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

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: Execute<'q, Self::Database> + 'q,

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

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: Execute<'q, Self::Database> + 'q,

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

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

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

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

Execute the query and returns exactly one row.
Source§

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

Prepare the SQL query to inspect the type information of its parameters and results. Read more
Source§

impl<'c> Executor<'c> for &'c mut PoolConnection<MySql>

Source§

type Database = MySql

Source§

fn fetch_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<Either<<MySql as Database>::QueryResult, MySqlRow>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, MySql> + 'q,

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

fn fetch_optional<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Option<MySqlRow>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, MySql> + 'q,

Execute the query and returns at most one row.
Source§

fn prepare_with<'e, 'q>( self, sql: &'q str, parameters: &'e [<MySql as Database>::TypeInfo], ) -> Pin<Box<dyn Future<Output = Result<<MySql as HasStatement<'q>>::Statement, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e,

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

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

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

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: Execute<'q, Self::Database> + 'q,

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

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: Execute<'q, Self::Database> + 'q,

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

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

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

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

Execute the query and returns exactly one row.
Source§

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

Prepare the SQL query to inspect the type information of its parameters and results. Read more
Source§

impl<'c> Executor<'c> for &'c mut PoolConnection<Odbc>

Source§

type Database = Odbc

Source§

fn fetch_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<Either<<Odbc as Database>::QueryResult, OdbcRow>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Odbc> + 'q,

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

fn fetch_optional<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Option<OdbcRow>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Odbc> + 'q,

Execute the query and returns at most one row.
Source§

fn prepare_with<'e, 'q>( self, sql: &'q str, parameters: &'e [<Odbc as Database>::TypeInfo], ) -> Pin<Box<dyn Future<Output = Result<<Odbc as HasStatement<'q>>::Statement, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e,

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

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

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

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: Execute<'q, Self::Database> + 'q,

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

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: Execute<'q, Self::Database> + 'q,

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

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

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

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

Execute the query and returns exactly one row.
Source§

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

Prepare the SQL query to inspect the type information of its parameters and results. Read more
Source§

impl<'c> Executor<'c> for &'c mut PoolConnection<Postgres>

Source§

type Database = Postgres

Source§

fn fetch_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<Either<<Postgres as Database>::QueryResult, PgRow>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Postgres> + 'q,

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

fn fetch_optional<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Option<PgRow>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Postgres> + 'q,

Execute the query and returns at most one row.
Source§

fn prepare_with<'e, 'q>( self, sql: &'q str, parameters: &'e [<Postgres as Database>::TypeInfo], ) -> Pin<Box<dyn Future<Output = Result<<Postgres as HasStatement<'q>>::Statement, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e,

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

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

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

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: Execute<'q, Self::Database> + 'q,

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

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: Execute<'q, Self::Database> + 'q,

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

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

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

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

Execute the query and returns exactly one row.
Source§

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

Prepare the SQL query to inspect the type information of its parameters and results. Read more
Source§

impl<'c> Executor<'c> for &'c mut PoolConnection<Sqlite>

Source§

type Database = Sqlite

Source§

fn fetch_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<Either<<Sqlite as Database>::QueryResult, SqliteRow>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Sqlite> + 'q,

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

fn fetch_optional<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Option<SqliteRow>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Sqlite> + 'q,

Execute the query and returns at most one row.
Source§

fn prepare_with<'e, 'q>( self, sql: &'q str, parameters: &'e [<Sqlite as Database>::TypeInfo], ) -> Pin<Box<dyn Future<Output = Result<<Sqlite as HasStatement<'q>>::Statement, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e,

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

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

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

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: Execute<'q, Self::Database> + 'q,

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

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: Execute<'q, Self::Database> + 'q,

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

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

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

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: Execute<'q, Self::Database> + 'q,

Execute the query and returns exactly one row.
Source§

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

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

Auto Trait Implementations§

§

impl<DB> Freeze for PoolConnection<DB>
where <DB as Database>::Connection: Freeze,

§

impl<DB> !RefUnwindSafe for PoolConnection<DB>

§

impl<DB> Send for PoolConnection<DB>

§

impl<DB> Sync for PoolConnection<DB>
where <DB as Database>::Connection: Sync,

§

impl<DB> Unpin for PoolConnection<DB>
where <DB as Database>::Connection: Unpin,

§

impl<DB> UnsafeUnpin for PoolConnection<DB>
where <DB as Database>::Connection: UnsafeUnpin,

§

impl<DB> !UnwindSafe for PoolConnection<DB>

Blanket Implementations§

Source§

impl<R> TryRngCore for R
where R: TryRng,

Source§

type Error = <R as TryRng>::Error

👎Deprecated since 0.10.0:

use TryRng instead

Error type.
Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<R> Rng for R
where R: TryRng<Error = Infallible> + ?Sized,

Source§

fn next_u32(&mut self) -> u32

Return the next random u32.
Source§

fn next_u64(&mut self) -> u64

Return the next random u64.
Source§

fn fill_bytes(&mut self, dst: &mut [u8])

Fill dest with random data. Read more
Source§

impl<R> RngExt for R
where R: Rng + ?Sized,

Source§

fn random<T>(&mut self) -> T
where StandardUniform: Distribution<T>,

Return a random value via the StandardUniform distribution. Read more
Source§

fn random_iter<T>(self) -> Iter<StandardUniform, Self, T>
where Self: Sized, StandardUniform: Distribution<T>,

Return an iterator over random variates Read more
Source§

fn random_range<T, R>(&mut self, range: R) -> T
where T: SampleUniform, R: SampleRange<T>,

Generate a random value in the given range. Read more
Source§

fn random_bool(&mut self, p: f64) -> bool

Return a bool with a probability p of being true. Read more
Source§

fn random_ratio(&mut self, numerator: u32, denominator: u32) -> bool

Return a bool with a probability of numerator/denominator of being true. Read more
Source§

fn sample<T, D>(&mut self, distr: D) -> T
where D: Distribution<T>,

Sample a new value, using the given distribution. Read more
Source§

fn sample_iter<T, D>(self, distr: D) -> Iter<D, Self, T>
where D: Distribution<T>, Self: Sized,

Create an iterator that generates values using the given distribution. Read more
Source§

fn fill<T>(&mut self, dest: &mut [T])
where T: Fill,

Fill any type implementing Fill with random data Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> ToHex for T
where T: AsRef<[u8]>,

Source§

fn encode_hex<U>(&self) -> U
where U: FromIterator<char>,

Encode the hex strict representing self into the result. Lower case letters are used (e.g. f9b4ca)
Source§

fn encode_hex_upper<U>(&self) -> U
where U: FromIterator<char>,

Encode the hex strict representing self into the result. Upper case letters are used (e.g. F9B4CA)
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<R> TryRng for R
where R: DerefMut, <R as Deref>::Target: TryRng,

Source§

type Error = <<R as Deref>::Target as TryRng>::Error

The type returned in the event of a RNG error. Read more
Source§

fn try_next_u32(&mut self) -> Result<u32, <R as TryRng>::Error>

Return the next random u32.
Source§

fn try_next_u64(&mut self) -> Result<u64, <R as TryRng>::Error>

Return the next random u64.
Source§

fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), <R as TryRng>::Error>

Fill dst entirely with random data.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<R> CryptoRng for R
where R: TryCryptoRng<Error = Infallible> + ?Sized,

Source§

impl<T> Formattable for T
where T: Deref, <T as Deref>::Target: Formattable,

Source§

impl<T> Parsable for T
where T: Deref, <T as Deref>::Target: Parsable,

Source§

impl<R> RngCore for R
where R: Rng,

Source§

impl<R> TryCryptoRng for R
where R: DerefMut, <R as Deref>::Target: TryCryptoRng,