Struct MySqlAsyncConnection 

pub struct MySqlAsyncConnection { /* private fields */ }

Async MySQL connection.

This connection uses asupersync’s TCP stream for non-blocking I/O and implements the Connection trait from sqlmodel-core.

Implementations

impl MySqlAsyncConnection

pub async fn connect(_cx: &Cx, config: MySqlConfig) -> Outcome<Self, Error>

Establish a new async connection to the MySQL server.

This performs the complete connection handshake asynchronously:

1. TCP connection
2. Receive server handshake
3. Send handshake response with authentication
4. Handle auth result (possibly auth switch)

pub fn state(&self) -> ConnectionState

Get the current connection state.

pub fn is_ready(&self) -> bool

Check if the connection is ready for queries.

pub fn connection_id(&self) -> u32

Get the connection ID.

pub fn server_version(&self) -> Option<&str>

Get the server version.

pub fn affected_rows(&self) -> u64

Get the number of affected rows from the last statement.

pub fn last_insert_id(&self) -> u64

Get the last insert ID.

pub async fn query_async( &mut self, _cx: &Cx, sql: &str, params: &[Value], ) -> Outcome<Vec<Row>, Error>

Execute a text protocol query asynchronously.

pub async fn execute_async( &mut self, cx: &Cx, sql: &str, params: &[Value], ) -> Outcome<u64, Error>

Execute a statement asynchronously and return affected rows.

This is similar to query_async but returns the number of affected rows instead of the result set. Useful for INSERT, UPDATE, DELETE statements.

pub async fn prepare_async( &mut self, _cx: &Cx, sql: &str, ) -> Outcome<PreparedStatement, Error>

Prepare a statement for later execution using the binary protocol.

This sends COM_STMT_PREPARE to the server and stores the metadata needed for later execution via query_prepared_async or execute_prepared_async.

pub async fn query_prepared_async( &mut self, _cx: &Cx, stmt: &PreparedStatement, params: &[Value], ) -> Outcome<Vec<Row>, Error>

Execute a prepared statement and return result rows (binary protocol).

pub async fn execute_prepared_async( &mut self, cx: &Cx, stmt: &PreparedStatement, params: &[Value], ) -> Outcome<u64, Error>

Execute a prepared statement and return affected row count.

pub async fn close_prepared_async(&mut self, stmt: &PreparedStatement)

Close a prepared statement.

pub async fn ping_async(&mut self, _cx: &Cx) -> Outcome<(), Error>

Ping the server asynchronously.

pub async fn close_async(self, _cx: &Cx) -> Result<(), Error>

Close the connection asynchronously.

Trait Implementations

impl Connection for MySqlAsyncConnection

type Tx<'conn> = MySqlTransaction<'conn>

The transaction type returned by this connection.

fn query( &self, _cx: &Cx, _sql: &str, _params: &[Value], ) -> impl Future<Output = Outcome<Vec<Row>, Error>> + Send

Execute a query and return all rows.

fn query_one( &self, _cx: &Cx, _sql: &str, _params: &[Value], ) -> impl Future<Output = Outcome<Option<Row>, Error>> + Send

Execute a query and return the first row, if any.

fn execute( &self, _cx: &Cx, _sql: &str, _params: &[Value], ) -> impl Future<Output = Outcome<u64, Error>> + Send

Execute a statement (INSERT, UPDATE, DELETE) and return rows affected.

fn insert( &self, _cx: &Cx, _sql: &str, _params: &[Value], ) -> impl Future<Output = Outcome<i64, Error>> + Send

Execute an INSERT and return the last inserted ID.

fn batch( &self, _cx: &Cx, _statements: &[(String, Vec<Value>)], ) -> impl Future<Output = Outcome<Vec<u64>, Error>> + Send

Execute multiple statements in a batch.

fn begin( &self, _cx: &Cx, ) -> impl Future<Output = Outcome<Self::Tx<'_>, Error>> + Send

Begin a transaction with default isolation level (ReadCommitted).

fn begin_with( &self, _cx: &Cx, _isolation: IsolationLevel, ) -> impl Future<Output = Outcome<Self::Tx<'_>, Error>> + Send

Begin a transaction with a specific isolation level.

fn prepare( &self, _cx: &Cx, _sql: &str, ) -> impl Future<Output = Outcome<PreparedStatement, Error>> + Send

Prepare a statement for repeated execution.

fn query_prepared( &self, _cx: &Cx, _stmt: &PreparedStatement, _params: &[Value], ) -> impl Future<Output = Outcome<Vec<Row>, Error>> + Send

Execute a prepared statement and return all rows.

fn execute_prepared( &self, _cx: &Cx, _stmt: &PreparedStatement, _params: &[Value], ) -> impl Future<Output = Outcome<u64, Error>> + Send

Execute a prepared statement (INSERT, UPDATE, DELETE) and return rows affected.

fn ping(&self, _cx: &Cx) -> impl Future<Output = Outcome<(), Error>> + Send

Check if the connection is still valid by sending a ping.

fn close(self, cx: &Cx) -> impl Future<Output = Result<(), Error>> + Send

Close the connection gracefully.

fn dialect(&self) -> Dialect

Get the SQL dialect for this connection.

fn is_valid(&self, cx: &Cx) -> impl Future<Output = bool> + Send

Check if the connection is still valid (alias for ping that returns bool).

impl Debug for MySqlAsyncConnection

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

Formats the value using the given formatter.