Header And Logo

PostgreSQL
| The world's most advanced open source database.

Defines | Functions

date.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <limits.h>
#include <float.h>
#include <time.h>
#include "access/hash.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "parser/scansup.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/datetime.h"
#include "utils/nabstime.h"
#include "utils/sortsupport.h"
Include dependency graph for date.c:

Go to the source code of this file.

Defines

#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 void EncodeSpecialDate (DateADT dt, char *str)
static int time2tm (TimeADT time, struct pg_tm *tm, fsec_t *fsec)
static int timetz2tm (TimeTzADT *time, struct pg_tm *tm, fsec_t *fsec, int *tzp)
static int tm2time (struct pg_tm *tm, fsec_t fsec, TimeADT *result)
static int tm2timetz (struct pg_tm *tm, fsec_t fsec, int tz, TimeTzADT *result)
static void AdjustTimeForTypmod (TimeADT *time, int32 typmod)
static int32 anytime_typmodin (bool istz, ArrayType *ta)
static char * anytime_typmodout (bool istz, int32 typmod)
Datum date_in (PG_FUNCTION_ARGS)
Datum date_out (PG_FUNCTION_ARGS)
Datum date_recv (PG_FUNCTION_ARGS)
Datum date_send (PG_FUNCTION_ARGS)
Datum 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)
static Timestamp date2timestamp (DateADT dateVal)
static TimestampTz date2timestamptz (DateADT dateVal)
double date2timestamp_no_overflow (DateADT dateVal)
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)
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 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 abstime_date (PG_FUNCTION_ARGS)
Datum time_in (PG_FUNCTION_ARGS)
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 time_transform (PG_FUNCTION_ARGS)
Datum time_scale (PG_FUNCTION_ARGS)
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_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 time_part (PG_FUNCTION_ARGS)
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)
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_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 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)

Define Documentation

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

Referenced by overlaps_time().

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

Referenced by overlaps_time().

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

Referenced by overlaps_timetz().

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

Referenced by overlaps_timetz().


Function Documentation

Datum abstime_date ( PG_FUNCTION_ARGS   ) 

Definition at line 995 of file date.c.

References abstime2tm(), date2j(), DATE_NOBEGIN, DATE_NOEND, ereport, errcode(), errmsg(), ERROR, INVALID_ABSTIME, NOEND_ABSTIME, NOSTART_ABSTIME, NULL, PG_GETARG_ABSOLUTETIME, PG_RETURN_DATEADT, tm, pg_tm::tm_mday, pg_tm::tm_mon, and pg_tm::tm_year.

{
    AbsoluteTime abstime = PG_GETARG_ABSOLUTETIME(0);
    DateADT     result;
    struct pg_tm tt,
               *tm = &tt;
    int         tz;

    switch (abstime)
    {
        case INVALID_ABSTIME:
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                   errmsg("cannot convert reserved abstime value to date")));
            result = 0;         /* keep compiler quiet */
            break;

        case NOSTART_ABSTIME:
            DATE_NOBEGIN(result);
            break;

        case NOEND_ABSTIME:
            DATE_NOEND(result);
            break;

        default:
            abstime2tm(abstime, &tz, tm, NULL);
            result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - POSTGRES_EPOCH_JDATE;
            break;
    }

    PG_RETURN_DATEADT(result);
}

static void AdjustTimeForTypmod ( TimeADT time,
int32  typmod 
) [static]

Definition at line 1248 of file date.c.

References INT64CONST, MAX_TIME_PRECISION, and rint().

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

{
#ifdef HAVE_INT64_TIMESTAMP
    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)
    };
#else
    /* note MAX_TIME_PRECISION differs in this case */
    static const double TimeScales[MAX_TIME_PRECISION + 1] = {
        1.0,
        10.0,
        100.0,
        1000.0,
        10000.0,
        100000.0,
        1000000.0,
        10000000.0,
        100000000.0,
        1000000000.0,
        10000000000.0
    };
#endif

    if (typmod >= 0 && typmod <= MAX_TIME_PRECISION)
    {
        /*
         * Note: this round-to-nearest code is not completely consistent about
         * rounding values that are exactly halfway between integral values.
         * On most platforms, rint() will implement round-to-nearest-even, but
         * the integer code always rounds up (away from zero).  Is it worth
         * trying to be consistent?
         */
#ifdef HAVE_INT64_TIMESTAMP
        if (*time >= INT64CONST(0))
            *time = ((*time + TimeOffsets[typmod]) / TimeScales[typmod]) *
                TimeScales[typmod];
        else
            *time = -((((-*time) + TimeOffsets[typmod]) / TimeScales[typmod]) *
                      TimeScales[typmod]);
#else
        *time = rint((double) *time * TimeScales[typmod]) / TimeScales[typmod];
#endif
    }
}

static int32 anytime_typmodin ( bool  istz,
ArrayType ta 
) [static]

Definition at line 53 of file date.c.

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

Referenced by timetypmodin(), and timetztypmodin().

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

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

    return typmod;
}

static char* anytime_typmodout ( bool  istz,
int32  typmod 
) [static]

Definition at line 92 of file date.c.

References palloc(), and snprintf().

Referenced by timetypmodout(), and timetztypmodout().

{
    char       *res = (char *) palloc(64);
    const char *tz = istz ? " with time zone" : " without time zone";

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

static Timestamp date2timestamp ( DateADT  dateVal  )  [static]

Definition at line 423 of file date.c.

References DATE_IS_NOBEGIN, DATE_IS_NOEND, ereport, errcode(), errmsg(), ERROR, SECS_PER_DAY, TIMESTAMP_NOBEGIN, and TIMESTAMP_NOEND.

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

{
    Timestamp   result;

    if (DATE_IS_NOBEGIN(dateVal))
        TIMESTAMP_NOBEGIN(result);
    else if (DATE_IS_NOEND(dateVal))
        TIMESTAMP_NOEND(result);
    else
    {
#ifdef HAVE_INT64_TIMESTAMP
        /* date is days since 2000, timestamp is microseconds since same... */
        result = dateVal * USECS_PER_DAY;
        /* Date's range is wider than timestamp's, so check for overflow */
        if (result / USECS_PER_DAY != dateVal)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("date out of range for timestamp")));
#else
        /* date is days since 2000, timestamp is seconds since same... */
        result = dateVal * (double) SECS_PER_DAY;
#endif
    }

    return result;
}

double date2timestamp_no_overflow ( DateADT  dateVal  ) 

Definition at line 497 of file date.c.

References DATE_IS_NOBEGIN, DATE_IS_NOEND, SECS_PER_DAY, 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
    {
#ifdef HAVE_INT64_TIMESTAMP
        /* date is days since 2000, timestamp is microseconds since same... */
        result = dateVal * (double) USECS_PER_DAY;
#else
        /* date is days since 2000, timestamp is seconds since same... */
        result = dateVal * (double) SECS_PER_DAY;
#endif
    }

    return result;
}

static TimestampTz date2timestamptz ( DateADT  dateVal  )  [static]

Definition at line 451 of file date.c.

References DATE_IS_NOBEGIN, DATE_IS_NOEND, DetermineTimeZoneOffset(), ereport, errcode(), errmsg(), ERROR, j2date(), POSTGRES_EPOCH_JDATE, SECS_PER_DAY, session_timezone, 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, and USECS_PER_DAY.

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

{
    TimestampTz result;
    struct pg_tm tt,
               *tm = &tt;
    int         tz;

    if (DATE_IS_NOBEGIN(dateVal))
        TIMESTAMP_NOBEGIN(result);
    else if (DATE_IS_NOEND(dateVal))
        TIMESTAMP_NOEND(result);
    else
    {
        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);

#ifdef HAVE_INT64_TIMESTAMP
        result = dateVal * USECS_PER_DAY + tz * USECS_PER_SEC;
        /* Date's range is wider than timestamp's, so check for overflow */
        if ((result - tz * USECS_PER_SEC) / USECS_PER_DAY != dateVal)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("date out of range for timestamp")));
#else
        result = dateVal * (double) SECS_PER_DAY + tz;
#endif
    }

    return result;
}

Datum date_cmp ( PG_FUNCTION_ARGS   ) 

Definition at line 312 of file date.c.

References PG_GETARG_DATEADT, and PG_RETURN_INT32.

Referenced by gbt_datekey_cmp().

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

Datum date_cmp_timestamp ( PG_FUNCTION_ARGS   ) 
Datum date_cmp_timestamptz ( PG_FUNCTION_ARGS   ) 
Datum date_eq ( PG_FUNCTION_ARGS   ) 

Definition at line 258 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);
}

Datum date_eq_timestamp ( PG_FUNCTION_ARGS   ) 
Datum date_eq_timestamptz ( PG_FUNCTION_ARGS   ) 
static int date_fastcmp ( Datum  x,
Datum  y,
SortSupport  ssup 
) [static]

Definition at line 325 of file date.c.

References DatumGetDateADT.

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

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

Datum date_finite ( PG_FUNCTION_ARGS   ) 

Definition at line 347 of file date.c.

References DATE_NOT_FINITE, PG_GETARG_DATEADT, and PG_RETURN_BOOL.

Datum date_ge ( PG_FUNCTION_ARGS   ) 

Definition at line 303 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);
}

Datum date_ge_timestamp ( PG_FUNCTION_ARGS   ) 
Datum date_ge_timestamptz ( PG_FUNCTION_ARGS   ) 
Datum date_gt ( PG_FUNCTION_ARGS   ) 

Definition at line 294 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);
}

Datum date_gt_timestamp ( PG_FUNCTION_ARGS   ) 
Datum date_gt_timestamptz ( PG_FUNCTION_ARGS   ) 
Datum date_in ( PG_FUNCTION_ARGS   ) 

Definition at line 114 of file date.c.

References date2j(), DATE_NOBEGIN, DATE_NOEND, DateTimeParseError(), DecodeDateTime(), DTERR_BAD_FORMAT, DTK_CURRENT, DTK_DATE, DTK_EARLY, DTK_EPOCH, DTK_LATE, ereport, errcode(), errmsg(), ERROR, GetCurrentDateTime(), GetEpochTime(), IS_VALID_JULIAN, MAXDATEFIELDS, MAXDATELEN, ParseDateTime(), PG_GETARG_CSTRING, PG_RETURN_DATEADT, 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_CURRENT:
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
              errmsg("date/time value \"current\" is no longer supported")));

            GetCurrentDateTime(tm);
            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;
    }

    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;

    PG_RETURN_DATEADT(date);
}

Datum date_larger ( PG_FUNCTION_ARGS   ) 

Definition at line 355 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);
}

Datum date_le ( PG_FUNCTION_ARGS   ) 

Definition at line 285 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);
}

Datum date_le_timestamp ( PG_FUNCTION_ARGS   ) 
Datum date_le_timestamptz ( PG_FUNCTION_ARGS   ) 
Datum date_lt ( PG_FUNCTION_ARGS   ) 

Definition at line 276 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);
}

Datum date_lt_timestamp ( PG_FUNCTION_ARGS   ) 
Datum date_lt_timestamptz ( PG_FUNCTION_ARGS   ) 
Datum date_mi ( PG_FUNCTION_ARGS   ) 

Definition at line 375 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));
}

Datum date_mi_interval ( PG_FUNCTION_ARGS   ) 
Datum date_mii ( PG_FUNCTION_ARGS   ) 

Definition at line 406 of file date.c.

References DATE_NOT_FINITE, days, PG_GETARG_DATEADT, PG_GETARG_INT32, and PG_RETURN_DATEADT.

{
    DateADT     dateVal = PG_GETARG_DATEADT(0);
    int32       days = PG_GETARG_INT32(1);

    if (DATE_NOT_FINITE(dateVal))
        days = 0;               /* can't change infinity */

    PG_RETURN_DATEADT(dateVal - days);
}

Datum date_ne ( PG_FUNCTION_ARGS   ) 

Definition at line 267 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);
}

Datum date_ne_timestamp ( PG_FUNCTION_ARGS   ) 
Datum date_ne_timestamptz ( PG_FUNCTION_ARGS   ) 
Datum date_out ( PG_FUNCTION_ARGS   ) 

Definition at line 180 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);
}

Datum date_pl_interval ( PG_FUNCTION_ARGS   ) 
Datum date_pli ( PG_FUNCTION_ARGS   ) 

Definition at line 392 of file date.c.

References DATE_NOT_FINITE, days, 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);

    if (DATE_NOT_FINITE(dateVal))
        days = 0;               /* can't change infinity */

    PG_RETURN_DATEADT(dateVal + days);
}

Datum date_recv ( PG_FUNCTION_ARGS   ) 

Definition at line 205 of file date.c.

References buf, DATE_NOT_FINITE, ereport, errcode(), errmsg(), ERROR, JULIAN_MAX, PG_GETARG_POINTER, PG_RETURN_DATEADT, POSTGRES_EPOCH_JDATE, 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 (result < -POSTGRES_EPOCH_JDATE ||
             result >= JULIAN_MAX - POSTGRES_EPOCH_JDATE)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("date out of range")));

    PG_RETURN_DATEADT(result);
}

Datum date_send ( PG_FUNCTION_ARGS   ) 
Datum date_smaller ( PG_FUNCTION_ARGS   ) 

Definition at line 364 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);
}

Datum date_sortsupport ( PG_FUNCTION_ARGS   ) 

Definition at line 338 of file date.c.

References SortSupportData::comparator, PG_GETARG_POINTER, and PG_RETURN_VOID.

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

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

Datum date_timestamp ( PG_FUNCTION_ARGS   ) 

Definition at line 905 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);
}

Datum date_timestamptz ( PG_FUNCTION_ARGS   ) 

Definition at line 949 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);
}

Datum datetime_timestamp ( PG_FUNCTION_ARGS   ) 

Definition at line 1606 of file date.c.

References date2timestamp(), 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;

    PG_RETURN_TIMESTAMP(result);
}

Datum datetimetz_timestamptz ( PG_FUNCTION_ARGS   ) 

Definition at line 2474 of file date.c.

References DATE_IS_NOBEGIN, DATE_IS_NOEND, PG_GETARG_DATEADT, PG_GETARG_TIMETZADT_P, PG_RETURN_TIMESTAMP, SECS_PER_DAY, TimeTzADT::time, TIMESTAMP_NOBEGIN, TIMESTAMP_NOEND, USECS_PER_DAY, 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
    {
#ifdef HAVE_INT64_TIMESTAMP
        result = date * USECS_PER_DAY + time->time + time->zone * USECS_PER_SEC;
#else
        result = date * (double) SECS_PER_DAY + time->time + time->zone;
#endif
    }

    PG_RETURN_TIMESTAMP(result);
}

static void EncodeSpecialDate ( DateADT  dt,
char *  str 
) [static]

Definition at line 242 of file date.c.

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

Referenced by date_out().

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

Datum interval_time ( PG_FUNCTION_ARGS   ) 

Definition at line 1646 of file date.c.

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

{
    Interval   *span = PG_GETARG_INTERVAL_P(0);
    TimeADT     result;

#ifdef HAVE_INT64_TIMESTAMP
    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;
    }
#else
    result = span->time;
    if (result >= (double) SECS_PER_DAY || result < 0)
        result -= floor(result / (double) SECS_PER_DAY) * (double) SECS_PER_DAY;
#endif

    PG_RETURN_TIMEADT(result);
}

Datum overlaps_time ( PG_FUNCTION_ARGS   ) 

Definition at line 1413 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
}

Datum overlaps_timetz ( PG_FUNCTION_ARGS   ) 

Definition at line 2283 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
}

static int time2tm ( TimeADT  time,
struct pg_tm tm,
fsec_t fsec 
) [static]

Definition at line 1091 of file date.c.

References SECS_PER_HOUR, SECS_PER_MINUTE, TIMEROUND, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, and TMODULO.

Referenced by time_out(), time_part(), and time_timetz().

{
#ifdef HAVE_INT64_TIMESTAMP
    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;
#else
    double      trem;

recalc:
    trem = time;
    TMODULO(trem, tm->tm_hour, (double) SECS_PER_HOUR);
    TMODULO(trem, tm->tm_min, (double) SECS_PER_MINUTE);
    TMODULO(trem, tm->tm_sec, 1.0);
    trem = TIMEROUND(trem);
    /* roundoff may need to propagate to higher-order fields */
    if (trem >= 1.0)
    {
        time = ceil(time);
        goto recalc;
    }
    *fsec = trem;
#endif

    return 0;
}

Datum time_cmp ( PG_FUNCTION_ARGS   ) 

Definition at line 1365 of file date.c.

References PG_GETARG_TIMEADT, and PG_RETURN_INT32.

Referenced by gbt_timekey_cmp().

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

Datum time_eq ( PG_FUNCTION_ARGS   ) 

Definition at line 1311 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);
}

Datum time_ge ( PG_FUNCTION_ARGS   ) 

Definition at line 1356 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);
}

Datum time_gt ( PG_FUNCTION_ARGS   ) 

Definition at line 1347 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);
}

Datum time_hash ( PG_FUNCTION_ARGS   ) 

Definition at line 1378 of file date.c.

References hashfloat8(), and hashint8().

{
    /* We can use either hashint8 or hashfloat8 directly */
#ifdef HAVE_INT64_TIMESTAMP
    return hashint8(fcinfo);
#else
    return hashfloat8(fcinfo);
#endif
}

Datum time_in ( PG_FUNCTION_ARGS   ) 

Definition at line 1035 of file date.c.

References AdjustTimeForTypmod(), DateTimeParseError(), DecodeTimeOnly(), MAXDATEFIELDS, MAXDATELEN, ParseDateTime(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_TIMEADT, 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);
}

Datum time_interval ( PG_FUNCTION_ARGS   ) 

Definition at line 1623 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);
}

Datum time_larger ( PG_FUNCTION_ARGS   ) 

Definition at line 1389 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);
}

Datum time_le ( PG_FUNCTION_ARGS   ) 

Definition at line 1338 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);
}

Datum time_lt ( PG_FUNCTION_ARGS   ) 

Definition at line 1329 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);
}

Datum time_mi_interval ( PG_FUNCTION_ARGS   ) 

Definition at line 1724 of file date.c.

References INT64CONST, PG_GETARG_INTERVAL_P, PG_GETARG_TIMEADT, PG_RETURN_TIMEADT, SECS_PER_DAY, Interval::time, TMODULO, and USECS_PER_DAY.

{
    TimeADT     time = PG_GETARG_TIMEADT(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    TimeADT     result;

#ifdef HAVE_INT64_TIMESTAMP
    result = time - span->time;
    result -= result / USECS_PER_DAY * USECS_PER_DAY;
    if (result < INT64CONST(0))
        result += USECS_PER_DAY;
#else
    TimeADT     time1;

    result = time - span->time;
    TMODULO(result, time1, (double) SECS_PER_DAY);
    if (result < 0)
        result += SECS_PER_DAY;
#endif

    PG_RETURN_TIMEADT(result);
}

Datum time_mi_time ( PG_FUNCTION_ARGS   ) 

Definition at line 1678 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);
}

Datum time_ne ( PG_FUNCTION_ARGS   ) 

Definition at line 1320 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);
}

Datum time_out ( PG_FUNCTION_ARGS   ) 

Definition at line 1123 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);
}

Datum time_part ( PG_FUNCTION_ARGS   ) 

Definition at line 1752 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, 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:
#ifdef HAVE_INT64_TIMESTAMP
                result = tm->tm_sec * 1000000.0 + fsec;
#else
                result = (tm->tm_sec + fsec) * 1000000;
#endif
                break;

            case DTK_MILLISEC:
#ifdef HAVE_INT64_TIMESTAMP
                result = tm->tm_sec * 1000.0 + fsec / 1000.0;
#else
                result = (tm->tm_sec + fsec) * 1000;
#endif
                break;

            case DTK_SECOND:
#ifdef HAVE_INT64_TIMESTAMP
                result = tm->tm_sec + fsec / 1000000.0;
#else
                result = tm->tm_sec + fsec;
#endif
                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)
    {
#ifdef HAVE_INT64_TIMESTAMP
        result = time / 1000000.0;
#else
        result = time;
#endif
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("\"time\" units \"%s\" not recognized",
                        lowunits)));
        result = 0;
    }

    PG_RETURN_FLOAT8(result);
}

Datum time_pl_interval ( PG_FUNCTION_ARGS   ) 

Definition at line 1697 of file date.c.

References INT64CONST, PG_GETARG_INTERVAL_P, PG_GETARG_TIMEADT, PG_RETURN_TIMEADT, SECS_PER_DAY, Interval::time, TMODULO, and USECS_PER_DAY.

{
    TimeADT     time = PG_GETARG_TIMEADT(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    TimeADT     result;

#ifdef HAVE_INT64_TIMESTAMP
    result = time + span->time;
    result -= result / USECS_PER_DAY * USECS_PER_DAY;
    if (result < INT64CONST(0))
        result += USECS_PER_DAY;
#else
    TimeADT     time1;

    result = time + span->time;
    TMODULO(result, time1, (double) SECS_PER_DAY);
    if (result < 0)
        result += SECS_PER_DAY;
#endif

    PG_RETURN_TIMEADT(result);
}

Datum time_recv ( PG_FUNCTION_ARGS   ) 

Definition at line 1146 of file date.c.

References AdjustTimeForTypmod(), buf, ereport, errcode(), errmsg(), ERROR, INT64CONST, PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_TIMEADT, pq_getmsgfloat8(), pq_getmsgint64(), SECS_PER_DAY, 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;

#ifdef HAVE_INT64_TIMESTAMP
    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")));
#else
    result = pq_getmsgfloat8(buf);

    if (result < 0 || result > (double) SECS_PER_DAY)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("time out of range")));
#endif

    AdjustTimeForTypmod(&result, typmod);

    PG_RETURN_TIMEADT(result);
}

Datum time_scale ( PG_FUNCTION_ARGS   ) 

Definition at line 1228 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);
}

Datum time_send ( PG_FUNCTION_ARGS   ) 

Definition at line 1181 of file date.c.

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

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

    pq_begintypsend(&buf);
#ifdef HAVE_INT64_TIMESTAMP
    pq_sendint64(&buf, time);
#else
    pq_sendfloat8(&buf, time);
#endif
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

Datum time_smaller ( PG_FUNCTION_ARGS   ) 

Definition at line 1398 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);
}

Datum time_timetz ( PG_FUNCTION_ARGS   ) 

Definition at line 2416 of file date.c.

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

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

Datum time_transform ( PG_FUNCTION_ARGS   ) 
Datum timestamp_cmp_date ( PG_FUNCTION_ARGS   ) 
Datum timestamp_date ( PG_FUNCTION_ARGS   ) 

Definition at line 919 of file date.c.

References date2j(), DATE_NOBEGIN, DATE_NOEND, ereport, errcode(), errmsg(), ERROR, NULL, PG_GETARG_TIMESTAMP, PG_RETURN_DATEADT, 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);
}

Datum timestamp_eq_date ( PG_FUNCTION_ARGS   ) 
Datum timestamp_ge_date ( PG_FUNCTION_ARGS   ) 
Datum timestamp_gt_date ( PG_FUNCTION_ARGS   ) 
Datum timestamp_le_date ( PG_FUNCTION_ARGS   ) 
Datum timestamp_lt_date ( PG_FUNCTION_ARGS   ) 
Datum timestamp_ne_date ( PG_FUNCTION_ARGS   ) 
Datum timestamp_time ( PG_FUNCTION_ARGS   ) 

Definition at line 1535 of file date.c.

References ereport, errcode(), errmsg(), ERROR, MINS_PER_HOUR, NULL, 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")));

#ifdef HAVE_INT64_TIMESTAMP

    /*
     * 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;
#else
    result = ((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec + fsec;
#endif

    PG_RETURN_TIMEADT(result);
}

Datum timestamptz_cmp_date ( PG_FUNCTION_ARGS   ) 
Datum timestamptz_date ( PG_FUNCTION_ARGS   ) 

Definition at line 964 of file date.c.

References date2j(), DATE_NOBEGIN, DATE_NOEND, ereport, errcode(), errmsg(), ERROR, NULL, PG_GETARG_TIMESTAMP, PG_RETURN_DATEADT, 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);
}

Datum timestamptz_eq_date ( PG_FUNCTION_ARGS   ) 
Datum timestamptz_ge_date ( PG_FUNCTION_ARGS   ) 
Datum timestamptz_gt_date ( PG_FUNCTION_ARGS   ) 
Datum timestamptz_le_date ( PG_FUNCTION_ARGS   ) 
Datum timestamptz_lt_date ( PG_FUNCTION_ARGS   ) 
Datum timestamptz_ne_date ( PG_FUNCTION_ARGS   ) 
Datum timestamptz_time ( PG_FUNCTION_ARGS   ) 

Definition at line 1570 of file date.c.

References ereport, errcode(), errmsg(), ERROR, MINS_PER_HOUR, NULL, 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")));

#ifdef HAVE_INT64_TIMESTAMP

    /*
     * 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;
#else
    result = ((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec + fsec;
#endif

    PG_RETURN_TIMEADT(result);
}

Datum timestamptz_timetz ( PG_FUNCTION_ARGS   ) 

Definition at line 2442 of file date.c.

References ereport, errcode(), errmsg(), ERROR, NULL, 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);
}

Datum timetypmodin ( PG_FUNCTION_ARGS   ) 
Datum timetypmodout ( PG_FUNCTION_ARGS   ) 

Definition at line 1204 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));
}

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

Definition at line 2010 of file date.c.

References NULL, SECS_PER_HOUR, SECS_PER_MINUTE, TimeTzADT::time, TIMEROUND, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, TMODULO, and TimeTzADT::zone.

Referenced by timetz_out(), and timetz_part().

{
    TimeOffset  trem = time->time;

#ifdef HAVE_INT64_TIMESTAMP
    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;
#else
recalc:
    TMODULO(trem, tm->tm_hour, (double) SECS_PER_HOUR);
    TMODULO(trem, tm->tm_min, (double) SECS_PER_MINUTE);
    TMODULO(trem, tm->tm_sec, 1.0);
    trem = TIMEROUND(trem);
    /* roundoff may need to propagate to higher-order fields */
    if (trem >= 1.0)
    {
        trem = ceil(time->time);
        goto recalc;
    }
    *fsec = trem;
#endif

    if (tzp != NULL)
        *tzp = time->zone;

    return 0;
}

Datum timetz_cmp ( PG_FUNCTION_ARGS   ) 
static int timetz_cmp_internal ( TimeTzADT time1,
TimeTzADT time2 
) [static]

Definition at line 2065 of file date.c.

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

Referenced by 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 */
#ifdef HAVE_INT64_TIMESTAMP
    t1 = time1->time + (time1->zone * USECS_PER_SEC);
    t2 = time2->time + (time2->zone * USECS_PER_SEC);
#else
    t1 = time1->time + time1->zone;
    t2 = time2->time + time2->zone;
#endif

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

Datum timetz_eq ( PG_FUNCTION_ARGS   ) 

Definition at line 2097 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

Datum timetz_ge ( PG_FUNCTION_ARGS   ) 

Definition at line 2142 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

Datum timetz_gt ( PG_FUNCTION_ARGS   ) 

Definition at line 2133 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

Datum timetz_hash ( PG_FUNCTION_ARGS   ) 

Definition at line 2160 of file date.c.

References DatumGetUInt32, DirectFunctionCall1, Float8GetDatumFast, hash_uint32(), hashfloat8(), hashint8(), Int64GetDatumFast, 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.  This also provides a convenient
     * framework for dealing with the fact that the time field might be either
     * double or int64.
     */
#ifdef HAVE_INT64_TIMESTAMP
    thash = DatumGetUInt32(DirectFunctionCall1(hashint8,
                                               Int64GetDatumFast(key->time)));
#else
    thash = DatumGetUInt32(DirectFunctionCall1(hashfloat8,
                                             Float8GetDatumFast(key->time)));
#endif
    thash ^= DatumGetUInt32(hash_uint32(key->zone));
    PG_RETURN_UINT32(thash);
}

Datum timetz_in ( PG_FUNCTION_ARGS   ) 

Definition at line 1873 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, 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);
}

Datum timetz_izone ( PG_FUNCTION_ARGS   ) 

Definition at line 2692 of file date.c.

References DatumGetCString, Interval::day, DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, INT64CONST, interval_out(), Interval::month, palloc(), PG_GETARG_INTERVAL_P, PG_GETARG_TIMETZADT_P, PG_RETURN_TIMETZADT_P, PointerGetDatum, SECS_PER_DAY, 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))))));

#ifdef HAVE_INT64_TIMESTAMP
    tz = -(zone->time / USECS_PER_SEC);
#else
    tz = -(zone->time);
#endif

    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));

#ifdef HAVE_INT64_TIMESTAMP
    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;
#else
    result->time = time->time + (time->zone - tz);
    while (result->time < 0)
        result->time += SECS_PER_DAY;
    while (result->time >= SECS_PER_DAY)
        result->time -= SECS_PER_DAY;
#endif

    result->zone = tz;

    PG_RETURN_TIMETZADT_P(result);
}

Datum timetz_larger ( PG_FUNCTION_ARGS   ) 

Definition at line 2183 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);
}

Datum timetz_le ( PG_FUNCTION_ARGS   ) 

Definition at line 2124 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

Datum timetz_lt ( PG_FUNCTION_ARGS   ) 

Definition at line 2115 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

Datum timetz_mi_interval ( PG_FUNCTION_ARGS   ) 

Definition at line 2247 of file date.c.

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

{
    TimeTzADT  *time = PG_GETARG_TIMETZADT_P(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    TimeTzADT  *result;

#ifndef HAVE_INT64_TIMESTAMP
    TimeTzADT   time1;
#endif

    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));

#ifdef HAVE_INT64_TIMESTAMP
    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;
#else
    result->time = time->time - span->time;
    TMODULO(result->time, time1.time, (double) SECS_PER_DAY);
    if (result->time < 0)
        result->time += SECS_PER_DAY;
#endif

    result->zone = time->zone;

    PG_RETURN_TIMETZADT_P(result);
}

Datum timetz_ne ( PG_FUNCTION_ARGS   ) 

Definition at line 2106 of file date.c.

References PG_GETARG_TIMETZADT_P, PG_RETURN_BOOL, and timetz_cmp_internal().

Datum timetz_out ( PG_FUNCTION_ARGS   ) 

Definition at line 1908 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);
}

Datum timetz_part ( PG_FUNCTION_ARGS   ) 

Definition at line 2501 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, 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:
#ifdef HAVE_INT64_TIMESTAMP
                result = tm->tm_sec * 1000000.0 + fsec;
#else
                result = (tm->tm_sec + fsec) * 1000000;
#endif
                break;

            case DTK_MILLISEC:
#ifdef HAVE_INT64_TIMESTAMP
                result = tm->tm_sec * 1000.0 + fsec / 1000.0;
#else
                result = (tm->tm_sec + fsec) * 1000;
#endif
                break;

            case DTK_SECOND:
#ifdef HAVE_INT64_TIMESTAMP
                result = tm->tm_sec + fsec / 1000000.0;
#else
                result = tm->tm_sec + fsec;
#endif
                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)
    {
#ifdef HAVE_INT64_TIMESTAMP
        result = time->time / 1000000.0 + time->zone;
#else
        result = time->time + time->zone;
#endif
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("\"time with time zone\" units \"%s\" not recognized",
                        lowunits)));
        result = 0;
    }

    PG_RETURN_FLOAT8(result);
}

Datum timetz_pl_interval ( PG_FUNCTION_ARGS   ) 

Definition at line 2214 of file date.c.

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

{
    TimeTzADT  *time = PG_GETARG_TIMETZADT_P(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    TimeTzADT  *result;

#ifndef HAVE_INT64_TIMESTAMP
    TimeTzADT   time1;
#endif

    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));

#ifdef HAVE_INT64_TIMESTAMP
    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;
#else
    result->time = time->time + span->time;
    TMODULO(result->time, time1.time, (double) SECS_PER_DAY);
    if (result->time < 0)
        result->time += SECS_PER_DAY;
#endif

    result->zone = time->zone;

    PG_RETURN_TIMETZADT_P(result);
}

Datum timetz_recv ( PG_FUNCTION_ARGS   ) 

Definition at line 1929 of file date.c.

References AdjustTimeForTypmod(), buf, ereport, errcode(), errmsg(), ERROR, INT64CONST, palloc(), PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_TIMETZADT_P, pq_getmsgfloat8(), pq_getmsgint(), pq_getmsgint64(), SECS_PER_DAY, 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));

#ifdef HAVE_INT64_TIMESTAMP
    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")));
#else
    result->time = pq_getmsgfloat8(buf);

    if (result->time < 0 || result->time > (double) SECS_PER_DAY)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("time out of range")));
#endif

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

Datum timetz_scale ( PG_FUNCTION_ARGS   ) 

Definition at line 2047 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);
}

Datum timetz_send ( PG_FUNCTION_ARGS   ) 

Definition at line 1974 of file date.c.

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

{
    TimeTzADT  *time = PG_GETARG_TIMETZADT_P(0);
    StringInfoData buf;

    pq_begintypsend(&buf);
#ifdef HAVE_INT64_TIMESTAMP
    pq_sendint64(&buf, time->time);
#else
    pq_sendfloat8(&buf, time->time);
#endif
    pq_sendint(&buf, time->zone, sizeof(time->zone));
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

Datum timetz_smaller ( PG_FUNCTION_ARGS   ) 

Definition at line 2197 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);
}

Datum timetz_time ( PG_FUNCTION_ARGS   ) 

Definition at line 2403 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);
}

Datum timetz_zone ( PG_FUNCTION_ARGS   ) 

Definition at line 2617 of file date.c.

References DecodeSpecial(), downcase_truncate_identifier(), DTZ, ereport, errcode(), errmsg(), ERROR, INT64CONST, now(), NULL, palloc(), PG_GETARG_TEXT_PP, PG_GETARG_TIMETZADT_P, pg_localtime(), PG_RETURN_TIMETZADT_P, pg_tzset(), SECS_PER_DAY, text_to_cstring_buffer(), TimeTzADT::time, tm, pg_tm::tm_gmtoff, 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);
    TimeTzADT  *result;
    int         tz;
    char        tzname[TZ_STRLEN_MAX + 1];
    char       *lowzone;
    int         type,
                val;
    pg_tz      *tzp;

    /*
     * Look up the requested timezone.  First we look in the date token table
     * (to handle cases like "EST"), and if that fails, we look in the
     * timezone database (to handle cases like "America/New_York").  (This
     * matches the order in which timestamp input checks the cases; it's
     * important because the timezone database unwisely uses a few zone names
     * that are identical to offset abbreviations.)
     */
    text_to_cstring_buffer(zone, tzname, sizeof(tzname));
    lowzone = downcase_truncate_identifier(tzname,
                                           strlen(tzname),
                                           false);

    type = DecodeSpecial(0, lowzone, &val);

    if (type == TZ || type == DTZ)
        tz = val * MINS_PER_HOUR;
    else
    {
        tzp = pg_tzset(tzname);
        if (tzp)
        {
            /* Get the offset-from-GMT that is valid today for the zone */
            pg_time_t   now = (pg_time_t) time(NULL);
            struct pg_tm *tm;

            tm = pg_localtime(&now, tzp);
            tz = -tm->tm_gmtoff;
        }
        else
        {
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("time zone \"%s\" not recognized", tzname)));
            tz = 0;             /* keep compiler quiet */
        }
    }

    result = (TimeTzADT *) palloc(sizeof(TimeTzADT));

#ifdef HAVE_INT64_TIMESTAMP
    result->time = t->time + (t->zone - tz) * USECS_PER_SEC;
    while (result->time < INT64CONST(0))
        result->time += USECS_PER_DAY;
    while (result->time >= USECS_PER_DAY)
        result->time -= USECS_PER_DAY;
#else
    result->time = t->time + (t->zone - tz);
    while (result->time < 0)
        result->time += SECS_PER_DAY;
    while (result->time >= SECS_PER_DAY)
        result->time -= SECS_PER_DAY;
#endif

    result->zone = tz;

    PG_RETURN_TIMETZADT_P(result);
}

Datum timetztypmodin ( PG_FUNCTION_ARGS   ) 
Datum timetztypmodout ( PG_FUNCTION_ARGS   ) 

Definition at line 1998 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(true, typmod));
}

static int tm2time ( struct pg_tm tm,
fsec_t  fsec,
TimeADT result 
) [static]

Definition at line 1072 of file date.c.

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

Referenced by time_in().

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

static int tm2timetz ( struct pg_tm tm,
fsec_t  fsec,
int  tz,
TimeTzADT result 
) [static]

Definition at line 1859 of file date.c.

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

Referenced by timestamptz_timetz(), and timetz_in().

{
#ifdef HAVE_INT64_TIMESTAMP
    result->time = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
                    USECS_PER_SEC) + fsec;
#else
    result->time = ((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec + fsec;
#endif
    result->zone = tz;

    return 0;
}