Struct odbc_api::parameter::WithDataType

pub struct WithDataType<T> {
    pub value: T,
    pub data_type: DataType,
}

Annotates an instance of an inner type with an SQL Data type in order to indicate how it should be bound as a parameter to an SQL Statement.

Example

use odbc_api::{Environment, ConnectionOptions, DataType, parameter::WithDataType};

let env = Environment::new()?;

let mut conn = env.connect(
    "YourDatabase", "SA", "My@Test@Password1",
    ConnectionOptions::default()
)?;
// Bind year as VARCHAR(4) rather than integer.
let year = WithDataType{
   value: 1980,
   data_type: DataType::Varchar {length: 4}
};
if let Some(cursor) = conn.execute("SELECT year, name FROM Birthdays WHERE year > ?;", &year)? {
    // Use cursor to process query results.
}

Can also be used to wrap crate::sys::Timestamp so they implement OutputParameter.

let mut ts = WithDataType {
    value: Timestamp::default(),
    data_type: DataType::Timestamp { precision: 0 },
};
connection.execute(
    "INSERT INTO Posts (text, timestamps) VALUES (?,?)",
    (&"Hello".into_parameter(), &ts.into_parameter())
);

Fields

value: T

Value to wrap with a Data Type. Should implement crate::handles::CData, to be useful.

data_type: DataType

The SQL type this value is supposed to map onto. What exactly happens with this information is up to the ODBC driver in use.

Trait Implementations

impl<'a, T> BoundInputSlice<'a> for WithDataType<T>where T: BoundInputSlice<'a>,

type SliceMut = <T as BoundInputSlice<'a>>::SliceMut

Intended to allow for modifying buffer contents, while leaving the bound parameter buffers valid.

unsafe fn as_view_mut( &'a mut self, parameter_index: u16, stmt: StatementRef<'a> ) -> Self::SliceMut

Obtain a mutable view on a parameter buffer in order to change the parameter value(s) submitted when executing the statement.

impl<T> CData for WithDataType<T>where T: CData,

fn cdata_type(&self) -> CDataType

The identifier of the C data type of the value buffer. When it is retrieving data from the data source with fetch, the driver converts the data to this type. When it sends data to the source, the driver converts the data from this type.

fn indicator_ptr(&self) -> *const isize

Indicates the length of variable sized types. May be zero for fixed sized types. Used to determine the size or existence of input parameters.

fn value_ptr(&self) -> *const c_void

Pointer to a value corresponding to the one described by cdata_type.

fn buffer_length(&self) -> isize

Maximum length of the type in bytes (not characters). It is required to index values in bound buffers, if more than one parameter is bound. Can be set to zero for types not bound as parameter arrays, i.e. CStr.

impl<T> CDataMut for WithDataType<T>where T: CDataMut,

fn mut_indicator_ptr(&mut self) -> *mut isize

Indicates the length of variable sized types. May be zero for fixed sized types.

fn mut_value_ptr(&mut self) -> *mut c_void

Pointer to a value corresponding to the one described by cdata_type.

impl<T> ColumnBuffer for WithDataType<T>where T: ColumnBuffer,

type View<'a> where T: 'a = <T as ColumnBuffer>::View<'a>

Immutable view on the column data. Used in safe abstractions. User must not be able to access uninitialized or invalid memory of the buffer through this interface.

fn view(&self, valid_rows: usize) -> T::View<'_>

Num rows may not exceed the actually amount of valid num_rows filled be the ODBC API. The column buffer does not know how many elements were in the last row group, and therefore can not guarantee the accessed element to be valid and in a defined state. It also can not panic on accessing an undefined element.

fn fill_default(&mut self, from: usize, to: usize)

Fills the column with the default representation of values, between from and to index.

fn capacity(&self) -> usize

Current capacity of the column

fn has_truncated_values(&self, num_rows: usize) -> bool

true if any value is truncated in the range [0, num_rows).

impl<T: Debug> Debug for WithDataType<T>

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

Formats the value using the given formatter.

impl<T> HasDataType for WithDataType<T>

fn data_type(&self) -> DataType

The SQL data as which the parameter is bound to ODBC.

impl<T> CElement for WithDataType<T>where T: CElement,

impl<T> OutputParameter for WithDataType<T>where T: Pod,