date.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <limits.h>
#include <float.h>
#include <math.h>
#include <time.h>
#include "access/xact.h"
#include "catalog/pg_type.h"
#include "common/hashfn.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/supportnodes.h"
#include "parser/scansup.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/datetime.h"
#include "utils/numeric.h"
#include "utils/sortsupport.h"

Include dependency graph for date.c:

Go to the source code of this file.

Macros
#define	TIMEADT_GT(t1, t2)    (DatumGetTimeADT(t1) > DatumGetTimeADT(t2))
#define	TIMEADT_LT(t1, t2)    (DatumGetTimeADT(t1) < DatumGetTimeADT(t2))
#define	TIMETZ_GT(t1, t2)    DatumGetBool(DirectFunctionCall2(timetz_gt,t1,t2))
#define	TIMETZ_LT(t1, t2)    DatumGetBool(DirectFunctionCall2(timetz_lt,t1,t2))

Functions
static int32	anytime_typmod_check (bool istz, int32 typmod)
static int32	anytime_typmodin (bool istz, ArrayType *ta)
static char *	anytime_typmodout (bool istz, int32 typmod)
Datum	date_in (PG_FUNCTION_ARGS)
Datum	date_out (PG_FUNCTION_ARGS)
Datum	date_recv (PG_FUNCTION_ARGS)
Datum	date_send (PG_FUNCTION_ARGS)
Datum	make_date (PG_FUNCTION_ARGS)
void	EncodeSpecialDate (DateADT dt, char *str)
Datum	current_date (PG_FUNCTION_ARGS)
Datum	current_time (PG_FUNCTION_ARGS)
Datum	sql_localtime (PG_FUNCTION_ARGS)
Datum	date_eq (PG_FUNCTION_ARGS)
Datum	date_ne (PG_FUNCTION_ARGS)
Datum	date_lt (PG_FUNCTION_ARGS)
Datum	date_le (PG_FUNCTION_ARGS)
Datum	date_gt (PG_FUNCTION_ARGS)
Datum	date_ge (PG_FUNCTION_ARGS)
Datum	date_cmp (PG_FUNCTION_ARGS)
Datum	date_sortsupport (PG_FUNCTION_ARGS)
Datum	date_finite (PG_FUNCTION_ARGS)
Datum	date_larger (PG_FUNCTION_ARGS)
Datum	date_smaller (PG_FUNCTION_ARGS)
Datum	date_mi (PG_FUNCTION_ARGS)
Datum	date_pli (PG_FUNCTION_ARGS)
Datum	date_mii (PG_FUNCTION_ARGS)
Timestamp	date2timestamp_opt_overflow (DateADT dateVal, int *overflow)
static TimestampTz	date2timestamp (DateADT dateVal)
TimestampTz	date2timestamptz_opt_overflow (DateADT dateVal, int *overflow)
static TimestampTz	date2timestamptz (DateADT dateVal)
double	date2timestamp_no_overflow (DateADT dateVal)
int32	date_cmp_timestamp_internal (DateADT dateVal, Timestamp dt2)
Datum	date_eq_timestamp (PG_FUNCTION_ARGS)
Datum	date_ne_timestamp (PG_FUNCTION_ARGS)
Datum	date_lt_timestamp (PG_FUNCTION_ARGS)
Datum	date_gt_timestamp (PG_FUNCTION_ARGS)
Datum	date_le_timestamp (PG_FUNCTION_ARGS)
Datum	date_ge_timestamp (PG_FUNCTION_ARGS)
Datum	date_cmp_timestamp (PG_FUNCTION_ARGS)
int32	date_cmp_timestamptz_internal (DateADT dateVal, TimestampTz dt2)
Datum	date_eq_timestamptz (PG_FUNCTION_ARGS)
Datum	date_ne_timestamptz (PG_FUNCTION_ARGS)
Datum	date_lt_timestamptz (PG_FUNCTION_ARGS)
Datum	date_gt_timestamptz (PG_FUNCTION_ARGS)
Datum	date_le_timestamptz (PG_FUNCTION_ARGS)
Datum	date_ge_timestamptz (PG_FUNCTION_ARGS)
Datum	date_cmp_timestamptz (PG_FUNCTION_ARGS)
Datum	timestamp_eq_date (PG_FUNCTION_ARGS)
Datum	timestamp_ne_date (PG_FUNCTION_ARGS)
Datum	timestamp_lt_date (PG_FUNCTION_ARGS)
Datum	timestamp_gt_date (PG_FUNCTION_ARGS)
Datum	timestamp_le_date (PG_FUNCTION_ARGS)
Datum	timestamp_ge_date (PG_FUNCTION_ARGS)
Datum	timestamp_cmp_date (PG_FUNCTION_ARGS)
Datum	timestamptz_eq_date (PG_FUNCTION_ARGS)
Datum	timestamptz_ne_date (PG_FUNCTION_ARGS)
Datum	timestamptz_lt_date (PG_FUNCTION_ARGS)
Datum	timestamptz_gt_date (PG_FUNCTION_ARGS)
Datum	timestamptz_le_date (PG_FUNCTION_ARGS)
Datum	timestamptz_ge_date (PG_FUNCTION_ARGS)
Datum	timestamptz_cmp_date (PG_FUNCTION_ARGS)
Datum	in_range_date_interval (PG_FUNCTION_ARGS)
Datum	extract_date (PG_FUNCTION_ARGS)
Datum	date_pl_interval (PG_FUNCTION_ARGS)
Datum	date_mi_interval (PG_FUNCTION_ARGS)
Datum	date_timestamp (PG_FUNCTION_ARGS)
Datum	timestamp_date (PG_FUNCTION_ARGS)
Datum	date_timestamptz (PG_FUNCTION_ARGS)
Datum	timestamptz_date (PG_FUNCTION_ARGS)
Datum	time_in (PG_FUNCTION_ARGS)
int	tm2time (struct pg_tm *tm, fsec_t fsec, TimeADT *result)
bool	time_overflows (int hour, int min, int sec, fsec_t fsec)
bool	float_time_overflows (int hour, int min, double sec)
int	time2tm (TimeADT time, struct pg_tm *tm, fsec_t *fsec)
Datum	time_out (PG_FUNCTION_ARGS)
Datum	time_recv (PG_FUNCTION_ARGS)
Datum	time_send (PG_FUNCTION_ARGS)
Datum	timetypmodin (PG_FUNCTION_ARGS)
Datum	timetypmodout (PG_FUNCTION_ARGS)
Datum	make_time (PG_FUNCTION_ARGS)
Datum	time_support (PG_FUNCTION_ARGS)
Datum	time_scale (PG_FUNCTION_ARGS)
void	AdjustTimeForTypmod (TimeADT *time, int32 typmod)
Datum	time_eq (PG_FUNCTION_ARGS)
Datum	time_ne (PG_FUNCTION_ARGS)
Datum	time_lt (PG_FUNCTION_ARGS)
Datum	time_le (PG_FUNCTION_ARGS)
Datum	time_gt (PG_FUNCTION_ARGS)
Datum	time_ge (PG_FUNCTION_ARGS)
Datum	time_cmp (PG_FUNCTION_ARGS)
Datum	time_hash (PG_FUNCTION_ARGS)
Datum	time_hash_extended (PG_FUNCTION_ARGS)
Datum	time_larger (PG_FUNCTION_ARGS)
Datum	time_smaller (PG_FUNCTION_ARGS)
Datum	overlaps_time (PG_FUNCTION_ARGS)
Datum	timestamp_time (PG_FUNCTION_ARGS)
Datum	timestamptz_time (PG_FUNCTION_ARGS)
Datum	datetime_timestamp (PG_FUNCTION_ARGS)
Datum	time_interval (PG_FUNCTION_ARGS)
Datum	interval_time (PG_FUNCTION_ARGS)
Datum	time_mi_time (PG_FUNCTION_ARGS)
Datum	time_pl_interval (PG_FUNCTION_ARGS)
Datum	time_mi_interval (PG_FUNCTION_ARGS)
Datum	in_range_time_interval (PG_FUNCTION_ARGS)
static Datum	time_part_common (PG_FUNCTION_ARGS, bool retnumeric)
Datum	time_part (PG_FUNCTION_ARGS)
Datum	extract_time (PG_FUNCTION_ARGS)
int	tm2timetz (struct pg_tm *tm, fsec_t fsec, int tz, TimeTzADT *result)
Datum	timetz_in (PG_FUNCTION_ARGS)
Datum	timetz_out (PG_FUNCTION_ARGS)
Datum	timetz_recv (PG_FUNCTION_ARGS)
Datum	timetz_send (PG_FUNCTION_ARGS)
Datum	timetztypmodin (PG_FUNCTION_ARGS)
Datum	timetztypmodout (PG_FUNCTION_ARGS)
int	timetz2tm (TimeTzADT *time, struct pg_tm *tm, fsec_t *fsec, int *tzp)
Datum	timetz_scale (PG_FUNCTION_ARGS)
static int	timetz_cmp_internal (TimeTzADT *time1, TimeTzADT *time2)
Datum	timetz_eq (PG_FUNCTION_ARGS)
Datum	timetz_ne (PG_FUNCTION_ARGS)
Datum	timetz_lt (PG_FUNCTION_ARGS)
Datum	timetz_le (PG_FUNCTION_ARGS)
Datum	timetz_gt (PG_FUNCTION_ARGS)
Datum	timetz_ge (PG_FUNCTION_ARGS)
Datum	timetz_cmp (PG_FUNCTION_ARGS)
Datum	timetz_hash (PG_FUNCTION_ARGS)
Datum	timetz_hash_extended (PG_FUNCTION_ARGS)
Datum	timetz_larger (PG_FUNCTION_ARGS)
Datum	timetz_smaller (PG_FUNCTION_ARGS)
Datum	timetz_pl_interval (PG_FUNCTION_ARGS)
Datum	timetz_mi_interval (PG_FUNCTION_ARGS)
Datum	in_range_timetz_interval (PG_FUNCTION_ARGS)
Datum	overlaps_timetz (PG_FUNCTION_ARGS)
Datum	timetz_time (PG_FUNCTION_ARGS)
Datum	time_timetz (PG_FUNCTION_ARGS)
Datum	timestamptz_timetz (PG_FUNCTION_ARGS)
Datum	datetimetz_timestamptz (PG_FUNCTION_ARGS)
static Datum	timetz_part_common (PG_FUNCTION_ARGS, bool retnumeric)
Datum	timetz_part (PG_FUNCTION_ARGS)
Datum	extract_timetz (PG_FUNCTION_ARGS)
Datum	timetz_zone (PG_FUNCTION_ARGS)
Datum	timetz_izone (PG_FUNCTION_ARGS)

Macro Definition Documentation

TIMEADT_GT

#define TIMEADT_GT	(		t1,
			t2
	)		(DatumGetTimeADT(t1) > DatumGetTimeADT(t2))

TIMEADT_LT

#define TIMEADT_LT	(		t1,
			t2
	)		(DatumGetTimeADT(t1) < DatumGetTimeADT(t2))

TIMETZ_GT

#define TIMETZ_GT	(		t1,
			t2
	)		DatumGetBool(DirectFunctionCall2(timetz_gt,t1,t2))

TIMETZ_LT

#define TIMETZ_LT	(		t1,
			t2
	)		DatumGetBool(DirectFunctionCall2(timetz_lt,t1,t2))

Function Documentation

AdjustTimeForTypmod()

void AdjustTimeForTypmod	(	TimeADT *	time,
		int32	typmod
	)

Definition at line 1653 of file date.c.

{
    static const int64 TimeScales[MAX_TIME_PRECISION + 1] = {
        INT64CONST(1000000),
        INT64CONST(100000),
        INT64CONST(10000),
        INT64CONST(1000),
        INT64CONST(100),
        INT64CONST(10),
        INT64CONST(1)
    };
 
    static const int64 TimeOffsets[MAX_TIME_PRECISION + 1] = {
        INT64CONST(500000),
        INT64CONST(50000),
        INT64CONST(5000),
        INT64CONST(500),
        INT64CONST(50),
        INT64CONST(5),
        INT64CONST(0)
    };
 
    if (typmod >= 0 && typmod <= MAX_TIME_PRECISION)
    {
        if (*time >= INT64CONST(0))
            *time = ((*time + TimeOffsets[typmod]) / TimeScales[typmod]) *
                TimeScales[typmod];
        else
            *time = -((((-*time) + TimeOffsets[typmod]) / TimeScales[typmod]) *
                      TimeScales[typmod]);
    }
}

References MAX_TIME_PRECISION.

Referenced by current_time(), parse_datetime(), sql_localtime(), time_in(), time_recv(), time_scale(), timetz_in(), timetz_recv(), and timetz_scale().

anytime_typmod_check()

static int32 anytime_typmod_check ( bool  istz, int32  typmod  )

static

Definition at line 49 of file date.c.

{
    if (typmod < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("TIME(%d)%s precision must not be negative",
                        typmod, (istz ? " WITH TIME ZONE" : ""))));
    if (typmod > MAX_TIME_PRECISION)
    {
        ereport(WARNING,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("TIME(%d)%s precision reduced to maximum allowed, %d",
                        typmod, (istz ? " WITH TIME ZONE" : ""),
                        MAX_TIME_PRECISION)));
        typmod = MAX_TIME_PRECISION;
    }
 
    return typmod;
}

References ereport, errcode(), errmsg(), ERROR, MAX_TIME_PRECISION, and WARNING.

Referenced by anytime_typmodin(), current_time(), and sql_localtime().

anytime_typmodin()

static int32 anytime_typmodin ( bool  istz, ArrayType *  ta  )

static

Definition at line 70 of file date.c.

{
    int32      *tl;
    int         n;
 
    tl = ArrayGetIntegerTypmods(ta, &n);
 
    /*
     * we're not too tense about good error message here because grammar
     * shouldn't allow wrong number of modifiers for TIME
     */
    if (n != 1)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid type modifier")));
 
    return anytime_typmod_check(istz, tl[0]);
}

References anytime_typmod_check(), ArrayGetIntegerTypmods(), ereport, errcode(), errmsg(), and ERROR.

Referenced by timetypmodin(), and timetztypmodin().

anytime_typmodout()

static char* anytime_typmodout ( bool  istz, int32  typmod  )

static

Definition at line 91 of file date.c.

{
    const char *tz = istz ? " with time zone" : " without time zone";
 
    if (typmod >= 0)
        return psprintf("(%d)%s", (int) typmod, tz);
    else
        return pstrdup(tz);
}

References psprintf(), and pstrdup().

Referenced by timetypmodout(), and timetztypmodout().

current_date()

Datum current_date

(

PG_FUNCTION_ARGS

)

Definition at line 307 of file date.c.

{
    struct pg_tm tm;
 
    static int  cache_year = 0;
    static int  cache_mon = 0;
    static int  cache_mday = 0;
    static DateADT cache_date;
 
    GetCurrentDateTime(&tm);
 
    /*
     * date2j involves several integer divisions; moreover, unless our session
     * lives across local midnight, we don't really have to do it more than
     * once.  So it seems worth having a separate cache here.
     */
    if (tm.tm_year != cache_year ||
        tm.tm_mon != cache_mon ||
        tm.tm_mday != cache_mday)
    {
        cache_date = date2j(tm.tm_year, tm.tm_mon, tm.tm_mday) - POSTGRES_EPOCH_JDATE;
        cache_year = tm.tm_year;
        cache_mon = tm.tm_mon;
        cache_mday = tm.tm_mday;
    }
 
    return DateADTGetDatum(cache_date);
}

References date2j(), DateADTGetDatum(), GetCurrentDateTime(), POSTGRES_EPOCH_JDATE, tm, pg_tm::tm_mday, pg_tm::tm_mon, and pg_tm::tm_year.

current_time()

Datum current_time

(

PG_FUNCTION_ARGS

)

Definition at line 340 of file date.c.

{
    TimeTzADT  *result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    int         tz;
    int32       typmod = -1;
 
    if (!PG_ARGISNULL(0))
        typmod = anytime_typmod_check(true, PG_GETARG_INT32(0));
 
    GetCurrentTimeUsec(tm, &fsec, &tz);
 
    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
    tm2timetz(tm, fsec, tz, result);
    AdjustTimeForTypmod(&(result->time), typmod);
 
    return TimeTzADTPGetDatum(result);
}

References AdjustTimeForTypmod(), anytime_typmod_check(), GetCurrentTimeUsec(), palloc(), PG_ARGISNULL, PG_GETARG_INT32, TimeTzADT::time, TimeTzADTPGetDatum(), tm, and tm2timetz().

Referenced by AutoVacLauncherMain(), do_start_worker(), launcher_determine_sleep(), rebuild_database_list(), run_permutation(), and try_complete_step().

date2timestamp()

static TimestampTz date2timestamp ( DateADT  dateVal )

static

Definition at line 616 of file date.c.

{
    return date2timestamp_opt_overflow(dateVal, NULL);
}

References date2timestamp_opt_overflow().

Referenced by date_mi_interval(), date_pl_interval(), date_timestamp(), datetime_timestamp(), and in_range_date_interval().

date2timestamp_no_overflow()

double date2timestamp_no_overflow

(

DateADT

dateVal

)

Definition at line 728 of file date.c.

{
    double      result;
 
    if (DATE_IS_NOBEGIN(dateVal))
        result = -DBL_MAX;
    else if (DATE_IS_NOEND(dateVal))
        result = DBL_MAX;
    else
    {
        /* date is days since 2000, timestamp is microseconds since same... */
        result = dateVal * (double) USECS_PER_DAY;
    }
 
    return result;
}

References DATE_IS_NOBEGIN, DATE_IS_NOEND, and USECS_PER_DAY.

Referenced by convert_timevalue_to_scalar().

date2timestamp_opt_overflow()

Timestamp date2timestamp_opt_overflow	(	DateADT	dateVal,
		int *	overflow
	)

Definition at line 572 of file date.c.

{
    Timestamp   result;
 
    if (overflow)
        *overflow = 0;
 
    if (DATE_IS_NOBEGIN(dateVal))
        TIMESTAMP_NOBEGIN(result);
    else if (DATE_IS_NOEND(dateVal))
        TIMESTAMP_NOEND(result);
    else
    {
        /*
         * Since dates have the same minimum values as timestamps, only upper
         * boundary need be checked for overflow.
         */
        if (dateVal >= (TIMESTAMP_END_JULIAN - POSTGRES_EPOCH_JDATE))
        {
            if (overflow)
            {
                *overflow = 1;
                TIMESTAMP_NOEND(result);
                return result;
            }
            else
            {
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("date out of range for timestamp")));
            }
        }
 
        /* date is days since 2000, timestamp is microseconds since same... */
        result = dateVal * USECS_PER_DAY;
    }
 
    return result;
}

References DATE_IS_NOBEGIN, DATE_IS_NOEND, ereport, errcode(), errmsg(), ERROR, POSTGRES_EPOCH_JDATE, TIMESTAMP_END_JULIAN, TIMESTAMP_NOBEGIN, TIMESTAMP_NOEND, and USECS_PER_DAY.

Referenced by date2timestamp(), and date_cmp_timestamp_internal().

date2timestamptz()

static TimestampTz date2timestamptz ( DateADT  dateVal )

static

Definition at line 712 of file date.c.

{
    return date2timestamptz_opt_overflow(dateVal, NULL);
}

References date2timestamptz_opt_overflow().

Referenced by date_timestamptz().

date2timestamptz_opt_overflow()

TimestampTz date2timestamptz_opt_overflow	(	DateADT	dateVal,
		int *	overflow
	)

Definition at line 632 of file date.c.

{
    TimestampTz result;
    struct pg_tm tt,
               *tm = &tt;
    int         tz;
 
    if (overflow)
        *overflow = 0;
 
    if (DATE_IS_NOBEGIN(dateVal))
        TIMESTAMP_NOBEGIN(result);
    else if (DATE_IS_NOEND(dateVal))
        TIMESTAMP_NOEND(result);
    else
    {
        /*
         * Since dates have the same minimum values as timestamps, only upper
         * boundary need be checked for overflow.
         */
        if (dateVal >= (TIMESTAMP_END_JULIAN - POSTGRES_EPOCH_JDATE))
        {
            if (overflow)
            {
                *overflow = 1;
                TIMESTAMP_NOEND(result);
                return result;
            }
            else
            {
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("date out of range for timestamp")));
            }
        }
 
        j2date(dateVal + POSTGRES_EPOCH_JDATE,
               &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
        tm->tm_hour = 0;
        tm->tm_min = 0;
        tm->tm_sec = 0;
        tz = DetermineTimeZoneOffset(tm, session_timezone);
 
        result = dateVal * USECS_PER_DAY + tz * USECS_PER_SEC;
 
        /*
         * Since it is possible to go beyond allowed timestamptz range because
         * of time zone, check for allowed timestamp range after adding tz.
         */
        if (!IS_VALID_TIMESTAMP(result))
        {
            if (overflow)
            {
                if (result < MIN_TIMESTAMP)
                {
                    *overflow = -1;
                    TIMESTAMP_NOBEGIN(result);
                }
                else
                {
                    *overflow = 1;
                    TIMESTAMP_NOEND(result);
                }
            }
            else
            {
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("date out of range for timestamp")));
            }
        }
    }
 
    return result;
}

References DATE_IS_NOBEGIN, DATE_IS_NOEND, DetermineTimeZoneOffset(), ereport, errcode(), errmsg(), ERROR, IS_VALID_TIMESTAMP, j2date(), MIN_TIMESTAMP, POSTGRES_EPOCH_JDATE, session_timezone, TIMESTAMP_END_JULIAN, TIMESTAMP_NOBEGIN, TIMESTAMP_NOEND, tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, USECS_PER_DAY, and USECS_PER_SEC.

Referenced by date2timestamptz(), and date_cmp_timestamptz_internal().

date_cmp()

Datum date_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 445 of file date.c.

{
    DateADT     dateVal1 = PG_GETARG_DATEADT(0);
    DateADT     dateVal2 = PG_GETARG_DATEADT(1);
 
    if (dateVal1 < dateVal2)
        PG_RETURN_INT32(-1);
    else if (dateVal1 > dateVal2)
        PG_RETURN_INT32(1);
    PG_RETURN_INT32(0);
}

References PG_GETARG_DATEADT, and PG_RETURN_INT32.

Referenced by compareDatetime(), and gbt_datekey_cmp().

date_cmp_timestamp()

Datum date_cmp_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 822 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
 
    PG_RETURN_INT32(date_cmp_timestamp_internal(dateVal, dt2));
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_INT32.

date_cmp_timestamp_internal()

int32 date_cmp_timestamp_internal	(	DateADT	dateVal,
		Timestamp	dt2
	)

Definition at line 751 of file date.c.

{
    Timestamp   dt1;
    int         overflow;
 
    dt1 = date2timestamp_opt_overflow(dateVal, &overflow);
    if (overflow > 0)
    {
        /* dt1 is larger than any finite timestamp, but less than infinity */
        return TIMESTAMP_IS_NOEND(dt2) ? -1 : +1;
    }
    Assert(overflow == 0);      /* -1 case cannot occur */
 
    return timestamp_cmp_internal(dt1, dt2);
}

References Assert(), date2timestamp_opt_overflow(), timestamp_cmp_internal(), and TIMESTAMP_IS_NOEND.

Referenced by cmpDateToTimestamp(), date_cmp_timestamp(), date_eq_timestamp(), date_ge_timestamp(), date_gt_timestamp(), date_le_timestamp(), date_lt_timestamp(), date_ne_timestamp(), timestamp_cmp_date(), timestamp_eq_date(), timestamp_ge_date(), timestamp_gt_date(), timestamp_le_date(), timestamp_lt_date(), and timestamp_ne_date().

date_cmp_timestamptz()

Datum date_cmp_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 906 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
 
    PG_RETURN_INT32(date_cmp_timestamptz_internal(dateVal, dt2));
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_INT32.

date_cmp_timestamptz_internal()

int32 date_cmp_timestamptz_internal	(	DateADT	dateVal,
		TimestampTz	dt2
	)

Definition at line 831 of file date.c.

{
    TimestampTz dt1;
    int         overflow;
 
    dt1 = date2timestamptz_opt_overflow(dateVal, &overflow);
    if (overflow > 0)
    {
        /* dt1 is larger than any finite timestamp, but less than infinity */
        return TIMESTAMP_IS_NOEND(dt2) ? -1 : +1;
    }
    if (overflow < 0)
    {
        /* dt1 is less than any finite timestamp, but more than -infinity */
        return TIMESTAMP_IS_NOBEGIN(dt2) ? +1 : -1;
    }
 
    return timestamptz_cmp_internal(dt1, dt2);
}

References date2timestamptz_opt_overflow(), TIMESTAMP_IS_NOBEGIN, TIMESTAMP_IS_NOEND, and timestamptz_cmp_internal.

Referenced by cmpDateToTimestampTz(), date_cmp_timestamptz(), date_eq_timestamptz(), date_ge_timestamptz(), date_gt_timestamptz(), date_le_timestamptz(), date_lt_timestamptz(), date_ne_timestamptz(), timestamptz_cmp_date(), timestamptz_eq_date(), timestamptz_ge_date(), timestamptz_gt_date(), timestamptz_le_date(), timestamptz_lt_date(), and timestamptz_ne_date().

date_eq()

Datum date_eq

(

PG_FUNCTION_ARGS

)

Definition at line 391 of file date.c.

{
    DateADT     dateVal1 = PG_GETARG_DATEADT(0);
    DateADT     dateVal2 = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(dateVal1 == dateVal2);
}

References PG_GETARG_DATEADT, and PG_RETURN_BOOL.

Referenced by gbt_dateeq().

date_eq_timestamp()

Datum date_eq_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 768 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
 
    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) == 0);
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_BOOL.

date_eq_timestamptz()

Datum date_eq_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 852 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
 
    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) == 0);
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_BOOL.

date_finite()

Datum date_finite

(

PG_FUNCTION_ARGS

)

Definition at line 467 of file date.c.

{
    DateADT     date = PG_GETARG_DATEADT(0);
 
    PG_RETURN_BOOL(!DATE_NOT_FINITE(date));
}

References DATE_NOT_FINITE, PG_GETARG_DATEADT, and PG_RETURN_BOOL.

date_ge()

Datum date_ge

(

PG_FUNCTION_ARGS

)

Definition at line 436 of file date.c.

{
    DateADT     dateVal1 = PG_GETARG_DATEADT(0);
    DateADT     dateVal2 = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(dateVal1 >= dateVal2);
}

References PG_GETARG_DATEADT, and PG_RETURN_BOOL.

Referenced by gbt_datege().

date_ge_timestamp()

Datum date_ge_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 813 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
 
    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) >= 0);
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_BOOL.

date_ge_timestamptz()

Datum date_ge_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 897 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
 
    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) >= 0);
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_BOOL.

date_gt()

Datum date_gt

(

PG_FUNCTION_ARGS

)

Definition at line 427 of file date.c.

{
    DateADT     dateVal1 = PG_GETARG_DATEADT(0);
    DateADT     dateVal2 = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(dateVal1 > dateVal2);
}

References PG_GETARG_DATEADT, and PG_RETURN_BOOL.

Referenced by gbt_dategt().

date_gt_timestamp()

Datum date_gt_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 795 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
 
    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) > 0);
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_BOOL.

date_gt_timestamptz()

Datum date_gt_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 879 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
 
    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) > 0);
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_BOOL.

date_in()

Datum date_in

(

PG_FUNCTION_ARGS

)

Definition at line 111 of file date.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    DateADT     date;
    fsec_t      fsec;
    struct pg_tm tt,
               *tm = &tt;
    int         tzp;
    int         dtype;
    int         nf;
    int         dterr;
    char       *field[MAXDATEFIELDS];
    int         ftype[MAXDATEFIELDS];
    char        workbuf[MAXDATELEN + 1];
    DateTimeErrorExtra extra;
 
    dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
                          field, ftype, MAXDATEFIELDS, &nf);
    if (dterr == 0)
        dterr = DecodeDateTime(field, ftype, nf,
                               &dtype, tm, &fsec, &tzp, &extra);
    if (dterr != 0)
    {
        DateTimeParseError(dterr, &extra, str, "date", escontext);
        PG_RETURN_NULL();
    }
 
    switch (dtype)
    {
        case DTK_DATE:
            break;
 
        case DTK_EPOCH:
            GetEpochTime(tm);
            break;
 
        case DTK_LATE:
            DATE_NOEND(date);
            PG_RETURN_DATEADT(date);
 
        case DTK_EARLY:
            DATE_NOBEGIN(date);
            PG_RETURN_DATEADT(date);
 
        default:
            DateTimeParseError(DTERR_BAD_FORMAT, &extra, str, "date", escontext);
            PG_RETURN_NULL();
    }
 
    /* Prevent overflow in Julian-day routines */
    if (!IS_VALID_JULIAN(tm->tm_year, tm->tm_mon, tm->tm_mday))
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("date out of range: \"%s\"", str)));
 
    date = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - POSTGRES_EPOCH_JDATE;
 
    /* Now check for just-out-of-range dates */
    if (!IS_VALID_DATE(date))
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("date out of range: \"%s\"", str)));
 
    PG_RETURN_DATEADT(date);
}

References date2j(), DATE_NOBEGIN, DATE_NOEND, DateTimeParseError(), DecodeDateTime(), DTERR_BAD_FORMAT, DTK_DATE, DTK_EARLY, DTK_EPOCH, DTK_LATE, ereturn, errcode(), errmsg(), GetEpochTime(), IS_VALID_DATE, IS_VALID_JULIAN, MAXDATEFIELDS, MAXDATELEN, ParseDateTime(), PG_GETARG_CSTRING, PG_RETURN_DATEADT, PG_RETURN_NULL, POSTGRES_EPOCH_JDATE, generate_unaccent_rules::str, tm, pg_tm::tm_mday, pg_tm::tm_mon, and pg_tm::tm_year.

date_larger()

Datum date_larger

(

PG_FUNCTION_ARGS

)

Definition at line 475 of file date.c.

{
    DateADT     dateVal1 = PG_GETARG_DATEADT(0);
    DateADT     dateVal2 = PG_GETARG_DATEADT(1);
 
    PG_RETURN_DATEADT((dateVal1 > dateVal2) ? dateVal1 : dateVal2);
}

References PG_GETARG_DATEADT, and PG_RETURN_DATEADT.

date_le()

Datum date_le

(

PG_FUNCTION_ARGS

)

Definition at line 418 of file date.c.

{
    DateADT     dateVal1 = PG_GETARG_DATEADT(0);
    DateADT     dateVal2 = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(dateVal1 <= dateVal2);
}

References PG_GETARG_DATEADT, and PG_RETURN_BOOL.

Referenced by gbt_datele().

date_le_timestamp()

Datum date_le_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 804 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
 
    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) <= 0);
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_BOOL.

date_le_timestamptz()

Datum date_le_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 888 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
 
    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) <= 0);
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_BOOL.

date_lt()

Datum date_lt

(

PG_FUNCTION_ARGS

)

Definition at line 409 of file date.c.

{
    DateADT     dateVal1 = PG_GETARG_DATEADT(0);
    DateADT     dateVal2 = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(dateVal1 < dateVal2);
}

References PG_GETARG_DATEADT, and PG_RETURN_BOOL.

Referenced by gbt_datelt().

date_lt_timestamp()

Datum date_lt_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 786 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
 
    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) < 0);
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_BOOL.

date_lt_timestamptz()

Datum date_lt_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 870 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
 
    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) < 0);
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_BOOL.

date_mi()

Datum date_mi

(

PG_FUNCTION_ARGS

)

Definition at line 495 of file date.c.

{
    DateADT     dateVal1 = PG_GETARG_DATEADT(0);
    DateADT     dateVal2 = PG_GETARG_DATEADT(1);
 
    if (DATE_NOT_FINITE(dateVal1) || DATE_NOT_FINITE(dateVal2))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("cannot subtract infinite dates")));
 
    PG_RETURN_INT32((int32) (dateVal1 - dateVal2));
}

References DATE_NOT_FINITE, ereport, errcode(), errmsg(), ERROR, PG_GETARG_DATEADT, and PG_RETURN_INT32.

Referenced by date_dist(), gbt_date_penalty(), and gdb_date_dist().

date_mi_interval()

Datum date_mi_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1274 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    Timestamp   dateStamp;
 
    dateStamp = date2timestamp(dateVal);
 
    return DirectFunctionCall2(timestamp_mi_interval,
                               TimestampGetDatum(dateStamp),
                               PointerGetDatum(span));
}

References date2timestamp(), DirectFunctionCall2, PG_GETARG_DATEADT, PG_GETARG_INTERVAL_P, PointerGetDatum(), timestamp_mi_interval(), and TimestampGetDatum().

date_mii()

Datum date_mii

(

PG_FUNCTION_ARGS

)

Definition at line 536 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    int32       days = PG_GETARG_INT32(1);
    DateADT     result;
 
    if (DATE_NOT_FINITE(dateVal))
        PG_RETURN_DATEADT(dateVal); /* can't change infinity */
 
    result = dateVal - days;
 
    /* Check for integer overflow and out-of-allowed-range */
    if ((days >= 0 ? (result > dateVal) : (result < dateVal)) ||
        !IS_VALID_DATE(result))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("date out of range")));
 
    PG_RETURN_DATEADT(result);
}

References DATE_NOT_FINITE, days, ereport, errcode(), errmsg(), ERROR, IS_VALID_DATE, PG_GETARG_DATEADT, PG_GETARG_INT32, and PG_RETURN_DATEADT.

date_ne()

Datum date_ne

(

PG_FUNCTION_ARGS

)

Definition at line 400 of file date.c.

{
    DateADT     dateVal1 = PG_GETARG_DATEADT(0);
    DateADT     dateVal2 = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(dateVal1 != dateVal2);
}

References PG_GETARG_DATEADT, and PG_RETURN_BOOL.

date_ne_timestamp()

Datum date_ne_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 777 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
 
    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) != 0);
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_BOOL.

date_ne_timestamptz()

Datum date_ne_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 861 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
 
    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) != 0);
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_BOOL.

date_out()

Datum date_out

(

PG_FUNCTION_ARGS

)

Definition at line 182 of file date.c.

{
    DateADT     date = PG_GETARG_DATEADT(0);
    char       *result;
    struct pg_tm tt,
               *tm = &tt;
    char        buf[MAXDATELEN + 1];
 
    if (DATE_NOT_FINITE(date))
        EncodeSpecialDate(date, buf);
    else
    {
        j2date(date + POSTGRES_EPOCH_JDATE,
               &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
        EncodeDateOnly(tm, DateStyle, buf);
    }
 
    result = pstrdup(buf);
    PG_RETURN_CSTRING(result);
}

References buf, DATE_NOT_FINITE, DateStyle, EncodeDateOnly(), EncodeSpecialDate(), j2date(), MAXDATELEN, PG_GETARG_DATEADT, PG_RETURN_CSTRING, POSTGRES_EPOCH_JDATE, pstrdup(), tm, pg_tm::tm_mday, pg_tm::tm_mon, and pg_tm::tm_year.

date_pl_interval()

Datum date_pl_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1254 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    Timestamp   dateStamp;
 
    dateStamp = date2timestamp(dateVal);
 
    return DirectFunctionCall2(timestamp_pl_interval,
                               TimestampGetDatum(dateStamp),
                               PointerGetDatum(span));
}

References date2timestamp(), DirectFunctionCall2, PG_GETARG_DATEADT, PG_GETARG_INTERVAL_P, PointerGetDatum(), timestamp_pl_interval(), and TimestampGetDatum().

date_pli()

Datum date_pli

(

PG_FUNCTION_ARGS

)

Definition at line 512 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    int32       days = PG_GETARG_INT32(1);
    DateADT     result;
 
    if (DATE_NOT_FINITE(dateVal))
        PG_RETURN_DATEADT(dateVal); /* can't change infinity */
 
    result = dateVal + days;
 
    /* Check for integer overflow and out-of-allowed-range */
    if ((days >= 0 ? (result < dateVal) : (result > dateVal)) ||
        !IS_VALID_DATE(result))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("date out of range")));
 
    PG_RETURN_DATEADT(result);
}

References DATE_NOT_FINITE, days, ereport, errcode(), errmsg(), ERROR, IS_VALID_DATE, PG_GETARG_DATEADT, PG_GETARG_INT32, and PG_RETURN_DATEADT.

date_recv()

Datum date_recv

(

PG_FUNCTION_ARGS

)

Definition at line 207 of file date.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    DateADT     result;
 
    result = (DateADT) pq_getmsgint(buf, sizeof(DateADT));
 
    /* Limit to the same range that date_in() accepts. */
    if (DATE_NOT_FINITE(result))
         /* ok */ ;
    else if (!IS_VALID_DATE(result))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("date out of range")));
 
    PG_RETURN_DATEADT(result);
}

References buf, DATE_NOT_FINITE, ereport, errcode(), errmsg(), ERROR, IS_VALID_DATE, PG_GETARG_POINTER, PG_RETURN_DATEADT, and pq_getmsgint().

date_send()

Datum date_send

(

PG_FUNCTION_ARGS

)

Definition at line 229 of file date.c.

{
    DateADT     date = PG_GETARG_DATEADT(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendint32(&buf, date);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, PG_GETARG_DATEADT, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), and pq_sendint32().

date_smaller()

Datum date_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 484 of file date.c.

{
    DateADT     dateVal1 = PG_GETARG_DATEADT(0);
    DateADT     dateVal2 = PG_GETARG_DATEADT(1);
 
    PG_RETURN_DATEADT((dateVal1 < dateVal2) ? dateVal1 : dateVal2);
}

References PG_GETARG_DATEADT, and PG_RETURN_DATEADT.

date_sortsupport()

Datum date_sortsupport

(

PG_FUNCTION_ARGS

)

Definition at line 458 of file date.c.

{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
 
    ssup->comparator = ssup_datum_int32_cmp;
    PG_RETURN_VOID();
}

References SortSupportData::comparator, PG_GETARG_POINTER, PG_RETURN_VOID, and ssup_datum_int32_cmp().

date_timestamp()

Datum date_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 1291 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   result;
 
    result = date2timestamp(dateVal);
 
    PG_RETURN_TIMESTAMP(result);
}

References date2timestamp(), PG_GETARG_DATEADT, and PG_RETURN_TIMESTAMP.

date_timestamptz()

Datum date_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 1335 of file date.c.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz result;
 
    result = date2timestamptz(dateVal);
 
    PG_RETURN_TIMESTAMP(result);
}

References date2timestamptz(), PG_GETARG_DATEADT, and PG_RETURN_TIMESTAMP.

datetime_timestamp()

Datum datetime_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 1974 of file date.c.

{
    DateADT     date = PG_GETARG_DATEADT(0);
    TimeADT     time = PG_GETARG_TIMEADT(1);
    Timestamp   result;
 
    result = date2timestamp(date);
    if (!TIMESTAMP_NOT_FINITE(result))
    {
        result += time;
        if (!IS_VALID_TIMESTAMP(result))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
    }
 
    PG_RETURN_TIMESTAMP(result);
}

References date2timestamp(), ereport, errcode(), errmsg(), ERROR, IS_VALID_TIMESTAMP, PG_GETARG_DATEADT, PG_GETARG_TIMEADT, PG_RETURN_TIMESTAMP, and TIMESTAMP_NOT_FINITE.

datetimetz_timestamptz()

Datum datetimetz_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 2874 of file date.c.

{
    DateADT     date = PG_GETARG_DATEADT(0);
    TimeTzADT  *time = PG_GETARG_TIMETZADT_P(1);
    TimestampTz result;
 
    if (DATE_IS_NOBEGIN(date))
        TIMESTAMP_NOBEGIN(result);
    else if (DATE_IS_NOEND(date))
        TIMESTAMP_NOEND(result);
    else
    {
        /*
         * Date's range is wider than timestamp's, so check for boundaries.
         * Since dates have the same minimum values as timestamps, only upper
         * boundary need be checked for overflow.
         */
        if (date >= (TIMESTAMP_END_JULIAN - POSTGRES_EPOCH_JDATE))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("date out of range for timestamp")));
        result = date * USECS_PER_DAY + time->time + time->zone * USECS_PER_SEC;
 
        /*
         * Since it is possible to go beyond allowed timestamptz range because
         * of time zone, check for allowed timestamp range after adding tz.
         */
        if (!IS_VALID_TIMESTAMP(result))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("date out of range for timestamp")));
    }
 
    PG_RETURN_TIMESTAMP(result);
}

References DATE_IS_NOBEGIN, DATE_IS_NOEND, ereport, errcode(), errmsg(), ERROR, IS_VALID_TIMESTAMP, PG_GETARG_DATEADT, PG_GETARG_TIMETZADT_P, PG_RETURN_TIMESTAMP, POSTGRES_EPOCH_JDATE, TimeTzADT::time, TIMESTAMP_END_JULIAN, TIMESTAMP_NOBEGIN, TIMESTAMP_NOEND, USECS_PER_DAY, USECS_PER_SEC, and TimeTzADT::zone.

EncodeSpecialDate()

void EncodeSpecialDate	(	DateADT	dt,
		char *	str
	)

Definition at line 292 of file date.c.

{
    if (DATE_IS_NOBEGIN(dt))
        strcpy(str, EARLY);
    else if (DATE_IS_NOEND(dt))
        strcpy(str, LATE);
    else                        /* shouldn't happen */
        elog(ERROR, "invalid argument for EncodeSpecialDate");
}

References DATE_IS_NOBEGIN, DATE_IS_NOEND, EARLY, elog(), ERROR, LATE, and generate_unaccent_rules::str.

Referenced by date_out(), and JsonEncodeDateTime().

extract_date()

Datum extract_date

(

PG_FUNCTION_ARGS

)

Definition at line 1074 of file date.c.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    DateADT     date = PG_GETARG_DATEADT(1);
    int64       intresult;
    int         type,
                val;
    char       *lowunits;
    int         year,
                mon,
                mday;
 
    lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
                                            VARSIZE_ANY_EXHDR(units),
                                            false);
 
    type = DecodeUnits(0, lowunits, &val);
    if (type == UNKNOWN_FIELD)
        type = DecodeSpecial(0, lowunits, &val);
 
    if (DATE_NOT_FINITE(date) && (type == UNITS || type == RESERV))
    {
        switch (val)
        {
                /* Oscillating units */
            case DTK_DAY:
            case DTK_MONTH:
            case DTK_QUARTER:
            case DTK_WEEK:
            case DTK_DOW:
            case DTK_ISODOW:
            case DTK_DOY:
                PG_RETURN_NULL();
                break;
 
                /* Monotonically-increasing units */
            case DTK_YEAR:
            case DTK_DECADE:
            case DTK_CENTURY:
            case DTK_MILLENNIUM:
            case DTK_JULIAN:
            case DTK_ISOYEAR:
            case DTK_EPOCH:
                if (DATE_IS_NOBEGIN(date))
                    PG_RETURN_NUMERIC(DatumGetNumeric(DirectFunctionCall3(numeric_in,
                                                                          CStringGetDatum("-Infinity"),
                                                                          ObjectIdGetDatum(InvalidOid),
                                                                          Int32GetDatum(-1))));
                else
                    PG_RETURN_NUMERIC(DatumGetNumeric(DirectFunctionCall3(numeric_in,
                                                                          CStringGetDatum("Infinity"),
                                                                          ObjectIdGetDatum(InvalidOid),
                                                                          Int32GetDatum(-1))));
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("unit \"%s\" not supported for type %s",
                                lowunits, format_type_be(DATEOID))));
        }
    }
    else if (type == UNITS)
    {
        j2date(date + POSTGRES_EPOCH_JDATE, &year, &mon, &mday);
 
        switch (val)
        {
            case DTK_DAY:
                intresult = mday;
                break;
 
            case DTK_MONTH:
                intresult = mon;
                break;
 
            case DTK_QUARTER:
                intresult = (mon - 1) / 3 + 1;
                break;
 
            case DTK_WEEK:
                intresult = date2isoweek(year, mon, mday);
                break;
 
            case DTK_YEAR:
                if (year > 0)
                    intresult = year;
                else
                    /* there is no year 0, just 1 BC and 1 AD */
                    intresult = year - 1;
                break;
 
            case DTK_DECADE:
                /* see comments in timestamp_part */
                if (year >= 0)
                    intresult = year / 10;
                else
                    intresult = -((8 - (year - 1)) / 10);
                break;
 
            case DTK_CENTURY:
                /* see comments in timestamp_part */
                if (year > 0)
                    intresult = (year + 99) / 100;
                else
                    intresult = -((99 - (year - 1)) / 100);
                break;
 
            case DTK_MILLENNIUM:
                /* see comments in timestamp_part */
                if (year > 0)
                    intresult = (year + 999) / 1000;
                else
                    intresult = -((999 - (year - 1)) / 1000);
                break;
 
            case DTK_JULIAN:
                intresult = date + POSTGRES_EPOCH_JDATE;
                break;
 
            case DTK_ISOYEAR:
                intresult = date2isoyear(year, mon, mday);
                /* Adjust BC years */
                if (intresult <= 0)
                    intresult -= 1;
                break;
 
            case DTK_DOW:
            case DTK_ISODOW:
                intresult = j2day(date + POSTGRES_EPOCH_JDATE);
                if (val == DTK_ISODOW && intresult == 0)
                    intresult = 7;
                break;
 
            case DTK_DOY:
                intresult = date2j(year, mon, mday) - date2j(year, 1, 1) + 1;
                break;
 
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("unit \"%s\" not supported for type %s",
                                lowunits, format_type_be(DATEOID))));
                intresult = 0;
        }
    }
    else if (type == RESERV)
    {
        switch (val)
        {
            case DTK_EPOCH:
                intresult = ((int64) date + POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY;
                break;
 
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("unit \"%s\" not supported for type %s",
                                lowunits, format_type_be(DATEOID))));
                intresult = 0;
        }
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unit \"%s\" not recognized for type %s",
                        lowunits, format_type_be(DATEOID))));
        intresult = 0;
    }
 
    PG_RETURN_NUMERIC(int64_to_numeric(intresult));
}

References CStringGetDatum(), date2isoweek(), date2isoyear(), date2j(), DATE_IS_NOBEGIN, DATE_NOT_FINITE, DatumGetNumeric(), DecodeSpecial(), DecodeUnits(), DirectFunctionCall3, downcase_truncate_identifier(), DTK_CENTURY, DTK_DAY, DTK_DECADE, DTK_DOW, DTK_DOY, DTK_EPOCH, DTK_ISODOW, DTK_ISOYEAR, DTK_JULIAN, DTK_MILLENNIUM, DTK_MONTH, DTK_QUARTER, DTK_WEEK, DTK_YEAR, ereport, errcode(), errmsg(), ERROR, format_type_be(), Int32GetDatum(), int64_to_numeric(), InvalidOid, j2date(), j2day(), numeric_in(), ObjectIdGetDatum(), PG_GETARG_DATEADT, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_NUMERIC, POSTGRES_EPOCH_JDATE, RESERV, SECS_PER_DAY, generate_unaccent_rules::type, UNITS, UNIX_EPOCH_JDATE, UNKNOWN_FIELD, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

extract_time()

Datum extract_time

(

PG_FUNCTION_ARGS

)

Definition at line 2249 of file date.c.

{
    return time_part_common(fcinfo, true);
}

References time_part_common().

extract_timetz()

Datum extract_timetz

(

PG_FUNCTION_ARGS

)

Definition at line 3038 of file date.c.

{
    return timetz_part_common(fcinfo, true);
}

References timetz_part_common().

float_time_overflows()

bool float_time_overflows	(	int	hour,
		int	min,
		double	sec
	)

Definition at line 1459 of file date.c.

{
    /* Range-check the fields individually. */
    if (hour < 0 || hour > HOURS_PER_DAY ||
        min < 0 || min >= MINS_PER_HOUR)
        return true;
 
    /*
     * "sec", being double, requires extra care.  Cope with NaN, and round off
     * before applying the range check to avoid unexpected errors due to
     * imprecise input.  (We assume rint() behaves sanely with infinities.)
     */
    if (isnan(sec))
        return true;
    sec = rint(sec * USECS_PER_SEC);
    if (sec < 0 || sec > SECS_PER_MINUTE * USECS_PER_SEC)
        return true;
 
    /*
     * Because we allow, eg, hour = 24 or sec = 60, we must check separately
     * that the total time value doesn't exceed 24:00:00.  This must match the
     * way that callers will convert the fields to a time.
     */
    if (((((hour * MINS_PER_HOUR + min) * SECS_PER_MINUTE)
          * USECS_PER_SEC) + (int64) sec) > USECS_PER_DAY)
        return true;
 
    return false;
}

References HOURS_PER_DAY, MINS_PER_HOUR, SECS_PER_MINUTE, USECS_PER_DAY, and USECS_PER_SEC.

Referenced by make_time(), and make_timestamp_internal().

in_range_date_interval()

Datum in_range_date_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1047 of file date.c.

{
    DateADT     val = PG_GETARG_DATEADT(0);
    DateADT     base = PG_GETARG_DATEADT(1);
    Interval   *offset = PG_GETARG_INTERVAL_P(2);
    bool        sub = PG_GETARG_BOOL(3);
    bool        less = PG_GETARG_BOOL(4);
    Timestamp   valStamp;
    Timestamp   baseStamp;
 
    /* XXX we could support out-of-range cases here, perhaps */
    valStamp = date2timestamp(val);
    baseStamp = date2timestamp(base);
 
    return DirectFunctionCall5(in_range_timestamp_interval,
                               TimestampGetDatum(valStamp),
                               TimestampGetDatum(baseStamp),
                               IntervalPGetDatum(offset),
                               BoolGetDatum(sub),
                               BoolGetDatum(less));
}

References BoolGetDatum(), date2timestamp(), DirectFunctionCall5, in_range_timestamp_interval(), IntervalPGetDatum(), PG_GETARG_BOOL, PG_GETARG_DATEADT, PG_GETARG_INTERVAL_P, TimestampGetDatum(), and val.

in_range_time_interval()

Datum in_range_time_interval

(

PG_FUNCTION_ARGS

)

Definition at line 2100 of file date.c.

{
    TimeADT     val = PG_GETARG_TIMEADT(0);
    TimeADT     base = PG_GETARG_TIMEADT(1);
    Interval   *offset = PG_GETARG_INTERVAL_P(2);
    bool        sub = PG_GETARG_BOOL(3);
    bool        less = PG_GETARG_BOOL(4);
    TimeADT     sum;
 
    /*
     * Like time_pl_interval/time_mi_interval, we disregard the month and day
     * fields of the offset.  So our test for negative should too.
     */
    if (offset->time < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
                 errmsg("invalid preceding or following size in window function")));
 
    /*
     * We can't use time_pl_interval/time_mi_interval here, because their
     * wraparound behavior would give wrong (or at least undesirable) answers.
     * Fortunately the equivalent non-wrapping behavior is trivial, especially
     * since we don't worry about integer overflow.
     */
    if (sub)
        sum = base - offset->time;
    else
        sum = base + offset->time;
 
    if (less)
        PG_RETURN_BOOL(val <= sum);
    else
        PG_RETURN_BOOL(val >= sum);
}

References ereport, errcode(), errmsg(), ERROR, PG_GETARG_BOOL, PG_GETARG_INTERVAL_P, PG_GETARG_TIMEADT, PG_RETURN_BOOL, Interval::time, and val.

in_range_timetz_interval()

Datum in_range_timetz_interval

(

PG_FUNCTION_ARGS

)

Definition at line 2640 of file date.c.

{
    TimeTzADT  *val = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *base = PG_GETARG_TIMETZADT_P(1);
    Interval   *offset = PG_GETARG_INTERVAL_P(2);
    bool        sub = PG_GETARG_BOOL(3);
    bool        less = PG_GETARG_BOOL(4);
    TimeTzADT   sum;
 
    /*
     * Like timetz_pl_interval/timetz_mi_interval, we disregard the month and
     * day fields of the offset.  So our test for negative should too.
     */
    if (offset->time < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
                 errmsg("invalid preceding or following size in window function")));
 
    /*
     * We can't use timetz_pl_interval/timetz_mi_interval here, because their
     * wraparound behavior would give wrong (or at least undesirable) answers.
     * Fortunately the equivalent non-wrapping behavior is trivial, especially
     * since we don't worry about integer overflow.
     */
    if (sub)
        sum.time = base->time - offset->time;
    else
        sum.time = base->time + offset->time;
    sum.zone = base->zone;
 
    if (less)
        PG_RETURN_BOOL(timetz_cmp_internal(val, &sum) <= 0);
    else
        PG_RETURN_BOOL(timetz_cmp_internal(val, &sum) >= 0);
}

References ereport, errcode(), errmsg(), ERROR, PG_GETARG_BOOL, PG_GETARG_INTERVAL_P, PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, Interval::time, TimeTzADT::time, timetz_cmp_internal(), val, and TimeTzADT::zone.

interval_time()

Datum interval_time

(

PG_FUNCTION_ARGS

)

Definition at line 2020 of file date.c.

{
    Interval   *span = PG_GETARG_INTERVAL_P(0);
    TimeADT     result;
    int64       days;
 
    result = span->time;
    if (result >= USECS_PER_DAY)
    {
        days = result / USECS_PER_DAY;
        result -= days * USECS_PER_DAY;
    }
    else if (result < 0)
    {
        days = (-result + USECS_PER_DAY - 1) / USECS_PER_DAY;
        result += days * USECS_PER_DAY;
    }
 
    PG_RETURN_TIMEADT(result);
}

References days, PG_GETARG_INTERVAL_P, PG_RETURN_TIMEADT, Interval::time, and USECS_PER_DAY.

make_date()

Datum make_date

(

PG_FUNCTION_ARGS

)

Definition at line 243 of file date.c.

{
    struct pg_tm tm;
    DateADT     date;
    int         dterr;
    bool        bc = false;
 
    tm.tm_year = PG_GETARG_INT32(0);
    tm.tm_mon = PG_GETARG_INT32(1);
    tm.tm_mday = PG_GETARG_INT32(2);
 
    /* Handle negative years as BC */
    if (tm.tm_year < 0)
    {
        bc = true;
        tm.tm_year = -tm.tm_year;
    }
 
    dterr = ValidateDate(DTK_DATE_M, false, false, bc, &tm);
 
    if (dterr != 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_FIELD_OVERFLOW),
                 errmsg("date field value out of range: %d-%02d-%02d",
                        tm.tm_year, tm.tm_mon, tm.tm_mday)));
 
    /* Prevent overflow in Julian-day routines */
    if (!IS_VALID_JULIAN(tm.tm_year, tm.tm_mon, tm.tm_mday))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("date out of range: %d-%02d-%02d",
                        tm.tm_year, tm.tm_mon, tm.tm_mday)));
 
    date = date2j(tm.tm_year, tm.tm_mon, tm.tm_mday) - POSTGRES_EPOCH_JDATE;
 
    /* Now check for just-out-of-range dates */
    if (!IS_VALID_DATE(date))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("date out of range: %d-%02d-%02d",
                        tm.tm_year, tm.tm_mon, tm.tm_mday)));
 
    PG_RETURN_DATEADT(date);
}

References date2j(), DTK_DATE_M, ereport, errcode(), errmsg(), ERROR, IS_VALID_DATE, IS_VALID_JULIAN, PG_GETARG_INT32, PG_RETURN_DATEADT, POSTGRES_EPOCH_JDATE, tm, pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_year, and ValidateDate().

make_time()

Datum make_time

(

PG_FUNCTION_ARGS

)

Definition at line 1585 of file date.c.

{
    int         tm_hour = PG_GETARG_INT32(0);
    int         tm_min = PG_GETARG_INT32(1);
    double      sec = PG_GETARG_FLOAT8(2);
    TimeADT     time;
 
    /* Check for time overflow */
    if (float_time_overflows(tm_hour, tm_min, sec))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_FIELD_OVERFLOW),
                 errmsg("time field value out of range: %d:%02d:%02g",
                        tm_hour, tm_min, sec)));
 
    /* This should match tm2time */
    time = (((tm_hour * MINS_PER_HOUR + tm_min) * SECS_PER_MINUTE)
            * USECS_PER_SEC) + (int64) rint(sec * USECS_PER_SEC);
 
    PG_RETURN_TIMEADT(time);
}

References ereport, errcode(), errmsg(), ERROR, float_time_overflows(), MINS_PER_HOUR, PG_GETARG_FLOAT8, PG_GETARG_INT32, PG_RETURN_TIMEADT, SECS_PER_MINUTE, pg_tm::tm_hour, pg_tm::tm_min, and USECS_PER_SEC.

overlaps_time()

Datum overlaps_time

(

PG_FUNCTION_ARGS

)

Definition at line 1791 of file date.c.

{
    /*
     * The arguments are TimeADT, but we leave them as generic Datums to avoid
     * dereferencing nulls (TimeADT is pass-by-reference!)
     */
    Datum       ts1 = PG_GETARG_DATUM(0);
    Datum       te1 = PG_GETARG_DATUM(1);
    Datum       ts2 = PG_GETARG_DATUM(2);
    Datum       te2 = PG_GETARG_DATUM(3);
    bool        ts1IsNull = PG_ARGISNULL(0);
    bool        te1IsNull = PG_ARGISNULL(1);
    bool        ts2IsNull = PG_ARGISNULL(2);
    bool        te2IsNull = PG_ARGISNULL(3);
 
#define TIMEADT_GT(t1,t2) \
    (DatumGetTimeADT(t1) > DatumGetTimeADT(t2))
#define TIMEADT_LT(t1,t2) \
    (DatumGetTimeADT(t1) < DatumGetTimeADT(t2))
 
    /*
     * If both endpoints of interval 1 are null, the result is null (unknown).
     * If just one endpoint is null, take ts1 as the non-null one. Otherwise,
     * take ts1 as the lesser endpoint.
     */
    if (ts1IsNull)
    {
        if (te1IsNull)
            PG_RETURN_NULL();
        /* swap null for non-null */
        ts1 = te1;
        te1IsNull = true;
    }
    else if (!te1IsNull)
    {
        if (TIMEADT_GT(ts1, te1))
        {
            Datum       tt = ts1;
 
            ts1 = te1;
            te1 = tt;
        }
    }
 
    /* Likewise for interval 2. */
    if (ts2IsNull)
    {
        if (te2IsNull)
            PG_RETURN_NULL();
        /* swap null for non-null */
        ts2 = te2;
        te2IsNull = true;
    }
    else if (!te2IsNull)
    {
        if (TIMEADT_GT(ts2, te2))
        {
            Datum       tt = ts2;
 
            ts2 = te2;
            te2 = tt;
        }
    }
 
    /*
     * At this point neither ts1 nor ts2 is null, so we can consider three
     * cases: ts1 > ts2, ts1 < ts2, ts1 = ts2
     */
    if (TIMEADT_GT(ts1, ts2))
    {
        /*
         * This case is ts1 < te2 OR te1 < te2, which may look redundant but
         * in the presence of nulls it's not quite completely so.
         */
        if (te2IsNull)
            PG_RETURN_NULL();
        if (TIMEADT_LT(ts1, te2))
            PG_RETURN_BOOL(true);
        if (te1IsNull)
            PG_RETURN_NULL();
 
        /*
         * If te1 is not null then we had ts1 <= te1 above, and we just found
         * ts1 >= te2, hence te1 >= te2.
         */
        PG_RETURN_BOOL(false);
    }
    else if (TIMEADT_LT(ts1, ts2))
    {
        /* This case is ts2 < te1 OR te2 < te1 */
        if (te1IsNull)
            PG_RETURN_NULL();
        if (TIMEADT_LT(ts2, te1))
            PG_RETURN_BOOL(true);
        if (te2IsNull)
            PG_RETURN_NULL();
 
        /*
         * If te2 is not null then we had ts2 <= te2 above, and we just found
         * ts2 >= te1, hence te2 >= te1.
         */
        PG_RETURN_BOOL(false);
    }
    else
    {
        /*
         * For ts1 = ts2 the spec says te1 <> te2 OR te1 = te2, which is a
         * rather silly way of saying "true if both are nonnull, else null".
         */
        if (te1IsNull || te2IsNull)
            PG_RETURN_NULL();
        PG_RETURN_BOOL(true);
    }
 
#undef TIMEADT_GT
#undef TIMEADT_LT
}

References PG_ARGISNULL, PG_GETARG_DATUM, PG_RETURN_BOOL, PG_RETURN_NULL, TIMEADT_GT, and TIMEADT_LT.

overlaps_timetz()

Datum overlaps_timetz

(

PG_FUNCTION_ARGS

)

Definition at line 2683 of file date.c.

{
    /*
     * The arguments are TimeTzADT *, but we leave them as generic Datums for
     * convenience of notation --- and to avoid dereferencing nulls.
     */
    Datum       ts1 = PG_GETARG_DATUM(0);
    Datum       te1 = PG_GETARG_DATUM(1);
    Datum       ts2 = PG_GETARG_DATUM(2);
    Datum       te2 = PG_GETARG_DATUM(3);
    bool        ts1IsNull = PG_ARGISNULL(0);
    bool        te1IsNull = PG_ARGISNULL(1);
    bool        ts2IsNull = PG_ARGISNULL(2);
    bool        te2IsNull = PG_ARGISNULL(3);
 
#define TIMETZ_GT(t1,t2) \
    DatumGetBool(DirectFunctionCall2(timetz_gt,t1,t2))
#define TIMETZ_LT(t1,t2) \
    DatumGetBool(DirectFunctionCall2(timetz_lt,t1,t2))
 
    /*
     * If both endpoints of interval 1 are null, the result is null (unknown).
     * If just one endpoint is null, take ts1 as the non-null one. Otherwise,
     * take ts1 as the lesser endpoint.
     */
    if (ts1IsNull)
    {
        if (te1IsNull)
            PG_RETURN_NULL();
        /* swap null for non-null */
        ts1 = te1;
        te1IsNull = true;
    }
    else if (!te1IsNull)
    {
        if (TIMETZ_GT(ts1, te1))
        {
            Datum       tt = ts1;
 
            ts1 = te1;
            te1 = tt;
        }
    }
 
    /* Likewise for interval 2. */
    if (ts2IsNull)
    {
        if (te2IsNull)
            PG_RETURN_NULL();
        /* swap null for non-null */
        ts2 = te2;
        te2IsNull = true;
    }
    else if (!te2IsNull)
    {
        if (TIMETZ_GT(ts2, te2))
        {
            Datum       tt = ts2;
 
            ts2 = te2;
            te2 = tt;
        }
    }
 
    /*
     * At this point neither ts1 nor ts2 is null, so we can consider three
     * cases: ts1 > ts2, ts1 < ts2, ts1 = ts2
     */
    if (TIMETZ_GT(ts1, ts2))
    {
        /*
         * This case is ts1 < te2 OR te1 < te2, which may look redundant but
         * in the presence of nulls it's not quite completely so.
         */
        if (te2IsNull)
            PG_RETURN_NULL();
        if (TIMETZ_LT(ts1, te2))
            PG_RETURN_BOOL(true);
        if (te1IsNull)
            PG_RETURN_NULL();
 
        /*
         * If te1 is not null then we had ts1 <= te1 above, and we just found
         * ts1 >= te2, hence te1 >= te2.
         */
        PG_RETURN_BOOL(false);
    }
    else if (TIMETZ_LT(ts1, ts2))
    {
        /* This case is ts2 < te1 OR te2 < te1 */
        if (te1IsNull)
            PG_RETURN_NULL();
        if (TIMETZ_LT(ts2, te1))
            PG_RETURN_BOOL(true);
        if (te2IsNull)
            PG_RETURN_NULL();
 
        /*
         * If te2 is not null then we had ts2 <= te2 above, and we just found
         * ts2 >= te1, hence te2 >= te1.
         */
        PG_RETURN_BOOL(false);
    }
    else
    {
        /*
         * For ts1 = ts2 the spec says te1 <> te2 OR te1 = te2, which is a
         * rather silly way of saying "true if both are nonnull, else null".
         */
        if (te1IsNull || te2IsNull)
            PG_RETURN_NULL();
        PG_RETURN_BOOL(true);
    }
 
#undef TIMETZ_GT
#undef TIMETZ_LT
}

References PG_ARGISNULL, PG_GETARG_DATUM, PG_RETURN_BOOL, PG_RETURN_NULL, TIMETZ_GT, and TIMETZ_LT.

sql_localtime()

Datum sql_localtime

(

PG_FUNCTION_ARGS

)

Definition at line 365 of file date.c.

{
    TimeADT     result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    int         tz;
    int32       typmod = -1;
 
    if (!PG_ARGISNULL(0))
        typmod = anytime_typmod_check(false, PG_GETARG_INT32(0));
 
    GetCurrentTimeUsec(tm, &fsec, &tz);
 
    tm2time(tm, fsec, &result);
    AdjustTimeForTypmod(&result, typmod);
 
    return TimeADTGetDatum(result);
}

References AdjustTimeForTypmod(), anytime_typmod_check(), GetCurrentTimeUsec(), PG_ARGISNULL, PG_GETARG_INT32, TimeADTGetDatum(), tm, and tm2time().

time2tm()

int time2tm	(	TimeADT	time,
		struct pg_tm *	tm,
		fsec_t *	fsec
	)

Definition at line 1496 of file date.c.

{
    tm->tm_hour = time / USECS_PER_HOUR;
    time -= tm->tm_hour * USECS_PER_HOUR;
    tm->tm_min = time / USECS_PER_MINUTE;
    time -= tm->tm_min * USECS_PER_MINUTE;
    tm->tm_sec = time / USECS_PER_SEC;
    time -= tm->tm_sec * USECS_PER_SEC;
    *fsec = time;
    return 0;
}

References tm, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, USECS_PER_HOUR, USECS_PER_MINUTE, and USECS_PER_SEC.

Referenced by JsonEncodeDateTime(), time_out(), time_part_common(), and time_timetz().

time_cmp()

Datum time_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 1742 of file date.c.

{
    TimeADT     time1 = PG_GETARG_TIMEADT(0);
    TimeADT     time2 = PG_GETARG_TIMEADT(1);
 
    if (time1 < time2)
        PG_RETURN_INT32(-1);
    if (time1 > time2)
        PG_RETURN_INT32(1);
    PG_RETURN_INT32(0);
}

References PG_GETARG_TIMEADT, and PG_RETURN_INT32.

Referenced by compareDatetime(), and gbt_timekey_cmp().

time_eq()

Datum time_eq

(

PG_FUNCTION_ARGS

)

Definition at line 1688 of file date.c.

{
    TimeADT     time1 = PG_GETARG_TIMEADT(0);
    TimeADT     time2 = PG_GETARG_TIMEADT(1);
 
    PG_RETURN_BOOL(time1 == time2);
}

References PG_GETARG_TIMEADT, and PG_RETURN_BOOL.

Referenced by gbt_timeeq().

time_ge()

Datum time_ge

(

PG_FUNCTION_ARGS

)

Definition at line 1733 of file date.c.

{
    TimeADT     time1 = PG_GETARG_TIMEADT(0);
    TimeADT     time2 = PG_GETARG_TIMEADT(1);
 
    PG_RETURN_BOOL(time1 >= time2);
}

References PG_GETARG_TIMEADT, and PG_RETURN_BOOL.

Referenced by gbt_timege().

time_gt()

Datum time_gt

(

PG_FUNCTION_ARGS

)

Definition at line 1724 of file date.c.

{
    TimeADT     time1 = PG_GETARG_TIMEADT(0);
    TimeADT     time2 = PG_GETARG_TIMEADT(1);
 
    PG_RETURN_BOOL(time1 > time2);
}

References PG_GETARG_TIMEADT, and PG_RETURN_BOOL.

Referenced by gbt_timegt().

time_hash()

Datum time_hash

(

PG_FUNCTION_ARGS

)

Definition at line 1755 of file date.c.

{
    return hashint8(fcinfo);
}

References hashint8().

time_hash_extended()

Datum time_hash_extended

(

PG_FUNCTION_ARGS

)

Definition at line 1761 of file date.c.

{
    return hashint8extended(fcinfo);
}

References hashint8extended().

time_in()

Datum time_in

(

PG_FUNCTION_ARGS

)

Definition at line 1382 of file date.c.

{
    char       *str = PG_GETARG_CSTRING(0);
#ifdef NOT_USED
    Oid         typelem = PG_GETARG_OID(1);
#endif
    int32       typmod = PG_GETARG_INT32(2);
    Node       *escontext = fcinfo->context;
    TimeADT     result;
    fsec_t      fsec;
    struct pg_tm tt,
               *tm = &tt;
    int         tz;
    int         nf;
    int         dterr;
    char        workbuf[MAXDATELEN + 1];
    char       *field[MAXDATEFIELDS];
    int         dtype;
    int         ftype[MAXDATEFIELDS];
    DateTimeErrorExtra extra;
 
    dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
                          field, ftype, MAXDATEFIELDS, &nf);
    if (dterr == 0)
        dterr = DecodeTimeOnly(field, ftype, nf,
                               &dtype, tm, &fsec, &tz, &extra);
    if (dterr != 0)
    {
        DateTimeParseError(dterr, &extra, str, "time", escontext);
        PG_RETURN_NULL();
    }
 
    tm2time(tm, fsec, &result);
    AdjustTimeForTypmod(&result, typmod);
 
    PG_RETURN_TIMEADT(result);
}

References AdjustTimeForTypmod(), DateTimeParseError(), DecodeTimeOnly(), MAXDATEFIELDS, MAXDATELEN, ParseDateTime(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TIMEADT, generate_unaccent_rules::str, tm, and tm2time().

time_interval()

Datum time_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1997 of file date.c.

{
    TimeADT     time = PG_GETARG_TIMEADT(0);
    Interval   *result;
 
    result = (Interval *) palloc(sizeof(Interval));
 
    result->time = time;
    result->day = 0;
    result->month = 0;
 
    PG_RETURN_INTERVAL_P(result);
}

References Interval::day, Interval::month, palloc(), PG_GETARG_TIMEADT, PG_RETURN_INTERVAL_P, and Interval::time.

time_larger()

Datum time_larger

(

PG_FUNCTION_ARGS

)

Definition at line 1767 of file date.c.

{
    TimeADT     time1 = PG_GETARG_TIMEADT(0);
    TimeADT     time2 = PG_GETARG_TIMEADT(1);
 
    PG_RETURN_TIMEADT((time1 > time2) ? time1 : time2);
}

References PG_GETARG_TIMEADT, and PG_RETURN_TIMEADT.

time_le()

Datum time_le

(

PG_FUNCTION_ARGS

)

Definition at line 1715 of file date.c.

{
    TimeADT     time1 = PG_GETARG_TIMEADT(0);
    TimeADT     time2 = PG_GETARG_TIMEADT(1);
 
    PG_RETURN_BOOL(time1 <= time2);
}

References PG_GETARG_TIMEADT, and PG_RETURN_BOOL.

Referenced by gbt_timele().

time_lt()

Datum time_lt

(

PG_FUNCTION_ARGS

)

Definition at line 1706 of file date.c.

{
    TimeADT     time1 = PG_GETARG_TIMEADT(0);
    TimeADT     time2 = PG_GETARG_TIMEADT(1);
 
    PG_RETURN_BOOL(time1 < time2);
}

References PG_GETARG_TIMEADT, and PG_RETURN_BOOL.

Referenced by gbt_timelt().

time_mi_interval()

Datum time_mi_interval

(

PG_FUNCTION_ARGS

)

Definition at line 2082 of file date.c.

{
    TimeADT     time = PG_GETARG_TIMEADT(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    TimeADT     result;
 
    result = time - span->time;
    result -= result / USECS_PER_DAY * USECS_PER_DAY;
    if (result < INT64CONST(0))
        result += USECS_PER_DAY;
 
    PG_RETURN_TIMEADT(result);
}

References PG_GETARG_INTERVAL_P, PG_GETARG_TIMEADT, PG_RETURN_TIMEADT, Interval::time, and USECS_PER_DAY.

time_mi_time()

Datum time_mi_time

(

PG_FUNCTION_ARGS

)

Definition at line 2045 of file date.c.

{
    TimeADT     time1 = PG_GETARG_TIMEADT(0);
    TimeADT     time2 = PG_GETARG_TIMEADT(1);
    Interval   *result;
 
    result = (Interval *) palloc(sizeof(Interval));
 
    result->month = 0;
    result->day = 0;
    result->time = time1 - time2;
 
    PG_RETURN_INTERVAL_P(result);
}

References Interval::day, Interval::month, palloc(), PG_GETARG_TIMEADT, PG_RETURN_INTERVAL_P, and Interval::time.

Referenced by gbt_time_dist(), gbt_time_penalty(), and time_dist().

time_ne()

Datum time_ne

(

PG_FUNCTION_ARGS

)

Definition at line 1697 of file date.c.

{
    TimeADT     time1 = PG_GETARG_TIMEADT(0);
    TimeADT     time2 = PG_GETARG_TIMEADT(1);
 
    PG_RETURN_BOOL(time1 != time2);
}

References PG_GETARG_TIMEADT, and PG_RETURN_BOOL.

time_out()

Datum time_out

(

PG_FUNCTION_ARGS

)

Definition at line 1509 of file date.c.

{
    TimeADT     time = PG_GETARG_TIMEADT(0);
    char       *result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    char        buf[MAXDATELEN + 1];
 
    time2tm(time, tm, &fsec);
    EncodeTimeOnly(tm, fsec, false, 0, DateStyle, buf);
 
    result = pstrdup(buf);
    PG_RETURN_CSTRING(result);
}

References buf, DateStyle, EncodeTimeOnly(), MAXDATELEN, PG_GETARG_TIMEADT, PG_RETURN_CSTRING, pstrdup(), time2tm(), and tm.

time_overflows()

bool time_overflows	(	int	hour,
		int	min,
		int	sec,
		fsec_t	fsec
	)

Definition at line 1435 of file date.c.

{
    /* Range-check the fields individually. */
    if (hour < 0 || hour > HOURS_PER_DAY ||
        min < 0 || min >= MINS_PER_HOUR ||
        sec < 0 || sec > SECS_PER_MINUTE ||
        fsec < 0 || fsec > USECS_PER_SEC)
        return true;
 
    /*
     * Because we allow, eg, hour = 24 or sec = 60, we must check separately
     * that the total time value doesn't exceed 24:00:00.
     */
    if ((((((hour * MINS_PER_HOUR + min) * SECS_PER_MINUTE)
           + sec) * USECS_PER_SEC) + fsec) > USECS_PER_DAY)
        return true;
 
    return false;
}

References HOURS_PER_DAY, MINS_PER_HOUR, SECS_PER_MINUTE, USECS_PER_DAY, and USECS_PER_SEC.

Referenced by DecodeDateTime(), and DecodeTimeOnly().

time_part()

Datum time_part

(

PG_FUNCTION_ARGS

)

Definition at line 2243 of file date.c.

{
    return time_part_common(fcinfo, false);
}

References time_part_common().

time_part_common()

static Datum time_part_common ( PG_FUNCTION_ARGS  , bool  retnumeric  )

static

Definition at line 2140 of file date.c.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    TimeADT     time = PG_GETARG_TIMEADT(1);
    int64       intresult;
    int         type,
                val;
    char       *lowunits;
 
    lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
                                            VARSIZE_ANY_EXHDR(units),
                                            false);
 
    type = DecodeUnits(0, lowunits, &val);
    if (type == UNKNOWN_FIELD)
        type = DecodeSpecial(0, lowunits, &val);
 
    if (type == UNITS)
    {
        fsec_t      fsec;
        struct pg_tm tt,
                   *tm = &tt;
 
        time2tm(time, tm, &fsec);
 
        switch (val)
        {
            case DTK_MICROSEC:
                intresult = tm->tm_sec * INT64CONST(1000000) + fsec;
                break;
 
            case DTK_MILLISEC:
                if (retnumeric)
                    /*---
                     * tm->tm_sec * 1000 + fsec / 1000
                     * = (tm->tm_sec * 1'000'000 + fsec) / 1000
                     */
                    PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + fsec, 3));
                else
                    PG_RETURN_FLOAT8(tm->tm_sec * 1000.0 + fsec / 1000.0);
                break;
 
            case DTK_SECOND:
                if (retnumeric)
                    /*---
                     * tm->tm_sec + fsec / 1'000'000
                     * = (tm->tm_sec * 1'000'000 + fsec) / 1'000'000
                     */
                    PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + fsec, 6));
                else
                    PG_RETURN_FLOAT8(tm->tm_sec + fsec / 1000000.0);
                break;
 
            case DTK_MINUTE:
                intresult = tm->tm_min;
                break;
 
            case DTK_HOUR:
                intresult = tm->tm_hour;
                break;
 
            case DTK_TZ:
            case DTK_TZ_MINUTE:
            case DTK_TZ_HOUR:
            case DTK_DAY:
            case DTK_MONTH:
            case DTK_QUARTER:
            case DTK_YEAR:
            case DTK_DECADE:
            case DTK_CENTURY:
            case DTK_MILLENNIUM:
            case DTK_ISOYEAR:
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("unit \"%s\" not supported for type %s",
                                lowunits, format_type_be(TIMEOID))));
                intresult = 0;
        }
    }
    else if (type == RESERV && val == DTK_EPOCH)
    {
        if (retnumeric)
            PG_RETURN_NUMERIC(int64_div_fast_to_numeric(time, 6));
        else
            PG_RETURN_FLOAT8(time / 1000000.0);
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unit \"%s\" not recognized for type %s",
                        lowunits, format_type_be(TIMEOID))));
        intresult = 0;
    }
 
    if (retnumeric)
        PG_RETURN_NUMERIC(int64_to_numeric(intresult));
    else
        PG_RETURN_FLOAT8(intresult);
}

References DecodeSpecial(), DecodeUnits(), downcase_truncate_identifier(), DTK_CENTURY, DTK_DAY, DTK_DECADE, DTK_EPOCH, DTK_HOUR, DTK_ISOYEAR, DTK_MICROSEC, DTK_MILLENNIUM, DTK_MILLISEC, DTK_MINUTE, DTK_MONTH, DTK_QUARTER, DTK_SECOND, DTK_TZ, DTK_TZ_HOUR, DTK_TZ_MINUTE, DTK_YEAR, ereport, errcode(), errmsg(), ERROR, format_type_be(), int64_div_fast_to_numeric(), int64_to_numeric(), PG_GETARG_TEXT_PP, PG_GETARG_TIMEADT, PG_RETURN_FLOAT8, PG_RETURN_NUMERIC, RESERV, time2tm(), tm, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, generate_unaccent_rules::type, UNITS, UNKNOWN_FIELD, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by extract_time(), and time_part().

time_pl_interval()

Datum time_pl_interval

(

PG_FUNCTION_ARGS

)

Definition at line 2064 of file date.c.

{
    TimeADT     time = PG_GETARG_TIMEADT(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    TimeADT     result;
 
    result = time + span->time;
    result -= result / USECS_PER_DAY * USECS_PER_DAY;
    if (result < INT64CONST(0))
        result += USECS_PER_DAY;
 
    PG_RETURN_TIMEADT(result);
}

References PG_GETARG_INTERVAL_P, PG_GETARG_TIMEADT, PG_RETURN_TIMEADT, Interval::time, and USECS_PER_DAY.

time_recv()

Datum time_recv

(

PG_FUNCTION_ARGS

)

Definition at line 1529 of file date.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
 
#ifdef NOT_USED
    Oid         typelem = PG_GETARG_OID(1);
#endif
    int32       typmod = PG_GETARG_INT32(2);
    TimeADT     result;
 
    result = pq_getmsgint64(buf);
 
    if (result < INT64CONST(0) || result > USECS_PER_DAY)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("time out of range")));
 
    AdjustTimeForTypmod(&result, typmod);
 
    PG_RETURN_TIMEADT(result);
}

References AdjustTimeForTypmod(), buf, ereport, errcode(), errmsg(), ERROR, PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_TIMEADT, pq_getmsgint64(), and USECS_PER_DAY.

time_scale()

Datum time_scale

(

PG_FUNCTION_ARGS

)

Definition at line 1633 of file date.c.

{
    TimeADT     time = PG_GETARG_TIMEADT(0);
    int32       typmod = PG_GETARG_INT32(1);
    TimeADT     result;
 
    result = time;
    AdjustTimeForTypmod(&result, typmod);
 
    PG_RETURN_TIMEADT(result);
}

References AdjustTimeForTypmod(), PG_GETARG_INT32, PG_GETARG_TIMEADT, and PG_RETURN_TIMEADT.

time_send()

Datum time_send

(

PG_FUNCTION_ARGS

)

Definition at line 1555 of file date.c.

{
    TimeADT     time = PG_GETARG_TIMEADT(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendint64(&buf, time);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, PG_GETARG_TIMEADT, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), and pq_sendint64().

time_smaller()

Datum time_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 1776 of file date.c.

{
    TimeADT     time1 = PG_GETARG_TIMEADT(0);
    TimeADT     time2 = PG_GETARG_TIMEADT(1);
 
    PG_RETURN_TIMEADT((time1 < time2) ? time1 : time2);
}

References PG_GETARG_TIMEADT, and PG_RETURN_TIMEADT.

time_support()

Datum time_support

(

PG_FUNCTION_ARGS

)

Definition at line 1613 of file date.c.

{
    Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
    Node       *ret = NULL;
 
    if (IsA(rawreq, SupportRequestSimplify))
    {
        SupportRequestSimplify *req = (SupportRequestSimplify *) rawreq;
 
        ret = TemporalSimplify(MAX_TIME_PRECISION, (Node *) req->fcall);
    }
 
    PG_RETURN_POINTER(ret);
}

References SupportRequestSimplify::fcall, IsA, MAX_TIME_PRECISION, PG_GETARG_POINTER, PG_RETURN_POINTER, and TemporalSimplify().

time_timetz()

Datum time_timetz

(

PG_FUNCTION_ARGS

)

Definition at line 2816 of file date.c.

{
    TimeADT     time = PG_GETARG_TIMEADT(0);
    TimeTzADT  *result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    int         tz;
 
    GetCurrentDateTime(tm);
    time2tm(time, tm, &fsec);
    tz = DetermineTimeZoneOffset(tm, session_timezone);
 
    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
    result->time = time;
    result->zone = tz;
 
    PG_RETURN_TIMETZADT_P(result);
}

References DetermineTimeZoneOffset(), GetCurrentDateTime(), palloc(), PG_GETARG_TIMEADT, PG_RETURN_TIMETZADT_P, session_timezone, TimeTzADT::time, time2tm(), tm, and TimeTzADT::zone.

Referenced by castTimeToTimeTz().

timestamp_cmp_date()

Datum timestamp_cmp_date

(

PG_FUNCTION_ARGS

)

Definition at line 969 of file date.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_INT32(-date_cmp_timestamp_internal(dateVal, dt1));
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_INT32.

timestamp_date()

Datum timestamp_date

(

PG_FUNCTION_ARGS

)

Definition at line 1305 of file date.c.

{
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(0);
    DateADT     result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
 
    if (TIMESTAMP_IS_NOBEGIN(timestamp))
        DATE_NOBEGIN(result);
    else if (TIMESTAMP_IS_NOEND(timestamp))
        DATE_NOEND(result);
    else
    {
        if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
 
        result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - POSTGRES_EPOCH_JDATE;
    }
 
    PG_RETURN_DATEADT(result);
}

References date2j(), DATE_NOBEGIN, DATE_NOEND, ereport, errcode(), errmsg(), ERROR, PG_GETARG_TIMESTAMP, PG_RETURN_DATEADT, POSTGRES_EPOCH_JDATE, timestamp2tm(), TIMESTAMP_IS_NOBEGIN, TIMESTAMP_IS_NOEND, tm, pg_tm::tm_mday, pg_tm::tm_mon, and pg_tm::tm_year.

timestamp_eq_date()

Datum timestamp_eq_date

(

PG_FUNCTION_ARGS

)

Definition at line 915 of file date.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) == 0);
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_BOOL.

timestamp_ge_date()

Datum timestamp_ge_date

(

PG_FUNCTION_ARGS

)

Definition at line 960 of file date.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) <= 0);
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_BOOL.

timestamp_gt_date()

Datum timestamp_gt_date

(

PG_FUNCTION_ARGS

)

Definition at line 942 of file date.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) < 0);
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_BOOL.

timestamp_le_date()

Datum timestamp_le_date

(

PG_FUNCTION_ARGS

)

Definition at line 951 of file date.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) >= 0);
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_BOOL.

timestamp_lt_date()

Datum timestamp_lt_date

(

PG_FUNCTION_ARGS

)

Definition at line 933 of file date.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) > 0);
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_BOOL.

timestamp_ne_date()

Datum timestamp_ne_date

(

PG_FUNCTION_ARGS

)

Definition at line 924 of file date.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) != 0);
}

References date_cmp_timestamp_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMP, and PG_RETURN_BOOL.

timestamp_time()

Datum timestamp_time

(

PG_FUNCTION_ARGS

)

Definition at line 1913 of file date.c.

{
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(0);
    TimeADT     result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
        PG_RETURN_NULL();
 
    if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    /*
     * Could also do this with time = (timestamp / USECS_PER_DAY *
     * USECS_PER_DAY) - timestamp;
     */
    result = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
              USECS_PER_SEC) + fsec;
 
    PG_RETURN_TIMEADT(result);
}

References ereport, errcode(), errmsg(), ERROR, MINS_PER_HOUR, PG_GETARG_TIMESTAMP, PG_RETURN_NULL, PG_RETURN_TIMEADT, SECS_PER_MINUTE, timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, and USECS_PER_SEC.

timestamptz_cmp_date()

Datum timestamptz_cmp_date

(

PG_FUNCTION_ARGS

)

Definition at line 1032 of file date.c.

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_INT32(-date_cmp_timestamptz_internal(dateVal, dt1));
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_INT32.

timestamptz_date()

Datum timestamptz_date

(

PG_FUNCTION_ARGS

)

Definition at line 1350 of file date.c.

{
    TimestampTz timestamp = PG_GETARG_TIMESTAMP(0);
    DateADT     result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    int         tz;
 
    if (TIMESTAMP_IS_NOBEGIN(timestamp))
        DATE_NOBEGIN(result);
    else if (TIMESTAMP_IS_NOEND(timestamp))
        DATE_NOEND(result);
    else
    {
        if (timestamp2tm(timestamp, &tz, tm, &fsec, NULL, NULL) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
 
        result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - POSTGRES_EPOCH_JDATE;
    }
 
    PG_RETURN_DATEADT(result);
}

References date2j(), DATE_NOBEGIN, DATE_NOEND, ereport, errcode(), errmsg(), ERROR, PG_GETARG_TIMESTAMP, PG_RETURN_DATEADT, POSTGRES_EPOCH_JDATE, timestamp2tm(), TIMESTAMP_IS_NOBEGIN, TIMESTAMP_IS_NOEND, tm, pg_tm::tm_mday, pg_tm::tm_mon, and pg_tm::tm_year.

timestamptz_eq_date()

Datum timestamptz_eq_date

(

PG_FUNCTION_ARGS

)

Definition at line 978 of file date.c.

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) == 0);
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_BOOL.

timestamptz_ge_date()

Datum timestamptz_ge_date

(

PG_FUNCTION_ARGS

)

Definition at line 1023 of file date.c.

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) <= 0);
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_BOOL.

timestamptz_gt_date()

Datum timestamptz_gt_date

(

PG_FUNCTION_ARGS

)

Definition at line 1005 of file date.c.

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) < 0);
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_BOOL.

timestamptz_le_date()

Datum timestamptz_le_date

(

PG_FUNCTION_ARGS

)

Definition at line 1014 of file date.c.

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) >= 0);
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_BOOL.

timestamptz_lt_date()

Datum timestamptz_lt_date

(

PG_FUNCTION_ARGS

)

Definition at line 996 of file date.c.

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) > 0);
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_BOOL.

timestamptz_ne_date()

Datum timestamptz_ne_date

(

PG_FUNCTION_ARGS

)

Definition at line 987 of file date.c.

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);
 
    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) != 0);
}

References date_cmp_timestamptz_internal(), PG_GETARG_DATEADT, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_BOOL.

timestamptz_time()

Datum timestamptz_time

(

PG_FUNCTION_ARGS

)

Definition at line 1943 of file date.c.

{
    TimestampTz timestamp = PG_GETARG_TIMESTAMP(0);
    TimeADT     result;
    struct pg_tm tt,
               *tm = &tt;
    int         tz;
    fsec_t      fsec;
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
        PG_RETURN_NULL();
 
    if (timestamp2tm(timestamp, &tz, tm, &fsec, NULL, NULL) != 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    /*
     * Could also do this with time = (timestamp / USECS_PER_DAY *
     * USECS_PER_DAY) - timestamp;
     */
    result = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
              USECS_PER_SEC) + fsec;
 
    PG_RETURN_TIMEADT(result);
}

References ereport, errcode(), errmsg(), ERROR, MINS_PER_HOUR, PG_GETARG_TIMESTAMP, PG_RETURN_NULL, PG_RETURN_TIMEADT, SECS_PER_MINUTE, timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, and USECS_PER_SEC.

timestamptz_timetz()

Datum timestamptz_timetz

(

PG_FUNCTION_ARGS

)

Definition at line 2842 of file date.c.

{
    TimestampTz timestamp = PG_GETARG_TIMESTAMP(0);
    TimeTzADT  *result;
    struct pg_tm tt,
               *tm = &tt;
    int         tz;
    fsec_t      fsec;
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
        PG_RETURN_NULL();
 
    if (timestamp2tm(timestamp, &tz, tm, &fsec, NULL, NULL) != 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
    tm2timetz(tm, fsec, tz, result);
 
    PG_RETURN_TIMETZADT_P(result);
}

References ereport, errcode(), errmsg(), ERROR, palloc(), PG_GETARG_TIMESTAMP, PG_RETURN_NULL, PG_RETURN_TIMETZADT_P, timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, and tm2timetz().

timetypmodin()

Datum timetypmodin

(

PG_FUNCTION_ARGS

)

Definition at line 1566 of file date.c.

{
    ArrayType  *ta = PG_GETARG_ARRAYTYPE_P(0);
 
    PG_RETURN_INT32(anytime_typmodin(false, ta));
}

References anytime_typmodin(), PG_GETARG_ARRAYTYPE_P, and PG_RETURN_INT32.

timetypmodout()

Datum timetypmodout

(

PG_FUNCTION_ARGS

)

Definition at line 1574 of file date.c.

{
    int32       typmod = PG_GETARG_INT32(0);
 
    PG_RETURN_CSTRING(anytime_typmodout(false, typmod));
}

References anytime_typmodout(), PG_GETARG_INT32, and PG_RETURN_CSTRING.

timetz2tm()

int timetz2tm	(	TimeTzADT *	time,
		struct pg_tm *	tm,
		fsec_t *	fsec,
		int *	tzp
	)

Definition at line 2403 of file date.c.

{
    TimeOffset  trem = time->time;
 
    tm->tm_hour = trem / USECS_PER_HOUR;
    trem -= tm->tm_hour * USECS_PER_HOUR;
    tm->tm_min = trem / USECS_PER_MINUTE;
    trem -= tm->tm_min * USECS_PER_MINUTE;
    tm->tm_sec = trem / USECS_PER_SEC;
    *fsec = trem - tm->tm_sec * USECS_PER_SEC;
 
    if (tzp != NULL)
        *tzp = time->zone;
 
    return 0;
}

References TimeTzADT::time, tm, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, USECS_PER_HOUR, USECS_PER_MINUTE, USECS_PER_SEC, and TimeTzADT::zone.

Referenced by JsonEncodeDateTime(), timetz_out(), and timetz_part_common().

timetz_cmp()

Datum timetz_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 2524 of file date.c.

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);
 
    PG_RETURN_INT32(timetz_cmp_internal(time1, time2));
}

References PG_GETARG_TIMETZADT_P, PG_RETURN_INT32, and timetz_cmp_internal().

Referenced by compareDatetime().

timetz_cmp_internal()

static int timetz_cmp_internal ( TimeTzADT *  time1, TimeTzADT *  time2  )

static

Definition at line 2443 of file date.c.

{
    TimeOffset  t1,
                t2;
 
    /* Primary sort is by true (GMT-equivalent) time */
    t1 = time1->time + (time1->zone * USECS_PER_SEC);
    t2 = time2->time + (time2->zone * USECS_PER_SEC);
 
    if (t1 > t2)
        return 1;
    if (t1 < t2)
        return -1;
 
    /*
     * If same GMT time, sort by timezone; we only want to say that two
     * timetz's are equal if both the time and zone parts are equal.
     */
    if (time1->zone > time2->zone)
        return 1;
    if (time1->zone < time2->zone)
        return -1;
 
    return 0;
}

References TimeTzADT::time, USECS_PER_SEC, and TimeTzADT::zone.

Referenced by in_range_timetz_interval(), timetz_cmp(), timetz_eq(), timetz_ge(), timetz_gt(), timetz_larger(), timetz_le(), timetz_lt(), timetz_ne(), and timetz_smaller().

timetz_eq()

Datum timetz_eq

(

PG_FUNCTION_ARGS

)

Definition at line 2470 of file date.c.

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);
 
    PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) == 0);
}

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

timetz_ge()

Datum timetz_ge

(

PG_FUNCTION_ARGS

)

Definition at line 2515 of file date.c.

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);
 
    PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) >= 0);
}

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

timetz_gt()

Datum timetz_gt

(

PG_FUNCTION_ARGS

)

Definition at line 2506 of file date.c.

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);
 
    PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) > 0);
}

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

timetz_hash()

Datum timetz_hash

(

PG_FUNCTION_ARGS

)

Definition at line 2533 of file date.c.

{
    TimeTzADT  *key = PG_GETARG_TIMETZADT_P(0);
    uint32      thash;
 
    /*
     * To avoid any problems with padding bytes in the struct, we figure the
     * field hashes separately and XOR them.
     */
    thash = DatumGetUInt32(DirectFunctionCall1(hashint8,
                                               Int64GetDatumFast(key->time)));
    thash ^= DatumGetUInt32(hash_uint32(key->zone));
    PG_RETURN_UINT32(thash);
}

References DatumGetUInt32(), DirectFunctionCall1, hash_uint32(), hashint8(), Int64GetDatumFast, sort-test::key, PG_GETARG_TIMETZADT_P, and PG_RETURN_UINT32.

timetz_hash_extended()

Datum timetz_hash_extended

(

PG_FUNCTION_ARGS

)

Definition at line 2549 of file date.c.

{
    TimeTzADT  *key = PG_GETARG_TIMETZADT_P(0);
    Datum       seed = PG_GETARG_DATUM(1);
    uint64      thash;
 
    /* Same approach as timetz_hash */
    thash = DatumGetUInt64(DirectFunctionCall2(hashint8extended,
                                               Int64GetDatumFast(key->time),
                                               seed));
    thash ^= DatumGetUInt64(hash_uint32_extended(key->zone,
                                                 DatumGetInt64(seed)));
    PG_RETURN_UINT64(thash);
}

References DatumGetInt64(), DatumGetUInt64(), DirectFunctionCall2, hash_uint32_extended(), hashint8extended(), Int64GetDatumFast, sort-test::key, PG_GETARG_DATUM, PG_GETARG_TIMETZADT_P, and PG_RETURN_UINT64.

timetz_in()

Datum timetz_in

(

PG_FUNCTION_ARGS

)

Definition at line 2273 of file date.c.

{
    char       *str = PG_GETARG_CSTRING(0);
#ifdef NOT_USED
    Oid         typelem = PG_GETARG_OID(1);
#endif
    int32       typmod = PG_GETARG_INT32(2);
    Node       *escontext = fcinfo->context;
    TimeTzADT  *result;
    fsec_t      fsec;
    struct pg_tm tt,
               *tm = &tt;
    int         tz;
    int         nf;
    int         dterr;
    char        workbuf[MAXDATELEN + 1];
    char       *field[MAXDATEFIELDS];
    int         dtype;
    int         ftype[MAXDATEFIELDS];
    DateTimeErrorExtra extra;
 
    dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
                          field, ftype, MAXDATEFIELDS, &nf);
    if (dterr == 0)
        dterr = DecodeTimeOnly(field, ftype, nf,
                               &dtype, tm, &fsec, &tz, &extra);
    if (dterr != 0)
    {
        DateTimeParseError(dterr, &extra, str, "time with time zone",
                           escontext);
        PG_RETURN_NULL();
    }
 
    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
    tm2timetz(tm, fsec, tz, result);
    AdjustTimeForTypmod(&(result->time), typmod);
 
    PG_RETURN_TIMETZADT_P(result);
}

References AdjustTimeForTypmod(), DateTimeParseError(), DecodeTimeOnly(), MAXDATEFIELDS, MAXDATELEN, palloc(), ParseDateTime(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TIMETZADT_P, generate_unaccent_rules::str, TimeTzADT::time, tm, and tm2timetz().

timetz_izone()

Datum timetz_izone

(

PG_FUNCTION_ARGS

)

Definition at line 3136 of file date.c.

{
    Interval   *zone = PG_GETARG_INTERVAL_P(0);
    TimeTzADT  *time = PG_GETARG_TIMETZADT_P(1);
    TimeTzADT  *result;
    int         tz;
 
    if (zone->month != 0 || zone->day != 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("interval time zone \"%s\" must not include months or days",
                        DatumGetCString(DirectFunctionCall1(interval_out,
                                                            PointerGetDatum(zone))))));
 
    tz = -(zone->time / USECS_PER_SEC);
 
    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
    result->time = time->time + (time->zone - tz) * USECS_PER_SEC;
    while (result->time < INT64CONST(0))
        result->time += USECS_PER_DAY;
    while (result->time >= USECS_PER_DAY)
        result->time -= USECS_PER_DAY;
 
    result->zone = tz;
 
    PG_RETURN_TIMETZADT_P(result);
}

References DatumGetCString(), DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, interval_out(), palloc(), PG_GETARG_INTERVAL_P, PG_GETARG_TIMETZADT_P, PG_RETURN_TIMETZADT_P, PointerGetDatum(), TimeTzADT::time, USECS_PER_DAY, USECS_PER_SEC, while(), and TimeTzADT::zone.

timetz_larger()

Datum timetz_larger

(

PG_FUNCTION_ARGS

)

Definition at line 2565 of file date.c.

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);
    TimeTzADT  *result;
 
    if (timetz_cmp_internal(time1, time2) > 0)
        result = time1;
    else
        result = time2;
    PG_RETURN_TIMETZADT_P(result);
}

References PG_GETARG_TIMETZADT_P, PG_RETURN_TIMETZADT_P, and timetz_cmp_internal().

timetz_le()

Datum timetz_le

(

PG_FUNCTION_ARGS

)

Definition at line 2497 of file date.c.

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);
 
    PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) <= 0);
}

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

timetz_lt()

Datum timetz_lt

(

PG_FUNCTION_ARGS

)

Definition at line 2488 of file date.c.

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);
 
    PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) < 0);
}

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

timetz_mi_interval()

Datum timetz_mi_interval

(

PG_FUNCTION_ARGS

)

Definition at line 2618 of file date.c.

{
    TimeTzADT  *time = PG_GETARG_TIMETZADT_P(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    TimeTzADT  *result;
 
    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
    result->time = time->time - span->time;
    result->time -= result->time / USECS_PER_DAY * USECS_PER_DAY;
    if (result->time < INT64CONST(0))
        result->time += USECS_PER_DAY;
 
    result->zone = time->zone;
 
    PG_RETURN_TIMETZADT_P(result);
}

References palloc(), PG_GETARG_INTERVAL_P, PG_GETARG_TIMETZADT_P, PG_RETURN_TIMETZADT_P, Interval::time, TimeTzADT::time, USECS_PER_DAY, and TimeTzADT::zone.

timetz_ne()

Datum timetz_ne

(

PG_FUNCTION_ARGS

)

Definition at line 2479 of file date.c.

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);
 
    PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) != 0);
}

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

timetz_out()

Datum timetz_out

(

PG_FUNCTION_ARGS

)

Definition at line 2314 of file date.c.

{
    TimeTzADT  *time = PG_GETARG_TIMETZADT_P(0);
    char       *result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    int         tz;
    char        buf[MAXDATELEN + 1];
 
    timetz2tm(time, tm, &fsec, &tz);
    EncodeTimeOnly(tm, fsec, true, tz, DateStyle, buf);
 
    result = pstrdup(buf);
    PG_RETURN_CSTRING(result);
}

References buf, DateStyle, EncodeTimeOnly(), MAXDATELEN, PG_GETARG_TIMETZADT_P, PG_RETURN_CSTRING, pstrdup(), timetz2tm(), and tm.

timetz_part()

Datum timetz_part

(

PG_FUNCTION_ARGS

)

Definition at line 3032 of file date.c.

{
    return timetz_part_common(fcinfo, false);
}

References timetz_part_common().

timetz_part_common()

static Datum timetz_part_common ( PG_FUNCTION_ARGS  , bool  retnumeric  )

static

Definition at line 2915 of file date.c.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    TimeTzADT  *time = PG_GETARG_TIMETZADT_P(1);
    int64       intresult;
    int         type,
                val;
    char       *lowunits;
 
    lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
                                            VARSIZE_ANY_EXHDR(units),
                                            false);
 
    type = DecodeUnits(0, lowunits, &val);
    if (type == UNKNOWN_FIELD)
        type = DecodeSpecial(0, lowunits, &val);
 
    if (type == UNITS)
    {
        int         tz;
        fsec_t      fsec;
        struct pg_tm tt,
                   *tm = &tt;
 
        timetz2tm(time, tm, &fsec, &tz);
 
        switch (val)
        {
            case DTK_TZ:
                intresult = -tz;
                break;
 
            case DTK_TZ_MINUTE:
                intresult = (-tz / SECS_PER_MINUTE) % MINS_PER_HOUR;
                break;
 
            case DTK_TZ_HOUR:
                intresult = -tz / SECS_PER_HOUR;
                break;
 
            case DTK_MICROSEC:
                intresult = tm->tm_sec * INT64CONST(1000000) + fsec;
                break;
 
            case DTK_MILLISEC:
                if (retnumeric)
                    /*---
                     * tm->tm_sec * 1000 + fsec / 1000
                     * = (tm->tm_sec * 1'000'000 + fsec) / 1000
                     */
                    PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + fsec, 3));
                else
                    PG_RETURN_FLOAT8(tm->tm_sec * 1000.0 + fsec / 1000.0);
                break;
 
            case DTK_SECOND:
                if (retnumeric)
                    /*---
                     * tm->tm_sec + fsec / 1'000'000
                     * = (tm->tm_sec * 1'000'000 + fsec) / 1'000'000
                     */
                    PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + fsec, 6));
                else
                    PG_RETURN_FLOAT8(tm->tm_sec + fsec / 1000000.0);
                break;
 
            case DTK_MINUTE:
                intresult = tm->tm_min;
                break;
 
            case DTK_HOUR:
                intresult = tm->tm_hour;
                break;
 
            case DTK_DAY:
            case DTK_MONTH:
            case DTK_QUARTER:
            case DTK_YEAR:
            case DTK_DECADE:
            case DTK_CENTURY:
            case DTK_MILLENNIUM:
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("unit \"%s\" not supported for type %s",
                                lowunits, format_type_be(TIMETZOID))));
                intresult = 0;
        }
    }
    else if (type == RESERV && val == DTK_EPOCH)
    {
        if (retnumeric)
            /*---
             * time->time / 1'000'000 + time->zone
             * = (time->time + time->zone * 1'000'000) / 1'000'000
             */
            PG_RETURN_NUMERIC(int64_div_fast_to_numeric(time->time + time->zone * INT64CONST(1000000), 6));
        else
            PG_RETURN_FLOAT8(time->time / 1000000.0 + time->zone);
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unit \"%s\" not recognized for type %s",
                        lowunits, format_type_be(TIMETZOID))));
        intresult = 0;
    }
 
    if (retnumeric)
        PG_RETURN_NUMERIC(int64_to_numeric(intresult));
    else
        PG_RETURN_FLOAT8(intresult);
}

References DecodeSpecial(), DecodeUnits(), downcase_truncate_identifier(), DTK_CENTURY, DTK_DAY, DTK_DECADE, DTK_EPOCH, DTK_HOUR, DTK_MICROSEC, DTK_MILLENNIUM, DTK_MILLISEC, DTK_MINUTE, DTK_MONTH, DTK_QUARTER, DTK_SECOND, DTK_TZ, DTK_TZ_HOUR, DTK_TZ_MINUTE, DTK_YEAR, ereport, errcode(), errmsg(), ERROR, format_type_be(), int64_div_fast_to_numeric(), int64_to_numeric(), MINS_PER_HOUR, PG_GETARG_TEXT_PP, PG_GETARG_TIMETZADT_P, PG_RETURN_FLOAT8, PG_RETURN_NUMERIC, RESERV, SECS_PER_HOUR, SECS_PER_MINUTE, TimeTzADT::time, timetz2tm(), tm, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, generate_unaccent_rules::type, UNITS, UNKNOWN_FIELD, val, VARDATA_ANY, VARSIZE_ANY_EXHDR, and TimeTzADT::zone.

Referenced by extract_timetz(), and timetz_part().

timetz_pl_interval()

Datum timetz_pl_interval

(

PG_FUNCTION_ARGS

)

Definition at line 2596 of file date.c.

{
    TimeTzADT  *time = PG_GETARG_TIMETZADT_P(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    TimeTzADT  *result;
 
    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
    result->time = time->time + span->time;
    result->time -= result->time / USECS_PER_DAY * USECS_PER_DAY;
    if (result->time < INT64CONST(0))
        result->time += USECS_PER_DAY;
 
    result->zone = time->zone;
 
    PG_RETURN_TIMETZADT_P(result);
}

References palloc(), PG_GETARG_INTERVAL_P, PG_GETARG_TIMETZADT_P, PG_RETURN_TIMETZADT_P, Interval::time, TimeTzADT::time, USECS_PER_DAY, and TimeTzADT::zone.

timetz_recv()

Datum timetz_recv

(

PG_FUNCTION_ARGS

)

Definition at line 2335 of file date.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
 
#ifdef NOT_USED
    Oid         typelem = PG_GETARG_OID(1);
#endif
    int32       typmod = PG_GETARG_INT32(2);
    TimeTzADT  *result;
 
    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
    result->time = pq_getmsgint64(buf);
 
    if (result->time < INT64CONST(0) || result->time > USECS_PER_DAY)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("time out of range")));
 
    result->zone = pq_getmsgint(buf, sizeof(result->zone));
 
    /* Check for sane GMT displacement; see notes in datatype/timestamp.h */
    if (result->zone <= -TZDISP_LIMIT || result->zone >= TZDISP_LIMIT)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TIME_ZONE_DISPLACEMENT_VALUE),
                 errmsg("time zone displacement out of range")));
 
    AdjustTimeForTypmod(&(result->time), typmod);
 
    PG_RETURN_TIMETZADT_P(result);
}

References AdjustTimeForTypmod(), buf, ereport, errcode(), errmsg(), ERROR, palloc(), PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_TIMETZADT_P, pq_getmsgint(), pq_getmsgint64(), TimeTzADT::time, TZDISP_LIMIT, USECS_PER_DAY, and TimeTzADT::zone.

timetz_scale()

Datum timetz_scale

(

PG_FUNCTION_ARGS

)

Definition at line 2425 of file date.c.

{
    TimeTzADT  *time = PG_GETARG_TIMETZADT_P(0);
    int32       typmod = PG_GETARG_INT32(1);
    TimeTzADT  *result;
 
    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
    result->time = time->time;
    result->zone = time->zone;
 
    AdjustTimeForTypmod(&(result->time), typmod);
 
    PG_RETURN_TIMETZADT_P(result);
}

References AdjustTimeForTypmod(), palloc(), PG_GETARG_INT32, PG_GETARG_TIMETZADT_P, PG_RETURN_TIMETZADT_P, TimeTzADT::time, and TimeTzADT::zone.

timetz_send()

Datum timetz_send

(

PG_FUNCTION_ARGS

)

Definition at line 2371 of file date.c.

{
    TimeTzADT  *time = PG_GETARG_TIMETZADT_P(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendint64(&buf, time->time);
    pq_sendint32(&buf, time->zone);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, PG_GETARG_TIMETZADT_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint32(), pq_sendint64(), TimeTzADT::time, and TimeTzADT::zone.

timetz_smaller()

Datum timetz_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 2579 of file date.c.

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);
    TimeTzADT  *result;
 
    if (timetz_cmp_internal(time1, time2) < 0)
        result = time1;
    else
        result = time2;
    PG_RETURN_TIMETZADT_P(result);
}

References PG_GETARG_TIMETZADT_P, PG_RETURN_TIMETZADT_P, and timetz_cmp_internal().

timetz_time()

Datum timetz_time

(

PG_FUNCTION_ARGS

)

Definition at line 2803 of file date.c.

{
    TimeTzADT  *timetz = PG_GETARG_TIMETZADT_P(0);
    TimeADT     result;
 
    /* swallow the time zone and just return the time */
    result = timetz->time;
 
    PG_RETURN_TIMEADT(result);
}

References PG_GETARG_TIMETZADT_P, PG_RETURN_TIMEADT, and TimeTzADT::time.

timetz_zone()

Datum timetz_zone

(

PG_FUNCTION_ARGS

)

Definition at line 3048 of file date.c.

{
    text       *zone = PG_GETARG_TEXT_PP(0);
    TimeTzADT  *t = PG_GETARG_TIMETZADT_P(1);
    TimeTzADT  *result;
    int         tz;
    char        tzname[TZ_STRLEN_MAX + 1];
    char       *lowzone;
    int         dterr,
                type,
                val;
    pg_tz      *tzp;
    DateTimeErrorExtra extra;
 
    /*
     * Look up the requested timezone.  First we look in the timezone
     * abbreviation table (to handle cases like "EST"), and if that fails, we
     * look in the timezone database (to handle cases like
     * "America/New_York").  (This matches the order in which timestamp input
     * checks the cases; it's important because the timezone database unwisely
     * uses a few zone names that are identical to offset abbreviations.)
     */
    text_to_cstring_buffer(zone, tzname, sizeof(tzname));
 
    /* DecodeTimezoneAbbrev requires lowercase input */
    lowzone = downcase_truncate_identifier(tzname,
                                           strlen(tzname),
                                           false);
 
    dterr = DecodeTimezoneAbbrev(0, lowzone, &type, &val, &tzp, &extra);
    if (dterr)
        DateTimeParseError(dterr, &extra, NULL, NULL, NULL);
 
    if (type == TZ || type == DTZ)
    {
        /* fixed-offset abbreviation */
        tz = -val;
    }
    else if (type == DYNTZ)
    {
        /* dynamic-offset abbreviation, resolve using transaction start time */
        TimestampTz now = GetCurrentTransactionStartTimestamp();
        int         isdst;
 
        tz = DetermineTimeZoneAbbrevOffsetTS(now, tzname, tzp, &isdst);
    }
    else
    {
        /* try it as a full zone name */
        tzp = pg_tzset(tzname);
        if (tzp)
        {
            /* Get the offset-from-GMT that is valid now for the zone */
            TimestampTz now = GetCurrentTransactionStartTimestamp();
            struct pg_tm tm;
            fsec_t      fsec;
 
            if (timestamp2tm(now, &tz, &tm, &fsec, NULL, tzp) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
        }
        else
        {
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("time zone \"%s\" not recognized", tzname)));
            tz = 0;             /* keep compiler quiet */
        }
    }
 
    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
 
    result->time = t->time + (t->zone - tz) * USECS_PER_SEC;
    while (result->time < INT64CONST(0))
        result->time += USECS_PER_DAY;
    while (result->time >= USECS_PER_DAY)
        result->time -= USECS_PER_DAY;
 
    result->zone = tz;
 
    PG_RETURN_TIMETZADT_P(result);
}

References DateTimeParseError(), DecodeTimezoneAbbrev(), DetermineTimeZoneAbbrevOffsetTS(), downcase_truncate_identifier(), DTZ, DYNTZ, ereport, errcode(), errmsg(), ERROR, GetCurrentTransactionStartTimestamp(), now(), palloc(), PG_GETARG_TEXT_PP, PG_GETARG_TIMETZADT_P, PG_RETURN_TIMETZADT_P, pg_tzset(), text_to_cstring_buffer(), TimeTzADT::time, timestamp2tm(), tm, generate_unaccent_rules::type, TZ, TZ_STRLEN_MAX, USECS_PER_DAY, USECS_PER_SEC, val, while(), and TimeTzADT::zone.

timetztypmodin()

Datum timetztypmodin

(

PG_FUNCTION_ARGS

)

Definition at line 2383 of file date.c.

{
    ArrayType  *ta = PG_GETARG_ARRAYTYPE_P(0);
 
    PG_RETURN_INT32(anytime_typmodin(true, ta));
}

References anytime_typmodin(), PG_GETARG_ARRAYTYPE_P, and PG_RETURN_INT32.

timetztypmodout()

Datum timetztypmodout

(

PG_FUNCTION_ARGS

)

Definition at line 2391 of file date.c.

{
    int32       typmod = PG_GETARG_INT32(0);
 
    PG_RETURN_CSTRING(anytime_typmodout(true, typmod));
}

References anytime_typmodout(), PG_GETARG_INT32, and PG_RETURN_CSTRING.

tm2time()

int tm2time	(	struct pg_tm *	tm,
		fsec_t	fsec,
		TimeADT *	result
	)

Definition at line 1424 of file date.c.

{
    *result = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec)
               * USECS_PER_SEC) + fsec;
    return 0;
}

References MINS_PER_HOUR, SECS_PER_MINUTE, tm, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, and USECS_PER_SEC.

Referenced by parse_datetime(), sql_localtime(), and time_in().

tm2timetz()

int tm2timetz	(	struct pg_tm *	tm,
		fsec_t	fsec,
		int	tz,
		TimeTzADT *	result
	)

Definition at line 2263 of file date.c.

{
    result->time = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
                    USECS_PER_SEC) + fsec;
    result->zone = tz;
 
    return 0;
}

References MINS_PER_HOUR, SECS_PER_MINUTE, TimeTzADT::time, tm, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, USECS_PER_SEC, and TimeTzADT::zone.

Referenced by current_time(), parse_datetime(), timestamptz_timetz(), and timetz_in().