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<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§

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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> !UnwindSafe for PoolConnection<DB>

Blanket Implementations§

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<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<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> ErasedDestructor for T
where T: 'static,

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,