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 "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/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_typmodin (bool istz, ArrayType *ta)
int32	anytime_typmod_check (bool istz, int32 typmod)
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)
DateADT	GetSQLCurrentDate (void)
TimeTzADT *	GetSQLCurrentTime (int32 typmod)
TimeADT	GetSQLLocalTime (int32 typmod)
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)
static int	date_fastcmp (Datum x, Datum y, SortSupport ssup)
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	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)
Datum	time_part (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)
Datum	timetz_part (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))

Referenced by overlaps_time().

TIMEADT_LT

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

Referenced by overlaps_time().

TIMETZ_GT

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

Referenced by overlaps_timetz().

TIMETZ_LT

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

Referenced by overlaps_timetz().

Function Documentation

AdjustTimeForTypmod()

void AdjustTimeForTypmod	(	TimeADT *	time,
		int32	typmod
	)

Definition at line 1469 of file date.c.

References MAX_TIME_PRECISION.

Referenced by GetSQLCurrentTime(), GetSQLLocalTime(), parse_datetime(), time_in(), time_recv(), time_scale(), timetz_in(), timetz_recv(), and timetz_scale().

{
    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]);
    }
}

anytime_typmod_check()

int32 anytime_typmod_check	(	bool	istz,
		int32	typmod
	)

Definition at line 68 of file date.c.

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

Referenced by anytime_typmodin(), and transformSQLValueFunction().

{
    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;
}

anytime_typmodin()

static int32 anytime_typmodin ( bool  istz, ArrayType *  ta  )

static

Definition at line 47 of file date.c.

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

Referenced by timetypmodin(), and timetztypmodin().

{
    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]);
}

anytime_typmodout()

static char* anytime_typmodout ( bool  istz, int32  typmod  )

static

Definition at line 90 of file date.c.

References psprintf().

Referenced by timetypmodout(), and timetztypmodout().

{
    const char *tz = istz ? " with time zone" : " without time zone";

    if (typmod >= 0)
        return psprintf("(%d)%s", (int) typmod, tz);
    else
        return psprintf("%s", tz);
}

date2timestamp()

static TimestampTz date2timestamp ( DateADT  dateVal )

static

Definition at line 612 of file date.c.

References date2timestamp_opt_overflow().

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

{
    return date2timestamp_opt_overflow(dateVal, NULL);
}

date2timestamp_no_overflow()

double date2timestamp_no_overflow

(

DateADT

dateVal

)

Definition at line 724 of file date.c.

References DATE_IS_NOBEGIN, DATE_IS_NOEND, and USECS_PER_DAY.

Referenced by convert_timevalue_to_scalar().

{
    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;
}

date2timestamp_opt_overflow()

Timestamp date2timestamp_opt_overflow	(	DateADT	dateVal,
		int *	overflow
	)

Definition at line 568 of file date.c.

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().

{
    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;
}

date2timestamptz()

static TimestampTz date2timestamptz ( DateADT  dateVal )

static

Definition at line 708 of file date.c.

References date2timestamptz_opt_overflow().

Referenced by date_timestamptz().

{
    return date2timestamptz_opt_overflow(dateVal, NULL);
}

date2timestamptz_opt_overflow()

TimestampTz date2timestamptz_opt_overflow	(	DateADT	dateVal,
		int *	overflow
	)

Definition at line 628 of file date.c.

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().

{
    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;
}

date_cmp()

Datum date_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 428 of file date.c.

References PG_GETARG_DATEADT, and PG_RETURN_INT32.

Referenced by compareDatetime(), gbt_datekey_cmp(), and leftmostvalue_date().

{
    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);
}

date_cmp_timestamp()

Datum date_cmp_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 818 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);

    PG_RETURN_INT32(date_cmp_timestamp_internal(dateVal, dt2));
}

date_cmp_timestamp_internal()

int32 date_cmp_timestamp_internal	(	DateADT	dateVal,
		Timestamp	dt2
	)

Definition at line 747 of file date.c.

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().

{
    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);
}

date_cmp_timestamptz()

Datum date_cmp_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 902 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);

    PG_RETURN_INT32(date_cmp_timestamptz_internal(dateVal, dt2));
}

date_cmp_timestamptz_internal()

int32 date_cmp_timestamptz_internal	(	DateADT	dateVal,
		TimestampTz	dt2
	)

Definition at line 827 of file date.c.

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().

{
    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);
}

date_eq()

Datum date_eq

(

PG_FUNCTION_ARGS

)

Definition at line 374 of file date.c.

References PG_GETARG_DATEADT, and PG_RETURN_BOOL.

Referenced by gbt_dateeq().

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

    PG_RETURN_BOOL(dateVal1 == dateVal2);
}

date_eq_timestamp()

Datum date_eq_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 764 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);

    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) == 0);
}

date_eq_timestamptz()

Datum date_eq_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 848 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);

    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) == 0);
}

date_fastcmp()

static int date_fastcmp ( Datum  x, Datum  y, SortSupport  ssup  )

static

Definition at line 441 of file date.c.

References DatumGetDateADT.

Referenced by date_sortsupport().

{
    DateADT     a = DatumGetDateADT(x);
    DateADT     b = DatumGetDateADT(y);

    if (a < b)
        return -1;
    else if (a > b)
        return 1;
    return 0;
}

date_finite()

Datum date_finite

(

PG_FUNCTION_ARGS

)

Definition at line 463 of file date.c.

References DATE_NOT_FINITE, PG_GETARG_DATEADT, and PG_RETURN_BOOL.

{
    DateADT     date = PG_GETARG_DATEADT(0);

    PG_RETURN_BOOL(!DATE_NOT_FINITE(date));
}

date_ge()

Datum date_ge

(

PG_FUNCTION_ARGS

)

Definition at line 419 of file date.c.

References PG_GETARG_DATEADT, and PG_RETURN_BOOL.

Referenced by gbt_datege().

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

    PG_RETURN_BOOL(dateVal1 >= dateVal2);
}

date_ge_timestamp()

Datum date_ge_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 809 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);

    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) >= 0);
}

date_ge_timestamptz()

Datum date_ge_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 893 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);

    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) >= 0);
}

date_gt()

Datum date_gt

(

PG_FUNCTION_ARGS

)

Definition at line 410 of file date.c.

References PG_GETARG_DATEADT, and PG_RETURN_BOOL.

Referenced by gbt_dategt().

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

    PG_RETURN_BOOL(dateVal1 > dateVal2);
}

date_gt_timestamp()

Datum date_gt_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 791 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);

    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) > 0);
}

date_gt_timestamptz()

Datum date_gt_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 875 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);

    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) > 0);
}

date_in()

Datum date_in

(

PG_FUNCTION_ARGS

)

Definition at line 110 of file date.c.

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

{
    char       *str = PG_GETARG_CSTRING(0);
    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];

    dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
                          field, ftype, MAXDATEFIELDS, &nf);
    if (dterr == 0)
        dterr = DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tzp);
    if (dterr != 0)
        DateTimeParseError(dterr, str, "date");

    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, str, "date");
            break;
    }

    /* 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: \"%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))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("date out of range: \"%s\"", str)));

    PG_RETURN_DATEADT(date);
}

date_larger()

Datum date_larger

(

PG_FUNCTION_ARGS

)

Definition at line 471 of file date.c.

References PG_GETARG_DATEADT, and PG_RETURN_DATEADT.

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

    PG_RETURN_DATEADT((dateVal1 > dateVal2) ? dateVal1 : dateVal2);
}

date_le()

Datum date_le

(

PG_FUNCTION_ARGS

)

Definition at line 401 of file date.c.

References PG_GETARG_DATEADT, and PG_RETURN_BOOL.

Referenced by gbt_datele().

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

    PG_RETURN_BOOL(dateVal1 <= dateVal2);
}

date_le_timestamp()

Datum date_le_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 800 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);

    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) <= 0);
}

date_le_timestamptz()

Datum date_le_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 884 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);

    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) <= 0);
}

date_lt()

Datum date_lt

(

PG_FUNCTION_ARGS

)

Definition at line 392 of file date.c.

References PG_GETARG_DATEADT, and PG_RETURN_BOOL.

Referenced by gbt_datelt().

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

    PG_RETURN_BOOL(dateVal1 < dateVal2);
}

date_lt_timestamp()

Datum date_lt_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 782 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);

    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) < 0);
}

date_lt_timestamptz()

Datum date_lt_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 866 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);

    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) < 0);
}

date_mi()

Datum date_mi

(

PG_FUNCTION_ARGS

)

Definition at line 491 of file date.c.

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().

{
    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));
}

date_mi_interval()

Datum date_mi_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1093 of file date.c.

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

{
    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));
}

date_mii()

Datum date_mii

(

PG_FUNCTION_ARGS

)

Definition at line 532 of file date.c.

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

{
    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);
}

date_ne()

Datum date_ne

(

PG_FUNCTION_ARGS

)

Definition at line 383 of file date.c.

References PG_GETARG_DATEADT, and PG_RETURN_BOOL.

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

    PG_RETURN_BOOL(dateVal1 != dateVal2);
}

date_ne_timestamp()

Datum date_ne_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 773 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);

    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) != 0);
}

date_ne_timestamptz()

Datum date_ne_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 857 of file date.c.

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

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);

    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) != 0);
}

date_out()

Datum date_out

(

PG_FUNCTION_ARGS

)

Definition at line 175 of file date.c.

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.

{
    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);
}

date_pl_interval()

Datum date_pl_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1073 of file date.c.

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

{
    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));
}

date_pli()

Datum date_pli

(

PG_FUNCTION_ARGS

)

Definition at line 508 of file date.c.

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

Referenced by daterange_canonical().

{
    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);
}

date_recv()

Datum date_recv

(

PG_FUNCTION_ARGS

)

Definition at line 200 of file date.c.

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

{
    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);
}

date_send()

Datum date_send

(

PG_FUNCTION_ARGS

)

Definition at line 222 of file date.c.

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

{
    DateADT     date = PG_GETARG_DATEADT(0);
    StringInfoData buf;

    pq_begintypsend(&buf);
    pq_sendint32(&buf, date);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

date_smaller()

Datum date_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 480 of file date.c.

References PG_GETARG_DATEADT, and PG_RETURN_DATEADT.

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

    PG_RETURN_DATEADT((dateVal1 < dateVal2) ? dateVal1 : dateVal2);
}

date_sortsupport()

Datum date_sortsupport

(

PG_FUNCTION_ARGS

)

Definition at line 454 of file date.c.

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

{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);

    ssup->comparator = date_fastcmp;
    PG_RETURN_VOID();
}

date_timestamp()

Datum date_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 1110 of file date.c.

References date2timestamp(), PG_GETARG_DATEADT, and PG_RETURN_TIMESTAMP.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    Timestamp   result;

    result = date2timestamp(dateVal);

    PG_RETURN_TIMESTAMP(result);
}

date_timestamptz()

Datum date_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 1154 of file date.c.

References date2timestamptz(), PG_GETARG_DATEADT, and PG_RETURN_TIMESTAMP.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    TimestampTz result;

    result = date2timestamptz(dateVal);

    PG_RETURN_TIMESTAMP(result);
}

datetime_timestamp()

Datum datetime_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 1790 of file date.c.

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

{
    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);
}

datetimetz_timestamptz()

Datum datetimetz_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 2652 of file date.c.

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.

{
    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);
}

EncodeSpecialDate()

void EncodeSpecialDate	(	DateADT	dt,
		char *	str
	)

Definition at line 285 of file date.c.

References DATE_IS_NOBEGIN, DATE_IS_NOEND, EARLY, elog, ERROR, and LATE.

Referenced by date_out(), and JsonEncodeDateTime().

{
    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");
}

float_time_overflows()

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

Definition at line 1273 of file date.c.

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().

{
    /* 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;
}

GetSQLCurrentDate()

DateADT GetSQLCurrentDate

(

void

)

Definition at line 300 of file date.c.

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

Referenced by ExecEvalSQLValueFunction().

{
    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 cache_date;
}

GetSQLCurrentTime()

TimeTzADT* GetSQLCurrentTime

(

int32

typmod

)

Definition at line 333 of file date.c.

References AdjustTimeForTypmod(), GetCurrentTimeUsec(), palloc(), TimeTzADT::time, tm, and tm2timetz().

Referenced by ExecEvalSQLValueFunction().

{
    TimeTzADT  *result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    int         tz;

    GetCurrentTimeUsec(tm, &fsec, &tz);

    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
    tm2timetz(tm, fsec, tz, result);
    AdjustTimeForTypmod(&(result->time), typmod);
    return result;
}

GetSQLLocalTime()

TimeADT GetSQLLocalTime

(

int32

typmod

)

Definition at line 353 of file date.c.

References AdjustTimeForTypmod(), GetCurrentTimeUsec(), tm, and tm2time().

Referenced by ExecEvalSQLValueFunction().

{
    TimeADT     result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    int         tz;

    GetCurrentTimeUsec(tm, &fsec, &tz);

    tm2time(tm, fsec, &result);
    AdjustTimeForTypmod(&result, typmod);
    return result;
}

in_range_date_interval()

Datum in_range_date_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1043 of file date.c.

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

{
    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));
}

in_range_time_interval()

Datum in_range_time_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1916 of file date.c.

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

{
    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);
}

in_range_timetz_interval()

Datum in_range_timetz_interval

(

PG_FUNCTION_ARGS

)

Definition at line 2418 of file date.c.

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

{
    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);
}

interval_time()

Datum interval_time

(

PG_FUNCTION_ARGS

)

Definition at line 1836 of file date.c.

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

{
    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);
}

make_date()

Datum make_date

(

PG_FUNCTION_ARGS

)

Definition at line 236 of file date.c.

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

{
    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);
}

make_time()

Datum make_time

(

PG_FUNCTION_ARGS

)

Definition at line 1401 of file date.c.

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.

{
    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);
}

overlaps_time()

Datum overlaps_time

(

PG_FUNCTION_ARGS

)

Definition at line 1607 of file date.c.

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

{
    /*
     * 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
}

overlaps_timetz()

Datum overlaps_timetz

(

PG_FUNCTION_ARGS

)

Definition at line 2461 of file date.c.

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

{
    /*
     * 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
}

time2tm()

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

Definition at line 1312 of file date.c.

References 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(), and time_timetz().

{
    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;
}

time_cmp()

Datum time_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 1558 of file date.c.

References PG_GETARG_TIMEADT, and PG_RETURN_INT32.

Referenced by compareDatetime(), gbt_timekey_cmp(), and leftmostvalue_time().

{
    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);
}

time_eq()

Datum time_eq

(

PG_FUNCTION_ARGS

)

Definition at line 1504 of file date.c.

References PG_GETARG_TIMEADT, and PG_RETURN_BOOL.

Referenced by gbt_timeeq().

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

    PG_RETURN_BOOL(time1 == time2);
}

time_ge()

Datum time_ge

(

PG_FUNCTION_ARGS

)

Definition at line 1549 of file date.c.

References PG_GETARG_TIMEADT, and PG_RETURN_BOOL.

Referenced by gbt_timege().

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

    PG_RETURN_BOOL(time1 >= time2);
}

time_gt()

Datum time_gt

(

PG_FUNCTION_ARGS

)

Definition at line 1540 of file date.c.

References PG_GETARG_TIMEADT, and PG_RETURN_BOOL.

Referenced by gbt_timegt().

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

    PG_RETURN_BOOL(time1 > time2);
}

time_hash()

Datum time_hash

(

PG_FUNCTION_ARGS

)

Definition at line 1571 of file date.c.

References hashint8().

{
    return hashint8(fcinfo);
}

time_hash_extended()

Datum time_hash_extended

(

PG_FUNCTION_ARGS

)

Definition at line 1577 of file date.c.

References hashint8extended().

{
    return hashint8extended(fcinfo);
}

time_in()

Datum time_in

(

PG_FUNCTION_ARGS

)

Definition at line 1201 of file date.c.

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

{
    char       *str = PG_GETARG_CSTRING(0);

#ifdef NOT_USED
    Oid         typelem = PG_GETARG_OID(1);
#endif
    int32       typmod = PG_GETARG_INT32(2);
    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];

    dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
                          field, ftype, MAXDATEFIELDS, &nf);
    if (dterr == 0)
        dterr = DecodeTimeOnly(field, ftype, nf, &dtype, tm, &fsec, &tz);
    if (dterr != 0)
        DateTimeParseError(dterr, str, "time");

    tm2time(tm, fsec, &result);
    AdjustTimeForTypmod(&result, typmod);

    PG_RETURN_TIMEADT(result);
}

time_interval()

Datum time_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1813 of file date.c.

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

{
    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);
}

time_larger()

Datum time_larger

(

PG_FUNCTION_ARGS

)

Definition at line 1583 of file date.c.

References PG_GETARG_TIMEADT, and PG_RETURN_TIMEADT.

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

    PG_RETURN_TIMEADT((time1 > time2) ? time1 : time2);
}

time_le()

Datum time_le

(

PG_FUNCTION_ARGS

)

Definition at line 1531 of file date.c.

References PG_GETARG_TIMEADT, and PG_RETURN_BOOL.

Referenced by gbt_timele().

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

    PG_RETURN_BOOL(time1 <= time2);
}

time_lt()

Datum time_lt

(

PG_FUNCTION_ARGS

)

Definition at line 1522 of file date.c.

References PG_GETARG_TIMEADT, and PG_RETURN_BOOL.

Referenced by gbt_timelt().

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

    PG_RETURN_BOOL(time1 < time2);
}

time_mi_interval()

Datum time_mi_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1898 of file date.c.

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

{
    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);
}

time_mi_time()

Datum time_mi_time

(

PG_FUNCTION_ARGS

)

Definition at line 1861 of file date.c.

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().

{
    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);
}

time_ne()

Datum time_ne

(

PG_FUNCTION_ARGS

)

Definition at line 1513 of file date.c.

References PG_GETARG_TIMEADT, and PG_RETURN_BOOL.

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

    PG_RETURN_BOOL(time1 != time2);
}

time_out()

Datum time_out

(

PG_FUNCTION_ARGS

)

Definition at line 1325 of file date.c.

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

{
    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);
}

time_overflows()

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

Definition at line 1249 of file date.c.

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

Referenced by DecodeDateTime(), and DecodeTimeOnly().

{
    /* 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;
}

time_part()

Datum time_part

(

PG_FUNCTION_ARGS

)

Definition at line 1956 of file date.c.

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, PG_GETARG_TEXT_PP, PG_GETARG_TIMEADT, PG_RETURN_FLOAT8, 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.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    TimeADT     time = PG_GETARG_TIMEADT(1);
    float8      result;
    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:
                result = tm->tm_sec * 1000000.0 + fsec;
                break;

            case DTK_MILLISEC:
                result = tm->tm_sec * 1000.0 + fsec / 1000.0;
                break;

            case DTK_SECOND:
                result = tm->tm_sec + fsec / 1000000.0;
                break;

            case DTK_MINUTE:
                result = tm->tm_min;
                break;

            case DTK_HOUR:
                result = 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_INVALID_PARAMETER_VALUE),
                         errmsg("\"time\" units \"%s\" not recognized",
                                lowunits)));
                result = 0;
        }
    }
    else if (type == RESERV && val == DTK_EPOCH)
    {
        result = time / 1000000.0;
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("\"time\" units \"%s\" not recognized",
                        lowunits)));
        result = 0;
    }

    PG_RETURN_FLOAT8(result);
}

time_pl_interval()

Datum time_pl_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1880 of file date.c.

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

{
    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);
}

time_recv()

Datum time_recv

(

PG_FUNCTION_ARGS

)

Definition at line 1345 of file date.c.

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.

{
    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);
}

time_scale()

Datum time_scale

(

PG_FUNCTION_ARGS

)

Definition at line 1449 of file date.c.

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

{
    TimeADT     time = PG_GETARG_TIMEADT(0);
    int32       typmod = PG_GETARG_INT32(1);
    TimeADT     result;

    result = time;
    AdjustTimeForTypmod(&result, typmod);

    PG_RETURN_TIMEADT(result);
}

time_send()

Datum time_send

(

PG_FUNCTION_ARGS

)

Definition at line 1371 of file date.c.

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

{
    TimeADT     time = PG_GETARG_TIMEADT(0);
    StringInfoData buf;

    pq_begintypsend(&buf);
    pq_sendint64(&buf, time);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

time_smaller()

Datum time_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 1592 of file date.c.

References PG_GETARG_TIMEADT, and PG_RETURN_TIMEADT.

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

    PG_RETURN_TIMEADT((time1 < time2) ? time1 : time2);
}

time_support()

Datum time_support

(

PG_FUNCTION_ARGS

)

Definition at line 1429 of file date.c.

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

{
    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);
}

time_timetz()

Datum time_timetz

(

PG_FUNCTION_ARGS

)

Definition at line 2594 of file date.c.

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

Referenced by castTimeToTimeTz().

{
    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);
}

timestamp_cmp_date()

Datum timestamp_cmp_date

(

PG_FUNCTION_ARGS

)

Definition at line 965 of file date.c.

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

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_INT32(-date_cmp_timestamp_internal(dateVal, dt1));
}

timestamp_date()

Datum timestamp_date

(

PG_FUNCTION_ARGS

)

Definition at line 1124 of file date.c.

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   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);
}

timestamp_eq_date()

Datum timestamp_eq_date

(

PG_FUNCTION_ARGS

)

Definition at line 911 of file date.c.

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

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) == 0);
}

timestamp_ge_date()

Datum timestamp_ge_date

(

PG_FUNCTION_ARGS

)

Definition at line 956 of file date.c.

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

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) <= 0);
}

timestamp_gt_date()

Datum timestamp_gt_date

(

PG_FUNCTION_ARGS

)

Definition at line 938 of file date.c.

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

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) < 0);
}

timestamp_le_date()

Datum timestamp_le_date

(

PG_FUNCTION_ARGS

)

Definition at line 947 of file date.c.

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

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) >= 0);
}

timestamp_lt_date()

Datum timestamp_lt_date

(

PG_FUNCTION_ARGS

)

Definition at line 929 of file date.c.

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

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) > 0);
}

timestamp_ne_date()

Datum timestamp_ne_date

(

PG_FUNCTION_ARGS

)

Definition at line 920 of file date.c.

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

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) != 0);
}

timestamp_time()

Datum timestamp_time

(

PG_FUNCTION_ARGS

)

Definition at line 1729 of file date.c.

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.

{
    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);
}

timestamptz_cmp_date()

Datum timestamptz_cmp_date

(

PG_FUNCTION_ARGS

)

Definition at line 1028 of file date.c.

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

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_INT32(-date_cmp_timestamptz_internal(dateVal, dt1));
}

timestamptz_date()

Datum timestamptz_date

(

PG_FUNCTION_ARGS

)

Definition at line 1169 of file date.c.

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 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);
}

timestamptz_eq_date()

Datum timestamptz_eq_date

(

PG_FUNCTION_ARGS

)

Definition at line 974 of file date.c.

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

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) == 0);
}

timestamptz_ge_date()

Datum timestamptz_ge_date

(

PG_FUNCTION_ARGS

)

Definition at line 1019 of file date.c.

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

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) <= 0);
}

timestamptz_gt_date()

Datum timestamptz_gt_date

(

PG_FUNCTION_ARGS

)

Definition at line 1001 of file date.c.

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

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) < 0);
}

timestamptz_le_date()

Datum timestamptz_le_date

(

PG_FUNCTION_ARGS

)

Definition at line 1010 of file date.c.

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

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) >= 0);
}

timestamptz_lt_date()

Datum timestamptz_lt_date

(

PG_FUNCTION_ARGS

)

Definition at line 992 of file date.c.

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

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) > 0);
}

timestamptz_ne_date()

Datum timestamptz_ne_date

(

PG_FUNCTION_ARGS

)

Definition at line 983 of file date.c.

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

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    DateADT     dateVal = PG_GETARG_DATEADT(1);

    PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) != 0);
}

timestamptz_time()

Datum timestamptz_time

(

PG_FUNCTION_ARGS

)

Definition at line 1759 of file date.c.

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 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);
}

timestamptz_timetz()

Datum timestamptz_timetz

(

PG_FUNCTION_ARGS

)

Definition at line 2620 of file date.c.

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

{
    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);
}

timetypmodin()

Datum timetypmodin

(

PG_FUNCTION_ARGS

)

Definition at line 1382 of file date.c.

References anytime_typmodin(), PG_GETARG_ARRAYTYPE_P, and PG_RETURN_INT32.

{
    ArrayType  *ta = PG_GETARG_ARRAYTYPE_P(0);

    PG_RETURN_INT32(anytime_typmodin(false, ta));
}

timetypmodout()

Datum timetypmodout

(

PG_FUNCTION_ARGS

)

Definition at line 1390 of file date.c.

References anytime_typmodout(), PG_GETARG_INT32, and PG_RETURN_CSTRING.

{
    int32       typmod = PG_GETARG_INT32(0);

    PG_RETURN_CSTRING(anytime_typmodout(false, typmod));
}

timetz2tm()

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

Definition at line 2181 of file date.c.

References TimeTzADT::time, 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().

{
    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;
}

timetz_cmp()

Datum timetz_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 2302 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_INT32, and timetz_cmp_internal().

Referenced by compareDatetime(), and leftmostvalue_timetz().

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);

    PG_RETURN_INT32(timetz_cmp_internal(time1, time2));
}

timetz_cmp_internal()

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

static

Definition at line 2221 of file date.c.

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().

{
    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;
}

timetz_eq()

Datum timetz_eq

(

PG_FUNCTION_ARGS

)

Definition at line 2248 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);

    PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) == 0);
}

timetz_ge()

Datum timetz_ge

(

PG_FUNCTION_ARGS

)

Definition at line 2293 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);

    PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) >= 0);
}

timetz_gt()

Datum timetz_gt

(

PG_FUNCTION_ARGS

)

Definition at line 2284 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);

    PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) > 0);
}

timetz_hash()

Datum timetz_hash

(

PG_FUNCTION_ARGS

)

Definition at line 2311 of file date.c.

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

{
    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);
}

timetz_hash_extended()

Datum timetz_hash_extended

(

PG_FUNCTION_ARGS

)

Definition at line 2327 of file date.c.

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

{
    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);
}

timetz_in()

Datum timetz_in

(

PG_FUNCTION_ARGS

)

Definition at line 2057 of file date.c.

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

{
    char       *str = PG_GETARG_CSTRING(0);

#ifdef NOT_USED
    Oid         typelem = PG_GETARG_OID(1);
#endif
    int32       typmod = PG_GETARG_INT32(2);
    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];

    dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
                          field, ftype, MAXDATEFIELDS, &nf);
    if (dterr == 0)
        dterr = DecodeTimeOnly(field, ftype, nf, &dtype, tm, &fsec, &tz);
    if (dterr != 0)
        DateTimeParseError(dterr, str, "time with time zone");

    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
    tm2timetz(tm, fsec, tz, result);
    AdjustTimeForTypmod(&(result->time), typmod);

    PG_RETURN_TIMETZADT_P(result);
}

timetz_izone()

Datum timetz_izone

(

PG_FUNCTION_ARGS

)

Definition at line 2875 of file date.c.

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

{
    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);
}

timetz_larger()

Datum timetz_larger

(

PG_FUNCTION_ARGS

)

Definition at line 2343 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_TIMETZADT_P, and timetz_cmp_internal().

{
    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);
}

timetz_le()

Datum timetz_le

(

PG_FUNCTION_ARGS

)

Definition at line 2275 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);

    PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) <= 0);
}

timetz_lt()

Datum timetz_lt

(

PG_FUNCTION_ARGS

)

Definition at line 2266 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);

    PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) < 0);
}

timetz_mi_interval()

Datum timetz_mi_interval

(

PG_FUNCTION_ARGS

)

Definition at line 2396 of file date.c.

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

{
    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);
}

timetz_ne()

Datum timetz_ne

(

PG_FUNCTION_ARGS

)

Definition at line 2257 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

{
    TimeTzADT  *time1 = PG_GETARG_TIMETZADT_P(0);
    TimeTzADT  *time2 = PG_GETARG_TIMETZADT_P(1);

    PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) != 0);
}

timetz_out()

Datum timetz_out

(

PG_FUNCTION_ARGS

)

Definition at line 2092 of file date.c.

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

{
    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);
}

timetz_part()

Datum timetz_part

(

PG_FUNCTION_ARGS

)

Definition at line 2693 of file date.c.

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, FMODULO, PG_GETARG_TEXT_PP, PG_GETARG_TIMETZADT_P, PG_RETURN_FLOAT8, 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.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    TimeTzADT  *time = PG_GETARG_TIMETZADT_P(1);
    float8      result;
    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)
    {
        double      dummy;
        int         tz;
        fsec_t      fsec;
        struct pg_tm tt,
                   *tm = &tt;

        timetz2tm(time, tm, &fsec, &tz);

        switch (val)
        {
            case DTK_TZ:
                result = -tz;
                break;

            case DTK_TZ_MINUTE:
                result = -tz;
                result /= SECS_PER_MINUTE;
                FMODULO(result, dummy, (double) SECS_PER_MINUTE);
                break;

            case DTK_TZ_HOUR:
                dummy = -tz;
                FMODULO(dummy, result, (double) SECS_PER_HOUR);
                break;

            case DTK_MICROSEC:
                result = tm->tm_sec * 1000000.0 + fsec;
                break;

            case DTK_MILLISEC:
                result = tm->tm_sec * 1000.0 + fsec / 1000.0;
                break;

            case DTK_SECOND:
                result = tm->tm_sec + fsec / 1000000.0;
                break;

            case DTK_MINUTE:
                result = tm->tm_min;
                break;

            case DTK_HOUR:
                result = 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_INVALID_PARAMETER_VALUE),
                         errmsg("\"time with time zone\" units \"%s\" not recognized",
                                lowunits)));
                result = 0;
        }
    }
    else if (type == RESERV && val == DTK_EPOCH)
    {
        result = time->time / 1000000.0 + time->zone;
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("\"time with time zone\" units \"%s\" not recognized",
                        lowunits)));
        result = 0;
    }

    PG_RETURN_FLOAT8(result);
}

timetz_pl_interval()

Datum timetz_pl_interval

(

PG_FUNCTION_ARGS

)

Definition at line 2374 of file date.c.

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

{
    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);
}

timetz_recv()

Datum timetz_recv

(

PG_FUNCTION_ARGS

)

Definition at line 2113 of file date.c.

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.

{
    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);
}

timetz_scale()

Datum timetz_scale

(

PG_FUNCTION_ARGS

)

Definition at line 2203 of file date.c.

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

{
    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);
}

timetz_send()

Datum timetz_send

(

PG_FUNCTION_ARGS

)

Definition at line 2149 of file date.c.

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

{
    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));
}

timetz_smaller()

Datum timetz_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 2357 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_TIMETZADT_P, and timetz_cmp_internal().

{
    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);
}

timetz_time()

Datum timetz_time

(

PG_FUNCTION_ARGS

)

Definition at line 2581 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_TIMEADT, and TimeTzADT::time.

{
    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);
}

timetz_zone()

Datum timetz_zone

(

PG_FUNCTION_ARGS

)

Definition at line 2793 of file date.c.

References DecodeTimezoneAbbrev(), DetermineTimeZoneAbbrevOffset(), downcase_truncate_identifier(), DTZ, DYNTZ, ereport, errcode(), errmsg(), ERROR, now(), palloc(), PG_GETARG_TEXT_PP, PG_GETARG_TIMETZADT_P, pg_localtime(), PG_RETURN_TIMETZADT_P, pg_tzset(), text_to_cstring_buffer(), TimeTzADT::time, tm, pg_tm::tm_gmtoff, generate_unaccent_rules::type, TZ, TZ_STRLEN_MAX, USECS_PER_DAY, USECS_PER_SEC, val, and TimeTzADT::zone.

{
    text       *zone = PG_GETARG_TEXT_PP(0);
    TimeTzADT  *t = PG_GETARG_TIMETZADT_P(1);