Trait Connection 

pub trait Connection: Send {
    type Database: Database;
    type Options: ConnectOptions<Connection = Self>;

    // Required methods
    fn close(self) -> BoxFuture<'static, Result<(), Error>>;
    fn ping(&mut self) -> BoxFuture<'_, Result<(), Error>>;
    fn begin(
        &mut self,
    ) -> BoxFuture<'_, Result<Transaction<'_, Self::Database>, Error>>
       where Self: Sized;
    fn dbms_name(&mut self) -> BoxFuture<'_, Result<String, Error>>;

    // Provided methods
    fn transaction<'a, F, R, E>(
        &'a mut self,
        callback: F,
    ) -> BoxFuture<'a, Result<R, E>>
       where for<'c> F: FnOnce(&'c mut Transaction<'_, Self::Database>) -> BoxFuture<'c, Result<R, E>> + 'a + Send + Sync,
             Self: Sized,
             R: Send,
             E: From<Error> + Send { ... }
    fn cached_statements_size(&self) -> usize
       where Self::Database: HasStatementCache { ... }
    fn clear_cached_statements(&mut self) -> BoxFuture<'_, Result<(), Error>>
       where Self::Database: HasStatementCache { ... }
    fn connect(url: &str) -> BoxFuture<'static, Result<Self, Error>>
       where Self: Sized { ... }
    fn connect_with(
        options: &Self::Options,
    ) -> BoxFuture<'_, Result<Self, Error>>
       where Self: Sized { ... }
}

Represents a single database connection.

Required Associated Types

type Database: Database

type Options: ConnectOptions<Connection = Self>

Required Methods

fn close(self) -> BoxFuture<'static, Result<(), Error>>

Explicitly close this database connection.

This method is not required for safe and consistent operation. However, it is recommended to call it instead of letting a connection drop as the database backend will be faster at cleaning up resources.

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

Checks if a connection to the database is still valid.

fn begin( &mut self, ) -> BoxFuture<'_, Result<Transaction<'_, Self::Database>, Error>>

where Self: Sized,

Begin a new transaction or establish a savepoint within the active transaction.

Returns a Transaction for controlling and tracking the new transaction.

fn dbms_name(&mut self) -> BoxFuture<'_, Result<String, Error>>

Returns the name of the Database Management System (DBMS) this connection is talking to.

This is intended to be compatible with the ODBC SQL_DBMS_NAME info value and should generally return the same string as an ODBC driver for the same database. This makes it easier to write conditional SQL or feature probes that work across both native and ODBC connections.

Typical return values include:

• “PostgreSQL”
• “MySQL”
• “SQLite”
• “Microsoft SQL Server” (includes Azure SQL)
• ODBC: the exact string reported by the driver via SQL_DBMS_NAME

Implementations for built-in drivers return a well-known constant string, while the ODBC driver queries the underlying driver at runtime.

Provided Methods

fn transaction<'a, F, R, E>( &'a mut self, callback: F, ) -> BoxFuture<'a, Result<R, E>>

where for<'c> F: FnOnce(&'c mut Transaction<'_, Self::Database>) -> BoxFuture<'c, Result<R, E>> + 'a + Send + Sync, Self: Sized, R: Send, E: From<Error> + Send,

Execute the function inside a transaction.

If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.

Example

use sqlx_core_oldapi::connection::Connection;
use sqlx_core_oldapi::error::Error;
use sqlx_core_oldapi::executor::Executor;
use sqlx_core_oldapi::postgres::{PgConnection, PgRow};
use sqlx_core_oldapi::query::query;

conn.transaction(|conn|Box::pin(async move {
    query("select * from ..").fetch_all(conn).await
})).await

fn cached_statements_size(&self) -> usize

where Self::Database: HasStatementCache,

The number of statements currently cached in the connection.

fn clear_cached_statements(&mut self) -> BoxFuture<'_, Result<(), Error>>

where Self::Database: HasStatementCache,

Removes all statements from the cache, closing them on the server if needed.

fn connect(url: &str) -> BoxFuture<'static, Result<Self, Error>>

where Self: Sized,

Establish a new database connection.

A value of Options is parsed from the provided connection string. This parsing is database-specific.

fn connect_with(options: &Self::Options) -> BoxFuture<'_, Result<Self, Error>>

where Self: Sized,

Establish a new database connection with the provided options.

Implementors

impl Connection for AnyConnection

Available on (crate features postgres or mysql or mssql or sqlite or odbc) and crate feature any only.

type Database = Any

type Options = AnyConnectOptions

impl Connection for MssqlConnection

Available on crate feature mssql only.

type Database = Mssql

type Options = MssqlConnectOptions

impl Connection for MySqlConnection

Available on crate feature mysql only.

type Database = MySql

type Options = MySqlConnectOptions

impl Connection for OdbcConnection

Available on crate feature odbc only.

type Database = Odbc

type Options = OdbcConnectOptions

impl Connection for PgConnection

Available on crate feature postgres only.

type Database = Postgres

type Options = PgConnectOptions

impl Connection for SqliteConnection

Available on crate feature sqlite only.

type Database = Sqlite

type Options = SqliteConnectOptions