Struct odbc_api::Preallocated

pub struct Preallocated<'open_connection> { /* fields omitted */ }

A preallocated SQL statement handle intended for sequential execution of different queries. See crate::Connection::preallocate.

Example

use odbc_api::{Connection, Error};
use std::io::{self, stdin, Read};

fn interactive(conn: &Connection) -> io::Result<()>{
    let mut statement = conn.preallocate().unwrap();
    let mut query = String::new();
    stdin().read_line(&mut query)?;
    while !query.is_empty() {
        match statement.execute(&query, ()) {
            Err(e) => println!("{}", e),
            Ok(None) => println!("No results set generated."),
            Ok(Some(cursor)) => {
                // ...print cursor contents...
            },
        }
        stdin().read_line(&mut query)?;
    }
    Ok(())
}

Implementations

impl<'o> Preallocated<'o>

pub fn execute_utf16(
    &mut self,
    query: &U16Str,
    params: impl ParameterCollection
) -> Result<Option<CursorImpl<'o, &mut StatementImpl<'o>>>, Error>

Executes an sql statement using a wide string. See Self::execute.

pub fn execute(
    &mut self,
    query: &str,
    params: impl ParameterCollection
) -> Result<Option<CursorImpl<'o, &mut StatementImpl<'o>>>, Error>

Executes a statement. This is the fastest way to sequentially execute different SQL Statements.

Parameters

• query: The text representation of the SQL statement. E.g. “SELECT * FROM my_table;”.
• params: ? may be used as a placeholder in the statement text. You can use () to represent no parameters. Check the crate::parameter module level documentation for more information on how to pass parameters.

Return

Returns Some if a cursor is created. If None is returned no cursor has been created ( e.g. the query came back empty). Note that an empty query may also create a cursor with zero rows. Since we want to reuse the statement handle a returned cursor will not take ownership of it and instead burrow it.

Example

use odbc_api::{Connection, Error};
use std::io::{self, stdin, Read};

fn interactive(conn: &Connection) -> io::Result<()>{
    let mut statement = conn.preallocate().unwrap();
    let mut query = String::new();
    stdin().read_line(&mut query)?;
    while !query.is_empty() {
        match statement.execute(&query, ()) {
            Err(e) => println!("{}", e),
            Ok(None) => println!("No results set generated."),
            Ok(Some(cursor)) => {
                // ...print cursor contents...
            },
        }
        stdin().read_line(&mut query)?;
    }
    Ok(())
}

pub fn into_statement(self) -> StatementImpl<'o>

Transfer ownership to the underlying statement handle.

The resulting type is one level of indirection away from the raw pointer of the ODBC API. It no longer has any guarantees about bound buffers, but is still guaranteed to be a valid allocated statement handle. This serves together with crate::handles::StatementImpl::into_sys or crate::handles::Statement::as_sys this serves as an escape hatch to access the functionality provided by crate::sys not yet accessible through safe abstractions.

pub fn columns(
    &mut self,
    catalog_name: &str,
    schema_name: &str,
    table_name: &str,
    column_name: &str
) -> Result<Option<CursorImpl<'o, &mut StatementImpl<'o>>>, Error>

Query all columns that match the provided catalog name, schema pattern, table pattern, and column pattern.