Enum InnerValue

#[non_exhaustive]
pub enum InnerValue<'a> {
    Int64(i64),
    UInt64(u64),
    Float(f32),
    Double(f64),
    Char(&'a [u8]),
    Number(&'a str),
    Raw(&'a [u8]),
    Timestamp(&'a dpiTimestamp),
    IntervalDS(&'a dpiIntervalDS),
    IntervalYM(&'a dpiIntervalYM),
    Clob(*mut dpiLob),
    Blob(*mut dpiLob),
    Object(*mut dpiObject),
    Stmt(*mut dpiStmt),
    Boolean(bool),
    Rowid(*mut dpiRowid),
    Vector(*mut dpiVector),
}

Raw data inside of SqlValue

When the data type of an enum variant field is a reference, the field refers to the internal buffer provided by ODPI-C.

It is intended to be used in the following case.

Assuming that you have a decimal class Decimal which has from_str and from_i64 methods and try to get Oralce numbers as the class without precision loss, you need to get the SQL value as String and convert it by from_str without using this type.

For example

for number_col_result in conn.query_as::<String>("select number_column from table_name", &[])? {
   let number_col = number_col_result?;
   let decimal_value = Decimal::from_str(&number_col);
}

Another example

impl FromSql for Decimal {
    fn from_sql(val: &SqlValue) -> Result<Decimal> {
        Ok(Decimal::from_str(&val.get::<String>()?))
    }
}
for decimal_value_result in conn.query_as::<Decimal>("select number_column from table_name", &[])? {
   let decimal_value = decimal_value_result?;
}

These codes are inefficient because String values are created just to be passed to from_str().

By using the InnerValue type, you can refer to the internal str value directly and avoid temporary memory allocation.

impl FromSql for Decimal {
    fn from_sql(val: &SqlValue) -> Result<Decimal> {
        match val.as_inner_value()? {
            InnerValue::Int64(val) => Ok(Decimal::from_i64(val)),
            InnerValue::Number(val) => Decimal::from_str(val).map_err(|err|
               Error::with_source(ErrorKind::InvalidTypeConversion, err)
            ),
            _ => Err(Error::new(
                ErrorKind::InvalidTypeConversion,
                format!("Cannot convert {} to Decimal", val.oracle_type()?)
            )),
        }
    }
}
for decimal_value_result in conn.query_as::<Decimal>("select number_column from table_name", &[])? {
   let decimal_value = decimal_value_result?;
}

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.

Int64(i64)

UInt64(u64)

Float(f32)

Double(f64)

Char(&'a [u8])

Number(&'a str)

Raw(&'a [u8])

Timestamp(&'a dpiTimestamp)

IntervalDS(&'a dpiIntervalDS)

IntervalYM(&'a dpiIntervalYM)

Clob(*mut dpiLob)

Blob(*mut dpiLob)

Object(*mut dpiObject)

Stmt(*mut dpiStmt)

Boolean(bool)

Rowid(*mut dpiRowid)

Vector(*mut dpiVector)

Trait Implementations

impl<'a> Clone for InnerValue<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for InnerValue<'a>

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

Formats the value using the given formatter.