Struct Environment 

pub struct Environment<V: VersionOption> { /* private fields */ }

An Environment is a global context, in which to access data.

Associated with an Environment is any information that is global in nature, such as:

• The Environment’s state
• The current environment-level diagnostics
• The handles of connections currently allocated on the environment
• The current stetting of each environment attribute

See: [Environment Handles in the ODBC Reference][1] [1]: https://docs.microsoft.com/sql/odbc/reference/develop-app/environment-handles

Implementations

impl<V: VersionOption> Environment<V>

pub fn as_raw(&self) -> SQLHENV

Provides access to the raw ODBC environment handle.

impl<V: Version> Environment<V>

pub fn data_sources( &mut self, direction: FetchOrientation, server_name: &mut [u8], description: &mut [u8], ) -> ReturnOption<(SQLSMALLINT, SQLSMALLINT)>

Fills buffers with information about the available datasources

A 32 / 64 Bit Application will only return information about either 32 or 64 Bit DataSources.

Returns

(server_name_length, description_length)

See [SQLDataSources][1] [1]: https://docs.microsoft.com/sql/odbc/reference/syntax/sqldatasources-function

Examples found in repository

examples/list_datasources.rs (line 20)

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()
        );
    }
}

pub fn drivers( &mut self, direction: FetchOrientation, description: &mut [u8], attributes: &mut [u8], ) -> ReturnOption<(SQLSMALLINT, SQLSMALLINT)>

Fills buffers with information about the available datasources

A 32 / 64 Bit Application will only return information about either 32 or 64 Bit DataSources.

Returns

(description_length, attributes_length)

See [SQLDrivers][1] [1]: https://docs.microsoft.com/sql/odbc/reference/syntax/sqldrivers-function

Examples found in repository

examples/list_drivers.rs (line 20)

fn main() {

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

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

    println!("ODBC Drivers:");

    loop {
        let (description_length, attributes_length) =
            match env.drivers(SQL_FETCH_NEXT, &mut description, &mut attributes) {
                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!(
            "\tDescription: {}\n\tAttributes: {}\n",
            from_utf8(&description[..(description_length as usize)]).unwrap(),
            from_utf8(&attributes[..(attributes_length as usize)]).unwrap()
        );
    }
}

impl Environment<NoVersion>

pub fn new() -> Return<Self>

Allocates a new Environment

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),
    }
}

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),
    }
}

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!("");
    }
}

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'");
}

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 declare_version<V: Version>( self, ) -> Return<Environment<V>, Environment<NoVersion>>

Before an application allocates a connection which specification it follows. Currently these bindings only support ODBC 3.x.

It is valid to specify ODBC 3.x even then connecting to an ODBC 2.x driver. Applications must however avoid calling 3.x functionality on 2.x drivers. Since drivers are connected at runtime, these kind of errors can not be catched by the type system.

pub fn declare_version_3_8( self, ) -> Return<Environment<Odbc3m8>, Environment<NoVersion>>

Before an application allocates a connection which specification it follows. Currently these bindings only support ODBC 3.x.

It is valid to specify ODBC 3.x even then connecting to an ODBC 2.x driver. Applications must however avoid calling 3.x functionality on 2.x drivers. Since drivers are connected at runtime, these kind of errors can not be catched by the type system.

This method is a shorthand for declare_version::<Odbc3m8>.

pub fn declare_version_3( self, ) -> Return<Environment<Odbc3>, Environment<NoVersion>>

Before an application allocates a connection which specification it follows. Currently these bindings only support ODBC 3.x.

It is valid to specify ODBC 3.x even then connecting to an ODBC 2.x driver. Applications must however avoid calling 3.x functionality on 2.x drivers. Since drivers are connected at runtime, these kind of errors can not be catched by the type system.

This method is a shorthand for declare_version::<Odbc3>.

Examples found in repository

examples/bind_columns.rs (line 48)

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),
    }
}

examples/print_table.rs (line 48)

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),
    }
}

examples/prepared_query.rs (line 9)

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!("");
    }
}

examples/affected_row_count.rs (line 8)

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'");
}

examples/transactions.rs (line 7)

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 11)

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

Trait Implementations

impl<V: Debug + VersionOption> Debug for Environment<V>

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

Formats the value using the given formatter.

impl<V: VersionOption> Diagnostics for Environment<V>

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.