Struct TextColumnSliceMut

pub struct TextColumnSliceMut<'a, C> { /* private fields */ }

A view to a mutable array parameter text buffer, which allows for filling the buffer with values.

Implementations

impl<'a, C> TextColumnSliceMut<'a, C>

where C: Default + Copy,

pub fn set_cell(&mut self, row_index: usize, element: Option<&[C]>)

Sets the value of the buffer at index at Null or the specified binary Text. This method will panic on out of bounds index, or if input holds a text which is larger than the maximum allowed element length. element must be specified without the terminating zero.

pub fn ensure_max_element_length( &mut self, element_length: usize, num_rows_to_copy: usize, ) -> Result<(), Error>

where TextColumn<C>: HasDataType + CData,

Ensures that the buffer is large enough to hold elements of element_length. Does nothing if the buffer is already large enough. Otherwise it will reallocate and rebind the buffer. The first num_rows_to_copy_elements will be copied from the old value buffer to the new one. This makes this an extremely expensive operation.

pub fn set_mut(&mut self, index: usize, length: usize) -> &mut [C]

Can be used to set a value at a specific row index without performing a memcopy on an input slice and instead provides direct access to the underlying buffer.

In situations there the memcopy can not be avoided anyway Self::set_cell is likely to be more convenient. This method is very useful if you want to write! a string value to the buffer and the binary (!) length of the formatted string is known upfront.

Example: Write timestamp to text column.

use odbc_api::buffers::TextColumnSliceMut;
use std::io::Write;

/// Writes times formatted as hh::mm::ss.fff
fn write_time(
    col: &mut TextColumnSliceMut<u8>,
    index: usize,
    hours: u8,
    minutes: u8,
    seconds: u8,
    milliseconds: u16)
{
    write!(
        col.set_mut(index, 12),
        "{:02}:{:02}:{:02}.{:03}",
        hours, minutes, seconds, milliseconds
    ).unwrap();
}