Struct FbConnection 

pub struct FbConnection {
    pub raw: SimpleConnection,
    /* private fields */
}

Fields

raw: SimpleConnection

Implementations

impl FbConnection

pub fn init(conn: FbRawConnection) -> ConnectionResult<Self>

Create a diesel instance from a active firebird connection

Trait Implementations

impl Connection for FbConnection

type TransactionManager = FbTransactionManager

The transaction manager implementation used by this connection

type Backend = Fb

The backend this type connects to

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

Establishes a new connection to the database

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

where T: QueryFragment<Self::Backend> + QueryId,

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

fn transaction_state( &mut self, ) -> &mut <Self::TransactionManager as TransactionManager<Self>>::TransactionStateData

Get access to the current transaction state of 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<'conn, 'query> ConnectionGatWorkaround<'conn, 'query, Fb> for FbConnection

type Cursor = Box<dyn Iterator<Item = Result<<FbConnection as ConnectionGatWorkaround<'conn, 'query, Fb>>::Row, Error>>>

The cursor type returned by LoadConnection::load

type Row = FbRow

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

impl LoadConnection for FbConnection

where (): Helper,

fn load<'conn, 'query, T>( &'conn mut self, source: T, ) -> QueryResult<LoadRowIter<'conn, 'query, Self, Self::Backend, DefaultLoadingMode>>

where T: Query + QueryFragment<Self::Backend> + QueryId + 'query, Self::Backend: QueryMetadata<T::SqlType>,

Executes a given query and returns any requested values

impl SimpleConnection for FbConnection

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

Execute multiple SQL statements within the same string.

impl TransactionManager<FbConnection> for FbTransactionManager

type TransactionStateData = FbTransactionManager

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

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

Begin a new transaction or savepoint

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

Rollback the inner-most transaction or savepoint

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

Commit the inner-most transaction or savepoint

fn transaction_manager_status_mut( conn: &mut FbConnection, ) -> &mut TransactionManagerStatus

Fetch the current transaction status as mutable

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

fn is_broken_transaction_manager(conn: &mut Conn) -> bool

This methods checks if the connection manager is considered to be broken by connection pool implementations