Struct IntervalDS

pub struct IntervalDS { /* private fields */ }

Oracle-specific Interval Day to Second data type.

This struct doesn’t have arithmetic methods and they won’t be added to avoid reinventing the wheel. If you need methods such as adding an interval to a timestamp, enable chrono feature and use chrono::Duration instead.

Examples

// Create an interval by new().
let intvl1 = IntervalDS::new(1, 2, 3, 4, 500000000)?;

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

// Convert to string.
assert_eq!(intvl1.to_string(), "+000000001 02:03:04.500000000");
assert_eq!(intvl2.to_string(), "-000000001 02:03:04.500000000");

// Create an interval with leading field and fractional second precisions.
let intvl3 = IntervalDS::new(1, 2, 3, 4, 500000000)?.and_prec(2, 3)?;

// The string representation depends on the precisions.
assert_eq!(intvl3.to_string(), "+01 02:03:04.500");

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

// Create an interval from string.
let intvl4: IntervalDS = "+1 02:03:04.50".parse()?;

// The precisions are determined by number of decimal digits in the string.
assert_eq!(intvl4.lfprec(), 1);
assert_eq!(intvl4.fsprec(), 2);

Fetch and bind interval values.

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

// Fetch IntervalDS
let sql = "select interval '+01 02:03:04.500' day to second(3) from dual";
let intvl = conn.query_row_as::<IntervalDS>(sql, &[])?;
assert_eq!(intvl.to_string(), "+01 02:03:04.500");

// Bind IntervalDS
let sql = "begin \
             :outval := to_timestamp('2017-08-09', 'yyyy-mm-dd') + :inval; \
           end;";
let mut stmt = conn.statement(sql).build()?;
stmt.execute(&[&OracleType::Timestamp(3), // bind null as timestamp(3)
               &intvl, // bind the intvl variable
              ])?;
let outval: Timestamp = stmt.bind_value(1)?; // get the first bind value.
// 2017-08-09 + (1 day, 2 hours, 3 minutes and 4.5 seconds)
assert_eq!(outval.to_string(), "2017-08-10 02:03:04.500");

Implementations

impl IntervalDS

pub fn new( days: i32, hours: i32, minutes: i32, seconds: i32, nanoseconds: i32, ) -> Result<IntervalDS>

Creates a new IntervalDS.

Valid values are:

argument	valid values
days	-999999999 to 999999999
hours	-23 to 23
minutes	-59 to 59
seconds	-59 to 59
nanoseconds	-999999999 to 999999999

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, lfprec: u8, fsprec: u8) -> Result<IntervalDS>

Creates a new IntervalDS with precisions.

lfprec and fsprec are leading field precision and fractional second precision respectively. The precisions affect text representation of IntervalDS. They don’t affect comparison.

pub fn days(&self) -> i32

Returns days component.

pub fn hours(&self) -> i32

Returns hours component.

pub fn minutes(&self) -> i32

Returns minutes component.

pub fn seconds(&self) -> i32

Returns seconds component.

pub fn nanoseconds(&self) -> i32

Returns nanoseconds component.

pub fn lfprec(&self) -> u8

Returns leading field precision.

pub fn fsprec(&self) -> u8

Returns fractional second precision.

Trait Implementations

impl Clone for IntervalDS

fn clone(&self) -> IntervalDS

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IntervalDS

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

Formats the value using the given formatter.

impl Display for IntervalDS

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

Formats the value using the given formatter.

impl FromSql for IntervalDS

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

impl FromStr for IntervalDS

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 IntervalDS

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 IntervalDS

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

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

impl ToSqlNull for IntervalDS

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

impl Copy for IntervalDS