Struct PooledConn 

pub struct PooledConn { /* private fields */ }

Methods from Deref<Target = Conn>

pub fn server_version(&self) -> &[u8]

pub fn capability_flags(&self) -> CapabilityFlags

Get the negotiated capability flags

pub fn is_mysql(&self) -> bool

Check if the server is MySQL (as opposed to MariaDB)

pub fn is_mariadb(&self) -> bool

Check if the server is MariaDB (as opposed to MySQL)

pub fn connection_id(&self) -> u64

Get the connection ID assigned by the server

pub fn status_flags(&self) -> ServerStatusFlags

Get the server status flags from the initial handshake

pub fn is_broken(&self) -> bool

Check if the connection is broken due to a previous I/O error

pub fn in_transaction(&self) -> bool

Returns true if the connection is currently in a transaction

pub async fn prepare(&mut self, sql: &str) -> Result<PreparedStatement>

Prepare a statement and return the PreparedStatement (async)

Returns Ok(PreparedStatement) on success.

pub async fn exec<P, H>( &mut self, stmt: &mut PreparedStatement, params: P, handler: &mut H, ) -> Result<()>

where P: Params, H: BinaryResultSetHandler,

Execute a prepared statement with a result set handler (async)

pub async fn exec_bulk_insert_or_update<P, I, H>( &mut self, stmt: &mut PreparedStatement, params: P, flags: BulkFlags, handler: &mut H, ) -> Result<()>

where P: BulkParamsSet + IntoIterator<Item = I>, I: Params, H: BinaryResultSetHandler,

Execute a bulk prepared statement with a result set handler (async)

pub async fn exec_first<Row, P>( &mut self, stmt: &mut PreparedStatement, params: P, ) -> Result<Option<Row>>

where Row: for<'buf> FromRawRow<'buf>, P: Params,

Execute a prepared statement and return only the first row, dropping the rest (async).

pub async fn exec_drop<P>( &mut self, stmt: &mut PreparedStatement, params: P, ) -> Result<()>

where P: Params,

Execute a prepared statement and discard all results (async)

pub async fn exec_collect<Row, P>( &mut self, stmt: &mut PreparedStatement, params: P, ) -> Result<Vec<Row>>

where Row: for<'buf> FromRawRow<'buf>, P: Params,

Execute a prepared statement and collect all rows into a Vec (async).

pub async fn exec_foreach<Row, P, F>( &mut self, stmt: &mut PreparedStatement, params: P, f: F, ) -> Result<()>

where Row: for<'buf> FromRawRow<'buf>, P: Params, F: FnMut(Row) -> Result<()>,

Execute a prepared statement and call a closure for each row (async).

The closure can return an error to stop iteration early.

pub async fn query<H>(&mut self, sql: &str, handler: &mut H) -> Result<()>

where H: TextResultSetHandler,

Execute a text protocol SQL query (async)

pub async fn query_drop(&mut self, sql: &str) -> Result<()>

Execute a text protocol SQL query and discard all results (async)

pub async fn ping(&mut self) -> Result<()>

Send a ping to the server to check if the connection is alive (async)

This sends a COM_PING command to the MySQL server and waits for an OK response.

pub async fn reset(&mut self) -> Result<()>

Reset the connection to its initial state (async)

pub async fn transaction<F, R>(&mut self, f: F) -> Result<R>

where F: AsyncFnOnce(&mut Conn, Transaction) -> Result<R>,

Execute a closure within a transaction (async)

Errors

Returns Error::NestedTransaction if called while already in a transaction

Trait Implementations

impl Deref for PooledConn

type Target = Conn

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for PooledConn

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Drop for PooledConn

fn drop(&mut self)

Executes the destructor for this type.