Struct Statement

Source
pub struct Statement<'a, 'b, S, R, AC: AutocommitMode> { /* private fields */ }
Expand description

A Statement can be used to execute queries and retrieves results.

Implementations§

Source§

impl<'a, 'b, S, R, AC: AutocommitMode> Statement<'a, 'b, S, R, AC>

Source

pub fn bind_parameter<'c, T>( self, parameter_index: u16, value: &'c T, ) -> Result<Statement<'a, 'c, S, R, AC>>
where T: OdbcType<'c> + ?Sized, 'b: 'c,

Binds a parameter to a parameter marker in an SQL statement.

§Result

This method will destroy the statement and create a new one which may not outlive the bound parameter. This is to ensure that the statement will not dereference an invalid pointer during execution.

§Arguments
  • parameter_index - Index of the marker to bind to the parameter. Starting at 1
  • value - Reference to bind to the marker
§Example
let env = create_environment_v3().map_err(|e| e.unwrap())?;
let conn = env.connect("TestDataSource", "", "")?;
let stmt = Statement::with_parent(&conn)?;
let param = 1968;
let stmt = stmt.bind_parameter(1, &param)?;
let sql_text = "SELECT TITLE FROM MOVIES WHERE YEAR = ?";
if let Data(mut stmt) = stmt.exec_direct(sql_text)? {
    // ...
}
Source

pub fn reset_parameters(self) -> Result<Statement<'a, 'a, S, R, AC>>

Releasing all parameter buffers set by bind_parameter. This method consumes the statement and returns a new one those lifetime is no longer limited by the buffers bound.

Source§

impl<'a, 'b, AC: AutocommitMode> Statement<'a, 'b, Allocated, NoResult, AC>

Source

pub fn prepare( self, sql_text: &str, ) -> Result<Statement<'a, 'b, Prepared, NoResult, AC>>

Prepares a statement for execution. Executing a prepared statement is faster than directly executing an unprepared statement, since it is already compiled into an Access Plan. This makes preparing statement a good idea if you want to repeatedly execute a query with a different set of parameters and care about performance.

§Example
let env = create_environment_v3().map_err(|e| e.unwrap())?;
let conn = env.connect("TestDataSource", "", "")?;
let stmt = Statement::with_parent(&conn)?;
let mut stmt = stmt.prepare("SELECT TITLE FROM MOVIES WHERE YEAR = ?")?;

fn print_one_movie_from<'a> (year: u16, stmt: Statement<'a,'a, Prepared, NoResult, safe::AutocommitOn>) -> Result<Statement<'a, 'a, Prepared, NoResult, safe::AutocommitOn>>{
   let stmt = stmt.bind_parameter(1, &year)?;
   let stmt = if let Data(mut stmt) = stmt.execute()?{
       if let Some(mut cursor) = stmt.fetch()?{
           println!("{}", cursor.get_data::<String>(1)?.unwrap());
       }
       stmt.close_cursor()?
   } else {
      panic!("SELECT statement returned no result set");
   };
   stmt.reset_parameters()
};

for year in 1990..2010{
    stmt = print_one_movie_from(year, stmt)?
}
Source

pub fn prepare_bytes( self, bytes: &[u8], ) -> Result<Statement<'a, 'b, Prepared, NoResult, AC>>

Prepares a statement for execution. Executing a prepared statement is faster than directly executing an unprepared statement, since it is already compiled into an Access Plan. This makes preparing statement a good idea if you want to repeatedly execute a query with a different set of parameters and care about performance.

§Example
let env = create_environment_v3().map_err(|e| e.unwrap())?;
let conn = env.connect("TestDataSource", "", "")?;
let stmt = Statement::with_parent(&conn)?;
// need encode_rs crate
// let mut stmt = stmt.prepare_bytes(&GB2312.encode("select '你好' as hello").0)?;
Source§

impl<'a, 'b, AC: AutocommitMode> Statement<'a, 'b, Prepared, NoResult, AC>

Source

pub fn num_result_cols(&self) -> Result<i16>

The number of columns in a result set

Can be called successfully only when the statement is in the prepared, executed, or positioned state. If the statement does not return columns the result will be 0.

Source

pub fn describe_col(&self, idx: u16) -> Result<ColumnDescriptor>

Returns description struct for result set column with a given index. Note: indexing is starting from 1.

Source

pub fn execute(self) -> Result<ResultSetState<'a, 'b, Prepared, AC>>

Executes a prepared statement.

Source§

impl<'a, 'b, 'env, AC: AutocommitMode> Statement<'a, 'b, Allocated, NoResult, AC>

Source

pub fn with_parent(ds: &'a Connection<'env, AC>) -> Result<Self>

Source

pub fn affected_row_count(&self) -> Result<SQLLEN>

Source

pub fn tables( self, catalog_name: &String, schema_name: &String, table_name: &String, table_type: &String, ) -> Result<Statement<'a, 'b, Executed, HasResult, AC>>

Source

pub fn tables_str( self, catalog_name: &str, schema_name: &str, table_name: &str, table_type: &str, ) -> Result<Statement<'a, 'b, Executed, HasResult, AC>>

Source

pub fn tables_opt_str( self, catalog_name: Option<&str>, schema_name: Option<&str>, table_name: Option<&str>, table_type: &str, ) -> Result<Statement<'a, 'b, Executed, HasResult, AC>>

Source

pub fn exec_direct( self, statement_text: &str, ) -> Result<ResultSetState<'a, 'b, Executed, AC>>

Executes a preparable statement, using the current values of the parameter marker variables if any parameters exist in the statement.

SQLExecDirect is the fastest way to submit an SQL statement for one-time execution.

Source

pub fn exec_direct_bytes( self, bytes: &[u8], ) -> Result<ResultSetState<'a, 'b, Executed, AC>>

Executes a preparable statement, using the current values of the parameter marker variables if any parameters exist in the statement.

SQLExecDirect is the fastest way to submit an SQL statement for one-time execution.

Source§

impl<'a, 'b, S, AC: AutocommitMode> Statement<'a, 'b, S, HasResult, AC>

Source

pub fn affected_row_count(&self) -> Result<SQLLEN>

Source

pub fn num_result_cols(&self) -> Result<i16>

The number of columns in a result set

Can be called successfully only when the statement is in the prepared, executed, or positioned state. If the statement does not return columns the result will be 0.

Source

pub fn describe_col(&self, idx: u16) -> Result<ColumnDescriptor>

Returns description struct for result set column with a given index. Note: indexing is starting from 1.

Source

pub fn fetch<'s>(&'s mut self) -> Result<Option<Cursor<'s, 'a, 'b, S, AC>>>

Fetches the next rowset of data from the result set and returns data for all bound columns.

Source

pub fn close_cursor(self) -> Result<Statement<'a, 'b, S, NoResult, AC>>

Call this method to reuse the statement to execute another query.

For many drivers allocating new statements is expensive. So reusing a Statement is usually more efficient than freeing an existing and allocating a new one. However to reuse a statement any open result sets must be closed. Only call this method if you have already read the result set returned by the previous query, or if you do no not intend to read it.

§Example
let env = create_environment_v3().map_err(|e| e.unwrap())?;
let conn = env.connect("TestDataSource", "", "")?;
let stmt = Statement::with_parent(&conn)?;
let stmt = match stmt.exec_direct("CREATE TABLE STAGE (A TEXT, B TEXT);")?{
    // Some drivers will return an empty result set. We need to close it before we can use
    // statement again.
    Data(stmt) => stmt.close_cursor()?,
    NoData(stmt) => stmt,
};
let stmt = stmt.exec_direct("INSERT INTO STAGE (A, B) VALUES ('Hello', 'World');")?;
//...

Trait Implementations§

Source§

impl<'a, 'b, S, R, AC: AutocommitMode> Handle for Statement<'a, 'b, S, R, AC>

Source§

type To = Stmt

Source§

unsafe fn handle(&self) -> SQLHSTMT

Returns a valid handle to the odbc type.
Source§

impl<'con, 'param, C, P, AC: AutocommitMode> Handle for Statement<'con, 'param, C, P, AC>

Source§

const HANDLE_TYPE: HandleType = ffi::SQL_HANDLE_STMT

Used to identify the type of the handle in various functions of the ODBC C interface
Source§

fn handle(&self) -> SQLHANDLE

Returns a ptr to the wrapped ODBC Object

Auto Trait Implementations§

§

impl<'a, 'b, S, R, AC> Freeze for Statement<'a, 'b, S, R, AC>

§

impl<'a, 'b, S, R, AC> RefUnwindSafe for Statement<'a, 'b, S, R, AC>

§

impl<'a, 'b, S, R, AC> !Send for Statement<'a, 'b, S, R, AC>

§

impl<'a, 'b, S, R, AC> !Sync for Statement<'a, 'b, S, R, AC>

§

impl<'a, 'b, S, R, AC> Unpin for Statement<'a, 'b, S, R, AC>
where S: Unpin, AC: Unpin, R: Unpin,

§

impl<'a, 'b, S, R, AC> UnwindSafe for Statement<'a, 'b, S, R, AC>
where S: UnwindSafe, AC: UnwindSafe, R: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<H> Diagnostics for H
where H: Handle,

Source§

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

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

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<D> GetDiagRec for D
where D: Diagnostics,

Source§

fn get_diag_rec(&self, record_number: i16) -> Option<DiagnosticRecord>

Retrieves a diagnostic record Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.