Struct Timestamp

pub struct Timestamp(/* private fields */);

A safe wrapper around Postgres TIMESTAMP WITHOUT TIME ZONE type, backed by a pg_sys::Timestamp integer value.

Implementations

impl Timestamp

pub fn new( year: i32, month: u8, day: u8, hour: u8, minute: u8, second: f64, ) -> Result<Timestamp, DateTimeConversionError>

Construct a new Timestamp from its constituent parts.

Errors

Returns a DateTimeConversionError if any part is outside the bounds for that part

pub fn new_unchecked( year: isize, month: u8, day: u8, hour: u8, minute: u8, second: f64, ) -> Timestamp

Construct a new Timestamp from its constituent parts.

Elides the overhead of trapping errors for out-of-bounds parts

Panics

This function panics if any part is out-of-bounds

pub fn positive_infinity() -> Timestamp

Construct a new Timestamp representing positive infinity

pub fn negative_infinity() -> Timestamp

Construct a new Timestamp representing negative infinity

pub fn is_infinity(&self) -> bool

Does this Timestamp represent positive infinity?

pub fn is_neg_infinity(&self) -> bool

Does this Timestamp represent negative infinity?

pub fn month(&self) -> u8

Extract the month

pub fn day(&self) -> u8

Extract the day

pub fn year(&self) -> i32

Extract the year

pub fn hour(&self) -> u8

Extract the hour

pub fn minute(&self) -> u8

Extract the minute

pub fn second(&self) -> f64

Extract the second

pub fn microseconds(&self) -> u32

Return the microseconds part. This is not the time counted in microseconds, but the fractional seconds

pub fn to_hms_micro(&self) -> (u8, u8, u8, u32)

Return the hour, minute, second, and microseconds as a Rust tuple

pub fn is_finite(&self) -> bool

pub fn truncate(self, units: DateTimeParts) -> Timestamp

Truncate Timestamp to specified units

pub fn age(&self, other: &Timestamp) -> Interval

Subtract other from self, producing a “symbolic” result that uses years and months, rather than just days

pub fn into_inner(self) -> i64

Return the backing pg_sys::Timestamp value.

Trait Implementations

impl Add<Interval> for Timestamp

type Output = Timestamp

The resulting type after applying the + operator.

fn add(self, rhs: Interval) -> <Timestamp as Add<Interval>>::Output

Performs the + operation.

impl Add<Timestamp> for Interval

type Output = Timestamp

The resulting type after applying the + operator.

fn add(self, rhs: Timestamp) -> <Interval as Add<Timestamp>>::Output

Performs the + operation.

impl Clone for Timestamp

fn clone(&self) -> Timestamp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Timestamp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Timestamp

fn deserialize<D>( deserializer: D, ) -> Result<Timestamp, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Timestamp

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

Uses the underlying “output” function to convert this type to a String

impl From<(Date, Time)> for Timestamp

fn from(value: (Date, Time)) -> Timestamp

Converts to this type from the input type.

impl From<Date> for Timestamp

fn from(value: Date) -> Timestamp

Converts to this type from the input type.

impl From<Timestamp> for Date

fn from(value: Timestamp) -> Date

Converts to this type from the input type.

impl From<Timestamp> for Time

fn from(value: Timestamp) -> Time

Converts to this type from the input type.

impl From<Timestamp> for TimestampWithTimeZone

fn from(value: Timestamp) -> TimestampWithTimeZone

Converts to this type from the input type.

impl From<TimestampWithTimeZone> for Timestamp

fn from(value: TimestampWithTimeZone) -> Timestamp

Converts to this type from the input type.

impl From<i64> for Timestamp

Create a Timestamp from a pg_sys::Timestamp

Note that pg_sys::Timestamp is an i64 as a microsecond offset from the “Postgres epoch”. This impl currently allows producing a Timestamp that cannot be constructed by SQL, such as a timestamp before “Julian day zero”.

The details of the encoding may also prove surprising, for instance:

• Postgres uses Julian days to reason about time instead of the Gregorian calendar
• There is no “year zero”, so Postgres defines the offset of -2000 years as 1 BC instead
• Some values such as i64::MIN and i64::MAX have special meanings as infinities
• The way Timestamp translates to/from TimestampWithTimeZone, or rather doesn’t, is “fun”
• In the past pg_sys::Timestamp’s type has changed, so in the future this may change with it
• This is likely to coincide with a change in Timestamp’s precision

fn from(value: i64) -> Timestamp

Converts to this type from the input type.

impl FromDatum for Timestamp

unsafe fn from_polymorphic_datum( datum: Datum, is_null: bool, _: Oid, ) -> Option<Timestamp>

where Timestamp: Sized,

Like from_datum for instantiating polymorphic types which require preserving the dynamic type metadata.

const GET_TYPOID: bool = false

Should a type OID be fetched when calling from_datum?

unsafe fn from_datum(datum: Datum, is_null: bool) -> Option<Self>

where Self: Sized,

Safety

unsafe fn from_datum_in_memory_context( memory_context: PgMemoryContexts, datum: Datum, is_null: bool, typoid: Oid, ) -> Option<Self>

where Self: Sized,

Default implementation switched to the specified memory context and then simply calls FromDatum::from_datum(...) from within that context.

unsafe fn try_from_datum( datum: Datum, is_null: bool, type_oid: Oid, ) -> Result<Option<Self>, TryFromDatumError>

where Self: Sized + IntoDatum,

try_from_datum is a convenience wrapper around FromDatum::from_datum that returns a a Result around an Option, as a Datum can be null. It’s intended to be used in situations where the caller needs to know whether the type conversion succeeded or failed.

unsafe fn try_from_datum_in_memory_context( memory_context: PgMemoryContexts, datum: Datum, is_null: bool, type_oid: Oid, ) -> Result<Option<Self>, TryFromDatumError>

where Self: Sized + IntoDatum,

A version of try_from_datum that switches to the given context to convert from Datum

impl FromStr for Timestamp

fn from_str(s: &str) -> Result<Timestamp, <Timestamp as FromStr>::Err>

Create this type from a string.

type Err = DateTimeConversionError

The associated error which can be returned from parsing.

impl HasExtractableParts for Timestamp

const EXTRACT_FUNCTION: unsafe fn(*mut FunctionCallInfoBaseData) -> Datum = {pgrx::pg_sys::extract_timestamp as unsafe fn(*mut pgrx::pg_sys::FunctionCallInfoBaseData) -> pgrx::pg_sys::Datum}

fn extract_part(&self, field: DateTimeParts) -> Option<AnyNumeric>

Extract a DateTimeParts part from a date/time-like type

impl Hash for Timestamp

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Uses the underlying Postgres “hash” function for this type

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoDatum for Timestamp

fn into_datum(self) -> Option<Datum>

fn type_oid() -> Oid

fn composite_type_oid(&self) -> Option<Oid>

fn array_type_oid() -> Oid

fn is_compatible_with(other: Oid) -> bool

Is a Datum of this type compatible with another Postgres type?

impl Ord for Timestamp

fn cmp(&self, other: &Timestamp) -> Ordering

Uses the underlying Postgres “_cmp()” function for this type

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Timestamp

fn eq(&self, other: &Timestamp) -> bool

Uses the underlying Postgres “_eq()” function for this type

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 PartialOrd for Timestamp

fn partial_cmp(&self, other: &Timestamp) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl RangeSubType for Timestamp

for Timestamp/tsrange

fn range_type_oid() -> Oid

impl Serialize for Timestamp

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this Timestamp in ISO form, compatible with most JSON parsers

impl SqlTranslatable for Timestamp

fn argument_sql() -> Result<SqlMapping, ArgumentError>

fn return_sql() -> Result<Returns, ReturnsError>

fn type_name() -> &'static str

fn variadic() -> bool

fn optional() -> bool

fn entity() -> FunctionMetadataTypeEntity

impl Sub<Interval> for Timestamp

type Output = Timestamp

The resulting type after applying the - operator.

fn sub(self, rhs: Interval) -> <Timestamp as Sub<Interval>>::Output

Performs the - operation.

impl Sub for Timestamp

type Output = Interval

The resulting type after applying the - operator.

fn sub(self, rhs: Timestamp) -> <Timestamp as Sub>::Output

Performs the - operation.

impl ToIsoString for Timestamp

fn to_iso_string(self) -> String

Encode of this date/time-like type into JSON string in ISO format using optionally preallocated buffer ‘buf’.

fn to_iso_string_with_timezone<Tz>( self, timezone: Tz, ) -> Result<String, DateTimeConversionError>

where Tz: AsRef<str>,

Encode of this date/time-like type into JSON string in ISO format using optionally preallocated buffer ‘buf’.

impl TryFrom<Datum> for Timestamp

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from( datum: Datum, ) -> Result<Timestamp, <Timestamp as TryFrom<Datum>>::Error>

Performs the conversion.

impl Copy for Timestamp

impl Eq for Timestamp