Struct MysqlConnection

pub struct MysqlConnection { /* private fields */ }

A connection to a MySQL database. Connection URLs should be in the form mysql://[user[:password]@]host/database_name[?unix_socket=socket-path&ssl_mode=SSL_MODE*&ssl_ca=/etc/ssl/certs/ca-certificates.crt&ssl_cert=/etc/ssl/certs/client-cert.crt&ssl_key=/etc/ssl/certs/client-key.crt]

• host can be an IP address or a hostname. If it is set to localhost, a connection will be attempted through the socket at /tmp/mysql.sock. If you want to connect to a local server via TCP (e.g. docker containers), use 0.0.0.0 or 127.0.0.1 instead.
• unix_socket expects the path to the unix socket
• ssl_ca accepts a path to the system’s certificate roots
• ssl_cert accepts a path to the client’s certificate file
• ssl_key accepts a path to the client’s private key file
• ssl_mode expects a value defined for MySQL client command option --ssl-mode See https://dev.mysql.com/doc/refman/5.7/en/connection-options.html#option_general_ssl-mode

Supported loading model implementations

• DefaultLoadingMode

As MysqlConnection only supports a single loading mode implementation it is not required to explicitly specify a loading mode when calling RunQueryDsl::load_iter() or LoadConnection::load

DefaultLoadingMode

MysqlConnection only supports a single loading mode, which loads values row by row from the result set.

use diesel::connection::DefaultLoadingMode;
{ // scope to restrict the lifetime of the iterator
    let iter1 = users::table.load_iter::<(i32, String), DefaultLoadingMode>(connection)?;

    for r in iter1 {
        let (id, name) = r?;
        println!("Id: {} Name: {}", id, name);
    }
}

// works without specifying the loading mode
let iter2 = users::table.load_iter::<(i32, String), _>(connection)?;

for r in iter2 {
    let (id, name) = r?;
    println!("Id: {} Name: {}", id, name);
}

This mode does not support creating multiple iterators using the same connection.

use diesel::connection::DefaultLoadingMode;

let iter1 = users::table.load_iter::<(i32, String), DefaultLoadingMode>(connection)?;
let iter2 = users::table.load_iter::<(i32, String), DefaultLoadingMode>(connection)?;

for r in iter1 {
    let (id, name) = r?;
    println!("Id: {} Name: {}", id, name);
}

for r in iter2 {
    let (id, name) = r?;
    println!("Id: {} Name: {}", id, name);
}

Trait Implementations

impl Connection for MysqlConnection

fn establish(database_url: &str) -> Result<MysqlConnection, ConnectionError>

Establishes a new connection to the MySQL database database_url may be enhanced by GET parameters mysql://[user[:password]@]host[:port]/database_name[?unix_socket=socket-path&ssl_mode=SSL_MODE*&ssl_ca=/etc/ssl/certs/ca-certificates.crt&ssl_cert=/etc/ssl/certs/client-cert.crt&ssl_key=/etc/ssl/certs/client-key.crt]

• host can be an IP address or a hostname. If it is set to localhost, a connection will be attempted through the socket at /tmp/mysql.sock. If you want to connect to a local server via TCP (e.g. docker containers), use 0.0.0.0 or 127.0.0.1 instead.
• unix_socket expects the path to the unix socket
• ssl_ca accepts a path to the system’s certificate roots
• ssl_cert accepts a path to the client’s certificate file
• ssl_key accepts a path to the client’s private key file
• ssl_mode expects a value defined for MySQL client command option --ssl-mode See https://dev.mysql.com/doc/refman/5.7/en/connection-options.html#option_general_ssl-mode

type Backend = Mysql

The backend this type connects to

type TransactionManager = AnsiTransactionManager

The transaction manager implementation used by this connection

fn execute_returning_count<T>(&mut self, source: &T) -> Result<usize, Error>

where T: QueryFragment<<MysqlConnection as Connection>::Backend> + QueryId,

Execute a single SQL statements given by a query and return number of affected rows

fn transaction_state(&mut self) -> &mut AnsiTransactionManager

Get access to the current transaction state of this connection

fn instrumentation(&mut self) -> &mut (dyn Instrumentation + 'static)

Get the instrumentation instance stored in this connection

fn set_instrumentation(&mut self, instrumentation: impl Instrumentation)

Set a specific Instrumentation implementation for this connection

fn transaction<T, E, F>(&mut self, f: F) -> Result<T, E>

where F: FnOnce(&mut Self) -> Result<T, E>, E: From<Error>,

Executes the given function inside of a database transaction

fn begin_test_transaction(&mut self) -> Result<(), Error>

Creates a transaction that will never be committed. This is useful for tests. Panics if called while inside of a transaction or if called with a connection containing a broken transaction

fn test_transaction<T, E, F>(&mut self, f: F) -> T

where F: FnOnce(&mut Self) -> Result<T, E>, E: Debug,

Executes the given function inside a transaction, but does not commit it. Panics if the given function returns an error.

impl LoadConnection for MysqlConnection

type Cursor<'conn, 'query> = StatementIterator<'conn>

The cursor type returned by LoadConnection::load

type Row<'conn, 'query> = MysqlRow

The row type used as Iterator::Item for the iterator implementation of LoadConnection::Cursor

fn load<'conn, 'query, T>( &'conn mut self, source: T, ) -> Result<<MysqlConnection as LoadConnection>::Cursor<'conn, 'query>, Error>

where T: Query + QueryFragment<<MysqlConnection as Connection>::Backend> + QueryId + 'query, <MysqlConnection as Connection>::Backend: QueryMetadata<<T as Query>::SqlType>,

Executes a given query and returns any requested values

impl MigrationConnection for MysqlConnection

fn setup(&mut self) -> Result<usize, Error>

Setup the following table:

impl MultiConnectionHelper for MysqlConnection

fn to_any<'a>( lookup: &mut <<MysqlConnection as Connection>::Backend as TypeMetadata>::MetadataLookup, ) -> &mut (dyn Any + 'a)

Convert the lookup type to any

fn from_any( lookup: &mut (dyn Any + 'static), ) -> Option<&mut <<MysqlConnection as Connection>::Backend as TypeMetadata>::MetadataLookup>

Get the lookup type from any

impl R2D2Connection for MysqlConnection

fn ping(&mut self) -> Result<(), Error>

Check if a connection is still valid

fn is_broken(&mut self) -> bool

Checks if the connection is broken and should not be reused

impl SimpleConnection for MysqlConnection

fn batch_execute(&mut self, query: &str) -> Result<(), Error>

Execute multiple SQL statements within the same string.

impl<'b, Changes, Output> UpdateAndFetchResults<Changes, Output> for MysqlConnection

where Changes: Copy + Identifiable + AsChangeset<Target = <Changes as HasTable>::Table> + IntoUpdateTarget, <Changes as HasTable>::Table: FindDsl<<Changes as Identifiable>::Id>, UpdateStatement<<Changes as HasTable>::Table, <Changes as IntoUpdateTarget>::WhereClause, <Changes as AsChangeset>::Changeset>: ExecuteDsl<MysqlConnection>, <<Changes as HasTable>::Table as FindDsl<<Changes as Identifiable>::Id>>::Output: LoadQuery<'b, MysqlConnection, Output>, <<Changes as HasTable>::Table as Table>::AllColumns: ValidGrouping<()>, <<<Changes as HasTable>::Table as Table>::AllColumns as ValidGrouping<()>>::IsAggregate: MixedAggregates<No, Output = No>,

fn update_and_fetch(&mut self, changeset: Changes) -> Result<Output, Error>

See the traits documentation.

impl ConnectionSealed for MysqlConnection

impl Send for MysqlConnection