Enum Return 

pub enum Return<T, E = ()> {
    Success(T),
    Info(T),
    Error(E),
}

Holds result and indicates the overall success or failure of a function.

Variants

Success(T)

The function has been executed successfully. Holds result.

Info(T)

The function has been executed successfully. There have been warnings. Holds result.

Error(E)

An error occured.

Implementations

impl<T, E> Return<T, E>

pub fn map<F, U>(self, f: F) -> Return<U, E>

where F: FnOnce(T) -> U,

Maps a Return<T,E> to Return<U,E> by applying a function to a contained Success or Info value, leaving an Error value untouched.

pub fn map_error<F, U>(self, f: F) -> Return<T, U>

where F: FnOnce(E) -> U,

Maps a Return<T,E> to Result<T,U> by applying a function to a contained Error value, leaving a Successor anInfo` value untouched.

pub fn unwrap(self) -> T

Unwraps the result, yielding the content of Success or Info

Examples found in repository

examples/bind_columns.rs (line 47)

fn main() {

    let env = Environment::new().unwrap();
    let env = env.declare_version_3().unwrap();

    match run(&env) {
        Ok(()) => (),
        Err(LastError(message)) => println!("An error occurred: {}", message),
    }
}

fn run(env: &Environment<Odbc3>) -> MyResult<()> {

    let conn = connect(env)?;
    let result_set = execute_query(&conn)?;
    print_fields(result_set)
}

fn connect<V>(env: &Environment<V>) -> MyResult<Connection<impl AutocommitMode>>
where
    V: Version,
{
    let conn = DataSource::with_parent(env).unwrap();
    conn.connect("TestDataSource", "", "").into_result()
}

fn execute_query<'a, AC: AutocommitMode>(conn: &'a Connection<AC>) -> MyResult<ResultSet<'a, 'a, 'a, Unprepared>> {
    let stmt = Statement::with_parent(conn).unwrap();
    match stmt.exec_direct("SELECT year, title FROM Movies") {
        ReturnOption::Success(s) |
        ReturnOption::Info(s) => Ok(s),
        ReturnOption::NoData(_) => Err(LastError(
            "Statement did not return a Result Set.".to_owned(),
        )),
        ReturnOption::Error(e) => Err(e.into()),
    }
}

examples/print_table.rs (line 47)

fn main() {

    let env = Environment::new().unwrap();
    let env = env.declare_version_3().unwrap();

    match run(&env) {
        Ok(()) => (),
        Err(LastError(message)) => println!("An error occurred: {}", message),
    }
}

fn run(env: &Environment<Odbc3>) -> MyResult<()> {

    let conn = connect(&env)?;
    let result_set = execute_query(&conn)?;
    print_fields(result_set)
}

fn connect<V>(env: &Environment<V>) -> MyResult<Connection<impl AutocommitMode>>
where
    V: Version,
{
    let conn = DataSource::with_parent(env).unwrap();
    conn.connect("TestDataSource", "", "").into_result()
}

fn execute_query<'a, AC: AutocommitMode>(conn: &'a Connection<AC>) -> MyResult<ResultSet<'a, 'a, 'a, Unprepared>> {
    let stmt = Statement::with_parent(conn).unwrap();
    match stmt.exec_direct("SELECT * FROM MOVIES") {
        ReturnOption::Success(s) |
        ReturnOption::Info(s) => Ok(s),
        ReturnOption::NoData(_) => Err(LastError(
            "Statement did not return a Result Set.".to_owned(),
        )),
        ReturnOption::Error(e) => Err(e.into()),
    }
}

fn print_fields(result_set: ResultSet<Unprepared>) -> MyResult<()> {
    let cols = result_set.num_result_cols().unwrap();
    let mut buffer = [0u8; 512];
    let mut cursor = match result_set.fetch() {
        ReturnOption::Success(r) |
        ReturnOption::Info(r) => r,
        ReturnOption::NoData(_) => return Ok(()),
        ReturnOption::Error(e) => return Err(e.into()),
    };
    loop {
        for index in 1..(cols + 1) {
            match cursor.get_data(index as u16, &mut buffer as &mut [u8]) {
                ReturnOption::Success(ind) |
                ReturnOption::Info(ind) => {
                    match ind {
                        Indicator::NoTotal => panic!("No Total"),
                        Indicator::Null => println!("NULL"),
                        Indicator::Length(l) => {
                            print!("{}", from_utf8(&buffer[0..l as usize]).unwrap());
                        }
                    }
                }
                ReturnOption::NoData(_) => panic!("No Field Data"),
                ReturnOption::Error(_) => return Err(cursor.into()),
            }
            print!(" | ");
        }
        cursor = match cursor.fetch() {
            ReturnOption::Success(r) |
            ReturnOption::Info(r) => r,
            ReturnOption::NoData(_) => break Ok(()),
            ReturnOption::Error(e) => break Err(e.into()),
        };
        println!("");
    }
}

examples/prepared_query.rs (line 8)

fn main() {

    let env = Environment::new().unwrap();
    let env = env.declare_version_3().unwrap();
    let conn = connect(&env);
    let mut stmt = prepare_query(&conn);
    for &year in [1968, 1993].iter() {
        let result_set = execute_query(stmt, year);
        stmt = print_fields(result_set);
        println!("");
    }
}

fn connect<V>(env: &Environment<V>) -> Connection<impl AutocommitMode>
where
    V: Version,
{
    let conn = DataSource::with_parent(env).unwrap();
    conn.connect("TestDataSource", "", "").unwrap()
}

fn prepare_query<'a, AC: AutocommitMode>(conn: &'a Connection<AC>) -> Statement<'a, 'a, 'a, NoCursor, Prepared> {
    let stmt = Statement::with_parent(conn).unwrap();
    stmt.prepare("SELECT TITLE FROM MOVIES WHERE YEAR = ?")
        .unwrap()
}

fn execute_query<'a>(
    stmt: Statement<'a, 'a, 'a, NoCursor, Prepared>,
    year: i32,
) -> ResultSet<'a, 'a, 'a, Prepared> {
    let stmt = stmt.bind_input_parameter(1, DataType::Integer, &year, None)
        .unwrap();
    let stmt = match stmt.execute() {
        ReturnOption::Success(s) |
        ReturnOption::Info(s) => s,
        ReturnOption::NoData(_) |
        ReturnOption::Error(_) => panic!("No Result Set"),
    };
    stmt.reset_parameters()
}

examples/affected_row_count.rs (line 7)

fn main() {
    let env = Environment::new().unwrap();
    let env = env.declare_version_3().unwrap();
    let conn = DataSource::with_parent(&env).unwrap();
    let conn = conn.connect("TestDataSource", "", "").unwrap();
    exec(&conn, "INSERT INTO movies (title, year) VALUES ('TEST movie', 9999), ('TEST movie', 9998)");
    exec(&conn, "DELETE FROM movies WHERE title = 'TEST movie'");
}

fn exec(conn: &Connection<AutocommitOn>, sql: &str) {
    let stmt = Statement::with_parent(conn).unwrap();
    let rs = match stmt.exec_direct(sql) {
        ReturnOption::Success(s) |
        ReturnOption::Info(s) => Ok(s),
        ReturnOption::NoData(_) => Err("Statement did not return a Result Set.".to_owned()),
        ReturnOption::Error(_) => Err("Error".to_owned()),
    };

    let row_count = rs.unwrap().affected_row_count();
    println!("Affected row count for last statement: {:?}", row_count);
}

examples/transactions.rs (line 6)

fn main() {
    let env = Environment::new().unwrap();
    let env = env.declare_version_3().unwrap();

    let ds = DataSource::with_parent(&env).unwrap();
    let conn = ds.connect("TestDataSource", "", "").unwrap();
    let mut conn = conn.disable_autocommit().unwrap();

    {
        //Any statement now will start transaction which could be ended with conn.commit() or conn.rollback()
        //If either commit or rollback was not called before connection drop automatic rollback will be issued
        let stmt = Statement::with_parent(&conn).unwrap();
        let res = stmt.exec_direct("SELECT 'HELLO' FROM MOVIES");
        println!("Result {:?}", res);
    }

    let end_tx_result = conn.commit();

    println!("End TX result {:?}", end_tx_result);
}

examples/list_datasources.rs (line 10)

fn main() {

    let env = Environment::new().unwrap();
    let mut env = env.declare_version_3().unwrap();

    let mut server_name = [0; 512];
    let mut description = [0; 512];

    println!("ODBC Data Sources:");

    loop {
        let (name_length, description_length) =
            match env.data_sources(SQL_FETCH_NEXT, &mut server_name, &mut description) {
                ReturnOption::Success(v) => v,
                ReturnOption::Info(_) => panic!("Buffers not large enough. Truncation occurred."),
                ReturnOption::NoData(()) => break,
                ReturnOption::Error(()) => {
                    panic!("Error occurred. Could use diagnostics to learn more")
                }
            };

        println!(
            "\tName: {}\n\tDescription: {}\n",
            from_utf8(&server_name[..(name_length as usize)]).unwrap(),
            from_utf8(&description[..(description_length as usize)]).unwrap()
        );
    }
}

Additional examples can be found in:

• examples/list_drivers.rs

pub fn success<U>(self) -> Result<T, U>

where U: From<E>,

Transforms the Return<T,E> into a Result<T,U>, mapping Success(v) | Info(v) to Ok(v) and Error(err) to Err(err.into()).

Trait Implementations

impl<T: Debug, E: Debug> Debug for Return<T, E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S, E> Diagnostics for Return<S, E>

where S: Diagnostics, E: Diagnostics,

fn diagnostics( &self, rec_number: SQLSMALLINT, message_text: &mut [SQLCHAR], ) -> ReturnOption<DiagResult>

Returns the current values of multiple fields of a diagnostic record that contains error, warning, and status information.

impl From<SQLRETURN> for Return<()>

fn from(source: SQLRETURN) -> Return<()>

Converts to this type from the input type.