Struct odbc_api::handles::State

pub struct State(pub [u8; 5]);

A buffer large enough to hold an SOLState for diagnostics

Tuple Fields

0: [u8; 5]

Implementations

impl State

pub const INVALID_STATE_TRANSACTION: State = _

Can be returned from SQLDisconnect

pub const INVALID_ATTRIBUTE_VALUE: State = _

Given the specified Attribute value, an invalid value was specified in ValuePtr.

pub const INVALID_SQL_DATA_TYPE: State = _

An invalid data type has been bound to a statement. Is also returned by SQLFetch if trying to fetch into a 64Bit Integer Buffer.

pub const STRING_DATA_RIGHT_TRUNCATION: State = _

String or binary data returned for a column resulted in the truncation of nonblank character or non-NULL binary data. If it was a string value, it was right-truncated.

pub const INDICATOR_VARIABLE_REQUIRED_BUT_NOT_SUPPLIED: State = _

StrLen_or_IndPtr was a null pointer and NULL data was retrieved.

pub fn from_chars_with_nul(code: &[SqlChar; 6]) -> Self

Drops terminating zero and changes char type, if required

Examples found in repository

src/handles/diagnostics.rs (line 199)

    fn diagnostic_record(
        &self,
        rec_number: i16,
        message_text: &mut [SqlChar],
    ) -> Option<DiagnosticResult> {
        // Diagnostic records in ODBC are indexed starting with 1
        assert!(rec_number > 0);

        // The total number of characters (excluding the terminating NULL) available to return in
        // `message_text`.
        let mut text_length = 0;
        let mut state = [0; SQLSTATE_SIZE + 1];
        let mut native_error = 0;
        let ret = unsafe {
            sql_get_diag_rec(
                self.handle_type(),
                self.as_handle(),
                rec_number,
                state.as_mut_ptr(),
                &mut native_error,
                mut_buf_ptr(message_text),
                clamp_small_int(message_text.len()),
                &mut text_length,
            )
        };

        let result = DiagnosticResult {
            state: State::from_chars_with_nul(&state),
            native_error,
            text_length,
        };

        match ret {
            SqlReturn::SUCCESS | SqlReturn::SUCCESS_WITH_INFO => Some(result),
            SqlReturn::NO_DATA => None,
            SqlReturn::ERROR => panic!("rec_number argument of diagnostics must be > 0."),
            unexpected => panic!("SQLGetDiagRec returned: {:?}", unexpected),
        }
    }

pub fn as_str(&self) -> &str

View status code as string slice for displaying. Must always succeed as ODBC status code always consist of ASCII characters.

Examples found in repository

src/handles/diagnostics.rs (line 263)

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let message = slice_to_cow_utf8(&self.message);

        write!(
            f,
            "State: {}, Native error: {}, Message: {}",
            self.state.as_str(),
            self.native_error,
            message,
        )
    }

Trait Implementations

impl Clone for State

fn clone(&self) -> State

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for State

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

Formats the value using the given formatter.

impl Default for State

fn default() -> State

Returns the “default value” for a type.

impl PartialEq<State> for State

fn eq(&self, other: &State) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for State

impl Eq for State

impl StructuralEq for State

impl StructuralPartialEq for State