Struct diesel_oci::OciConnection

pub struct OciConnection { /* private fields */ }

Connections for the Oracle backend. The following connection url schema is supported:

oracle://user:password@host:[port]/database

where:

• user is your username
• password is the corresponding password
• host is the hostname/ip address of the database server
• port is an optional port number
• database is your database name

Supported loading model implementations

• [DefaultLoadingMode]

As OciConnection 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

OciConnection only supports a single loading mode, which internally loads all values at once.

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

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

Establishes a new connection to the database at the given URL. The URL should be a valid connection string for a given backend. See the documentation for the specific backend for specifics.

type Backend = Oracle

The backend this type connects to

type TransactionManager = OCITransactionManager

The transaction manager implementation used by this connection

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

Get access to the current transaction state of 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) -> Twhere 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.

fn execute_returning_count<T>(&mut self, source: &T) -> Result<usize, Error>where T: QueryFragment<Self::Backend, NotSpecialized> + QueryId,

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

impl Drop for OciConnection

fn drop(&mut self)

Executes the destructor for this type.

impl<V, T, QId, Op, const STATIC_QUERY_ID: bool> ExecuteDsl<OciConnection, <OciConnection as Connection>::Backend> for (Yes, InsertStatement<T, BatchInsert<Vec<ValuesClause<V, T>>, T, QId, STATIC_QUERY_ID>, Op>)where T: Table + Copy + QueryId + 'static, T::FromClause: QueryFragment<Oracle>, Op: Copy + QueryId + QueryFragment<Oracle>, V: InsertValues<T, Oracle> + CanInsertInSingleQuery<Oracle> + QueryId,

fn execute((Yes, query): Self, conn: &mut OciConnection) -> QueryResult<usize>

Execute this command

impl<V, T, QId, Op, const STATIC_QUERY_ID: bool> ExecuteDsl<OciConnection, Oracle> for (No, InsertStatement<T, BatchInsert<V, T, QId, STATIC_QUERY_ID>, Op>)where T: Table + QueryId + 'static, T::FromClause: QueryFragment<Oracle>, Op: QueryFragment<Oracle> + QueryId, OracleBatchInsertWrapper<V, T, QId, STATIC_QUERY_ID>: QueryFragment<Oracle> + QueryId + CanInsertInSingleQuery<Oracle>,

fn execute((No, query): Self, conn: &mut OciConnection) -> QueryResult<usize>

Execute this command

impl<V, T, QId, Op, O, const STATIC_QUERY_ID: bool> ExecuteDsl<OciConnection, Oracle> for InsertStatement<T, BatchInsert<Vec<ValuesClause<V, T>>, T, QId, STATIC_QUERY_ID>, Op>where T: QuerySource, V: ContainsDefaultableValue<Out = O>, O: Default, (O, Self): ExecuteDsl<OciConnection, Oracle>,

fn execute(query: Self, conn: &mut OciConnection) -> QueryResult<usize>

Execute this command

impl LoadConnection<DefaultLoadingMode> for OciConnection

type Cursor<'conn, 'query> = RowIter

The cursor type returned by LoadConnection::load

type Row<'conn, 'query> = OciRow

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

fn load<'conn, 'query, T>(&'conn mut self, source: T) -> QueryResult<RowIter>where T: AsQuery, T::Query: QueryFragment<Self::Backend> + QueryId + 'query, Self::Backend: QueryMetadata<T::SqlType>,

Executes a given query and returns any requested values

impl MigrationConnection for OciConnection

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

Setup the following table:

impl MultiConnectionHelper for OciConnection

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

Convert the lookup type to any

fn from_any( lookup: &mut dyn Any ) -> Option<&mut <Self::Backend as TypeMetadata>::MetadataLookup>

Get the lookup type from any

impl R2D2Connection for OciConnection

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 OciConnection

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

Execute multiple SQL statements within the same string.

impl<'query, Changes, Output> UpdateAndFetchResults<Changes, Output> for OciConnectionwhere Changes: Copy + Identifiable + AsChangeset<Target = <Changes as HasTable>::Table> + IntoUpdateTarget, Changes::Table: FindDsl<Changes::Id>, Update<Changes, Changes>: ExecuteDsl<OciConnection> + AsQuery, Find<Changes::Table, Changes::Id>: LoadQuery<'query, OciConnection, Output>,

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

See the traits documentation.

impl ConnectionSealed for OciConnection

impl Send for OciConnection