Struct odbc_api::parameter::VarChar

pub struct VarChar<B> { /* fields omitted */ }

A mutable buffer for character data which can be used as either input parameter or ouput buffer. It can not be used for columar bulk fetches, but if the buffer type is stack allocated in can be utilized in row wise bulk fetches.

This type is very similar to self::VarCharRef and indeed it can perform many of the same tasks, since self::VarCharRef is exclusive used as an input parameter though it must not account for a terminating zero at the end of the buffer.

Implementations

impl<B> VarChar<B> where
    B: BorrowMut<[u8]>, 

pub fn from_buffer(buffer: B, indicator: Option<usize>) -> Self

Creates a new instance. It takes ownership of the buffer. The indicator tells us up to which position the buffer is filled. Pass None for the indicator to create a value representing NULL. The constructor will write a terminating zero after the end of the valid sequence in the buffer.

pub fn copy_from_bytes(bytes: Option<&[u8]>) -> Self where
    B: Default, 

Construct a new VarChar and copy the value of the slice into the internal buffer. None indicates NULL.

pub fn as_bytes(&self) -> Option<&[u8]>

Returns the binary representation of the string, excluding the terminating zero.

pub fn is_complete(&self) -> bool

Call this method to ensure that the entire field content did fit into the buffer. If you retrieve a field using crate::CursorRow::get_data, you can repeat the call until this method is false to read all the data.

use odbc_api::{CursorRow, parameter::VarChar512, Error, handles::Statement};

fn process_large_text<S: Statement>(
    col_index: u16,
    row: &mut CursorRow<S>
) -> Result<(), Error>{
    let mut buf = VarChar512::from_buffer([0;512], None);
    row.get_data(col_index, &mut buf)?;
    while !buf.is_complete() {
        // Process bytes in stream without allocation. We can assume repeated calls to
        // get_data do not return `None` since it would have done so on the first call.
        process_text_slice(buf.as_bytes().unwrap());
    }
    Ok(())
}

fn process_text_slice(text: &[u8]) { /*...*/}

pub fn indicator(&self) -> isize

Read access to the underlying ODBC indicator. After data has been fetched the indicator value is set to the length the buffer should have had, excluding the terminating zere. It may also be NULL_DATA to indicate NULL or NO_TOTAL which tells us the data source does not know how big the buffer must be to hold the complete value. NO_TOTAL implies that the content of the current buffer is valid up to its maximum capacity.

Trait Implementations

impl<B> CData for VarChar<B> where
    B: Borrow<[u8]>, 

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.

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. 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<B> CDataMut for VarChar<B> where
    B: BorrowMut<[u8]>, 

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<B: Clone> Clone for VarChar<B>

fn clone(&self) -> VarChar<B>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Copy> Copy for VarChar<B>

impl<B: Debug> Debug for VarChar<B>

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

Formats the value using the given formatter.

impl<B> HasDataType for VarChar<B> where
    B: Borrow<[u8]>, 

fn data_type(&self) -> DataType

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

impl<'a> InputParameter for VarChar<&'a [u8]>