Struct IntervalYM

pub struct IntervalYM { /* private fields */ }

Oracle-specific Interval Year to Month data type.

Examples

// Create an interval by new().
let intvl1 = IntervalYM::new(2, 3)?;

// All arguments must be zero or negative to create a negative interval.
let intvl2 = IntervalYM::new(-2, -3)?;

// Convert to string.
assert_eq!(intvl1.to_string(), "+000000002-03");
assert_eq!(intvl2.to_string(), "-000000002-03");

// Create an interval with precision.
let intvl3 = IntervalYM::new(2, 3)?.and_prec(3)?;

// The string representation depends on the precisions.
assert_eq!(intvl3.to_string(), "+002-03");

// Precisions are ignored when intervals are compared.
assert!(intvl1 == intvl3);

// Create an interval from string.
let intvl4: IntervalYM = "+002-3".parse()?;

// The precision is determined by number of decimal digits in the string.
assert_eq!(intvl4.precision(), 3);

Fetch and bind interval values.

let conn = Connection::connect("scott", "tiger", "")?;

// Fetch IntervalYM
let sql = "select interval '+02-03' year to month from dual";
let intvl = conn.query_row_as::<IntervalYM>(sql, &[])?;
assert_eq!(intvl.to_string(), "+02-03");

// Bind IntervalYM
let sql = "begin \
             :outval := to_timestamp('2017-08-09', 'yyyy-mm-dd') + :inval; \
           end;";
let mut stmt = conn.statement(sql).build()?;
stmt.execute(&[&OracleType::Date, // bind null as date
               &intvl, // bind the intvl variable
              ])?;
let outval: Timestamp = stmt.bind_value(1)?; // get the first bind value.
// 2017-08-09 + (2 years and 3 months)
assert_eq!(outval.to_string(), "2019-11-09 00:00:00");

Implementations

impl IntervalYM

pub fn new(years: i32, months: i32) -> Result<IntervalYM>

Creates a new IntervalYM.

Valid values are:

argument	valid values
years	-999999999 to 999999999
months	-11 to 11

All arguments must be zero or positive to create a positive interval. All arguments must be zero or negative to create a negative interval.

pub fn and_prec(&self, precision: u8) -> Result<IntervalYM>

Creates a new IntervalYM with precision.

The precision affects text representation of IntervalYM. It doesn’t affect comparison.

pub fn years(&self) -> i32

Returns years component.

pub fn months(&self) -> i32

Returns months component.

pub fn precision(&self) -> u8

Returns precision.

Trait Implementations

impl Clone for IntervalYM

fn clone(&self) -> IntervalYM

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IntervalYM

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

Formats the value using the given formatter.

impl Display for IntervalYM

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

Formats the value using the given formatter.

impl FromSql for IntervalYM

fn from_sql(val: &SqlValue<'_>) -> Result<IntervalYM>

impl FromStr for IntervalYM

type Err = ParseOracleTypeError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for IntervalYM

fn eq(&self, other: &Self) -> 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 ToSql for IntervalYM

fn oratype(&self, _conn: &Connection) -> Result<OracleType>

fn to_sql(&self, val: &mut SqlValue<'_>) -> Result<()>

impl ToSqlNull for IntervalYM

fn oratype_for_null(_conn: &Connection) -> Result<OracleType>

impl Copy for IntervalYM