Enum AnyConnection

pub enum AnyConnection {
    Postgresql(PgConnection),
    Sqlite(SqliteConnection),
}

Represents a connection to either a PostgreSQL or SQLite database.

Variants

Postgresql(PgConnection)

A connection to a PostgreSQL database.

This is used when the database_url is a PostgreSQL URL.

Example

postgres://user:password@localhost:5432/database

Sqlite(SqliteConnection)

A connection to a SQLite database.

This is used when the database_url is a SQLite URL.

Note: The directory where the database is stored will also be populated with a WAL file and a journal file.

Example

# Relative path
sqlite://database.db
sqlite://data/database.db

# Absolute path
sqlite:///data/database.db

# In-memory database
sqlite://:memory: # In-memory database

Implementations

impl AnyConnection

pub fn pre_init(database_url: &str) -> Result<()>

pub fn migrate(&mut self) -> Result<()>

pub fn save_changes(&mut self, ev: &mut ScanEvent) -> Result<ScanEvent>

pub fn insert_and_return(&mut self, ev: &NewScanEvent) -> Result<ScanEvent>

Trait Implementations

impl Connection for MultiConnection

type Backend = MultiBackend

The backend this type connects to

fn establish(database_url: &str) -> ConnectionResult<Self>

Establishes a new connection to the database

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

Set a specific [Instrumentation] implementation for this connection

fn set_prepared_statement_cache_size(&mut self, size: CacheSize)

Set the prepared statement cache size to [CacheSize] for this connection

fn begin_test_transaction(&mut self) -> QueryResult<()>

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 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 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 MultiConnection

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

The cursor type returned by [LoadConnection::load]

type Row<'conn, 'query> = MultiRow<'conn, 'query>

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

impl MigrationConnection for MultiConnection

fn setup(&mut self) -> QueryResult<usize>

Setup the following table:

impl R2D2Connection for MultiConnection

fn ping(&mut self) -> QueryResult<()>

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 MultiConnection

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

Execute multiple SQL statements within the same string.

impl TransactionManager<AnyConnection> for MultiConnection

type TransactionStateData = AnyConnection

Data stored as part of the connection implementation to track the current transaction state of a connection

fn begin_transaction(conn: &mut MultiConnection) -> QueryResult<()>

Begin a new transaction or savepoint

fn rollback_transaction(conn: &mut MultiConnection) -> QueryResult<()>

Rollback the inner-most transaction or savepoint

fn commit_transaction(conn: &mut MultiConnection) -> QueryResult<()>

Commit the inner-most transaction or savepoint

fn transaction<F, R, E>(conn: &mut Conn, callback: F) -> Result<R, E>

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

Executes the given function inside of a database transaction

impl ConnectionSealed for MultiConnection