Struct oracle::Timestamp

pub struct Timestamp { /* fields omitted */ }

Oracle-specific Datetime 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::Date, chrono::DateTime, chrono::naive::NaiveDate or chrono::naive::NaiveDateTime instead.

Examples

use oracle::Timestamp;

// Create a timestamp.
let ts1 = Timestamp::new(2017, 8, 9, 11, 22, 33, 500000000);

// Convert to string.
assert_eq!(ts1.to_string(), "2017-08-09 11:22:33.500000000");

// Create a timestamp with time zone (-8:00).
let ts2 = Timestamp::new(2017, 8, 9, 11, 22, 33, 500000000).and_tz_hm_offset(-8, 0);

// Convert to string.
assert_eq!(ts2.to_string(), "2017-08-09 11:22:33.500000000 -08:00");

// Create a timestamp with precision
let ts3 = Timestamp::new(2017, 8, 9, 11, 22, 33, 500000000).and_prec(3);

// The string representation depends on the precision.
assert_eq!(ts3.to_string(), "2017-08-09 11:22:33.500");

// Precisions are ignored when intervals are compared.
assert_eq!(ts1, ts3);

// Create a timestamp from string.
let ts4: Timestamp = "2017-08-09 11:22:33.500 -08:00".parse().unwrap();

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

Fetch and bind interval values.

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

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

// Fetch Timestamp
let sql = "select TIMESTAMP '2017-08-09 11:22:33.500' from dual";
let mut stmt = conn.execute(sql, &[]).unwrap();
let row = stmt.fetch().unwrap();
let ts: Timestamp = row.get(0).unwrap();
assert_eq!(ts.to_string(), "2017-08-09 11:22:33.500000000");

// Bind Timestamp
let sql = "begin \
             :outval := :inval + interval '+1 02:03:04.5' day to second; \
           end;";
let stmt = conn.execute(sql,
                        &[&OracleType::Timestamp(3), // bind null as timestamp(3)
                          &ts, // bind the ts variable
                         ]).unwrap();
let outval: Timestamp = stmt.bind_value(1).unwrap(); // get the first bind value.
// ts + (1 day, 2 hours, 3 minutes and 4.5 seconds)
assert_eq!(outval.to_string(), "2017-08-10 13:25:38.000");

Methods

impl Timestamp

fn new(
    year: i32,
    month: u32,
    day: u32,
    hour: u32,
    minute: u32,
    second: u32,
    nanosecond: u32
) -> Timestamp

Creates a timestamp.

Valid values are:

argument	valid values
year	-4713 to 9999
month	1 to 12
day	1 to 31
hour	0 to 23
minute	0 to 59
second	0 to 59
nanosecond	0 to 999,999,999

fn and_tz_offset(&self, offset: i32) -> Timestamp

Creates a timestamp with time zone.

offset is time zone offset seconds from UTC.

fn and_tz_hm_offset(&self, hour_offset: i32, minute_offset: i32) -> Timestamp

Creates a timestamp with time zone.

hour_offset and minute_offset are time zone offset in hours and minutes from UTC. All arguments must be zero or positive in the eastern hemisphere. They must be zero or negative in the western hemisphere.

fn and_prec(&self, precision: u8) -> Timestamp

Creates a timestamp with precision.

The precision affects text representation of Timestamp. It doesn't affect comparison.

fn year(&self) -> i32

Returns the year number from -4713 to 9999.

fn month(&self) -> u32

Returns the month number from 1 to 12.

fn day(&self) -> u32

Returns the day number from 1 to 31.

fn hour(&self) -> u32

Returns the hour number from 0 to 23.

fn minute(&self) -> u32

Returns the minute number from 0 to 59.

fn second(&self) -> u32

Returns the second number from 0 to 59.

fn nanosecond(&self) -> u32

Returns the nanosecond number from 0 to 999,999,999.

fn tz_hour_offset(&self) -> i32

Returns hour component of time zone.

fn tz_minute_offset(&self) -> i32

Returns minute component of time zone.

fn precision(&self) -> u8

Returns precision

fn with_tz(&self) -> bool

Returns true when the timestamp's text representation includes time zone information. Otherwise, false.

fn tz_offset(&self) -> i32

Returns total time zone offset from UTC in seconds.

Trait Implementations

impl Debug for Timestamp

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

Formats the value using the given formatter.

impl Clone for Timestamp

fn clone(&self) -> Timestamp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Timestamp

impl PartialEq for Timestamp

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 Timestamp

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

Formats the value using the given formatter.

impl FromStr for Timestamp

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 Timestamp

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

impl ToSqlNull for Timestamp

fn oratype_for_null() -> Result<OracleType>

impl ToSql for Timestamp

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

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