timestamp.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <math.h>
#include <float.h>
#include <limits.h>
#include <sys/time.h>
#include "access/hash.h"
#include "access/xact.h"
#include "catalog/pg_type.h"
#include "common/int128.h"
#include "funcapi.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "parser/scansup.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/datetime.h"

Include dependency graph for timestamp.c:

Go to the source code of this file.

Data Structures
struct	generate_series_timestamp_fctx
struct	generate_series_timestamptz_fctx

Macros
#define	SAMESIGN(a, b)   (((a) < 0) == ((b) < 0))
#define	TIMESTAMP_GT(t1, t2)   DatumGetBool(DirectFunctionCall2(timestamp_gt,t1,t2))
#define	TIMESTAMP_LT(t1, t2)   DatumGetBool(DirectFunctionCall2(timestamp_lt,t1,t2))

Functions
static TimeOffset	time2t (const int hour, const int min, const int sec, const fsec_t fsec)
static Timestamp	dt2local (Timestamp dt, int timezone)
static void	AdjustTimestampForTypmod (Timestamp *time, int32 typmod)
static void	AdjustIntervalForTypmod (Interval *interval, int32 typmod)
static TimestampTz	timestamp2timestamptz (Timestamp timestamp)
static Timestamp	timestamptz2timestamp (TimestampTz timestamp)
static int32	anytimestamp_typmodin (bool istz, ArrayType *ta)
int32	anytimestamp_typmod_check (bool istz, int32 typmod)
static char *	anytimestamp_typmodout (bool istz, int32 typmod)
Datum	timestamp_in (PG_FUNCTION_ARGS)
Datum	timestamp_out (PG_FUNCTION_ARGS)
Datum	timestamp_recv (PG_FUNCTION_ARGS)
Datum	timestamp_send (PG_FUNCTION_ARGS)
Datum	timestamptypmodin (PG_FUNCTION_ARGS)
Datum	timestamptypmodout (PG_FUNCTION_ARGS)
Datum	timestamp_transform (PG_FUNCTION_ARGS)
Datum	timestamp_scale (PG_FUNCTION_ARGS)
Datum	timestamptz_in (PG_FUNCTION_ARGS)
static int	parse_sane_timezone (struct pg_tm *tm, text *zone)
static Timestamp	make_timestamp_internal (int year, int month, int day, int hour, int min, double sec)
Datum	make_timestamp (PG_FUNCTION_ARGS)
Datum	make_timestamptz (PG_FUNCTION_ARGS)
Datum	make_timestamptz_at_timezone (PG_FUNCTION_ARGS)
Datum	float8_timestamptz (PG_FUNCTION_ARGS)
Datum	timestamptz_out (PG_FUNCTION_ARGS)
Datum	timestamptz_recv (PG_FUNCTION_ARGS)
Datum	timestamptz_send (PG_FUNCTION_ARGS)
Datum	timestamptztypmodin (PG_FUNCTION_ARGS)
Datum	timestamptztypmodout (PG_FUNCTION_ARGS)
Datum	timestamptz_scale (PG_FUNCTION_ARGS)
Datum	interval_in (PG_FUNCTION_ARGS)
Datum	interval_out (PG_FUNCTION_ARGS)
Datum	interval_recv (PG_FUNCTION_ARGS)
Datum	interval_send (PG_FUNCTION_ARGS)
Datum	intervaltypmodin (PG_FUNCTION_ARGS)
Datum	intervaltypmodout (PG_FUNCTION_ARGS)
static int	intervaltypmodleastfield (int32 typmod)
Datum	interval_transform (PG_FUNCTION_ARGS)
Datum	interval_scale (PG_FUNCTION_ARGS)
Datum	make_interval (PG_FUNCTION_ARGS)
void	EncodeSpecialTimestamp (Timestamp dt, char *str)
Datum	now (PG_FUNCTION_ARGS)
Datum	statement_timestamp (PG_FUNCTION_ARGS)
Datum	clock_timestamp (PG_FUNCTION_ARGS)
Datum	pg_postmaster_start_time (PG_FUNCTION_ARGS)
Datum	pg_conf_load_time (PG_FUNCTION_ARGS)
TimestampTz	GetCurrentTimestamp (void)
TimestampTz	GetSQLCurrentTimestamp (int32 typmod)
Timestamp	GetSQLLocalTimestamp (int32 typmod)
void	TimestampDifference (TimestampTz start_time, TimestampTz stop_time, long *secs, int *microsecs)
bool	TimestampDifferenceExceeds (TimestampTz start_time, TimestampTz stop_time, int msec)
TimestampTz	time_t_to_timestamptz (pg_time_t tm)
pg_time_t	timestamptz_to_time_t (TimestampTz t)
const char *	timestamptz_to_str (TimestampTz t)
void	dt2time (Timestamp jd, int *hour, int *min, int *sec, fsec_t *fsec)
int	timestamp2tm (Timestamp dt, int *tzp, struct pg_tm *tm, fsec_t *fsec, const char **tzn, pg_tz *attimezone)
int	tm2timestamp (struct pg_tm *tm, fsec_t fsec, int *tzp, Timestamp *result)
int	interval2tm (Interval span, struct pg_tm *tm, fsec_t *fsec)
int	tm2interval (struct pg_tm *tm, fsec_t fsec, Interval *span)
Datum	timestamp_finite (PG_FUNCTION_ARGS)
Datum	interval_finite (PG_FUNCTION_ARGS)
void	GetEpochTime (struct pg_tm *tm)
Timestamp	SetEpochTimestamp (void)
int	timestamp_cmp_internal (Timestamp dt1, Timestamp dt2)
Datum	timestamp_eq (PG_FUNCTION_ARGS)
Datum	timestamp_ne (PG_FUNCTION_ARGS)
Datum	timestamp_lt (PG_FUNCTION_ARGS)
Datum	timestamp_gt (PG_FUNCTION_ARGS)
Datum	timestamp_le (PG_FUNCTION_ARGS)
Datum	timestamp_ge (PG_FUNCTION_ARGS)
Datum	timestamp_cmp (PG_FUNCTION_ARGS)
static int	timestamp_fastcmp (Datum x, Datum y, SortSupport ssup)
Datum	timestamp_sortsupport (PG_FUNCTION_ARGS)
Datum	timestamp_hash (PG_FUNCTION_ARGS)
Datum	timestamp_eq_timestamptz (PG_FUNCTION_ARGS)
Datum	timestamp_ne_timestamptz (PG_FUNCTION_ARGS)
Datum	timestamp_lt_timestamptz (PG_FUNCTION_ARGS)
Datum	timestamp_gt_timestamptz (PG_FUNCTION_ARGS)
Datum	timestamp_le_timestamptz (PG_FUNCTION_ARGS)
Datum	timestamp_ge_timestamptz (PG_FUNCTION_ARGS)
Datum	timestamp_cmp_timestamptz (PG_FUNCTION_ARGS)
Datum	timestamptz_eq_timestamp (PG_FUNCTION_ARGS)
Datum	timestamptz_ne_timestamp (PG_FUNCTION_ARGS)
Datum	timestamptz_lt_timestamp (PG_FUNCTION_ARGS)
Datum	timestamptz_gt_timestamp (PG_FUNCTION_ARGS)
Datum	timestamptz_le_timestamp (PG_FUNCTION_ARGS)
Datum	timestamptz_ge_timestamp (PG_FUNCTION_ARGS)
Datum	timestamptz_cmp_timestamp (PG_FUNCTION_ARGS)
static INT128	interval_cmp_value (const Interval *interval)
static int	interval_cmp_internal (Interval *interval1, Interval *interval2)
Datum	interval_eq (PG_FUNCTION_ARGS)
Datum	interval_ne (PG_FUNCTION_ARGS)
Datum	interval_lt (PG_FUNCTION_ARGS)
Datum	interval_gt (PG_FUNCTION_ARGS)
Datum	interval_le (PG_FUNCTION_ARGS)
Datum	interval_ge (PG_FUNCTION_ARGS)
Datum	interval_cmp (PG_FUNCTION_ARGS)
Datum	interval_hash (PG_FUNCTION_ARGS)
Datum	overlaps_timestamp (PG_FUNCTION_ARGS)
Datum	timestamp_smaller (PG_FUNCTION_ARGS)
Datum	timestamp_larger (PG_FUNCTION_ARGS)
Datum	timestamp_mi (PG_FUNCTION_ARGS)
Datum	interval_justify_interval (PG_FUNCTION_ARGS)
Datum	interval_justify_hours (PG_FUNCTION_ARGS)
Datum	interval_justify_days (PG_FUNCTION_ARGS)
Datum	timestamp_pl_interval (PG_FUNCTION_ARGS)
Datum	timestamp_mi_interval (PG_FUNCTION_ARGS)
Datum	timestamptz_pl_interval (PG_FUNCTION_ARGS)
Datum	timestamptz_mi_interval (PG_FUNCTION_ARGS)
Datum	interval_um (PG_FUNCTION_ARGS)
Datum	interval_smaller (PG_FUNCTION_ARGS)
Datum	interval_larger (PG_FUNCTION_ARGS)
Datum	interval_pl (PG_FUNCTION_ARGS)
Datum	interval_mi (PG_FUNCTION_ARGS)
Datum	interval_mul (PG_FUNCTION_ARGS)
Datum	mul_d_interval (PG_FUNCTION_ARGS)
Datum	interval_div (PG_FUNCTION_ARGS)
Datum	interval_accum (PG_FUNCTION_ARGS)
Datum	interval_combine (PG_FUNCTION_ARGS)
Datum	interval_accum_inv (PG_FUNCTION_ARGS)
Datum	interval_avg (PG_FUNCTION_ARGS)
Datum	timestamp_age (PG_FUNCTION_ARGS)
Datum	timestamptz_age (PG_FUNCTION_ARGS)
Datum	timestamp_trunc (PG_FUNCTION_ARGS)
Datum	timestamptz_trunc (PG_FUNCTION_ARGS)
Datum	interval_trunc (PG_FUNCTION_ARGS)
int	isoweek2j (int year, int week)
void	isoweek2date (int woy, int *year, int *mon, int *mday)
void	isoweekdate2date (int isoweek, int wday, int *year, int *mon, int *mday)
int	date2isoweek (int year, int mon, int mday)
int	date2isoyear (int year, int mon, int mday)
int	date2isoyearday (int year, int mon, int mday)
static float8	NonFiniteTimestampTzPart (int type, int unit, char *lowunits, bool isNegative, bool isTz)
Datum	timestamp_part (PG_FUNCTION_ARGS)
Datum	timestamptz_part (PG_FUNCTION_ARGS)
Datum	interval_part (PG_FUNCTION_ARGS)
Datum	timestamp_zone_transform (PG_FUNCTION_ARGS)
Datum	timestamp_zone (PG_FUNCTION_ARGS)
Datum	timestamp_izone_transform (PG_FUNCTION_ARGS)
Datum	timestamp_izone (PG_FUNCTION_ARGS)
Datum	timestamp_timestamptz (PG_FUNCTION_ARGS)
Datum	timestamptz_timestamp (PG_FUNCTION_ARGS)
Datum	timestamptz_zone (PG_FUNCTION_ARGS)
Datum	timestamptz_izone (PG_FUNCTION_ARGS)
Datum	generate_series_timestamp (PG_FUNCTION_ARGS)
Datum	generate_series_timestamptz (PG_FUNCTION_ARGS)

Variables
TimestampTz	PgStartTime
TimestampTz	PgReloadTime

Macro Definition Documentation

#define SAMESIGN	(		a,
			b
	)		(((a) < 0) == ((b) < 0))

Definition at line 46 of file timestamp.c.

Referenced by interval2tm(), interval_mi(), interval_pl(), and interval_um().

#define TIMESTAMP_GT	(		t1,
			t2
	)		DatumGetBool(DirectFunctionCall2(timestamp_gt,t1,t2))

Referenced by overlaps_timestamp().

#define TIMESTAMP_LT	(		t1,
			t2
	)		DatumGetBool(DirectFunctionCall2(timestamp_lt,t1,t2))

Referenced by overlaps_timestamp().

Function Documentation

static void AdjustIntervalForTypmod ( Interval *  interval, int32  typmod  )

static

Definition at line 1320 of file timestamp.c.

References Interval::day, DAY, elog, ereport, errcode(), errmsg(), ERROR, HOUR, INT64CONST, INTERVAL_FULL_PRECISION, INTERVAL_FULL_RANGE, INTERVAL_MASK, INTERVAL_PRECISION, INTERVAL_RANGE, MAX_INTERVAL_PRECISION, MINUTE, Interval::month, MONTH, MONTHS_PER_YEAR, range(), SECOND, Interval::time, USECS_PER_HOUR, USECS_PER_MINUTE, and YEAR.

Referenced by interval_in(), interval_recv(), and interval_scale().

{
    static const int64 IntervalScales[MAX_INTERVAL_PRECISION + 1] = {
        INT64CONST(1000000),
        INT64CONST(100000),
        INT64CONST(10000),
        INT64CONST(1000),
        INT64CONST(100),
        INT64CONST(10),
        INT64CONST(1)
    };

    static const int64 IntervalOffsets[MAX_INTERVAL_PRECISION + 1] = {
        INT64CONST(500000),
        INT64CONST(50000),
        INT64CONST(5000),
        INT64CONST(500),
        INT64CONST(50),
        INT64CONST(5),
        INT64CONST(0)
    };

    /*
     * Unspecified range and precision? Then not necessary to adjust. Setting
     * typmod to -1 is the convention for all data types.
     */
    if (typmod >= 0)
    {
        int         range = INTERVAL_RANGE(typmod);
        int         precision = INTERVAL_PRECISION(typmod);

        /*
         * Our interpretation of intervals with a limited set of fields is
         * that fields to the right of the last one specified are zeroed out,
         * but those to the left of it remain valid.  Thus for example there
         * is no operational difference between INTERVAL YEAR TO MONTH and
         * INTERVAL MONTH.  In some cases we could meaningfully enforce that
         * higher-order fields are zero; for example INTERVAL DAY could reject
         * nonzero "month" field.  However that seems a bit pointless when we
         * can't do it consistently.  (We cannot enforce a range limit on the
         * highest expected field, since we do not have any equivalent of
         * SQL's <interval leading field precision>.)  If we ever decide to
         * revisit this, interval_transform will likely require adjusting.
         *
         * Note: before PG 8.4 we interpreted a limited set of fields as
         * actually causing a "modulo" operation on a given value, potentially
         * losing high-order as well as low-order information.  But there is
         * no support for such behavior in the standard, and it seems fairly
         * undesirable on data consistency grounds anyway.  Now we only
         * perform truncation or rounding of low-order fields.
         */
        if (range == INTERVAL_FULL_RANGE)
        {
            /* Do nothing... */
        }
        else if (range == INTERVAL_MASK(YEAR))
        {
            interval->month = (interval->month / MONTHS_PER_YEAR) * MONTHS_PER_YEAR;
            interval->day = 0;
            interval->time = 0;
        }
        else if (range == INTERVAL_MASK(MONTH))
        {
            interval->day = 0;
            interval->time = 0;
        }
        /* YEAR TO MONTH */
        else if (range == (INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH)))
        {
            interval->day = 0;
            interval->time = 0;
        }
        else if (range == INTERVAL_MASK(DAY))
        {
            interval->time = 0;
        }
        else if (range == INTERVAL_MASK(HOUR))
        {
            interval->time = (interval->time / USECS_PER_HOUR) *
                USECS_PER_HOUR;
        }
        else if (range == INTERVAL_MASK(MINUTE))
        {
            interval->time = (interval->time / USECS_PER_MINUTE) *
                USECS_PER_MINUTE;
        }
        else if (range == INTERVAL_MASK(SECOND))
        {
            /* fractional-second rounding will be dealt with below */
        }
        /* DAY TO HOUR */
        else if (range == (INTERVAL_MASK(DAY) |
                           INTERVAL_MASK(HOUR)))
        {
            interval->time = (interval->time / USECS_PER_HOUR) *
                USECS_PER_HOUR;
        }
        /* DAY TO MINUTE */
        else if (range == (INTERVAL_MASK(DAY) |
                           INTERVAL_MASK(HOUR) |
                           INTERVAL_MASK(MINUTE)))
        {
            interval->time = (interval->time / USECS_PER_MINUTE) *
                USECS_PER_MINUTE;
        }
        /* DAY TO SECOND */
        else if (range == (INTERVAL_MASK(DAY) |
                           INTERVAL_MASK(HOUR) |
                           INTERVAL_MASK(MINUTE) |
                           INTERVAL_MASK(SECOND)))
        {
            /* fractional-second rounding will be dealt with below */
        }
        /* HOUR TO MINUTE */
        else if (range == (INTERVAL_MASK(HOUR) |
                           INTERVAL_MASK(MINUTE)))
        {
            interval->time = (interval->time / USECS_PER_MINUTE) *
                USECS_PER_MINUTE;
        }
        /* HOUR TO SECOND */
        else if (range == (INTERVAL_MASK(HOUR) |
                           INTERVAL_MASK(MINUTE) |
                           INTERVAL_MASK(SECOND)))
        {
            /* fractional-second rounding will be dealt with below */
        }
        /* MINUTE TO SECOND */
        else if (range == (INTERVAL_MASK(MINUTE) |
                           INTERVAL_MASK(SECOND)))
        {
            /* fractional-second rounding will be dealt with below */
        }
        else
            elog(ERROR, "unrecognized interval typmod: %d", typmod);

        /* Need to adjust sub-second precision? */
        if (precision != INTERVAL_FULL_PRECISION)
        {
            if (precision < 0 || precision > MAX_INTERVAL_PRECISION)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("interval(%d) precision must be between %d and %d",
                                precision, 0, MAX_INTERVAL_PRECISION)));

            if (interval->time >= INT64CONST(0))
            {
                interval->time = ((interval->time +
                                   IntervalOffsets[precision]) /
                                  IntervalScales[precision]) *
                    IntervalScales[precision];
            }
            else
            {
                interval->time = -(((-interval->time +
                                     IntervalOffsets[precision]) /
                                    IntervalScales[precision]) *
                                   IntervalScales[precision]);
            }
        }
    }
}

static void AdjustTimestampForTypmod ( Timestamp *  time, int32  typmod  )

static

Definition at line 334 of file timestamp.c.

References ereport, errcode(), errmsg(), ERROR, INT64CONST, MAX_TIMESTAMP_PRECISION, and TIMESTAMP_NOT_FINITE.

Referenced by GetSQLCurrentTimestamp(), GetSQLLocalTimestamp(), timestamp_in(), timestamp_recv(), timestamp_scale(), timestamptz_in(), timestamptz_recv(), and timestamptz_scale().

{
    static const int64 TimestampScales[MAX_TIMESTAMP_PRECISION + 1] = {
        INT64CONST(1000000),
        INT64CONST(100000),
        INT64CONST(10000),
        INT64CONST(1000),
        INT64CONST(100),
        INT64CONST(10),
        INT64CONST(1)
    };

    static const int64 TimestampOffsets[MAX_TIMESTAMP_PRECISION + 1] = {
        INT64CONST(500000),
        INT64CONST(50000),
        INT64CONST(5000),
        INT64CONST(500),
        INT64CONST(50),
        INT64CONST(5),
        INT64CONST(0)
    };

    if (!TIMESTAMP_NOT_FINITE(*time)
        && (typmod != -1) && (typmod != MAX_TIMESTAMP_PRECISION))
    {
        if (typmod < 0 || typmod > MAX_TIMESTAMP_PRECISION)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("timestamp(%d) precision must be between %d and %d",
                            typmod, 0, MAX_TIMESTAMP_PRECISION)));

        if (*time >= INT64CONST(0))
        {
            *time = ((*time + TimestampOffsets[typmod]) / TimestampScales[typmod]) *
                TimestampScales[typmod];
        }
        else
        {
            *time = -((((-*time) + TimestampOffsets[typmod]) / TimestampScales[typmod])
                      * TimestampScales[typmod]);
        }
    }
}

int32 anytimestamp_typmod_check	(	bool	istz,
		int32	typmod
	)

Definition at line 102 of file timestamp.c.

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

Referenced by anytimestamp_typmodin(), and transformSQLValueFunction().

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

    return typmod;
}

static int32 anytimestamp_typmodin ( bool  istz, ArrayType *  ta  )

static

Definition at line 81 of file timestamp.c.

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

Referenced by timestamptypmodin(), and timestamptztypmodin().

{
    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 TIMESTAMP
     */
    if (n != 1)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid type modifier")));

    return anytimestamp_typmod_check(istz, tl[0]);
}

static char* anytimestamp_typmodout ( bool  istz, int32  typmod  )

static

Definition at line 124 of file timestamp.c.

References psprintf().

Referenced by timestamptypmodout(), and timestamptztypmodout().

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

Datum clock_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 1546 of file timestamp.c.

References GetCurrentTimestamp(), and PG_RETURN_TIMESTAMPTZ.

{
    PG_RETURN_TIMESTAMPTZ(GetCurrentTimestamp());
}

int date2isoweek	(	int	year,
		int	mon,
		int	mday
	)

Definition at line 4073 of file timestamp.c.

References date2j(), j2day(), and result.

Referenced by DCH_to_char(), timestamp_part(), timestamp_trunc(), timestamptz_part(), and timestamptz_trunc().

{
    float8      result;
    int         day0,
                day4,
                dayn;

    /* current day */
    dayn = date2j(year, mon, mday);

    /* fourth day of current year */
    day4 = date2j(year, 1, 4);

    /* day0 == offset to first day of week (Monday) */
    day0 = j2day(day4 - 1);

    /*
     * We need the first week containing a Thursday, otherwise this day falls
     * into the previous year for purposes of counting weeks
     */
    if (dayn < day4 - day0)
    {
        day4 = date2j(year - 1, 1, 4);

        /* day0 == offset to first day of week (Monday) */
        day0 = j2day(day4 - 1);
    }

    result = (dayn - (day4 - day0)) / 7 + 1;

    /*
     * Sometimes the last few days in a year will fall into the first week of
     * the next year, so check for this.
     */
    if (result >= 52)
    {
        day4 = date2j(year + 1, 1, 4);

        /* day0 == offset to first day of week (Monday) */
        day0 = j2day(day4 - 1);

        if (dayn >= day4 - day0)
            result = (dayn - (day4 - day0)) / 7 + 1;
    }

    return (int) result;
}

int date2isoyear	(	int	year,
		int	mon,
		int	mday
	)

Definition at line 4127 of file timestamp.c.

References date2j(), j2day(), and result.

Referenced by date2isoyearday(), DCH_to_char(), timestamp_part(), and timestamptz_part().

{
    float8      result;
    int         day0,
                day4,
                dayn;

    /* current day */
    dayn = date2j(year, mon, mday);

    /* fourth day of current year */
    day4 = date2j(year, 1, 4);

    /* day0 == offset to first day of week (Monday) */
    day0 = j2day(day4 - 1);

    /*
     * We need the first week containing a Thursday, otherwise this day falls
     * into the previous year for purposes of counting weeks
     */
    if (dayn < day4 - day0)
    {
        day4 = date2j(year - 1, 1, 4);

        /* day0 == offset to first day of week (Monday) */
        day0 = j2day(day4 - 1);

        year--;
    }

    result = (dayn - (day4 - day0)) / 7 + 1;

    /*
     * Sometimes the last few days in a year will fall into the first week of
     * the next year, so check for this.
     */
    if (result >= 52)
    {
        day4 = date2j(year + 1, 1, 4);

        /* day0 == offset to first day of week (Monday) */
        day0 = j2day(day4 - 1);

        if (dayn >= day4 - day0)
            year++;
    }

    return year;
}

int date2isoyearday	(	int	year,
		int	mon,
		int	mday
	)

Definition at line 4184 of file timestamp.c.

References date2isoyear(), date2j(), and isoweek2j().

Referenced by DCH_to_char().

{
    return date2j(year, mon, mday) - isoweek2j(date2isoyear(year, mon, mday), 1) + 1;
}

static Timestamp dt2local ( Timestamp  dt, int  timezone  )

static

Definition at line 1952 of file timestamp.c.

References USECS_PER_SEC.

Referenced by make_timestamptz_at_timezone(), timestamp_izone(), timestamp_zone(), timestamptz_izone(), timestamptz_zone(), and tm2timestamp().

{
    dt -= (tz * USECS_PER_SEC);
    return dt;
}

void dt2time	(	Timestamp	jd,
		int *	hour,
		int *	min,
		int *	sec,
		fsec_t *	fsec
	)

Definition at line 1731 of file timestamp.c.

References USECS_PER_HOUR, USECS_PER_MINUTE, and USECS_PER_SEC.

Referenced by DecodeDateTime(), DecodeTimeOnly(), and timestamp2tm().

{
    TimeOffset  time;

    time = jd;

    *hour = time / USECS_PER_HOUR;
    time -= (*hour) * USECS_PER_HOUR;
    *min = time / USECS_PER_MINUTE;
    time -= (*min) * USECS_PER_MINUTE;
    *sec = time / USECS_PER_SEC;
    *fsec = time - (*sec * USECS_PER_SEC);
}                               /* dt2time() */

void EncodeSpecialTimestamp	(	Timestamp	dt,
		char *	str
	)

Definition at line 1523 of file timestamp.c.

References EARLY, elog, ERROR, LATE, TIMESTAMP_IS_NOBEGIN, and TIMESTAMP_IS_NOEND.

Referenced by datum_to_json(), datum_to_jsonb(), PGTYPEStimestamp_to_asc(), timestamp_out(), timestamptz_out(), and timestamptz_to_str().

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

Datum float8_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 711 of file timestamp.c.

References DATETIME_MIN_JULIAN, ereport, errcode(), errmsg(), ERROR, IS_VALID_TIMESTAMP, isinf(), PG_GETARG_FLOAT8, PG_RETURN_TIMESTAMP, POSTGRES_EPOCH_JDATE, result, rint(), SECS_PER_DAY, TIMESTAMP_END_JULIAN, TIMESTAMP_NOBEGIN, TIMESTAMP_NOEND, UNIX_EPOCH_JDATE, and USECS_PER_SEC.

{
    float8      seconds = PG_GETARG_FLOAT8(0);
    TimestampTz result;

    /* Deal with NaN and infinite inputs ... */
    if (isnan(seconds))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp cannot be NaN")));

    if (isinf(seconds))
    {
        if (seconds < 0)
            TIMESTAMP_NOBEGIN(result);
        else
            TIMESTAMP_NOEND(result);
    }
    else
    {
        /* Out of range? */
        if (seconds <
            (float8) SECS_PER_DAY * (DATETIME_MIN_JULIAN - UNIX_EPOCH_JDATE)
            || seconds >=
            (float8) SECS_PER_DAY * (TIMESTAMP_END_JULIAN - UNIX_EPOCH_JDATE))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range: \"%g\"", seconds)));

        /* Convert UNIX epoch to Postgres epoch */
        seconds -= ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY);

        seconds = rint(seconds * USECS_PER_SEC);
        result = (int64) seconds;

        /* Recheck in case roundoff produces something just out of range */
        if (!IS_VALID_TIMESTAMP(result))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range: \"%g\"",
                            PG_GETARG_FLOAT8(0))));
    }

    PG_RETURN_TIMESTAMP(result);
}

Datum generate_series_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 5136 of file timestamp.c.

References generate_series_timestamp_fctx::current, DatumGetTimestamp, DirectFunctionCall2, ereport, errcode(), errmsg(), ERROR, generate_series_timestamp_fctx::finish, interval_cmp_internal(), MemoryContextSwitchTo(), MemSet, FuncCallContext::multi_call_memory_ctx, palloc(), PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMP, PointerGetDatum, result, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, generate_series_timestamp_fctx::step, generate_series_timestamp_fctx::step_sign, timestamp_cmp_internal(), timestamp_pl_interval(), TimestampGetDatum, and FuncCallContext::user_fctx.

{
    FuncCallContext *funcctx;
    generate_series_timestamp_fctx *fctx;
    Timestamp   result;

    /* stuff done only on the first call of the function */
    if (SRF_IS_FIRSTCALL())
    {
        Timestamp   start = PG_GETARG_TIMESTAMP(0);
        Timestamp   finish = PG_GETARG_TIMESTAMP(1);
        Interval   *step = PG_GETARG_INTERVAL_P(2);
        MemoryContext oldcontext;
        Interval    interval_zero;

        /* create a function context for cross-call persistence */
        funcctx = SRF_FIRSTCALL_INIT();

        /*
         * switch to memory context appropriate for multiple function calls
         */
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);

        /* allocate memory for user context */
        fctx = (generate_series_timestamp_fctx *)
            palloc(sizeof(generate_series_timestamp_fctx));

        /*
         * Use fctx to keep state from call to call. Seed current with the
         * original start value
         */
        fctx->current = start;
        fctx->finish = finish;
        fctx->step = *step;

        /* Determine sign of the interval */
        MemSet(&interval_zero, 0, sizeof(Interval));
        fctx->step_sign = interval_cmp_internal(&fctx->step, &interval_zero);

        if (fctx->step_sign == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("step size cannot equal zero")));

        funcctx->user_fctx = fctx;
        MemoryContextSwitchTo(oldcontext);
    }

    /* stuff done on every call of the function */
    funcctx = SRF_PERCALL_SETUP();

    /*
     * get the saved state and use current as the result for this iteration
     */
    fctx = funcctx->user_fctx;
    result = fctx->current;

    if (fctx->step_sign > 0 ?
        timestamp_cmp_internal(result, fctx->finish) <= 0 :
        timestamp_cmp_internal(result, fctx->finish) >= 0)
    {
        /* increment current in preparation for next iteration */
        fctx->current = DatumGetTimestamp(
                                          DirectFunctionCall2(timestamp_pl_interval,
                                                              TimestampGetDatum(fctx->current),
                                                              PointerGetDatum(&fctx->step)));

        /* do when there is more left to send */
        SRF_RETURN_NEXT(funcctx, TimestampGetDatum(result));
    }
    else
    {
        /* do when there is no more left */
        SRF_RETURN_DONE(funcctx);
    }
}

Datum generate_series_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 5217 of file timestamp.c.

References generate_series_timestamptz_fctx::current, DatumGetTimestampTz, DirectFunctionCall2, ereport, errcode(), errmsg(), ERROR, generate_series_timestamptz_fctx::finish, interval_cmp_internal(), MemoryContextSwitchTo(), MemSet, FuncCallContext::multi_call_memory_ctx, palloc(), PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMPTZ, PointerGetDatum, result, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, generate_series_timestamptz_fctx::step, generate_series_timestamptz_fctx::step_sign, timestamp_cmp_internal(), timestamptz_pl_interval(), TimestampTzGetDatum, and FuncCallContext::user_fctx.

{
    FuncCallContext *funcctx;
    generate_series_timestamptz_fctx *fctx;
    TimestampTz result;

    /* stuff done only on the first call of the function */
    if (SRF_IS_FIRSTCALL())
    {
        TimestampTz start = PG_GETARG_TIMESTAMPTZ(0);
        TimestampTz finish = PG_GETARG_TIMESTAMPTZ(1);
        Interval   *step = PG_GETARG_INTERVAL_P(2);
        MemoryContext oldcontext;
        Interval    interval_zero;

        /* create a function context for cross-call persistence */
        funcctx = SRF_FIRSTCALL_INIT();

        /*
         * switch to memory context appropriate for multiple function calls
         */
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);

        /* allocate memory for user context */
        fctx = (generate_series_timestamptz_fctx *)
            palloc(sizeof(generate_series_timestamptz_fctx));

        /*
         * Use fctx to keep state from call to call. Seed current with the
         * original start value
         */
        fctx->current = start;
        fctx->finish = finish;
        fctx->step = *step;

        /* Determine sign of the interval */
        MemSet(&interval_zero, 0, sizeof(Interval));
        fctx->step_sign = interval_cmp_internal(&fctx->step, &interval_zero);

        if (fctx->step_sign == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("step size cannot equal zero")));

        funcctx->user_fctx = fctx;
        MemoryContextSwitchTo(oldcontext);
    }

    /* stuff done on every call of the function */
    funcctx = SRF_PERCALL_SETUP();

    /*
     * get the saved state and use current as the result for this iteration
     */
    fctx = funcctx->user_fctx;
    result = fctx->current;

    if (fctx->step_sign > 0 ?
        timestamp_cmp_internal(result, fctx->finish) <= 0 :
        timestamp_cmp_internal(result, fctx->finish) >= 0)
    {
        /* increment current in preparation for next iteration */
        fctx->current = DatumGetTimestampTz(
                                            DirectFunctionCall2(timestamptz_pl_interval,
                                                                TimestampTzGetDatum(fctx->current),
                                                                PointerGetDatum(&fctx->step)));

        /* do when there is more left to send */
        SRF_RETURN_NEXT(funcctx, TimestampTzGetDatum(result));
    }
    else
    {
        /* do when there is no more left */
        SRF_RETURN_DONE(funcctx);
    }
}

TimestampTz GetCurrentTimestamp

(

void

)

Definition at line 1570 of file timestamp.c.

References gettimeofday(), NULL, POSTGRES_EPOCH_JDATE, result, SECS_PER_DAY, UNIX_EPOCH_JDATE, and USECS_PER_SEC.

Referenced by ApplyLauncherMain(), ApplyWorkerMain(), asyncQueueFillWarning(), autovac_refresh_stats(), AutoVacLauncherMain(), backend_read_statsfile(), BackendInitialize(), BackgroundWriterMain(), check_log_duration(), CheckPointBuffers(), CleanupBackgroundWorker(), clock_timestamp(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateRestartPoint(), DetermineSleepTime(), disable_timeout(), disable_timeouts(), do_analyze_rel(), do_start_bgworker(), do_start_worker(), enable_timeout_after(), enable_timeout_at(), enable_timeouts(), get_role_password(), GetCurrentTransactionStopTimestamp(), GetReplicationApplyDelay(), GetSnapshotCurrentTimestamp(), handle_sig_alarm(), launcher_determine_sleep(), lazy_vacuum_rel(), log_disconnections(), LogCheckpointEnd(), logicalrep_worker_launch(), LogicalRepApplyLoop(), maybe_start_bgworkers(), perform_base_backup(), pgfdw_cancel_query(), pgfdw_exec_cleanup_query(), pgfdw_get_cleanup_result(), pgstat_bestart(), pgstat_read_statsfiles(), pgstat_recv_inquiry(), pgstat_recv_resetsharedcounter(), pgstat_recv_resetsinglecounter(), pgstat_report_activity(), pgstat_report_analyze(), pgstat_report_autovac(), pgstat_report_vacuum(), pgstat_send_archiver(), pgstat_write_statsfiles(), PostgresMain(), PostmasterMain(), PrepareTransaction(), process_syncing_tables_for_apply(), ProcessRepliesIfAny(), ProcessStandbyReplyMessage(), ProcessWalSndrMessage(), ProcSleep(), rebuild_database_list(), RecordTransactionAbort(), RecordTransactionAbortPrepared(), RecordTransactionCommitPrepared(), recoveryApplyDelay(), reschedule_timeouts(), reset_dbentry_counters(), ResolveRecoveryConflictWithBufferPin(), ResolveRecoveryConflictWithLock(), ResolveRecoveryConflictWithVirtualXIDs(), send_feedback(), SetCurrentStatementStartTimestamp(), SetCurrentTransactionStopTimestamp(), StartupXLOG(), throttle(), UpdateWorkerStats(), WaitExceedsMaxStandbyDelay(), WaitForWALToBecomeAvailable(), WalReceiverMain(), WalSndKeepalive(), WalSndLoop(), WalSndUpdateProgress(), WalSndWaitForWal(), WalSndWriteData(), XLogBackgroundFlush(), XLogFileRead(), XLogRestorePoint(), XLogSendPhysical(), XLogWalRcvSendHSFeedback(), and XLogWalRcvSendReply().

{
    TimestampTz result;
    struct timeval tp;

    gettimeofday(&tp, NULL);

    result = (TimestampTz) tp.tv_sec -
        ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY);
    result = (result * USECS_PER_SEC) + tp.tv_usec;

    return result;
}

void GetEpochTime

(

struct pg_tm *

tm

)

Definition at line 1984 of file timestamp.c.

References epoch, pg_gmtime(), pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, and pg_tm::tm_year.

Referenced by date_in(), PGTYPESdate_from_asc(), and SetEpochTimestamp().

{
    struct pg_tm *t0;
    pg_time_t   epoch = 0;

    t0 = pg_gmtime(&epoch);

    tm->tm_year = t0->tm_year;
    tm->tm_mon = t0->tm_mon;
    tm->tm_mday = t0->tm_mday;
    tm->tm_hour = t0->tm_hour;
    tm->tm_min = t0->tm_min;
    tm->tm_sec = t0->tm_sec;

    tm->tm_year += 1900;
    tm->tm_mon++;
}

TimestampTz GetSQLCurrentTimestamp

(

int32

typmod

)

Definition at line 1588 of file timestamp.c.

References AdjustTimestampForTypmod(), and GetCurrentTransactionStartTimestamp().

Referenced by ExecEvalSQLValueFunction().

{
    TimestampTz ts;

    ts = GetCurrentTransactionStartTimestamp();
    if (typmod >= 0)
        AdjustTimestampForTypmod(&ts, typmod);
    return ts;
}

Timestamp GetSQLLocalTimestamp

(

int32

typmod

)

Definition at line 1602 of file timestamp.c.

References AdjustTimestampForTypmod(), GetCurrentTransactionStartTimestamp(), and timestamptz2timestamp().

Referenced by ExecEvalSQLValueFunction().

{
    Timestamp   ts;

    ts = timestamptz2timestamp(GetCurrentTransactionStartTimestamp());
    if (typmod >= 0)
        AdjustTimestampForTypmod(&ts, typmod);
    return ts;
}

int interval2tm	(	Interval	span,
		struct pg_tm *	tm,
		fsec_t *	fsec
	)

Definition at line 1902 of file timestamp.c.

References Interval::day, ereport, errcode(), errmsg(), ERROR, Interval::month, MONTHS_PER_YEAR, SAMESIGN, Interval::time, 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_HOUR, USECS_PER_MINUTE, and USECS_PER_SEC.

Referenced by interval_out(), interval_part(), interval_to_char(), and interval_trunc().

{
    TimeOffset  time;
    TimeOffset  tfrac;

    tm->tm_year = span.month / MONTHS_PER_YEAR;
    tm->tm_mon = span.month % MONTHS_PER_YEAR;
    tm->tm_mday = span.day;
    time = span.time;

    tfrac = time / USECS_PER_HOUR;
    time -= tfrac * USECS_PER_HOUR;
    tm->tm_hour = tfrac;
    if (!SAMESIGN(tm->tm_hour, tfrac))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
    tfrac = time / USECS_PER_MINUTE;
    time -= tfrac * USECS_PER_MINUTE;
    tm->tm_min = tfrac;
    tfrac = time / USECS_PER_SEC;
    *fsec = time - (tfrac * USECS_PER_SEC);
    tm->tm_sec = tfrac;

    return 0;
}

Datum interval_accum

(

PG_FUNCTION_ARGS

)

Definition at line 3253 of file timestamp.c.

References construct_array(), DatumGetIntervalP, deconstruct_array(), DirectFunctionCall2, elog, ERROR, interval_pl(), INTERVALOID, IntervalPGetDatum, newval, NULL, PG_GETARG_ARRAYTYPE_P, PG_GETARG_INTERVAL_P, PG_RETURN_ARRAYTYPE_P, result, and Interval::time.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    Interval   *newval = PG_GETARG_INTERVAL_P(1);
    Datum      *transdatums;
    int         ndatums;
    Interval    sumX,
                N;
    Interval   *newsum;
    ArrayType  *result;

    deconstruct_array(transarray,
                      INTERVALOID, sizeof(Interval), false, 'd',
                      &transdatums, NULL, &ndatums);
    if (ndatums != 2)
        elog(ERROR, "expected 2-element interval array");

    sumX = *(DatumGetIntervalP(transdatums[0]));
    N = *(DatumGetIntervalP(transdatums[1]));

    newsum = DatumGetIntervalP(DirectFunctionCall2(interval_pl,
                                                   IntervalPGetDatum(&sumX),
                                                   IntervalPGetDatum(newval)));
    N.time += 1;

    transdatums[0] = IntervalPGetDatum(newsum);
    transdatums[1] = IntervalPGetDatum(&N);

    result = construct_array(transdatums, 2,
                             INTERVALOID, sizeof(Interval), false, 'd');

    PG_RETURN_ARRAYTYPE_P(result);
}

Datum interval_accum_inv

(

PG_FUNCTION_ARGS

)

Definition at line 3337 of file timestamp.c.

References construct_array(), DatumGetIntervalP, deconstruct_array(), DirectFunctionCall2, elog, ERROR, interval_mi(), INTERVALOID, IntervalPGetDatum, newval, NULL, PG_GETARG_ARRAYTYPE_P, PG_GETARG_INTERVAL_P, PG_RETURN_ARRAYTYPE_P, result, and Interval::time.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    Interval   *newval = PG_GETARG_INTERVAL_P(1);
    Datum      *transdatums;
    int         ndatums;
    Interval    sumX,
                N;
    Interval   *newsum;
    ArrayType  *result;

    deconstruct_array(transarray,
                      INTERVALOID, sizeof(Interval), false, 'd',
                      &transdatums, NULL, &ndatums);
    if (ndatums != 2)
        elog(ERROR, "expected 2-element interval array");

    sumX = *(DatumGetIntervalP(transdatums[0]));
    N = *(DatumGetIntervalP(transdatums[1]));

    newsum = DatumGetIntervalP(DirectFunctionCall2(interval_mi,
                                                   IntervalPGetDatum(&sumX),
                                                   IntervalPGetDatum(newval)));
    N.time -= 1;

    transdatums[0] = IntervalPGetDatum(newsum);
    transdatums[1] = IntervalPGetDatum(&N);

    result = construct_array(transdatums, 2,
                             INTERVALOID, sizeof(Interval), false, 'd');

    PG_RETURN_ARRAYTYPE_P(result);
}

Datum interval_avg

(

PG_FUNCTION_ARGS

)

Definition at line 3372 of file timestamp.c.

References DatumGetIntervalP, deconstruct_array(), DirectFunctionCall2, elog, ERROR, Float8GetDatum(), interval_div(), INTERVALOID, IntervalPGetDatum, NULL, PG_GETARG_ARRAYTYPE_P, PG_RETURN_NULL, and Interval::time.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    Datum      *transdatums;
    int         ndatums;
    Interval    sumX,
                N;

    deconstruct_array(transarray,
                      INTERVALOID, sizeof(Interval), false, 'd',
                      &transdatums, NULL, &ndatums);
    if (ndatums != 2)
        elog(ERROR, "expected 2-element interval array");

    sumX = *(DatumGetIntervalP(transdatums[0]));
    N = *(DatumGetIntervalP(transdatums[1]));

    /* SQL defines AVG of no values to be NULL */
    if (N.time == 0)
        PG_RETURN_NULL();

    return DirectFunctionCall2(interval_div,
                               IntervalPGetDatum(&sumX),
                               Float8GetDatum((double) N.time));
}

Datum interval_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 2389 of file timestamp.c.

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_INT32.

Referenced by gbt_intvkey_cmp().

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);

    PG_RETURN_INT32(interval_cmp_internal(interval1, interval2));
}

static int interval_cmp_internal ( Interval *  interval1, Interval *  interval2  )

static

Definition at line 2326 of file timestamp.c.

References int128_compare(), and interval_cmp_value().

Referenced by generate_series_timestamp(), generate_series_timestamptz(), interval_cmp(), interval_eq(), interval_ge(), interval_gt(), interval_larger(), interval_le(), interval_lt(), interval_ne(), and interval_smaller().

{
    INT128      span1 = interval_cmp_value(interval1);
    INT128      span2 = interval_cmp_value(interval2);

    return int128_compare(span1, span2);
}

static INT128 interval_cmp_value ( const Interval *  interval )

inlinestatic

Definition at line 2301 of file timestamp.c.

References Interval::day, days, int128_add_int64_mul_int64(), int64_to_int128(), INT64CONST, Interval::month, Interval::time, and USECS_PER_DAY.

Referenced by interval_cmp_internal(), and interval_hash().

{
    INT128      span;
    int64       dayfraction;
    int64       days;

    /*
     * Separate time field into days and dayfraction, then add the month and
     * day fields to the days part.  We cannot overflow int64 days here.
     */
    dayfraction = interval->time % USECS_PER_DAY;
    days = interval->time / USECS_PER_DAY;
    days += interval->month * INT64CONST(30);
    days += interval->day;

    /* Widen dayfraction to 128 bits */
    span = int64_to_int128(dayfraction);

    /* Scale up days to microseconds, forming a 128-bit product */
    int128_add_int64_mul_int64(&span, days, USECS_PER_DAY);

    return span;
}

Datum interval_combine

(

PG_FUNCTION_ARGS

)

Definition at line 3288 of file timestamp.c.

References construct_array(), DatumGetIntervalP, deconstruct_array(), DirectFunctionCall2, elog, ERROR, interval_pl(), INTERVALOID, IntervalPGetDatum, NULL, PG_GETARG_ARRAYTYPE_P, PG_RETURN_ARRAYTYPE_P, result, and Interval::time.

{
    ArrayType  *transarray1 = PG_GETARG_ARRAYTYPE_P(0);
    ArrayType  *transarray2 = PG_GETARG_ARRAYTYPE_P(1);
    Datum      *transdatums1;
    Datum      *transdatums2;
    int         ndatums1;
    int         ndatums2;
    Interval    sum1,
                N1;
    Interval    sum2,
                N2;

    Interval   *newsum;
    ArrayType  *result;

    deconstruct_array(transarray1,
                      INTERVALOID, sizeof(Interval), false, 'd',
                      &transdatums1, NULL, &ndatums1);
    if (ndatums1 != 2)
        elog(ERROR, "expected 2-element interval array");

    sum1 = *(DatumGetIntervalP(transdatums1[0]));
    N1 = *(DatumGetIntervalP(transdatums1[1]));

    deconstruct_array(transarray2,
                      INTERVALOID, sizeof(Interval), false, 'd',
                      &transdatums2, NULL, &ndatums2);
    if (ndatums2 != 2)
        elog(ERROR, "expected 2-element interval array");

    sum2 = *(DatumGetIntervalP(transdatums2[0]));
    N2 = *(DatumGetIntervalP(transdatums2[1]));

    newsum = DatumGetIntervalP(DirectFunctionCall2(interval_pl,
                                                   IntervalPGetDatum(&sum1),
                                                   IntervalPGetDatum(&sum2)));
    N1.time += N2.time;

    transdatums1[0] = IntervalPGetDatum(newsum);
    transdatums1[1] = IntervalPGetDatum(&N1);

    result = construct_array(transdatums1, 2,
                             INTERVALOID, sizeof(Interval), false, 'd');

    PG_RETURN_ARRAYTYPE_P(result);
}

Datum interval_div

(

PG_FUNCTION_ARGS

)

Definition at line 3201 of file timestamp.c.

References Abs, Interval::day, DAYS_PER_MONTH, ereport, errcode(), errmsg(), ERROR, Interval::month, palloc(), PG_GETARG_FLOAT8, PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, result, rint(), SECS_PER_DAY, Interval::time, TSROUND, and USECS_PER_SEC.

Referenced by interval_avg().

{
    Interval   *span = PG_GETARG_INTERVAL_P(0);
    float8      factor = PG_GETARG_FLOAT8(1);
    double      month_remainder_days,
                sec_remainder;
    int32       orig_month = span->month,
                orig_day = span->day;
    Interval   *result;

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

    if (factor == 0.0)
        ereport(ERROR,
                (errcode(ERRCODE_DIVISION_BY_ZERO),
                 errmsg("division by zero")));

    result->month = (int32) (span->month / factor);
    result->day = (int32) (span->day / factor);

    /*
     * Fractional months full days into days.  See comment in interval_mul().
     */
    month_remainder_days = (orig_month / factor - result->month) * DAYS_PER_MONTH;
    month_remainder_days = TSROUND(month_remainder_days);
    sec_remainder = (orig_day / factor - result->day +
                     month_remainder_days - (int) month_remainder_days) * SECS_PER_DAY;
    sec_remainder = TSROUND(sec_remainder);
    if (Abs(sec_remainder) >= SECS_PER_DAY)
    {
        result->day += (int) (sec_remainder / SECS_PER_DAY);
        sec_remainder -= (int) (sec_remainder / SECS_PER_DAY) * SECS_PER_DAY;
    }

    /* cascade units down */
    result->day += (int32) month_remainder_days;
    result->time = rint(span->time / factor + sec_remainder * USECS_PER_SEC);

    PG_RETURN_INTERVAL_P(result);
}

Datum interval_eq

(

PG_FUNCTION_ARGS

)

Definition at line 2335 of file timestamp.c.

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

Referenced by gbt_intveq().

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);

    PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) == 0);
}

Datum interval_finite

(

PG_FUNCTION_ARGS

)

Definition at line 1973 of file timestamp.c.

References PG_RETURN_BOOL.

{
    PG_RETURN_BOOL(true);
}

Datum interval_ge

(

PG_FUNCTION_ARGS

)

Definition at line 2380 of file timestamp.c.

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

Referenced by gbt_intvge().

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);

    PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) >= 0);
}

Datum interval_gt

(

PG_FUNCTION_ARGS

)

Definition at line 2362 of file timestamp.c.

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

Referenced by gbt_intvgt().

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);

    PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) > 0);
}

Datum interval_hash

(

PG_FUNCTION_ARGS

)

Definition at line 2405 of file timestamp.c.

References DirectFunctionCall1, hashint8(), int128_to_int64(), Int64GetDatumFast, interval_cmp_value(), and PG_GETARG_INTERVAL_P.

{
    Interval   *interval = PG_GETARG_INTERVAL_P(0);
    INT128      span = interval_cmp_value(interval);
    int64       span64;

    /*
     * Use only the least significant 64 bits for hashing.  The upper 64 bits
     * seldom add any useful information, and besides we must do it like this
     * for compatibility with hashes calculated before use of INT128 was
     * introduced.
     */
    span64 = int128_to_int64(span);

    return DirectFunctionCall1(hashint8, Int64GetDatumFast(span64));
}

Datum interval_in

(

PG_FUNCTION_ARGS

)

Definition at line 876 of file timestamp.c.

References AdjustIntervalForTypmod(), DateTimeParseError(), DecodeInterval(), DecodeISO8601Interval(), DTERR_BAD_FORMAT, DTERR_FIELD_OVERFLOW, DTERR_INTERVAL_OVERFLOW, DTK_DELTA, DTK_INVALID, elog, ereport, errcode(), errmsg(), ERROR, INTERVAL_FULL_RANGE, INTERVAL_RANGE, MAXDATEFIELDS, palloc(), ParseDateTime(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_INTERVAL_P, range(), result, tm, tm2interval(), pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, and pg_tm::tm_year.

Referenced by check_timezone(), and flatten_set_variable_args().

{
    char       *str = PG_GETARG_CSTRING(0);

#ifdef NOT_USED
    Oid         typelem = PG_GETARG_OID(1);
#endif
    int32       typmod = PG_GETARG_INT32(2);
    Interval   *result;
    fsec_t      fsec;
    struct pg_tm tt,
               *tm = &tt;
    int         dtype;
    int         nf;
    int         range;
    int         dterr;
    char       *field[MAXDATEFIELDS];
    int         ftype[MAXDATEFIELDS];
    char        workbuf[256];

    tm->tm_year = 0;
    tm->tm_mon = 0;
    tm->tm_mday = 0;
    tm->tm_hour = 0;
    tm->tm_min = 0;
    tm->tm_sec = 0;
    fsec = 0;

    if (typmod >= 0)
        range = INTERVAL_RANGE(typmod);
    else
        range = INTERVAL_FULL_RANGE;

    dterr = ParseDateTime(str, workbuf, sizeof(workbuf), field,
                          ftype, MAXDATEFIELDS, &nf);
    if (dterr == 0)
        dterr = DecodeInterval(field, ftype, nf, range,
                               &dtype, tm, &fsec);

    /* if those functions think it's a bad format, try ISO8601 style */
    if (dterr == DTERR_BAD_FORMAT)
        dterr = DecodeISO8601Interval(str,
                                      &dtype, tm, &fsec);

    if (dterr != 0)
    {
        if (dterr == DTERR_FIELD_OVERFLOW)
            dterr = DTERR_INTERVAL_OVERFLOW;
        DateTimeParseError(dterr, str, "interval");
    }

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

    switch (dtype)
    {
        case DTK_DELTA:
            if (tm2interval(tm, fsec, result) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("interval out of range")));
            break;

        case DTK_INVALID:
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("date/time value \"%s\" is no longer supported", str)));
            break;

        default:
            elog(ERROR, "unexpected dtype %d while parsing interval \"%s\"",
                 dtype, str);
    }

    AdjustIntervalForTypmod(result, typmod);

    PG_RETURN_INTERVAL_P(result);
}

Datum interval_justify_days

(

PG_FUNCTION_ARGS

)

Definition at line 2736 of file timestamp.c.

References Interval::day, DAYS_PER_MONTH, Interval::month, palloc(), PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, result, and Interval::time.

{
    Interval   *span = PG_GETARG_INTERVAL_P(0);
    Interval   *result;
    int32       wholemonth;

    result = (Interval *) palloc(sizeof(Interval));
    result->month = span->month;
    result->day = span->day;
    result->time = span->time;

    wholemonth = result->day / DAYS_PER_MONTH;
    result->day -= wholemonth * DAYS_PER_MONTH;
    result->month += wholemonth;

    if (result->month > 0 && result->day < 0)
    {
        result->day += DAYS_PER_MONTH;
        result->month--;
    }
    else if (result->month < 0 && result->day > 0)
    {
        result->day -= DAYS_PER_MONTH;
        result->month++;
    }

    PG_RETURN_INTERVAL_P(result);
}

Datum interval_justify_hours

(

PG_FUNCTION_ARGS

)

Definition at line 2701 of file timestamp.c.

References Interval::day, Interval::month, palloc(), PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, result, Interval::time, TMODULO, and USECS_PER_DAY.

Referenced by timestamp_mi().

{
    Interval   *span = PG_GETARG_INTERVAL_P(0);
    Interval   *result;
    TimeOffset  wholeday;

    result = (Interval *) palloc(sizeof(Interval));
    result->month = span->month;
    result->day = span->day;
    result->time = span->time;

    TMODULO(result->time, wholeday, USECS_PER_DAY);
    result->day += wholeday;    /* could overflow... */

    if (result->day > 0 && result->time < 0)
    {
        result->time += USECS_PER_DAY;
        result->day--;
    }
    else if (result->day < 0 && result->time > 0)
    {
        result->time -= USECS_PER_DAY;
        result->day++;
    }

    PG_RETURN_INTERVAL_P(result);
}

Datum interval_justify_interval

(

PG_FUNCTION_ARGS

)

Definition at line 2646 of file timestamp.c.

References Interval::day, DAYS_PER_MONTH, Interval::month, palloc(), PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, result, Interval::time, TMODULO, and USECS_PER_DAY.

{
    Interval   *span = PG_GETARG_INTERVAL_P(0);
    Interval   *result;
    TimeOffset  wholeday;
    int32       wholemonth;

    result = (Interval *) palloc(sizeof(Interval));
    result->month = span->month;
    result->day = span->day;
    result->time = span->time;

    TMODULO(result->time, wholeday, USECS_PER_DAY);
    result->day += wholeday;    /* could overflow... */

    wholemonth = result->day / DAYS_PER_MONTH;
    result->day -= wholemonth * DAYS_PER_MONTH;
    result->month += wholemonth;

    if (result->month > 0 &&
        (result->day < 0 || (result->day == 0 && result->time < 0)))
    {
        result->day += DAYS_PER_MONTH;
        result->month--;
    }
    else if (result->month < 0 &&
             (result->day > 0 || (result->day == 0 && result->time > 0)))
    {
        result->day -= DAYS_PER_MONTH;
        result->month++;
    }

    if (result->day > 0 && result->time < 0)
    {
        result->time += USECS_PER_DAY;
        result->day--;
    }
    else if (result->day < 0 && result->time > 0)
    {
        result->time -= USECS_PER_DAY;
        result->day++;
    }

    PG_RETURN_INTERVAL_P(result);
}

Datum interval_larger

(

PG_FUNCTION_ARGS

)

Definition at line 3026 of file timestamp.c.

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, and result.

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);
    Interval   *result;

    if (interval_cmp_internal(interval1, interval2) > 0)
        result = interval1;
    else
        result = interval2;
    PG_RETURN_INTERVAL_P(result);
}

Datum interval_le

(

PG_FUNCTION_ARGS

)

Definition at line 2371 of file timestamp.c.

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

Referenced by gbt_intvle().

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);

    PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) <= 0);
}

Datum interval_lt

(

PG_FUNCTION_ARGS

)

Definition at line 2353 of file timestamp.c.

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

Referenced by abs_interval(), and gbt_intvlt().

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);

    PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) < 0);
}

Datum interval_mi

(

PG_FUNCTION_ARGS

)

Definition at line 3074 of file timestamp.c.

References Interval::day, ereport, errcode(), errmsg(), ERROR, Interval::month, palloc(), PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, result, SAMESIGN, and Interval::time.

Referenced by interval_accum_inv(), interval_dist(), and interval_lerp().

{
    Interval   *span1 = PG_GETARG_INTERVAL_P(0);
    Interval   *span2 = PG_GETARG_INTERVAL_P(1);
    Interval   *result;

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

    result->month = span1->month - span2->month;
    /* overflow check copied from int4mi */
    if (!SAMESIGN(span1->month, span2->month) &&
        !SAMESIGN(result->month, span1->month))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));

    result->day = span1->day - span2->day;
    if (!SAMESIGN(span1->day, span2->day) &&
        !SAMESIGN(result->day, span1->day))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));

    result->time = span1->time - span2->time;
    if (!SAMESIGN(span1->time, span2->time) &&
        !SAMESIGN(result->time, span1->time))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));

    PG_RETURN_INTERVAL_P(result);
}

Datum interval_mul

(

PG_FUNCTION_ARGS

)

Definition at line 3114 of file timestamp.c.

References Abs, Interval::day, DAYS_PER_MONTH, ereport, errcode(), errmsg(), ERROR, Interval::month, palloc(), PG_GETARG_FLOAT8, PG_GETARG_INTERVAL_P, PG_INT64_MAX, PG_INT64_MIN, PG_RETURN_INTERVAL_P, result, rint(), SECS_PER_DAY, Interval::time, TSROUND, and USECS_PER_SEC.

Referenced by interval_lerp(), and mul_d_interval().

{
    Interval   *span = PG_GETARG_INTERVAL_P(0);
    float8      factor = PG_GETARG_FLOAT8(1);
    double      month_remainder_days,
                sec_remainder,
                result_double;
    int32       orig_month = span->month,
                orig_day = span->day;
    Interval   *result;

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

    result_double = span->month * factor;
    if (isnan(result_double) ||
        result_double > INT_MAX || result_double < INT_MIN)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
    result->month = (int32) result_double;

    result_double = span->day * factor;
    if (isnan(result_double) ||
        result_double > INT_MAX || result_double < INT_MIN)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
    result->day = (int32) result_double;

    /*
     * The above correctly handles the whole-number part of the month and day
     * products, but we have to do something with any fractional part
     * resulting when the factor is non-integral.  We cascade the fractions
     * down to lower units using the conversion factors DAYS_PER_MONTH and
     * SECS_PER_DAY.  Note we do NOT cascade up, since we are not forced to do
     * so by the representation.  The user can choose to cascade up later,
     * using justify_hours and/or justify_days.
     */

    /*
     * Fractional months full days into days.
     *
     * Floating point calculation are inherently imprecise, so these
     * calculations are crafted to produce the most reliable result possible.
     * TSROUND() is needed to more accurately produce whole numbers where
     * appropriate.
     */
    month_remainder_days = (orig_month * factor - result->month) * DAYS_PER_MONTH;
    month_remainder_days = TSROUND(month_remainder_days);
    sec_remainder = (orig_day * factor - result->day +
                     month_remainder_days - (int) month_remainder_days) * SECS_PER_DAY;
    sec_remainder = TSROUND(sec_remainder);

    /*
     * Might have 24:00:00 hours due to rounding, or >24 hours because of time
     * cascade from months and days.  It might still be >24 if the combination
     * of cascade and the seconds factor operation itself.
     */
    if (Abs(sec_remainder) >= SECS_PER_DAY)
    {
        result->day += (int) (sec_remainder / SECS_PER_DAY);
        sec_remainder -= (int) (sec_remainder / SECS_PER_DAY) * SECS_PER_DAY;
    }

    /* cascade units down */
    result->day += (int32) month_remainder_days;
    result_double = rint(span->time * factor + sec_remainder * USECS_PER_SEC);
    if (result_double > PG_INT64_MAX || result_double < PG_INT64_MIN)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
    result->time = (int64) result_double;

    PG_RETURN_INTERVAL_P(result);
}

Datum interval_ne

(

PG_FUNCTION_ARGS

)

Definition at line 2344 of file timestamp.c.

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);

    PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) != 0);
}

Datum interval_out

(

PG_FUNCTION_ARGS

)

Definition at line 958 of file timestamp.c.

References buf, elog, EncodeInterval(), ERROR, interval2tm(), IntervalStyle, MAXDATELEN, PG_GETARG_INTERVAL_P, PG_RETURN_CSTRING, pstrdup(), result, and tm.

Referenced by flatten_set_variable_args(), timestamp_izone(), timestamptz_izone(), and timetz_izone().

{
    Interval   *span = PG_GETARG_INTERVAL_P(0);
    char       *result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    char        buf[MAXDATELEN + 1];

    if (interval2tm(*span, tm, &fsec) != 0)
        elog(ERROR, "could not convert interval to tm");

    EncodeInterval(tm, fsec, IntervalStyle, buf);

    result = pstrdup(buf);
    PG_RETURN_CSTRING(result);
}

Datum interval_part

(

PG_FUNCTION_ARGS

)

Definition at line 4673 of file timestamp.c.

References Interval::day, DAYS_PER_MONTH, DAYS_PER_YEAR, 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_YEAR, elog, ereport, errcode(), errmsg(), ERROR, interval2tm(), Interval::month, MONTHS_PER_YEAR, PG_GETARG_INTERVAL_P, PG_GETARG_TEXT_PP, PG_RETURN_FLOAT8, RESERV, result, SECS_PER_DAY, Interval::time, 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, UNITS, UNKNOWN_FIELD, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    Interval   *interval = PG_GETARG_INTERVAL_P(1);
    float8      result;
    int         type,
                val;
    char       *lowunits;
    fsec_t      fsec;
    struct pg_tm tt,
               *tm = &tt;

    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)
    {
        if (interval2tm(*interval, tm, &fsec) == 0)
        {
            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_DAY:
                    result = tm->tm_mday;
                    break;

                case DTK_MONTH:
                    result = tm->tm_mon;
                    break;

                case DTK_QUARTER:
                    result = (tm->tm_mon / 3) + 1;
                    break;

                case DTK_YEAR:
                    result = tm->tm_year;
                    break;

                case DTK_DECADE:
                    /* caution: C division may have negative remainder */
                    result = tm->tm_year / 10;
                    break;

                case DTK_CENTURY:
                    /* caution: C division may have negative remainder */
                    result = tm->tm_year / 100;
                    break;

                case DTK_MILLENNIUM:
                    /* caution: C division may have negative remainder */
                    result = tm->tm_year / 1000;
                    break;

                default:
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("interval units \"%s\" not supported",
                                    lowunits)));
                    result = 0;
            }

        }
        else
        {
            elog(ERROR, "could not convert interval to tm");
            result = 0;
        }
    }
    else if (type == RESERV && val == DTK_EPOCH)
    {
        result = interval->time / 1000000.0;
        result += ((double) DAYS_PER_YEAR * SECS_PER_DAY) * (interval->month / MONTHS_PER_YEAR);
        result += ((double) DAYS_PER_MONTH * SECS_PER_DAY) * (interval->month % MONTHS_PER_YEAR);
        result += ((double) SECS_PER_DAY) * interval->day;
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("interval units \"%s\" not recognized",
                        lowunits)));
        result = 0;
    }

    PG_RETURN_FLOAT8(result);
}

Datum interval_pl

(

PG_FUNCTION_ARGS

)

Definition at line 3040 of file timestamp.c.

References Interval::day, ereport, errcode(), errmsg(), ERROR, Interval::month, palloc(), PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, result, SAMESIGN, and Interval::time.

Referenced by interval_accum(), interval_combine(), and interval_lerp().

{
    Interval   *span1 = PG_GETARG_INTERVAL_P(0);
    Interval   *span2 = PG_GETARG_INTERVAL_P(1);
    Interval   *result;

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

    result->month = span1->month + span2->month;
    /* overflow check copied from int4pl */
    if (SAMESIGN(span1->month, span2->month) &&
        !SAMESIGN(result->month, span1->month))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));

    result->day = span1->day + span2->day;
    if (SAMESIGN(span1->day, span2->day) &&
        !SAMESIGN(result->day, span1->day))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));

    result->time = span1->time + span2->time;
    if (SAMESIGN(span1->time, span2->time) &&
        !SAMESIGN(result->time, span1->time))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));

    PG_RETURN_INTERVAL_P(result);
}

Datum interval_recv

(

PG_FUNCTION_ARGS

)

Definition at line 980 of file timestamp.c.

References AdjustIntervalForTypmod(), buf, Interval::day, Interval::month, palloc(), PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_INTERVAL_P, pq_getmsgint(), pq_getmsgint64(), and Interval::time.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);

#ifdef NOT_USED
    Oid         typelem = PG_GETARG_OID(1);
#endif
    int32       typmod = PG_GETARG_INT32(2);
    Interval   *interval;

    interval = (Interval *) palloc(sizeof(Interval));

    interval->time = pq_getmsgint64(buf);
    interval->day = pq_getmsgint(buf, sizeof(interval->day));
    interval->month = pq_getmsgint(buf, sizeof(interval->month));

    AdjustIntervalForTypmod(interval, typmod);

    PG_RETURN_INTERVAL_P(interval);
}

Datum interval_scale

(

PG_FUNCTION_ARGS

)

Definition at line 1301 of file timestamp.c.

References AdjustIntervalForTypmod(), palloc(), PG_GETARG_INT32, PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, and result.

{
    Interval   *interval = PG_GETARG_INTERVAL_P(0);
    int32       typmod = PG_GETARG_INT32(1);
    Interval   *result;

    result = palloc(sizeof(Interval));
    *result = *interval;

    AdjustIntervalForTypmod(result, typmod);

    PG_RETURN_INTERVAL_P(result);
}

Datum interval_send

(

PG_FUNCTION_ARGS

)

Definition at line 1005 of file timestamp.c.

References buf, Interval::day, Interval::month, PG_GETARG_INTERVAL_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint(), pq_sendint64(), and Interval::time.

{
    Interval   *interval = PG_GETARG_INTERVAL_P(0);
    StringInfoData buf;

    pq_begintypsend(&buf);
    pq_sendint64(&buf, interval->time);
    pq_sendint(&buf, interval->day, sizeof(interval->day));
    pq_sendint(&buf, interval->month, sizeof(interval->month));
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

Datum interval_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 3011 of file timestamp.c.

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, and result.

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);
    Interval   *result;

    /* use interval_cmp_internal to be sure this agrees with comparisons */
    if (interval_cmp_internal(interval1, interval2) < 0)
        result = interval1;
    else
        result = interval2;
    PG_RETURN_INTERVAL_P(result);
}

Datum interval_transform

(

PG_FUNCTION_ARGS

)

Definition at line 1244 of file timestamp.c.

References FuncExpr::args, Assert, castNode, DatumGetInt32, exprTypmod(), INTERVAL_FULL_PRECISION, INTERVAL_PRECISION, intervaltypmodleastfield(), IsA, linitial, list_length(), lsecond, MAX_INTERVAL_PRECISION, NULL, PG_GETARG_POINTER, PG_RETURN_POINTER, and relabel_to_typmod().

{
    FuncExpr   *expr = castNode(FuncExpr, PG_GETARG_POINTER(0));
    Node       *ret = NULL;
    Node       *typmod;

    Assert(list_length(expr->args) >= 2);

    typmod = (Node *) lsecond(expr->args);

    if (IsA(typmod, Const) &&!((Const *) typmod)->constisnull)
    {
        Node       *source = (Node *) linitial(expr->args);
        int32       new_typmod = DatumGetInt32(((Const *) typmod)->constvalue);
        bool        noop;

        if (new_typmod < 0)
            noop = true;
        else
        {
            int32       old_typmod = exprTypmod(source);
            int         old_least_field;
            int         new_least_field;
            int         old_precis;
            int         new_precis;

            old_least_field = intervaltypmodleastfield(old_typmod);
            new_least_field = intervaltypmodleastfield(new_typmod);
            if (old_typmod < 0)
                old_precis = INTERVAL_FULL_PRECISION;
            else
                old_precis = INTERVAL_PRECISION(old_typmod);
            new_precis = INTERVAL_PRECISION(new_typmod);

            /*
             * Cast is a no-op if least field stays the same or decreases
             * while precision stays the same or increases.  But precision,
             * which is to say, sub-second precision, only affects ranges that
             * include SECOND.
             */
            noop = (new_least_field <= old_least_field) &&
                (old_least_field > 0 /* SECOND */ ||
                 new_precis >= MAX_INTERVAL_PRECISION ||
                 new_precis >= old_precis);
        }
        if (noop)
            ret = relabel_to_typmod(source, new_typmod);
    }

    PG_RETURN_POINTER(ret);
}

Datum interval_trunc

(

PG_FUNCTION_ARGS

)

Definition at line 3926 of file timestamp.c.

References DecodeUnits(), downcase_truncate_identifier(), DTK_CENTURY, DTK_DAY, DTK_DECADE, DTK_HOUR, DTK_MICROSEC, DTK_MILLENNIUM, DTK_MILLISEC, DTK_MINUTE, DTK_MONTH, DTK_QUARTER, DTK_SECOND, DTK_WEEK, DTK_YEAR, elog, ereport, errcode(), errmsg(), ERROR, interval2tm(), palloc(), PG_GETARG_INTERVAL_P, PG_GETARG_TEXT_PP, PG_RETURN_INTERVAL_P, result, tm, tm2interval(), pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, UNITS, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    Interval   *interval = PG_GETARG_INTERVAL_P(1);
    Interval   *result;
    int         type,
                val;
    char       *lowunits;
    fsec_t      fsec;
    struct pg_tm tt,
               *tm = &tt;

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

    lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
                                            VARSIZE_ANY_EXHDR(units),
                                            false);

    type = DecodeUnits(0, lowunits, &val);

    if (type == UNITS)
    {
        if (interval2tm(*interval, tm, &fsec) == 0)
        {
            switch (val)
            {
                    /* fall through */
                case DTK_MILLENNIUM:
                    /* caution: C division may have negative remainder */
                    tm->tm_year = (tm->tm_year / 1000) * 1000;
                case DTK_CENTURY:
                    /* caution: C division may have negative remainder */
                    tm->tm_year = (tm->tm_year / 100) * 100;
                case DTK_DECADE:
                    /* caution: C division may have negative remainder */
                    tm->tm_year = (tm->tm_year / 10) * 10;
                case DTK_YEAR:
                    tm->tm_mon = 0;
                case DTK_QUARTER:
                    tm->tm_mon = 3 * (tm->tm_mon / 3);
                case DTK_MONTH:
                    tm->tm_mday = 0;
                case DTK_DAY:
                    tm->tm_hour = 0;
                case DTK_HOUR:
                    tm->tm_min = 0;
                case DTK_MINUTE:
                    tm->tm_sec = 0;
                case DTK_SECOND:
                    fsec = 0;
                    break;
                case DTK_MILLISEC:
                    fsec = (fsec / 1000) * 1000;
                    break;
                case DTK_MICROSEC:
                    break;

                default:
                    if (val == DTK_WEEK)
                        ereport(ERROR,
                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                 errmsg("interval units \"%s\" not supported "
                                        "because months usually have fractional weeks",
                                        lowunits)));
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                 errmsg("interval units \"%s\" not supported",
                                        lowunits)));
            }

            if (tm2interval(tm, fsec, result) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("interval out of range")));
        }
        else
            elog(ERROR, "could not convert interval to tm");
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("interval units \"%s\" not recognized",
                        lowunits)));
    }

    PG_RETURN_INTERVAL_P(result);
}

Datum interval_um

(

PG_FUNCTION_ARGS

)

Definition at line 2982 of file timestamp.c.

References Interval::day, ereport, errcode(), errmsg(), ERROR, Interval::month, palloc(), PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, result, SAMESIGN, and Interval::time.

Referenced by abs_interval().

{
    Interval   *interval = PG_GETARG_INTERVAL_P(0);
    Interval   *result;

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

    result->time = -interval->time;
    /* overflow check copied from int4um */
    if (interval->time != 0 && SAMESIGN(result->time, interval->time))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
    result->day = -interval->day;
    if (interval->day != 0 && SAMESIGN(result->day, interval->day))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
    result->month = -interval->month;
    if (interval->month != 0 && SAMESIGN(result->month, interval->month))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));

    PG_RETURN_INTERVAL_P(result);
}

Datum intervaltypmodin

(

PG_FUNCTION_ARGS

)

Definition at line 1030 of file timestamp.c.

References ArrayGetIntegerTypmods(), DAY, ereport, errcode(), errmsg(), ERROR, HOUR, INTERVAL_FULL_PRECISION, INTERVAL_FULL_RANGE, INTERVAL_MASK, INTERVAL_TYPMOD, MAX_INTERVAL_PRECISION, MINUTE, MONTH, PG_GETARG_ARRAYTYPE_P, PG_RETURN_INT32, SECOND, WARNING, and YEAR.

{
    ArrayType  *ta = PG_GETARG_ARRAYTYPE_P(0);
    int32      *tl;
    int         n;
    int32       typmod;

    tl = ArrayGetIntegerTypmods(ta, &n);

    /*
     * tl[0] - interval range (fields bitmask)  tl[1] - precision (optional)
     *
     * Note we must validate tl[0] even though it's normally guaranteed
     * correct by the grammar --- consider SELECT 'foo'::"interval"(1000).
     */
    if (n > 0)
    {
        switch (tl[0])
        {
            case INTERVAL_MASK(YEAR):
            case INTERVAL_MASK(MONTH):
            case INTERVAL_MASK(DAY):
            case INTERVAL_MASK(HOUR):
            case INTERVAL_MASK(MINUTE):
            case INTERVAL_MASK(SECOND):
            case INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH):
            case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR):
            case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE):
            case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
            case INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE):
            case INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
            case INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
            case INTERVAL_FULL_RANGE:
                /* all OK */
                break;
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("invalid INTERVAL type modifier")));
        }
    }

    if (n == 1)
    {
        if (tl[0] != INTERVAL_FULL_RANGE)
            typmod = INTERVAL_TYPMOD(INTERVAL_FULL_PRECISION, tl[0]);
        else
            typmod = -1;
    }
    else if (n == 2)
    {
        if (tl[1] < 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("INTERVAL(%d) precision must not be negative",
                            tl[1])));
        if (tl[1] > MAX_INTERVAL_PRECISION)
        {
            ereport(WARNING,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("INTERVAL(%d) precision reduced to maximum allowed, %d",
                            tl[1], MAX_INTERVAL_PRECISION)));
            typmod = INTERVAL_TYPMOD(MAX_INTERVAL_PRECISION, tl[0]);
        }
        else
            typmod = INTERVAL_TYPMOD(tl[1], tl[0]);
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid INTERVAL type modifier")));
        typmod = 0;             /* keep compiler quiet */
    }

    PG_RETURN_INT32(typmod);
}

static int intervaltypmodleastfield ( int32  typmod )

static

Definition at line 1195 of file timestamp.c.

References DAY, elog, ERROR, HOUR, INTERVAL_FULL_RANGE, INTERVAL_MASK, INTERVAL_RANGE, MINUTE, MONTH, SECOND, and YEAR.

Referenced by interval_transform().

{
    if (typmod < 0)
        return 0;               /* SECOND */

    switch (INTERVAL_RANGE(typmod))
    {
        case INTERVAL_MASK(YEAR):
            return 5;           /* YEAR */
        case INTERVAL_MASK(MONTH):
            return 4;           /* MONTH */
        case INTERVAL_MASK(DAY):
            return 3;           /* DAY */
        case INTERVAL_MASK(HOUR):
            return 2;           /* HOUR */
        case INTERVAL_MASK(MINUTE):
            return 1;           /* MINUTE */
        case INTERVAL_MASK(SECOND):
            return 0;           /* SECOND */
        case INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH):
            return 4;           /* MONTH */
        case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR):
            return 2;           /* HOUR */
        case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE):
            return 1;           /* MINUTE */
        case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
            return 0;           /* SECOND */
        case INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE):
            return 1;           /* MINUTE */
        case INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
            return 0;           /* SECOND */
        case INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
            return 0;           /* SECOND */
        case INTERVAL_FULL_RANGE:
            return 0;           /* SECOND */
        default:
            elog(ERROR, "invalid INTERVAL typmod: 0x%x", typmod);
            break;
    }
    return 0;                   /* can't get here, but keep compiler quiet */
}

Datum intervaltypmodout

(

PG_FUNCTION_ARGS

)

Definition at line 1109 of file timestamp.c.

References DAY, elog, ERROR, HOUR, INTERVAL_FULL_PRECISION, INTERVAL_FULL_RANGE, INTERVAL_MASK, INTERVAL_PRECISION, INTERVAL_RANGE, MINUTE, MONTH, palloc(), PG_GETARG_INT32, PG_RETURN_CSTRING, SECOND, snprintf(), and YEAR.

{
    int32       typmod = PG_GETARG_INT32(0);
    char       *res = (char *) palloc(64);
    int         fields;
    int         precision;
    const char *fieldstr;

    if (typmod < 0)
    {
        *res = '\0';
        PG_RETURN_CSTRING(res);
    }

    fields = INTERVAL_RANGE(typmod);
    precision = INTERVAL_PRECISION(typmod);

    switch (fields)
    {
        case INTERVAL_MASK(YEAR):
            fieldstr = " year";
            break;
        case INTERVAL_MASK(MONTH):
            fieldstr = " month";
            break;
        case INTERVAL_MASK(DAY):
            fieldstr = " day";
            break;
        case INTERVAL_MASK(HOUR):
            fieldstr = " hour";
            break;
        case INTERVAL_MASK(MINUTE):
            fieldstr = " minute";
            break;
        case INTERVAL_MASK(SECOND):
            fieldstr = " second";
            break;
        case INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH):
            fieldstr = " year to month";
            break;
        case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR):
            fieldstr = " day to hour";
            break;
        case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE):
            fieldstr = " day to minute";
            break;
        case INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
            fieldstr = " day to second";
            break;
        case INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE):
            fieldstr = " hour to minute";
            break;
        case INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
            fieldstr = " hour to second";
            break;
        case INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND):
            fieldstr = " minute to second";
            break;
        case INTERVAL_FULL_RANGE:
            fieldstr = "";
            break;
        default:
            elog(ERROR, "invalid INTERVAL typmod: 0x%x", typmod);
            fieldstr = "";
            break;
    }

    if (precision != INTERVAL_FULL_PRECISION)
        snprintf(res, 64, "%s(%d)", fieldstr, precision);
    else
        snprintf(res, 64, "%s", fieldstr);

    PG_RETURN_CSTRING(res);
}

void isoweek2date	(	int	woy,
		int *	year,
		int *	mon,
		int *	mday
	)

Definition at line 4042 of file timestamp.c.

References isoweek2j(), and j2date().

Referenced by do_to_timestamp(), timestamp_trunc(), and timestamptz_trunc().

{
    j2date(isoweek2j(*year, woy), year, mon, mday);
}

int isoweek2j	(	int	year,
		int	week
	)

Definition at line 4022 of file timestamp.c.

References date2j(), and j2day().

Referenced by date2isoyearday(), do_to_timestamp(), isoweek2date(), and isoweekdate2date().

{
    int         day0,
                day4;

    /* fourth day of current year */
    day4 = date2j(year, 1, 4);

    /* day0 == offset to first day of week (Monday) */
    day0 = j2day(day4 - 1);

    return ((week - 1) * 7) + (day4 - day0);
}

void isoweekdate2date	(	int	isoweek,
		int	wday,
		int *	year,
		int *	mon,
		int *	mday
	)

Definition at line 4055 of file timestamp.c.

References isoweek2j(), and j2date().

Referenced by do_to_timestamp().

{
    int         jday;

    jday = isoweek2j(*year, isoweek);
    /* convert Gregorian week start (Sunday=1) to ISO week start (Monday=1) */
    if (wday > 1)
        jday += wday - 2;
    else
        jday += 6;
    j2date(jday, year, mon, mday);
}

Datum make_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1487 of file timestamp.c.

References Interval::day, days, ereport, errcode(), errmsg(), ERROR, isinf(), Interval::month, months, MONTHS_PER_YEAR, palloc(), PG_GETARG_FLOAT8, PG_GETARG_INT32, PG_RETURN_INTERVAL_P, result, rint(), SECS_PER_HOUR, SECS_PER_MINUTE, Interval::time, and USECS_PER_SEC.

{
    int32       years = PG_GETARG_INT32(0);
    int32       months = PG_GETARG_INT32(1);
    int32       weeks = PG_GETARG_INT32(2);
    int32       days = PG_GETARG_INT32(3);
    int32       hours = PG_GETARG_INT32(4);
    int32       mins = PG_GETARG_INT32(5);
    double      secs = PG_GETARG_FLOAT8(6);
    Interval   *result;

    /*
     * Reject out-of-range inputs.  We really ought to check the integer
     * inputs as well, but it's not entirely clear what limits to apply.
     */
    if (isinf(secs) || isnan(secs))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));

    result = (Interval *) palloc(sizeof(Interval));
    result->month = years * MONTHS_PER_YEAR + months;
    result->day = weeks * 7 + days;

    secs = rint(secs * USECS_PER_SEC);
    result->time = hours * ((int64) SECS_PER_HOUR * USECS_PER_SEC) +
        mins * ((int64) SECS_PER_MINUTE * USECS_PER_SEC) +
        (int64) secs;

    PG_RETURN_INTERVAL_P(result);
}

Datum make_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 630 of file timestamp.c.

References make_timestamp_internal(), PG_GETARG_FLOAT8, PG_GETARG_INT32, PG_RETURN_TIMESTAMP, and result.

{
    int32       year = PG_GETARG_INT32(0);
    int32       month = PG_GETARG_INT32(1);
    int32       mday = PG_GETARG_INT32(2);
    int32       hour = PG_GETARG_INT32(3);
    int32       min = PG_GETARG_INT32(4);
    float8      sec = PG_GETARG_FLOAT8(5);
    Timestamp   result;

    result = make_timestamp_internal(year, month, mday,
                                     hour, min, sec);

    PG_RETURN_TIMESTAMP(result);
}

static Timestamp make_timestamp_internal ( int  year, int  month, int  day, int  hour, int  min, double  sec  )

static

Definition at line 542 of file timestamp.c.

References date2j(), DTK_DATE_M, ereport, errcode(), errmsg(), ERROR, HOURS_PER_DAY, IS_VALID_JULIAN, IS_VALID_TIMESTAMP, MINS_PER_HOUR, POSTGRES_EPOCH_JDATE, result, rint(), SECS_PER_MINUTE, pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_year, USECS_PER_DAY, USECS_PER_SEC, and ValidateDate().

Referenced by make_timestamp(), make_timestamptz(), and make_timestamptz_at_timezone().

{
    struct pg_tm tm;
    TimeOffset  date;
    TimeOffset  time;
    int         dterr;
    Timestamp   result;

    tm.tm_year = year;
    tm.tm_mon = month;
    tm.tm_mday = day;

    /*
     * Note: we'll reject zero or negative year values.  Perhaps negatives
     * should be allowed to represent BC years?
     */
    dterr = ValidateDate(DTK_DATE_M, false, false, false, &tm);

    if (dterr != 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_FIELD_OVERFLOW),
                 errmsg("date field value out of range: %d-%02d-%02d",
                        year, month, day)));

    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",
                        year, month, day)));

    date = date2j(tm.tm_year, tm.tm_mon, tm.tm_mday) - POSTGRES_EPOCH_JDATE;

    /*
     * This should match the checks in DecodeTimeOnly, except that since we're
     * dealing with a float "sec" value, we also explicitly reject NaN.  (An
     * infinity input should get rejected by the range comparisons, but we
     * can't be sure how those will treat a NaN.)
     */
    if (hour < 0 || min < 0 || min > MINS_PER_HOUR - 1 ||
        isnan(sec) ||
        sec < 0 || sec > SECS_PER_MINUTE ||
        hour > HOURS_PER_DAY ||
    /* test for > 24:00:00 */
        (hour == HOURS_PER_DAY && (min > 0 || sec > 0)))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_FIELD_OVERFLOW),
                 errmsg("time field value out of range: %d:%02d:%02g",
                        hour, min, sec)));

    /* This should match tm2time */
    time = (((hour * MINS_PER_HOUR + min) * SECS_PER_MINUTE)
            * USECS_PER_SEC) + rint(sec * USECS_PER_SEC);

    result = date * USECS_PER_DAY + time;
    /* check for major overflow */
    if ((result - time) / USECS_PER_DAY != date)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range: %d-%02d-%02d %d:%02d:%02g",
                        year, month, day,
                        hour, min, sec)));

    /* check for just-barely overflow (okay except time-of-day wraps) */
    /* caution: we want to allow 1999-12-31 24:00:00 */
    if ((result < 0 && date > 0) ||
        (result > 0 && date < -1))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range: %d-%02d-%02d %d:%02d:%02g",
                        year, month, day,
                        hour, min, sec)));

    /* final range check catches just-out-of-range timestamps */
    if (!IS_VALID_TIMESTAMP(result))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range: %d-%02d-%02d %d:%02d:%02g",
                        year, month, day,
                        hour, min, sec)));

    return result;
}

Datum make_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 650 of file timestamp.c.

References make_timestamp_internal(), PG_GETARG_FLOAT8, PG_GETARG_INT32, PG_RETURN_TIMESTAMPTZ, result, and timestamp2timestamptz().

{
    int32       year = PG_GETARG_INT32(0);
    int32       month = PG_GETARG_INT32(1);
    int32       mday = PG_GETARG_INT32(2);
    int32       hour = PG_GETARG_INT32(3);
    int32       min = PG_GETARG_INT32(4);
    float8      sec = PG_GETARG_FLOAT8(5);
    Timestamp   result;

    result = make_timestamp_internal(year, month, mday,
                                     hour, min, sec);

    PG_RETURN_TIMESTAMPTZ(timestamp2timestamptz(result));
}

Datum make_timestamptz_at_timezone

(

PG_FUNCTION_ARGS

)

Definition at line 671 of file timestamp.c.

References dt2local(), ereport, errcode(), errmsg(), ERROR, IS_VALID_TIMESTAMP, make_timestamp_internal(), NULL, parse_sane_timezone(), PG_GETARG_FLOAT8, PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_RETURN_TIMESTAMPTZ, result, and timestamp2tm().

{
    int32       year = PG_GETARG_INT32(0);
    int32       month = PG_GETARG_INT32(1);
    int32       mday = PG_GETARG_INT32(2);
    int32       hour = PG_GETARG_INT32(3);
    int32       min = PG_GETARG_INT32(4);
    float8      sec = PG_GETARG_FLOAT8(5);
    text       *zone = PG_GETARG_TEXT_PP(6);
    TimestampTz result;
    Timestamp   timestamp;
    struct pg_tm tt;
    int         tz;
    fsec_t      fsec;

    timestamp = make_timestamp_internal(year, month, mday,
                                        hour, min, sec);

    if (timestamp2tm(timestamp, NULL, &tt, &fsec, NULL, NULL) != 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));

    tz = parse_sane_timezone(&tt, zone);

    result = dt2local(timestamp, -tz);

    if (!IS_VALID_TIMESTAMP(result))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));

    PG_RETURN_TIMESTAMPTZ(result);
}

Datum mul_d_interval

(

PG_FUNCTION_ARGS

)

Definition at line 3191 of file timestamp.c.

References DirectFunctionCall2, interval_mul(), and PG_GETARG_DATUM.

{
    /* Args are float8 and Interval *, but leave them as generic Datum */
    Datum       factor = PG_GETARG_DATUM(0);
    Datum       span = PG_GETARG_DATUM(1);

    return DirectFunctionCall2(interval_mul, span, factor);
}

static float8 NonFiniteTimestampTzPart ( int  type, int  unit, char *  lowunits, bool  isNegative, bool  isTz  )

static

Definition at line 4201 of file timestamp.c.

References DTK_CENTURY, DTK_DAY, DTK_DECADE, DTK_DOW, DTK_DOY, DTK_EPOCH, DTK_HOUR, DTK_ISODOW, DTK_ISOYEAR, DTK_JULIAN, DTK_MICROSEC, DTK_MILLENNIUM, DTK_MILLISEC, DTK_MINUTE, DTK_MONTH, DTK_QUARTER, DTK_SECOND, DTK_TZ, DTK_TZ_HOUR, DTK_TZ_MINUTE, DTK_WEEK, DTK_YEAR, ereport, errcode(), errmsg(), ERROR, get_float8_infinity(), RESERV, and UNITS.

Referenced by timestamp_part(), and timestamptz_part().

{
    if ((type != UNITS) && (type != RESERV))
    {
        if (isTz)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("timestamp with time zone units \"%s\" not recognized",
                            lowunits)));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("timestamp units \"%s\" not recognized",
                            lowunits)));
    }

    switch (unit)
    {
            /* Oscillating units */
        case DTK_MICROSEC:
        case DTK_MILLISEC:
        case DTK_SECOND:
        case DTK_MINUTE:
        case DTK_HOUR:
        case DTK_DAY:
        case DTK_MONTH:
        case DTK_QUARTER:
        case DTK_WEEK:
        case DTK_DOW:
        case DTK_ISODOW:
        case DTK_DOY:
        case DTK_TZ:
        case DTK_TZ_MINUTE:
        case DTK_TZ_HOUR:
            return 0.0;

            /* Monotonically-increasing units */
        case DTK_YEAR:
        case DTK_DECADE:
        case DTK_CENTURY:
        case DTK_MILLENNIUM:
        case DTK_JULIAN:
        case DTK_ISOYEAR:
        case DTK_EPOCH:
            if (isNegative)
                return -get_float8_infinity();
            else
                return get_float8_infinity();

        default:
            if (isTz)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("timestamp with time zone units \"%s\" not supported",
                                lowunits)));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("timestamp units \"%s\" not supported",
                                lowunits)));
            return 0.0;         /* keep compiler quiet */
    }
}

Datum now

(

PG_FUNCTION_ARGS

)

Definition at line 1534 of file timestamp.c.

References GetCurrentTransactionStartTimestamp(), and PG_RETURN_TIMESTAMPTZ.

Referenced by ApplyLauncherMain(), BackgroundWriterMain(), CheckArchiveTimeout(), CheckpointerMain(), doCustom(), doLog(), dumpTimestamp(), enable_timeout(), enable_timeout_after(), enable_timeout_at(), enable_timeouts(), GetCurrentAbsoluteTime(), GetSnapshotCurrentTimestamp(), handle_sig_alarm(), HandleCopyStream(), logicalrep_worker_launch(), LogicalRepApplyLoop(), maybe_start_bgworkers(), mxid_age(), OutputFsync(), pg_timezone_abbrevs(), pgfdw_get_cleanup_result(), pgstat_report_stat(), pqSocketPoll(), process_syncing_tables_for_apply(), ProcessKeepaliveMsg(), ProcessStandbyReplyMessage(), progress_report(), RequestXLogStreaming(), send_feedback(), ServerLoop(), set_next_rotation_time(), StreamLogicalLog(), SysLoggerMain(), threadRun(), timetz_zone(), WaitForWALToBecomeAvailable(), WalRcvRunning(), WalRcvStreaming(), WalReceiverMain(), WalSndLoop(), WalSndUpdateProgress(), WalSndWaitForWal(), WalSndWriteData(), xid_age(), XLogBackgroundFlush(), XLogWalRcvSendHSFeedback(), and XLogWalRcvSendReply().

{
    PG_RETURN_TIMESTAMPTZ(GetCurrentTransactionStartTimestamp());
}

Datum overlaps_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 2429 of file timestamp.c.

References PG_ARGISNULL, PG_GETARG_DATUM, PG_RETURN_BOOL, PG_RETURN_NULL, TIMESTAMP_GT, and TIMESTAMP_LT.

{
    /*
     * The arguments are Timestamps, but we leave them as generic Datums to
     * avoid unnecessary conversions between value and reference forms --- not
     * to mention possible dereferences of null pointers.
     */
    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 TIMESTAMP_GT(t1,t2) \
    DatumGetBool(DirectFunctionCall2(timestamp_gt,t1,t2))
#define TIMESTAMP_LT(t1,t2) \
    DatumGetBool(DirectFunctionCall2(timestamp_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 (TIMESTAMP_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 (TIMESTAMP_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 (TIMESTAMP_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 (TIMESTAMP_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 (TIMESTAMP_LT(ts1, ts2))
    {
        /* This case is ts2 < te1 OR te2 < te1 */
        if (te1IsNull)
            PG_RETURN_NULL();
        if (TIMESTAMP_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 non-null, else null".
         */
        if (te1IsNull || te2IsNull)
            PG_RETURN_NULL();
        PG_RETURN_BOOL(true);
    }

#undef TIMESTAMP_GT
#undef TIMESTAMP_LT
}

static int parse_sane_timezone ( struct pg_tm *  tm, text *  zone  )

static

Definition at line 458 of file timestamp.c.

References DecodeTimezone(), DecodeTimezoneAbbrev(), DetermineTimeZoneAbbrevOffset(), DetermineTimeZoneOffset(), downcase_truncate_identifier(), DTERR_BAD_FORMAT, DTERR_TZDISP_OVERFLOW, DTZ, DYNTZ, ereport, errcode(), errhint(), errmsg(), ERROR, pg_tzset(), text_to_cstring_buffer(), TZ, TZ_STRLEN_MAX, and val.

Referenced by make_timestamptz_at_timezone().

{
    char        tzname[TZ_STRLEN_MAX + 1];
    int         rt;
    int         tz;

    text_to_cstring_buffer(zone, tzname, sizeof(tzname));

    /*
     * Look up the requested timezone.  First we try to interpret it as a
     * numeric timezone specification; if DecodeTimezone decides it doesn't
     * like the format, we look in the timezone abbreviation table (to handle
     * cases like "EST"), and if that also 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.)
     *
     * Note pg_tzset happily parses numeric input that DecodeTimezone would
     * reject.  To avoid having it accept input that would otherwise be seen
     * as invalid, it's enough to disallow having a digit in the first
     * position of our input string.
     */
    if (isdigit((unsigned char) *tzname))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid input syntax for numeric time zone: \"%s\"",
                        tzname),
                 errhint("Numeric time zones must have \"-\" or \"+\" as first character.")));

    rt = DecodeTimezone(tzname, &tz);
    if (rt != 0)
    {
        char       *lowzone;
        int         type,
                    val;
        pg_tz      *tzp;

        if (rt == DTERR_TZDISP_OVERFLOW)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("numeric time zone \"%s\" out of range", tzname)));
        else if (rt != DTERR_BAD_FORMAT)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("time zone \"%s\" not recognized", tzname)));

        /* DecodeTimezoneAbbrev requires lowercase input */
        lowzone = downcase_truncate_identifier(tzname,
                                               strlen(tzname),
                                               false);
        type = DecodeTimezoneAbbrev(0, lowzone, &val, &tzp);

        if (type == TZ || type == DTZ)
        {
            /* fixed-offset abbreviation */
            tz = -val;
        }
        else if (type == DYNTZ)
        {
            /* dynamic-offset abbreviation, resolve using specified time */
            tz = DetermineTimeZoneAbbrevOffset(tm, tzname, tzp);
        }
        else
        {
            /* try it as a full zone name */
            tzp = pg_tzset(tzname);
            if (tzp)
                tz = DetermineTimeZoneOffset(tm, tzp);
            else
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("time zone \"%s\" not recognized", tzname)));
        }
    }

    return tz;
}

Datum pg_conf_load_time

(

PG_FUNCTION_ARGS

)

Definition at line 1558 of file timestamp.c.

References PG_RETURN_TIMESTAMPTZ, and PgReloadTime.

{
    PG_RETURN_TIMESTAMPTZ(PgReloadTime);
}

Datum pg_postmaster_start_time

(

PG_FUNCTION_ARGS

)

Definition at line 1552 of file timestamp.c.

References PG_RETURN_TIMESTAMPTZ, and PgStartTime.

{
    PG_RETURN_TIMESTAMPTZ(PgStartTime);
}

Timestamp SetEpochTimestamp

(

void

)

Definition at line 2003 of file timestamp.c.

References GetEpochTime(), NULL, tm, and tm2timestamp().

Referenced by dttofmtasc_replace(), PGTYPEStimestamp_from_asc(), timestamp_in(), timestamp_part(), timestamptz_in(), and timestamptz_part().

{
    Timestamp   dt;
    struct pg_tm tt,
               *tm = &tt;

    GetEpochTime(tm);
    /* we don't bother to test for failure ... */
    tm2timestamp(tm, 0, NULL, &dt);

    return dt;
}                               /* SetEpochTimestamp() */

Datum statement_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 1540 of file timestamp.c.

References GetCurrentStatementStartTimestamp(), and PG_RETURN_TIMESTAMPTZ.

{
    PG_RETURN_TIMESTAMPTZ(GetCurrentStatementStartTimestamp());
}

static TimeOffset time2t ( const int  hour, const int  min, const int  sec, const fsec_t  fsec  )

static

Definition at line 1946 of file timestamp.c.

References MINS_PER_HOUR, SECS_PER_MINUTE, and USECS_PER_SEC.

Referenced by tm2timestamp().

{
    return (((((hour * MINS_PER_HOUR) + min) * SECS_PER_MINUTE) + sec) * USECS_PER_SEC) + fsec;
}

TimestampTz time_t_to_timestamptz

(

pg_time_t

tm

)

Definition at line 1670 of file timestamp.c.

References POSTGRES_EPOCH_JDATE, result, SECS_PER_DAY, UNIX_EPOCH_JDATE, and USECS_PER_SEC.

Referenced by pg_control_checkpoint(), pg_control_system(), pg_ls_dir_files(), and pg_stat_file().

{
    TimestampTz result;

    result = (TimestampTz) tm -
        ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY);
    result *= USECS_PER_SEC;

    return result;
}

static TimestampTz timestamp2timestamptz ( Timestamp  timestamp )

static

Definition at line 4947 of file timestamp.c.

References DetermineTimeZoneOffset(), ereport, errcode(), errmsg(), ERROR, NULL, result, session_timezone, timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, and tm2timestamp().

Referenced by make_timestamptz(), timestamp_cmp_timestamptz(), timestamp_eq_timestamptz(), timestamp_ge_timestamptz(), timestamp_gt_timestamptz(), timestamp_le_timestamptz(), timestamp_lt_timestamptz(), timestamp_ne_timestamptz(), timestamp_timestamptz(), timestamptz_cmp_timestamp(), timestamptz_eq_timestamp(), timestamptz_ge_timestamp(), timestamptz_gt_timestamp(), timestamptz_le_timestamp(), timestamptz_lt_timestamp(), and timestamptz_ne_timestamp().

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

    if (TIMESTAMP_NOT_FINITE(timestamp))
        result = timestamp;
    else
    {
        if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));

        tz = DetermineTimeZoneOffset(tm, session_timezone);

        if (tm2timestamp(tm, fsec, &tz, &result) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
    }

    return result;
}

int timestamp2tm	(	Timestamp	dt,
		int *	tzp,
		struct pg_tm *	tm,
		fsec_t *	fsec,
		const char **	tzn,
		pg_tz *	attimezone
	)

Definition at line 1758 of file timestamp.c.

References dt2time(), INT64CONST, j2date(), NULL, pg_localtime(), POSTGRES_EPOCH_JDATE, SECS_PER_DAY, session_timezone, pg_tm::tm_gmtoff, pg_tm::tm_hour, pg_tm::tm_isdst, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, pg_tm::tm_zone, TMODULO, UNIX_EPOCH_JDATE, USECS_PER_DAY, and USECS_PER_SEC.

Referenced by datum_to_json(), datum_to_jsonb(), DetermineTimeZoneAbbrevOffsetTS(), GetCurrentDateTime(), GetCurrentTimeUsec(), GetSQLCurrentDate(), GetSQLCurrentTime(), GetSQLLocalTime(), make_timestamptz_at_timezone(), map_sql_value_to_xml_value(), pg_timezone_names(), PGTYPEStimestamp_add_interval(), PGTYPEStimestamp_fmt_asc(), PGTYPEStimestamp_to_asc(), timestamp2timestamptz(), timestamp_abstime(), timestamp_age(), timestamp_date(), timestamp_out(), timestamp_part(), timestamp_pl_interval(), timestamp_recv(), timestamp_time(), timestamp_to_char(), timestamp_trunc(), timestamp_zone(), timestamptz2timestamp(), timestamptz_abstime(), timestamptz_age(), timestamptz_date(), timestamptz_out(), timestamptz_part(), timestamptz_pl_interval(), timestamptz_recv(), timestamptz_time(), timestamptz_timetz(), timestamptz_to_char(), timestamptz_to_str(), timestamptz_trunc(), and timestamptz_zone().

{
    Timestamp   date;
    Timestamp   time;
    pg_time_t   utime;

    /* Use session timezone if caller asks for default */
    if (attimezone == NULL)
        attimezone = session_timezone;

    time = dt;
    TMODULO(time, date, USECS_PER_DAY);

    if (time < INT64CONST(0))
    {
        time += USECS_PER_DAY;
        date -= 1;
    }

    /* add offset to go from J2000 back to standard Julian date */
    date += POSTGRES_EPOCH_JDATE;

    /* Julian day routine does not work for negative Julian days */
    if (date < 0 || date > (Timestamp) INT_MAX)
        return -1;

    j2date((int) date, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
    dt2time(time, &tm->tm_hour, &tm->tm_min, &tm->tm_sec, fsec);

    /* Done if no TZ conversion wanted */
    if (tzp == NULL)
    {
        tm->tm_isdst = -1;
        tm->tm_gmtoff = 0;
        tm->tm_zone = NULL;
        if (tzn != NULL)
            *tzn = NULL;
        return 0;
    }

    /*
     * If the time falls within the range of pg_time_t, use pg_localtime() to
     * rotate to the local time zone.
     *
     * First, convert to an integral timestamp, avoiding possibly
     * platform-specific roundoff-in-wrong-direction errors, and adjust to
     * Unix epoch.  Then see if we can convert to pg_time_t without loss. This
     * coding avoids hardwiring any assumptions about the width of pg_time_t,
     * so it should behave sanely on machines without int64.
     */
    dt = (dt - *fsec) / USECS_PER_SEC +
        (POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY;
    utime = (pg_time_t) dt;
    if ((Timestamp) utime == dt)
    {
        struct pg_tm *tx = pg_localtime(&utime, attimezone);

        tm->tm_year = tx->tm_year + 1900;
        tm->tm_mon = tx->tm_mon + 1;
        tm->tm_mday = tx->tm_mday;
        tm->tm_hour = tx->tm_hour;
        tm->tm_min = tx->tm_min;
        tm->tm_sec = tx->tm_sec;
        tm->tm_isdst = tx->tm_isdst;
        tm->tm_gmtoff = tx->tm_gmtoff;
        tm->tm_zone = tx->tm_zone;
        *tzp = -tm->tm_gmtoff;
        if (tzn != NULL)
            *tzn = tm->tm_zone;
    }
    else
    {
        /*
         * When out of range of pg_time_t, treat as GMT
         */
        *tzp = 0;
        /* Mark this as *no* time zone available */
        tm->tm_isdst = -1;
        tm->tm_gmtoff = 0;
        tm->tm_zone = NULL;
        if (tzn != NULL)
            *tzn = NULL;
    }

    return 0;
}

Datum timestamp_age

(

PG_FUNCTION_ARGS

)

Definition at line 3406 of file timestamp.c.

References day_tab, ereport, errcode(), errmsg(), ERROR, HOURS_PER_DAY, isleap, MINS_PER_HOUR, MONTHS_PER_YEAR, NULL, palloc(), PG_GETARG_TIMESTAMP, PG_RETURN_INTERVAL_P, result, SECS_PER_MINUTE, timestamp2tm(), tm, tm2interval(), 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_SEC.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
    Interval   *result;
    fsec_t      fsec,
                fsec1,
                fsec2;
    struct pg_tm tt,
               *tm = &tt;
    struct pg_tm tt1,
               *tm1 = &tt1;
    struct pg_tm tt2,
               *tm2 = &tt2;

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

    if (timestamp2tm(dt1, NULL, tm1, &fsec1, NULL, NULL) == 0 &&
        timestamp2tm(dt2, NULL, tm2, &fsec2, NULL, NULL) == 0)
    {
        /* form the symbolic difference */
        fsec = fsec1 - fsec2;
        tm->tm_sec = tm1->tm_sec - tm2->tm_sec;
        tm->tm_min = tm1->tm_min - tm2->tm_min;
        tm->tm_hour = tm1->tm_hour - tm2->tm_hour;
        tm->tm_mday = tm1->tm_mday - tm2->tm_mday;
        tm->tm_mon = tm1->tm_mon - tm2->tm_mon;
        tm->tm_year = tm1->tm_year - tm2->tm_year;

        /* flip sign if necessary... */
        if (dt1 < dt2)
        {
            fsec = -fsec;
            tm->