Enum SqlResult

#[non_exhaustive]
pub enum SqlResult<'a> {
    String(Option<&'a [u8]>),
    Real(Option<f64>),
    Int(Option<i64>),
    Decimal(Option<&'a str>),
}

A possible SQL result consisting of a type and nullable value

This enum is similar to SqlType, but actually contains the object.

It is of note that both SqlResult::String contains a u8 slice rather than a representation like &str. This is because there is no guarantee that the data is utf8. Use SqlResult::as_string() if you need an easy way to get a &str.

This enum is labeled non_exhaustive to leave room for future types and coercion options.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

String(Option<&'a [u8]>)

A string result

Real(Option<f64>)

A floating point result

Int(Option<i64>)

A nullable integer

Decimal(Option<&'a str>)

This is a string that is to be represented as a decimal

Implementations

impl<'a> SqlResult<'a>

pub fn display_name(&self) -> &'static str

Small helper function to get a displayable type name.

pub fn is_int(&self) -> bool

Check if this argument is an integer type, even if it may be null

pub fn is_real(&self) -> bool

Check if this argument is an real type, even if it may be null

pub fn is_string(&self) -> bool

Check if this argument is an string type, even if it may be null

pub fn is_decimal(&self) -> bool

Check if this argument is an decimal type, even if it may be null

pub fn as_int(&self) -> Option<i64>

Return this type as an integer if possible

This will exist if the variant is SqlResult::Int, and it contains a value.

These as_* methods are helpful to quickly obtain a value when you expect it to be of a specific type and present.

pub fn as_real(&'a self) -> Option<f64>

Return this type as a float if possible

This will exist if the variant is SqlResult::Real, and it contains a value. See SqlResult::as_int() for further details on as_* methods

pub fn as_string(&'a self) -> Option<&'a str>

Return this type as a string if possible

This will exist if the variant is SqlResult::String, or SqlResult::Decimal, and it contains a value, and the string can successfully be converted to utf8 (using str::from_utf8). It does not distinguish among errors (wrong type, None value, or invalid utf8)

• use pattern matching if you need that.

See SqlResult::as_int() for further details on as_* methods

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

Return this type as a byte slice if possible

This will exist if the variant is SqlResult::String, or SqlResult::Decimal. See SqlResult::as_int() for further details on as_* methods

Trait Implementations

impl<'a> Clone for SqlResult<'a>

fn clone(&self) -> SqlResult<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SqlResult<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for SqlResult<'a>

fn eq(&self, other: &SqlResult<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl TryFrom<&SqlResult<'_>> for SqlType

fn try_from(tag: &SqlResult<'_>) -> Result<Self, Self::Error>

Create an SqlType from an SqlResult

type Error = String

The type returned in the event of a conversion error.

impl<'a> StructuralPartialEq for SqlResult<'a>