Struct oracle::IntervalDS

pub struct IntervalDS { /* fields omitted */ }

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

use oracle::IntervalDS;

// 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().unwrap();

// 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.

use oracle::{Connection, IntervalDS, OracleType, Timestamp};

let conn = Connection::new("scott", "tiger", "").unwrap();

// Fetch IntervalDS
let sql = "select interval '+01 02:03:04.500' day to second(3) from dual";
let mut stmt = conn.execute(sql, &[]).unwrap();
let row = stmt.fetch().unwrap();
let intvl: IntervalDS = row.get(0).unwrap();
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 stmt = conn.execute(sql,
                        &[&OracleType::Timestamp(3), // bind null as timestamp(3)
                          &intvl, // bind the intvl variable
                         ]).unwrap();
let outval: Timestamp = stmt.bind_value(1).unwrap(); // 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");

Methods

impl IntervalDS

fn new(
    days: i32,
    hours: i32,
    minutes: i32,
    seconds: i32,
    nanoseconds: i32
) -> 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.

fn and_prec(&self, lfprec: u8, fsprec: u8) -> 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.

fn days(&self) -> i32

Returns days component.

fn hours(&self) -> i32

Returns hours component.

fn minutes(&self) -> i32

Returns minutes component.

fn seconds(&self) -> i32

Returns seconds component.

fn nanoseconds(&self) -> i32

Returns nanoseconds component.

fn lfprec(&self) -> u8

Returns leading field precision.

fn fsprec(&self) -> u8

Returns fractional second precision.

Trait Implementations

impl Debug for IntervalDS

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

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 Copy for IntervalDS

impl PartialEq for IntervalDS

fn eq(&self, other: &Self) -> 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 !=.

impl Display for IntervalDS

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

Formats the value using the given formatter.

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 FromSql for IntervalDS

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

impl ToSqlNull for IntervalDS

fn oratype_for_null() -> Result<OracleType>

impl ToSql for IntervalDS

fn oratype(&self) -> Result<OracleType>

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