Struct sqlx::pool::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,
impl<DB> PoolConnection<DB>where DB: Database,
sourcepub fn detach(self) -> <DB as Database>::Connection
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.
sourcepub fn leak(self) -> <DB as Database>::Connection
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>
impl<'c> Acquire<'c> for &'c mut PoolConnection<Any>
type Database = Any
type Connection = &'c mut <Any as Database>::Connection
fn acquire( self ) -> Pin<Box<dyn Future<Output = Result<<&'c mut PoolConnection<Any> as Acquire<'c>>::Connection, Error>> + Send + 'c, Global>>
fn begin( self ) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, Any>, Error>> + Send + 'c, Global>>
source§impl<'c> Acquire<'c> for &'c mut PoolConnection<Mssql>
impl<'c> Acquire<'c> for &'c mut PoolConnection<Mssql>
type Database = Mssql
type Connection = &'c mut <Mssql as Database>::Connection
fn acquire( self ) -> Pin<Box<dyn Future<Output = Result<<&'c mut PoolConnection<Mssql> as Acquire<'c>>::Connection, Error>> + Send + 'c, Global>>
fn begin( self ) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, Mssql>, Error>> + Send + 'c, Global>>
source§impl<'c> Acquire<'c> for &'c mut PoolConnection<MySql>
impl<'c> Acquire<'c> for &'c mut PoolConnection<MySql>
type Database = MySql
type Connection = &'c mut <MySql as Database>::Connection
fn acquire( self ) -> Pin<Box<dyn Future<Output = Result<<&'c mut PoolConnection<MySql> as Acquire<'c>>::Connection, Error>> + Send + 'c, Global>>
fn begin( self ) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, MySql>, Error>> + Send + 'c, Global>>
source§impl<'c> Acquire<'c> for &'c mut PoolConnection<Postgres>
impl<'c> Acquire<'c> for &'c mut PoolConnection<Postgres>
type Database = Postgres
type Connection = &'c mut <Postgres as Database>::Connection
fn acquire( self ) -> Pin<Box<dyn Future<Output = Result<<&'c mut PoolConnection<Postgres> as Acquire<'c>>::Connection, Error>> + Send + 'c, Global>>
fn begin( self ) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, Postgres>, Error>> + Send + 'c, Global>>
source§impl<'c> Acquire<'c> for &'c mut PoolConnection<Sqlite>
impl<'c> Acquire<'c> for &'c mut PoolConnection<Sqlite>
type Database = Sqlite
type Connection = &'c mut <Sqlite as Database>::Connection
fn acquire( self ) -> Pin<Box<dyn Future<Output = Result<<&'c mut PoolConnection<Sqlite> as Acquire<'c>>::Connection, Error>> + Send + 'c, Global>>
fn begin( self ) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, Sqlite>, Error>> + Send + 'c, Global>>
source§impl<DB> AsMut<<DB as Database>::Connection> for PoolConnection<DB>where
DB: Database,
impl<DB> AsMut<<DB as Database>::Connection> for PoolConnection<DB>where DB: Database,
source§fn as_mut(&mut self) -> &mut <DB as Database>::Connection
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,
impl<DB> AsRef<<DB as Database>::Connection> for PoolConnection<DB>where DB: Database,
source§fn as_ref(&self) -> &<DB as Database>::Connection
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,
impl<DB> Debug for PoolConnection<DB>where DB: Database,
source§impl<DB> Deref for PoolConnection<DB>where
DB: Database,
impl<DB> Deref for PoolConnection<DB>where DB: Database,
§type Target = <DB as Database>::Connection
type Target = <DB as Database>::Connection
The resulting type after dereferencing.
source§impl<DB> DerefMut for PoolConnection<DB>where
DB: Database,
impl<DB> DerefMut for PoolConnection<DB>where DB: Database,
source§impl<DB> Drop for PoolConnection<DB>where
DB: Database,
impl<DB> Drop for PoolConnection<DB>where DB: Database,
Returns the connection to the Pool
it was checked-out from.
source§impl<'c> Executor<'c> for &'c mut PoolConnection<Any>
impl<'c> Executor<'c> for &'c mut PoolConnection<Any>
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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Any>,
fn fetch_many<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<Either<<Any as Database>::QueryResult, AnyRow>, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Any>,
fn fetch_optional<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<Option<AnyRow>, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
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, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn execute<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn execute_many<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn fetch<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e, Global>>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, Global>, Error>> + Send + 'e, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn fetch_all<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row, Global>, Error>> + Send + 'e, Global>>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§impl<'c> Executor<'c> for &'c mut PoolConnection<Mssql>
impl<'c> Executor<'c> for &'c mut PoolConnection<Mssql>
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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Mssql>,
fn fetch_many<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<Either<<Mssql as Database>::QueryResult, MssqlRow>, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Mssql>,
fn fetch_optional<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<Option<MssqlRow>, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
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, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn execute<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn execute_many<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn fetch<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e, Global>>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, Global>, Error>> + Send + 'e, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn fetch_all<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row, Global>, Error>> + Send + 'e, Global>>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§impl<'c> Executor<'c> for &'c mut PoolConnection<MySql>
impl<'c> Executor<'c> for &'c mut PoolConnection<MySql>
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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, MySql>,
fn fetch_many<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<Either<<MySql as Database>::QueryResult, MySqlRow>, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, MySql>,
fn fetch_optional<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<Option<MySqlRow>, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
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, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn execute<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn execute_many<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn fetch<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e, Global>>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, Global>, Error>> + Send + 'e, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn fetch_all<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row, Global>, Error>> + Send + 'e, Global>>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§impl<'c> Executor<'c> for &'c mut PoolConnection<Postgres>
impl<'c> Executor<'c> for &'c mut PoolConnection<Postgres>
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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Postgres>,
fn fetch_many<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<Either<<Postgres as Database>::QueryResult, PgRow>, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Postgres>,
fn fetch_optional<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<Option<PgRow>, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
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, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn execute<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn execute_many<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn fetch<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e, Global>>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, Global>, Error>> + Send + 'e, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn fetch_all<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row, Global>, Error>> + Send + 'e, Global>>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§impl<'c> Executor<'c> for &'c mut PoolConnection<Sqlite>
impl<'c> Executor<'c> for &'c mut PoolConnection<Sqlite>
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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Sqlite>,
fn fetch_many<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<Either<<Sqlite as Database>::QueryResult, SqliteRow>, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Sqlite>,
fn fetch_optional<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<Option<SqliteRow>, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
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, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn execute<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn execute_many<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e, Global>>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, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn fetch<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e, Global>>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, Global>, Error>> + Send + 'e, Global>>where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
fn fetch_all<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row, Global>, Error>> + Send + 'e, Global>>where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,
Execute the query and return all the generated results, collected into a
Vec
.Auto Trait Implementations§
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> ToHex for Twhere
T: AsRef<[u8]>,
impl<T> ToHex for Twhere T: AsRef<[u8]>,
source§fn encode_hex<U>(&self) -> Uwhere
U: FromIterator<char>,
fn encode_hex<U>(&self) -> Uwhere 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) -> Uwhere
U: FromIterator<char>,
fn encode_hex_upper<U>(&self) -> Uwhere U: FromIterator<char>,
Encode the hex strict representing
self
into the result. Upper case
letters are used (e.g. F9B4CA
)