timestamp.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <math.h>
#include <limits.h>
#include <sys/time.h>
#include "access/xact.h"
#include "catalog/pg_type.h"
#include "common/int.h"
#include "common/int128.h"
#include "funcapi.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/supportnodes.h"
#include "parser/scansup.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/datetime.h"
#include "utils/float.h"
#include "utils/numeric.h"
#include "utils/sortsupport.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 bool	AdjustIntervalForTypmod (Interval *interval, int32 typmod, Node *escontext)
static TimestampTz	timestamp2timestamptz (Timestamp timestamp)
static Timestamp	timestamptz2timestamp (TimestampTz timestamp)
static int32	anytimestamp_typmod_check (bool istz, int32 typmod)
static int32	anytimestamp_typmodin (bool istz, ArrayType *ta)
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_support (PG_FUNCTION_ARGS)
Datum	timestamp_scale (PG_FUNCTION_ARGS)
bool	AdjustTimestampForTypmod (Timestamp *time, int32 typmod, Node *escontext)
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_support (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)
Datum	current_timestamp (PG_FUNCTION_ARGS)
Datum	sql_localtimestamp (PG_FUNCTION_ARGS)
Datum	timeofday (PG_FUNCTION_ARGS)
void	TimestampDifference (TimestampTz start_time, TimestampTz stop_time, long *secs, int *microsecs)
long	TimestampDifferenceMilliseconds (TimestampTz start_time, TimestampTz stop_time)
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)
void	interval2itm (Interval span, struct pg_itm *itm)
int	itm2interval (struct pg_itm *itm, Interval *span)
int	itmin2interval (struct pg_itm_in *itm_in, 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_hash_extended (PG_FUNCTION_ARGS)
int32	timestamp_cmp_timestamptz_internal (Timestamp timestampVal, TimestampTz dt2)
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 (const Interval *interval1, const 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	interval_hash_extended (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	in_range_timestamptz_interval (PG_FUNCTION_ARGS)
Datum	in_range_timestamp_interval (PG_FUNCTION_ARGS)
Datum	in_range_interval_interval (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_bin (PG_FUNCTION_ARGS)
Datum	timestamp_trunc (PG_FUNCTION_ARGS)
Datum	timestamptz_bin (PG_FUNCTION_ARGS)
static TimestampTz	timestamptz_trunc_internal (text *units, TimestampTz timestamp, pg_tz *tzp)
Datum	timestamptz_trunc (PG_FUNCTION_ARGS)
Datum	timestamptz_trunc_zone (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)
static Datum	timestamp_part_common (PG_FUNCTION_ARGS, bool retnumeric)
Datum	timestamp_part (PG_FUNCTION_ARGS)
Datum	extract_timestamp (PG_FUNCTION_ARGS)
static Datum	timestamptz_part_common (PG_FUNCTION_ARGS, bool retnumeric)
Datum	timestamptz_part (PG_FUNCTION_ARGS)
Datum	extract_timestamptz (PG_FUNCTION_ARGS)
static Datum	interval_part_common (PG_FUNCTION_ARGS, bool retnumeric)
Datum	interval_part (PG_FUNCTION_ARGS)
Datum	extract_interval (PG_FUNCTION_ARGS)
Datum	timestamp_zone (PG_FUNCTION_ARGS)
Datum	timestamp_izone (PG_FUNCTION_ARGS)
bool	TimestampTimestampTzRequiresRewrite (void)
Datum	timestamp_timestamptz (PG_FUNCTION_ARGS)
TimestampTz	timestamp2timestamptz_opt_overflow (Timestamp timestamp, int *overflow)
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

SAMESIGN

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

Definition at line 50 of file timestamp.c.

TIMESTAMP_GT

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

TIMESTAMP_LT

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

Function Documentation

AdjustIntervalForTypmod()

static bool AdjustIntervalForTypmod ( Interval *  interval, int32  typmod, Node *  escontext  )

static

Definition at line 1332 of file timestamp.c.

{
    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_support 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)
                ereturn(escontext, false,
                        (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]);
            }
        }
    }
 
    return true;
}

References DAY, elog(), ereturn, errcode(), errmsg(), ERROR, HOUR, INTERVAL_FULL_PRECISION, INTERVAL_FULL_RANGE, INTERVAL_MASK, INTERVAL_PRECISION, INTERVAL_RANGE, MAX_INTERVAL_PRECISION, MINUTE, MONTH, interval::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().

AdjustTimestampForTypmod()

bool AdjustTimestampForTypmod	(	Timestamp *	time,
		int32	typmod,
		Node *	escontext
	)

Definition at line 348 of file timestamp.c.

{
    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)
            ereturn(escontext, false,
                    (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]);
        }
    }
 
    return true;
}

References ereturn, errcode(), errmsg(), MAX_TIMESTAMP_PRECISION, and TIMESTAMP_NOT_FINITE.

Referenced by current_timestamp(), parse_datetime(), sql_localtimestamp(), timestamp_in(), timestamp_recv(), timestamp_scale(), timestamptz_in(), timestamptz_recv(), timestamptz_scale(), and to_timestamp().

anytimestamp_typmod_check()

static int32 anytimestamp_typmod_check ( bool  istz, int32  typmod  )

static

Definition at line 85 of file timestamp.c.

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

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

Referenced by anytimestamp_typmodin(), current_timestamp(), and sql_localtimestamp().

anytimestamp_typmodin()

static int32 anytimestamp_typmodin ( bool  istz, ArrayType *  ta  )

static

Definition at line 106 of file timestamp.c.

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

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

Referenced by timestamptypmodin(), and timestamptztypmodin().

anytimestamp_typmodout()

static char* anytimestamp_typmodout ( bool  istz, int32  typmod  )

static

Definition at line 127 of file timestamp.c.

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

References psprintf(), and pstrdup().

Referenced by timestamptypmodout(), and timestamptztypmodout().

clock_timestamp()

Datum clock_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 1561 of file timestamp.c.

{
    PG_RETURN_TIMESTAMPTZ(GetCurrentTimestamp());
}

References GetCurrentTimestamp(), and PG_RETURN_TIMESTAMPTZ.

current_timestamp()

Datum current_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 1603 of file timestamp.c.

{
    TimestampTz ts;
    int32       typmod = -1;
 
    if (!PG_ARGISNULL(0))
    {
        typmod = PG_GETARG_INT32(0);
        anytimestamp_typmod_check(true, typmod);
    }
 
    ts = GetCurrentTransactionStartTimestamp();
    if (typmod >= 0)
        AdjustTimestampForTypmod(&ts, typmod, NULL);
    return TimestampTzGetDatum(ts);
}

References AdjustTimestampForTypmod(), anytimestamp_typmod_check(), GetCurrentTransactionStartTimestamp(), PG_ARGISNULL, PG_GETARG_INT32, and TimestampTzGetDatum().

Referenced by GetSnapshotCurrentTimestamp(), and pgstat_report_activity().

date2isoweek()

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

Definition at line 4505 of file timestamp.c.

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

References date2j(), and j2day().

Referenced by DCH_to_char(), extract_date(), timestamp_part_common(), timestamp_trunc(), timestamptz_part_common(), and timestamptz_trunc_internal().

date2isoyear()

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

Definition at line 4560 of file timestamp.c.

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

References date2j(), and j2day().

Referenced by date2isoyearday(), DCH_to_char(), extract_date(), timestamp_part_common(), and timestamptz_part_common().

date2isoyearday()

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

Definition at line 4617 of file timestamp.c.

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

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

Referenced by DCH_to_char().

dt2local()

static Timestamp dt2local ( Timestamp  dt, int  timezone  )

static

Definition at line 2063 of file timestamp.c.

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

References USECS_PER_SEC.

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

dt2time()

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

Definition at line 1815 of file timestamp.c.

{
    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() */

References USECS_PER_HOUR, USECS_PER_MINUTE, and USECS_PER_SEC.

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

EncodeSpecialTimestamp()

void EncodeSpecialTimestamp	(	Timestamp	dt,
		char *	str
	)

Definition at line 1538 of file timestamp.c.

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

References EARLY, elog(), ERROR, LATE, generate_unaccent_rules::str, TIMESTAMP_IS_NOBEGIN, and TIMESTAMP_IS_NOEND.

Referenced by JsonEncodeDateTime(), PGTYPEStimestamp_to_asc(), timestamp_out(), timestamptz_out(), and timestamptz_to_str().

extract_interval()

Datum extract_interval

(

PG_FUNCTION_ARGS

)

Definition at line 5408 of file timestamp.c.

{
    return interval_part_common(fcinfo, true);
}

References interval_part_common().

extract_timestamp()

Datum extract_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 4955 of file timestamp.c.

{
    return timestamp_part_common(fcinfo, true);
}

References timestamp_part_common().

extract_timestamptz()

Datum extract_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 5227 of file timestamp.c.

{
    return timestamptz_part_common(fcinfo, true);
}

References timestamptz_part_common().

float8_timestamptz()

Datum float8_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 721 of file timestamp.c.

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

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

generate_series_timestamp()

Datum generate_series_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 5805 of file timestamp.c.

{
    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;
        const Interval interval_zero = {0};
 
        /* 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 */
        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);
    }
}

References generate_series_timestamp_fctx::current, DatumGetTimestamp(), DirectFunctionCall2, ereport, errcode(), errmsg(), ERROR, generate_series_timestamp_fctx::finish, interval_cmp_internal(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, palloc(), PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMP, PointerGetDatum(), 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.

generate_series_timestamptz()

Datum generate_series_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 5884 of file timestamp.c.

{
    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;
        const Interval interval_zero = {0};
 
        /* 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 */
        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);
    }
}

References generate_series_timestamptz_fctx::current, DatumGetTimestampTz(), DirectFunctionCall2, ereport, errcode(), errmsg(), ERROR, generate_series_timestamptz_fctx::finish, interval_cmp_internal(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, palloc(), PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMPTZ, PointerGetDatum(), 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.

GetCurrentTimestamp()

TimestampTz GetCurrentTimestamp

(

void

)

Definition at line 1585 of file timestamp.c.

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

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

Referenced by ApplyLauncherMain(), ApplyWorkerMain(), asyncQueueFillWarning(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), bbsink_copystream_archive_contents(), bbsink_copystream_end_archive(), bbsink_copystream_new(), bbsink_throttle_begin_backup(), begin_startup_progress_phase(), check_log_duration(), CheckPointGuts(), CleanupBackgroundWorker(), clock_timestamp(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateOverwriteContrecordRecord(), CreateRestartPoint(), DetermineSleepTime(), disable_timeout(), disable_timeouts(), do_analyze_rel(), do_start_bgworker(), do_start_worker(), drandom(), enable_timeout_after(), enable_timeout_at(), enable_timeout_every(), enable_timeouts(), entry_reset(), get_role_password(), GetCurrentTransactionStopTimestamp(), GetReplicationApplyDelay(), GetSnapshotCurrentTimestamp(), handle_sig_alarm(), has_startup_progress_timeout_expired(), heap_vacuum_rel(), InitProcessGlobals(), KnownAssignedXidsCompress(), launcher_determine_sleep(), LockBufferForCleanup(), log_disconnections(), LogCheckpointEnd(), logicalrep_worker_launch(), LogicalRepApplyLoop(), maybe_start_bgworkers(), PerformWalRecovery(), pgfdw_cancel_query(), pgfdw_exec_cleanup_query(), pgfdw_get_cleanup_result(), pgss_shmem_startup(), pgstat_build_snapshot(), pgstat_report_activity(), pgstat_report_analyze(), pgstat_report_archiver(), pgstat_report_autovac(), pgstat_report_checksum_failures_in_db(), pgstat_report_vacuum(), pgstat_reset(), pgstat_reset_after_failure(), pgstat_reset_counters(), pgstat_reset_of_kind(), pgstat_reset_slru(), PostgresSingleUserMain(), PostmasterMain(), PrepareTransaction(), process_syncing_tables_for_apply(), ProcessConfigFileInternal(), ProcessPendingWrites(), ProcessRepliesIfAny(), ProcessStandbyReplyMessage(), ProcessWalSndrMessage(), ProcSleep(), rebuild_database_list(), RecordTransactionAbort(), RecordTransactionAbortPrepared(), RecordTransactionCommitPrepared(), recoveryApplyDelay(), reschedule_timeouts(), ResolveRecoveryConflictWithBufferPin(), ResolveRecoveryConflictWithLock(), ResolveRecoveryConflictWithVirtualXIDs(), send_feedback(), SetCurrentStatementStartTimestamp(), StartTransaction(), test_pattern(), throttle(), UpdateWorkerStats(), WaitExceedsMaxStandbyDelay(), WaitForWALToBecomeAvailable(), WalReceiverMain(), WalSndKeepalive(), WalSndLoop(), WalSndUpdateProgress(), WalSndWaitForWal(), WalSndWriteData(), XLogBackgroundFlush(), XLogFileRead(), XLogPrefetchResetStats(), XLogPrefetchShmemInit(), XLogRestorePoint(), XLogSendPhysical(), XLogWalRcvSendHSFeedback(), and XLogWalRcvSendReply().

GetEpochTime()

void GetEpochTime

(

struct pg_tm *

tm

)

Definition at line 2095 of file timestamp.c.

{
    struct pg_tm *t0;
    pg_time_t   epoch = 0;
 
    t0 = pg_gmtime(&epoch);
 
    if (t0 == NULL)
        elog(ERROR, "could not convert epoch to timestamp: %m");
 
    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++;
}

References elog(), epoch, ERROR, pg_gmtime(), tm, 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().

in_range_interval_interval()

Datum in_range_interval_interval

(

PG_FUNCTION_ARGS

)

Definition at line 3462 of file timestamp.c.

{
    Interval   *val = PG_GETARG_INTERVAL_P(0);
    Interval   *base = PG_GETARG_INTERVAL_P(1);
    Interval   *offset = PG_GETARG_INTERVAL_P(2);
    bool        sub = PG_GETARG_BOOL(3);
    bool        less = PG_GETARG_BOOL(4);
    Interval   *sum;
 
    if (int128_compare(interval_cmp_value(offset), int64_to_int128(0)) < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
                 errmsg("invalid preceding or following size in window function")));
 
    /* We don't currently bother to avoid overflow hazards here */
    if (sub)
        sum = DatumGetIntervalP(DirectFunctionCall2(interval_mi,
                                                    IntervalPGetDatum(base),
                                                    IntervalPGetDatum(offset)));
    else
        sum = DatumGetIntervalP(DirectFunctionCall2(interval_pl,
                                                    IntervalPGetDatum(base),
                                                    IntervalPGetDatum(offset)));
 
    if (less)
        PG_RETURN_BOOL(interval_cmp_internal(val, sum) <= 0);
    else
        PG_RETURN_BOOL(interval_cmp_internal(val, sum) >= 0);
}

References DatumGetIntervalP(), DirectFunctionCall2, ereport, errcode(), errmsg(), ERROR, int128_compare(), int64_to_int128(), interval_cmp_internal(), interval_cmp_value(), interval_mi(), interval_pl(), IntervalPGetDatum(), PG_GETARG_BOOL, PG_GETARG_INTERVAL_P, PG_RETURN_BOOL, and val.

in_range_timestamp_interval()

Datum in_range_timestamp_interval

(

PG_FUNCTION_ARGS

)

Definition at line 3431 of file timestamp.c.

{
    Timestamp   val = PG_GETARG_TIMESTAMP(0);
    Timestamp   base = PG_GETARG_TIMESTAMP(1);
    Interval   *offset = PG_GETARG_INTERVAL_P(2);
    bool        sub = PG_GETARG_BOOL(3);
    bool        less = PG_GETARG_BOOL(4);
    Timestamp   sum;
 
    if (int128_compare(interval_cmp_value(offset), int64_to_int128(0)) < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
                 errmsg("invalid preceding or following size in window function")));
 
    /* We don't currently bother to avoid overflow hazards here */
    if (sub)
        sum = DatumGetTimestamp(DirectFunctionCall2(timestamp_mi_interval,
                                                    TimestampGetDatum(base),
                                                    IntervalPGetDatum(offset)));
    else
        sum = DatumGetTimestamp(DirectFunctionCall2(timestamp_pl_interval,
                                                    TimestampGetDatum(base),
                                                    IntervalPGetDatum(offset)));
 
    if (less)
        PG_RETURN_BOOL(val <= sum);
    else
        PG_RETURN_BOOL(val >= sum);
}

References DatumGetTimestamp(), DirectFunctionCall2, ereport, errcode(), errmsg(), ERROR, int128_compare(), int64_to_int128(), interval_cmp_value(), IntervalPGetDatum(), PG_GETARG_BOOL, PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMP, PG_RETURN_BOOL, timestamp_mi_interval(), timestamp_pl_interval(), TimestampGetDatum(), and val.

Referenced by in_range_date_interval().

in_range_timestamptz_interval()

Datum in_range_timestamptz_interval

(

PG_FUNCTION_ARGS

)

Definition at line 3400 of file timestamp.c.

{
    TimestampTz val = PG_GETARG_TIMESTAMPTZ(0);
    TimestampTz base = PG_GETARG_TIMESTAMPTZ(1);
    Interval   *offset = PG_GETARG_INTERVAL_P(2);
    bool        sub = PG_GETARG_BOOL(3);
    bool        less = PG_GETARG_BOOL(4);
    TimestampTz sum;
 
    if (int128_compare(interval_cmp_value(offset), int64_to_int128(0)) < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
                 errmsg("invalid preceding or following size in window function")));
 
    /* We don't currently bother to avoid overflow hazards here */
    if (sub)
        sum = DatumGetTimestampTz(DirectFunctionCall2(timestamptz_mi_interval,
                                                      TimestampTzGetDatum(base),
                                                      IntervalPGetDatum(offset)));
    else
        sum = DatumGetTimestampTz(DirectFunctionCall2(timestamptz_pl_interval,
                                                      TimestampTzGetDatum(base),
                                                      IntervalPGetDatum(offset)));
 
    if (less)
        PG_RETURN_BOOL(val <= sum);
    else
        PG_RETURN_BOOL(val >= sum);
}

References DatumGetTimestampTz(), DirectFunctionCall2, ereport, errcode(), errmsg(), ERROR, int128_compare(), int64_to_int128(), interval_cmp_value(), IntervalPGetDatum(), PG_GETARG_BOOL, PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMPTZ, PG_RETURN_BOOL, timestamptz_mi_interval(), timestamptz_pl_interval(), TimestampTzGetDatum(), and val.

interval2itm()

void interval2itm	(	Interval	span,
		struct pg_itm *	itm
	)

Definition at line 1988 of file timestamp.c.

{
    TimeOffset  time;
    TimeOffset  tfrac;
 
    itm->tm_year = span.month / MONTHS_PER_YEAR;
    itm->tm_mon = span.month % MONTHS_PER_YEAR;
    itm->tm_mday = span.day;
    time = span.time;
 
    tfrac = time / USECS_PER_HOUR;
    time -= tfrac * USECS_PER_HOUR;
    itm->tm_hour = tfrac;
    tfrac = time / USECS_PER_MINUTE;
    time -= tfrac * USECS_PER_MINUTE;
    itm->tm_min = (int) tfrac;
    tfrac = time / USECS_PER_SEC;
    time -= tfrac * USECS_PER_SEC;
    itm->tm_sec = (int) tfrac;
    itm->tm_usec = (int) time;
}

References Interval::day, Interval::month, MONTHS_PER_YEAR, Interval::time, pg_itm::tm_hour, pg_itm::tm_mday, pg_itm::tm_min, pg_itm::tm_mon, pg_itm::tm_sec, pg_itm::tm_usec, pg_itm::tm_year, USECS_PER_HOUR, USECS_PER_MINUTE, and USECS_PER_SEC.

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

interval_accum()

Datum interval_accum

(

PG_FUNCTION_ARGS

)

Definition at line 3504 of file timestamp.c.

{
    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, TYPALIGN_DOUBLE,
                      &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, TYPALIGN_DOUBLE);
 
    PG_RETURN_ARRAYTYPE_P(result);
}

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

interval_accum_inv()

Datum interval_accum_inv

(

PG_FUNCTION_ARGS

)

Definition at line 3588 of file timestamp.c.

{
    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, TYPALIGN_DOUBLE,
                      &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, TYPALIGN_DOUBLE);
 
    PG_RETURN_ARRAYTYPE_P(result);
}

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

interval_avg()

Datum interval_avg

(

PG_FUNCTION_ARGS

)

Definition at line 3623 of file timestamp.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    Datum      *transdatums;
    int         ndatums;
    Interval    sumX,
                N;
 
    deconstruct_array(transarray,
                      INTERVALOID, sizeof(Interval), false, TYPALIGN_DOUBLE,
                      &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));
}

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

interval_cmp()

Datum interval_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 2495 of file timestamp.c.

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);
 
    PG_RETURN_INT32(interval_cmp_internal(interval1, interval2));
}

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_INT32.

Referenced by gbt_intvkey_cmp().

interval_cmp_internal()

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

static

Definition at line 2432 of file timestamp.c.

{
    INT128      span1 = interval_cmp_value(interval1);
    INT128      span2 = interval_cmp_value(interval2);
 
    return int128_compare(span1, span2);
}

References int128_compare(), and interval_cmp_value().

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

interval_cmp_value()

static INT128 interval_cmp_value ( const Interval *  interval )

inlinestatic

Definition at line 2410 of file timestamp.c.

{
    INT128      span;
    int64       days;
 
    /*
     * Combine the month and day fields into an integral number of days.
     * Because the inputs are int32, int64 arithmetic suffices here.
     */
    days = interval->month * INT64CONST(30);
    days += interval->day;
 
    /* Widen time field to 128 bits */
    span = int64_to_int128(interval->time);
 
    /* Scale up days to microseconds, forming a 128-bit product */
    int128_add_int64_mul_int64(&span, days, USECS_PER_DAY);
 
    return span;
}

References days, int128_add_int64_mul_int64(), int64_to_int128(), interval::month, interval::time, and USECS_PER_DAY.

Referenced by in_range_interval_interval(), in_range_timestamp_interval(), in_range_timestamptz_interval(), interval_cmp_internal(), interval_hash(), and interval_hash_extended().

interval_combine()

Datum interval_combine

(

PG_FUNCTION_ARGS

)

Definition at line 3539 of file timestamp.c.

{
    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, TYPALIGN_DOUBLE,
                      &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, TYPALIGN_DOUBLE,
                      &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, TYPALIGN_DOUBLE);
 
    PG_RETURN_ARRAYTYPE_P(result);
}

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

interval_div()

Datum interval_div

(

PG_FUNCTION_ARGS

)

Definition at line 3348 of file timestamp.c.

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

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

Referenced by interval_avg().

interval_eq()

Datum interval_eq

(

PG_FUNCTION_ARGS

)

Definition at line 2441 of file timestamp.c.

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);
 
    PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) == 0);
}

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

Referenced by gbt_intveq().

interval_finite()

Datum interval_finite

(

PG_FUNCTION_ARGS

)

Definition at line 2084 of file timestamp.c.

{
    PG_RETURN_BOOL(true);
}

References PG_RETURN_BOOL.

interval_ge()

Datum interval_ge

(

PG_FUNCTION_ARGS

)

Definition at line 2486 of file timestamp.c.

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);
 
    PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) >= 0);
}

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

Referenced by gbt_intvge().

interval_gt()

Datum interval_gt

(

PG_FUNCTION_ARGS

)

Definition at line 2468 of file timestamp.c.

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);
 
    PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) > 0);
}

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

Referenced by gbt_intvgt().

interval_hash()

Datum interval_hash

(

PG_FUNCTION_ARGS

)

Definition at line 2511 of file timestamp.c.

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

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

interval_hash_extended()

Datum interval_hash_extended

(

PG_FUNCTION_ARGS

)

Definition at line 2529 of file timestamp.c.

{
    Interval   *interval = PG_GETARG_INTERVAL_P(0);
    INT128      span = interval_cmp_value(interval);
    int64       span64;
 
    /* Same approach as interval_hash */
    span64 = int128_to_int64(span);
 
    return DirectFunctionCall2(hashint8extended, Int64GetDatumFast(span64),
                               PG_GETARG_DATUM(1));
}

References DirectFunctionCall2, hashint8extended(), int128_to_int64(), Int64GetDatumFast, interval_cmp_value(), PG_GETARG_DATUM, and PG_GETARG_INTERVAL_P.

interval_in()

Datum interval_in

(

PG_FUNCTION_ARGS

)

Definition at line 886 of file timestamp.c.

{
    char       *str = PG_GETARG_CSTRING(0);
#ifdef NOT_USED
    Oid         typelem = PG_GETARG_OID(1);
#endif
    int32       typmod = PG_GETARG_INT32(2);
    Node       *escontext = fcinfo->context;
    Interval   *result;
    struct pg_itm_in tt,
               *itm_in = &tt;
    int         dtype;
    int         nf;
    int         range;
    int         dterr;
    char       *field[MAXDATEFIELDS];
    int         ftype[MAXDATEFIELDS];
    char        workbuf[256];
    DateTimeErrorExtra extra;
 
    itm_in->tm_year = 0;
    itm_in->tm_mon = 0;
    itm_in->tm_mday = 0;
    itm_in->tm_usec = 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, itm_in);
 
    /* if those functions think it's a bad format, try ISO8601 style */
    if (dterr == DTERR_BAD_FORMAT)
        dterr = DecodeISO8601Interval(str,
                                      &dtype, itm_in);
 
    if (dterr != 0)
    {
        if (dterr == DTERR_FIELD_OVERFLOW)
            dterr = DTERR_INTERVAL_OVERFLOW;
        DateTimeParseError(dterr, &extra, str, "interval", escontext);
        PG_RETURN_NULL();
    }
 
    result = (Interval *) palloc(sizeof(Interval));
 
    switch (dtype)
    {
        case DTK_DELTA:
            if (itmin2interval(itm_in, result) != 0)
                ereturn(escontext, (Datum) 0,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("interval out of range")));
            break;
 
        default:
            elog(ERROR, "unexpected dtype %d while parsing interval \"%s\"",
                 dtype, str);
    }
 
    AdjustIntervalForTypmod(result, typmod, escontext);
 
    PG_RETURN_INTERVAL_P(result);
}

References AdjustIntervalForTypmod(), DateTimeParseError(), DecodeInterval(), DecodeISO8601Interval(), DTERR_BAD_FORMAT, DTERR_FIELD_OVERFLOW, DTERR_INTERVAL_OVERFLOW, DTK_DELTA, elog(), ereturn, errcode(), errmsg(), ERROR, INTERVAL_FULL_RANGE, INTERVAL_RANGE, itmin2interval(), MAXDATEFIELDS, palloc(), ParseDateTime(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_INTERVAL_P, PG_RETURN_NULL, range(), generate_unaccent_rules::str, pg_itm_in::tm_mday, pg_itm_in::tm_mon, pg_itm_in::tm_usec, and pg_itm_in::tm_year.

Referenced by check_timezone(), and flatten_set_variable_args().

interval_justify_days()

Datum interval_justify_days

(

PG_FUNCTION_ARGS

)

Definition at line 2880 of file timestamp.c.

{
    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;
    if (pg_add_s32_overflow(result->month, wholemonth, &result->month))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
 
    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);
}

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

interval_justify_hours()

Datum interval_justify_hours

(

PG_FUNCTION_ARGS

)

Definition at line 2842 of file timestamp.c.

{
    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);
    if (pg_add_s32_overflow(result->day, wholeday, &result->day))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
 
    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);
}

References Interval::day, ereport, errcode(), errmsg(), ERROR, Interval::month, palloc(), pg_add_s32_overflow(), PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, Interval::time, TMODULO, and USECS_PER_DAY.

Referenced by timestamp_mi().

interval_justify_interval()

Datum interval_justify_interval

(

PG_FUNCTION_ARGS

)

Definition at line 2766 of file timestamp.c.

{
    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;
 
    /* pre-justify days if it might prevent overflow */
    if ((result->day > 0 && result->time > 0) ||
        (result->day < 0 && result->time < 0))
    {
        wholemonth = result->day / DAYS_PER_MONTH;
        result->day -= wholemonth * DAYS_PER_MONTH;
        if (pg_add_s32_overflow(result->month, wholemonth, &result->month))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
    }
 
    /*
     * Since TimeOffset is int64, abs(wholeday) can't exceed about 1.07e8.  If
     * we pre-justified then abs(result->day) is less than DAYS_PER_MONTH, so
     * this addition can't overflow.  If we didn't pre-justify, then day and
     * time are of different signs, so it still can't overflow.
     */
    TMODULO(result->time, wholeday, USECS_PER_DAY);
    result->day += wholeday;
 
    wholemonth = result->day / DAYS_PER_MONTH;
    result->day -= wholemonth * DAYS_PER_MONTH;
    if (pg_add_s32_overflow(result->month, wholemonth, &result->month))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
 
    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);
}

References Interval::day, DAYS_PER_MONTH, ereport, errcode(), errmsg(), ERROR, Interval::month, palloc(), pg_add_s32_overflow(), PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, Interval::time, TMODULO, and USECS_PER_DAY.

interval_larger()

Datum interval_larger

(

PG_FUNCTION_ARGS

)

Definition at line 3173 of file timestamp.c.

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

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_INTERVAL_P.

interval_le()

Datum interval_le

(

PG_FUNCTION_ARGS

)

Definition at line 2477 of file timestamp.c.

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);
 
    PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) <= 0);
}

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

Referenced by gbt_intvle().

interval_lt()

Datum interval_lt

(

PG_FUNCTION_ARGS

)

Definition at line 2459 of file timestamp.c.

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);
 
    PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) < 0);
}

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

Referenced by abs_interval(), and gbt_intvlt().

interval_mi()

Datum interval_mi

(

PG_FUNCTION_ARGS

)

Definition at line 3221 of file timestamp.c.

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

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

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

interval_mul()

Datum interval_mul

(

PG_FUNCTION_ARGS

)

Definition at line 3261 of file timestamp.c.

{
    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 (fabs(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 (isnan(result_double) || !FLOAT8_FITS_IN_INT64(result_double))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
    result->time = (int64) result_double;
 
    PG_RETURN_INTERVAL_P(result);
}

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

Referenced by interval_lerp(), and mul_d_interval().

interval_ne()

Datum interval_ne

(

PG_FUNCTION_ARGS

)

Definition at line 2450 of file timestamp.c.

{
    Interval   *interval1 = PG_GETARG_INTERVAL_P(0);
    Interval   *interval2 = PG_GETARG_INTERVAL_P(1);
 
    PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) != 0);
}

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

interval_out()

Datum interval_out

(

PG_FUNCTION_ARGS

)

Definition at line 960 of file timestamp.c.

{
    Interval   *span = PG_GETARG_INTERVAL_P(0);
    char       *result;
    struct pg_itm tt,
               *itm = &tt;
    char        buf[MAXDATELEN + 1];
 
    interval2itm(*span, itm);
    EncodeInterval(itm, IntervalStyle, buf);
 
    result = pstrdup(buf);
    PG_RETURN_CSTRING(result);
}

References buf, EncodeInterval(), interval2itm(), IntervalStyle, MAXDATELEN, PG_GETARG_INTERVAL_P, PG_RETURN_CSTRING, and pstrdup().

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

interval_part()

Datum interval_part

(

PG_FUNCTION_ARGS

)

Definition at line 5402 of file timestamp.c.

{
    return interval_part_common(fcinfo, false);
}

References interval_part_common().

interval_part_common()

static Datum interval_part_common ( PG_FUNCTION_ARGS  , bool  retnumeric  )

static

Definition at line 5237 of file timestamp.c.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    Interval   *interval = PG_GETARG_INTERVAL_P(1);
    int64       intresult;
    int         type,
                val;
    char       *lowunits;
    struct pg_itm 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)
    {
        interval2itm(*interval, tm);
        switch (val)
        {
            case DTK_MICROSEC:
                intresult = tm->tm_sec * INT64CONST(1000000) + tm->tm_usec;
                break;
 
            case DTK_MILLISEC:
                if (retnumeric)
                    /*---
                     * tm->tm_sec * 1000 + fsec / 1000
                     * = (tm->tm_sec * 1'000'000 + fsec) / 1000
                     */
                    PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + tm->tm_usec, 3));
                else
                    PG_RETURN_FLOAT8(tm->tm_sec * 1000.0 + tm->tm_usec / 1000.0);
                break;
 
            case DTK_SECOND:
                if (retnumeric)
                    /*---
                     * tm->tm_sec + fsec / 1'000'000
                     * = (tm->tm_sec * 1'000'000 + fsec) / 1'000'000
                     */
                    PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + tm->tm_usec, 6));
                else
                    PG_RETURN_FLOAT8(tm->tm_sec + tm->tm_usec / 1000000.0);
                break;
 
            case DTK_MINUTE:
                intresult = tm->tm_min;
                break;
 
            case DTK_HOUR:
                intresult = tm->tm_hour;
                break;
 
            case DTK_DAY:
                intresult = tm->tm_mday;
                break;
 
            case DTK_MONTH:
                intresult = tm->tm_mon;
                break;
 
            case DTK_QUARTER:
                intresult = (tm->tm_mon / 3) + 1;
                break;
 
            case DTK_YEAR:
                intresult = tm->tm_year;
                break;
 
            case DTK_DECADE:
                /* caution: C division may have negative remainder */
                intresult = tm->tm_year / 10;
                break;
 
            case DTK_CENTURY:
                /* caution: C division may have negative remainder */
                intresult = tm->tm_year / 100;
                break;
 
            case DTK_MILLENNIUM:
                /* caution: C division may have negative remainder */
                intresult = tm->tm_year / 1000;
                break;
 
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("unit \"%s\" not supported for type %s",
                                lowunits, format_type_be(INTERVALOID))));
                intresult = 0;
        }
    }
    else if (type == RESERV && val == DTK_EPOCH)
    {
        if (retnumeric)
        {
            Numeric     result;
            int64       secs_from_day_month;
            int64       val;
 
            /*
             * To do this calculation in integer arithmetic even though
             * DAYS_PER_YEAR is fractional, multiply everything by 4 and then
             * divide by 4 again at the end.  This relies on DAYS_PER_YEAR
             * being a multiple of 0.25 and on SECS_PER_DAY being a multiple
             * of 4.
             */
            secs_from_day_month = ((int64) (4 * DAYS_PER_YEAR) * (interval->month / MONTHS_PER_YEAR) +
                                   (int64) (4 * DAYS_PER_MONTH) * (interval->month % MONTHS_PER_YEAR) +
                                   (int64) 4 * interval->day) * (SECS_PER_DAY / 4);
 
            /*---
             * result = secs_from_day_month + interval->time / 1'000'000
             * = (secs_from_day_month * 1'000'000 + interval->time) / 1'000'000
             */
 
            /*
             * Try the computation inside int64; if it overflows, do it in
             * numeric (slower).  This overflow happens around 10^9 days, so
             * not common in practice.
             */
            if (!pg_mul_s64_overflow(secs_from_day_month, 1000000, &val) &&
                !pg_add_s64_overflow(val, interval->time, &val))
                result = int64_div_fast_to_numeric(val, 6);
            else
                result =
                    numeric_add_opt_error(int64_div_fast_to_numeric(interval->time, 6),
                                          int64_to_numeric(secs_from_day_month),
                                          NULL);
 
            PG_RETURN_NUMERIC(result);
        }
        else
        {
            float8      result;
 
            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;
 
            PG_RETURN_FLOAT8(result);
        }
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unit \"%s\" not recognized for type %s",
                        lowunits, format_type_be(INTERVALOID))));
        intresult = 0;
    }
 
    if (retnumeric)
        PG_RETURN_NUMERIC(int64_to_numeric(intresult));
    else
        PG_RETURN_FLOAT8(intresult);
}

References 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, ereport, errcode(), errmsg(), ERROR, format_type_be(), int64_div_fast_to_numeric(), int64_to_numeric(), interval2itm(), interval::month, MONTHS_PER_YEAR, numeric_add_opt_error(), pg_add_s64_overflow(), PG_GETARG_INTERVAL_P, PG_GETARG_TEXT_PP, pg_mul_s64_overflow(), PG_RETURN_FLOAT8, PG_RETURN_NUMERIC, RESERV, 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, generate_unaccent_rules::type, UNITS, UNKNOWN_FIELD, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by extract_interval(), and interval_part().

interval_pl()

Datum interval_pl

(

PG_FUNCTION_ARGS

)

Definition at line 3187 of file timestamp.c.

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

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

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

interval_recv()

Datum interval_recv

(

PG_FUNCTION_ARGS

)

Definition at line 979 of file timestamp.c.

{
    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, NULL);
 
    PG_RETURN_INTERVAL_P(interval);
}

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

interval_scale()

Datum interval_scale

(

PG_FUNCTION_ARGS

)

Definition at line 1310 of file timestamp.c.

{
    Interval   *interval = PG_GETARG_INTERVAL_P(0);
    int32       typmod = PG_GETARG_INT32(1);
    Interval   *result;
 
    result = palloc(sizeof(Interval));
    *result = *interval;
 
    AdjustIntervalForTypmod(result, typmod, NULL);
 
    PG_RETURN_INTERVAL_P(result);
}

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

interval_send()

Datum interval_send

(

PG_FUNCTION_ARGS

)

Definition at line 1004 of file timestamp.c.

{
    Interval   *interval = PG_GETARG_INTERVAL_P(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendint64(&buf, interval->time);
    pq_sendint32(&buf, interval->day);
    pq_sendint32(&buf, interval->month);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, interval::month, PG_GETARG_INTERVAL_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint32(), pq_sendint64(), and interval::time.

interval_smaller()

Datum interval_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 3158 of file timestamp.c.

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

References interval_cmp_internal(), PG_GETARG_INTERVAL_P, and PG_RETURN_INTERVAL_P.

interval_support()

Datum interval_support

(

PG_FUNCTION_ARGS

)

Definition at line 1247 of file timestamp.c.

{
    Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
    Node       *ret = NULL;
 
    if (IsA(rawreq, SupportRequestSimplify))
    {
        SupportRequestSimplify *req = (SupportRequestSimplify *) rawreq;
        FuncExpr   *expr = req->fcall;
        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);
}

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

interval_trunc()

Datum interval_trunc

(

PG_FUNCTION_ARGS

)

Definition at line 4361 of file timestamp.c.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    Interval   *interval = PG_GETARG_INTERVAL_P(1);
    Interval   *result;
    int         type,
                val;
    char       *lowunits;
    struct pg_itm 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)
    {
        interval2itm(*interval, tm);
        switch (val)
        {
            case DTK_MILLENNIUM:
                /* caution: C division may have negative remainder */
                tm->tm_year = (tm->tm_year / 1000) * 1000;
                /* FALL THRU */
            case DTK_CENTURY:
                /* caution: C division may have negative remainder */
                tm->tm_year = (tm->tm_year / 100) * 100;
                /* FALL THRU */
            case DTK_DECADE:
                /* caution: C division may have negative remainder */
                tm->tm_year = (tm->tm_year / 10) * 10;
                /* FALL THRU */
            case DTK_YEAR:
                tm->tm_mon = 0;
                /* FALL THRU */
            case DTK_QUARTER:
                tm->tm_mon = 3 * (tm->tm_mon / 3);
                /* FALL THRU */
            case DTK_MONTH:
                tm->tm_mday = 0;
                /* FALL THRU */
            case DTK_DAY:
                tm->tm_hour = 0;
                /* FALL THRU */
            case DTK_HOUR:
                tm->tm_min = 0;
                /* FALL THRU */
            case DTK_MINUTE:
                tm->tm_sec = 0;
                /* FALL THRU */
            case DTK_SECOND:
                tm->tm_usec = 0;
                break;
            case DTK_MILLISEC:
                tm->tm_usec = (tm->tm_usec / 1000) * 1000;
                break;
            case DTK_MICROSEC:
                break;
 
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("unit \"%s\" not supported for type %s",
                                lowunits, format_type_be(INTERVALOID)),
                         (val == DTK_WEEK) ? errdetail("Months usually have fractional weeks.") : 0));
        }
 
        if (itm2interval(tm, result) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unit \"%s\" not recognized for type %s",
                        lowunits, format_type_be(INTERVALOID))));
    }
 
    PG_RETURN_INTERVAL_P(result);
}

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, ereport, errcode(), errdetail(), errmsg(), ERROR, format_type_be(), interval2itm(), itm2interval(), palloc(), PG_GETARG_INTERVAL_P, PG_GETARG_TEXT_PP, PG_RETURN_INTERVAL_P, 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, generate_unaccent_rules::type, UNITS, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

interval_um()

Datum interval_um

(

PG_FUNCTION_ARGS

)

Definition at line 3129 of file timestamp.c.

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

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

Referenced by abs_interval().

intervaltypmodin()

Datum intervaltypmodin

(

PG_FUNCTION_ARGS

)

Definition at line 1029 of file timestamp.c.

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

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.

intervaltypmodleastfield()

static int intervaltypmodleastfield ( int32  typmod )

static

Definition at line 1194 of file timestamp.c.

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

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

Referenced by interval_support().

intervaltypmodout()

Datum intervaltypmodout

(

PG_FUNCTION_ARGS

)

Definition at line 1108 of file timestamp.c.

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

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, res, SECOND, snprintf, and YEAR.

isoweek2date()

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

Definition at line 4474 of file timestamp.c.

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

References isoweek2j(), and j2date().

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

isoweek2j()

int isoweek2j	(	int	year,
		int	week
	)

Definition at line 4454 of file timestamp.c.

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

References date2j(), and j2day().

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

isoweekdate2date()

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

Definition at line 4487 of file timestamp.c.

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

References isoweek2j(), and j2date().

Referenced by do_to_timestamp().

itm2interval()

int itm2interval	(	struct pg_itm *	itm,
		Interval *	span
	)

Definition at line 2015 of file timestamp.c.

{
    int64       total_months = (int64) itm->tm_year * MONTHS_PER_YEAR + itm->tm_mon;
 
    if (total_months > INT_MAX || total_months < INT_MIN)
        return -1;
    span->month = (int32) total_months;
    span->day = itm->tm_mday;
    if (pg_mul_s64_overflow(itm->tm_hour, USECS_PER_HOUR,
                            &span->time))
        return -1;
    /* tm_min, tm_sec are 32 bits, so intermediate products can't overflow */
    if (pg_add_s64_overflow(span->time, itm->tm_min * USECS_PER_MINUTE,
                            &span->time))
        return -1;
    if (pg_add_s64_overflow(span->time, itm->tm_sec * USECS_PER_SEC,
                            &span->time))
        return -1;
    if (pg_add_s64_overflow(span->time, itm->tm_usec,
                            &span->time))
        return -1;
    return 0;
}

References Interval::day, if(), Interval::month, MONTHS_PER_YEAR, pg_add_s64_overflow(), pg_mul_s64_overflow(), Interval::time, pg_itm::tm_hour, pg_itm::tm_mday, pg_itm::tm_min, pg_itm::tm_mon, pg_itm::tm_sec, pg_itm::tm_usec, pg_itm::tm_year, USECS_PER_HOUR, USECS_PER_MINUTE, and USECS_PER_SEC.

Referenced by interval_trunc(), timestamp_age(), and timestamptz_age().

itmin2interval()

int itmin2interval	(	struct pg_itm_in *	itm_in,
		Interval *	span
	)

Definition at line 2044 of file timestamp.c.

{
    int64       total_months = (int64) itm_in->tm_year * MONTHS_PER_YEAR + itm_in->tm_mon;
 
    if (total_months > INT_MAX || total_months < INT_MIN)
        return -1;
    span->month = (int32) total_months;
    span->day = itm_in->tm_mday;
    span->time = itm_in->tm_usec;
    return 0;
}

References Interval::day, if(), Interval::month, MONTHS_PER_YEAR, Interval::time, pg_itm_in::tm_mday, pg_itm_in::tm_mon, pg_itm_in::tm_usec, and pg_itm_in::tm_year.

Referenced by interval_in(), and pg_timezone_abbrevs().

make_interval()

Datum make_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1502 of file timestamp.c.

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

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

make_timestamp()

Datum make_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 640 of file timestamp.c.

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

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

make_timestamp_internal()

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

static

Definition at line 558 of file timestamp.c.

{
    struct pg_tm tm;
    TimeOffset  date;
    TimeOffset  time;
    int         dterr;
    bool        bc = false;
    Timestamp   result;
 
    tm.tm_year = year;
    tm.tm_mon = month;
    tm.tm_mday = day;
 
    /* Handle negative years as BC */
    if (tm.tm_year < 0)
    {
        bc = true;
        tm.tm_year = -tm.tm_year;
    }
 
    dterr = ValidateDate(DTK_DATE_M, false, false, bc, &tm);
 
    if (dterr != 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_FIELD_OVERFLOW),
                 errmsg("date field value out of range: %d-%02d-%02d",
                        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;
 
    /* Check for time overflow */
    if (float_time_overflows(hour, min, sec))
        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) + (int64) 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;
}

References date2j(), DTK_DATE_M, ereport, errcode(), errmsg(), ERROR, float_time_overflows(), IS_VALID_JULIAN, IS_VALID_TIMESTAMP, MINS_PER_HOUR, POSTGRES_EPOCH_JDATE, SECS_PER_MINUTE, tm, 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().

make_timestamptz()

Datum make_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 660 of file timestamp.c.

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

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

make_timestamptz_at_timezone()

Datum make_timestamptz_at_timezone

(

PG_FUNCTION_ARGS

)

Definition at line 681 of file timestamp.c.

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

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

mul_d_interval()

Datum mul_d_interval

(

PG_FUNCTION_ARGS

)

Definition at line 3338 of file timestamp.c.

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

References DirectFunctionCall2, interval_mul(), and PG_GETARG_DATUM.

NonFiniteTimestampTzPart()

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

static

Definition at line 4634 of file timestamp.c.

{
    if ((type != UNITS) && (type != RESERV))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unit \"%s\" not recognized for type %s",
                        lowunits,
                        format_type_be(isTz ? TIMESTAMPTZOID : TIMESTAMPOID))));
 
    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:
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("unit \"%s\" not supported for type %s",
                            lowunits,
                            format_type_be(isTz ? TIMESTAMPTZOID : TIMESTAMPOID))));
            return 0.0;         /* keep compiler quiet */
    }
}

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, format_type_be(), get_float8_infinity(), RESERV, generate_unaccent_rules::type, and UNITS.

Referenced by timestamp_part_common(), and timestamptz_part_common().

now()

Datum now

(

PG_FUNCTION_ARGS

)

Definition at line 1549 of file timestamp.c.

{
    PG_RETURN_TIMESTAMPTZ(GetCurrentTransactionStartTimestamp());
}

References GetCurrentTransactionStartTimestamp(), and PG_RETURN_TIMESTAMPTZ.

Referenced by advanceConnectionState(), ApplyLauncherMain(), BackgroundWriterMain(), bbsink_copystream_archive_contents(), CalculateCopyStreamSleeptime(), CheckArchiveTimeout(), CheckpointerMain(), doLog(), doRetry(), drandom(), dumpTimestamp(), enable_timeout(), enable_timeout_after(), enable_timeout_at(), enable_timeout_every(), enable_timeouts(), executeMetaCommand(), flushAndSendFeedback(), GetSnapshotCurrentTimestamp(), handle_sig_alarm(), HandleCopyStream(), has_startup_progress_timeout_expired(), IsCheckpointOnSchedule(), LagTrackerRead(), launch_worker(), LockBufferForCleanup(), logicalrep_worker_launch(), LogicalRepApplyLoop(), LogRecoveryConflict(), maybe_start_bgworkers(), mxid_age(), OutputFsync(), PerformRadiusTransaction(), pg_time_now(), pg_time_now_lazy(), pg_timezone_abbrevs(), pgfdw_get_cleanup_result(), pgstat_report_archiver(), pgstat_report_stat(), pqSocketPoll(), pqTraceFormatTimestamp(), printProgressReport(), printVerboseErrorMessages(), process_syncing_tables_for_apply(), ProcessKeepaliveMsg(), ProcessStandbyReplyMessage(), processXactStats(), ProcSleep(), progress_report(), RequestXLogStreaming(), ResolveRecoveryConflictWithLock(), ResolveRecoveryConflictWithVirtualXIDs(), schedule_alarm(), send_feedback(), sendFeedback(), ServerLoop(), set_next_rotation_time(), StreamLogicalLog(), SysLoggerMain(), threadRun(), timetz_zone(), WaitForWALToBecomeAvailable(), WalRcvComputeNextWakeup(), WalRcvRunning(), WalRcvStreaming(), WalReceiverMain(), WalSndComputeSleeptime(), WalSndUpdateProgress(), WalSndWriteData(), xid_age(), XLogBackgroundFlush(), XLogWalRcvSendHSFeedback(), and XLogWalRcvSendReply().

overlaps_timestamp()

Datum overlaps_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 2549 of file timestamp.c.

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

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

parse_sane_timezone()

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

static

Definition at line 471 of file timestamp.c.

{
    char        tzname[TZ_STRLEN_MAX + 1];
    int         dterr;
    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 type %s: \"%s\"",
                        "numeric time zone", tzname),
                 errhint("Numeric time zones must have \"-\" or \"+\" as first character.")));
 
    dterr = DecodeTimezone(tzname, &tz);
    if (dterr != 0)
    {
        char       *lowzone;
        int         type,
                    val;
        pg_tz      *tzp;
        DateTimeErrorExtra extra;
 
        if (dterr == DTERR_TZDISP_OVERFLOW)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("numeric time zone \"%s\" out of range", tzname)));
        else if (dterr != 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);
        dterr = DecodeTimezoneAbbrev(0, lowzone, &type, &val, &tzp, &extra);
        if (dterr)
            DateTimeParseError(dterr, &extra, NULL, NULL, NULL);
 
        if (type == TZ || type == DTZ)
        {
            /* fixed-offset abbreviation */
            tz = -val;
        }
        else if (type == DYNTZ)
        {
            /* dynamic-offset abbreviation, resolve using 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;
}

References DateTimeParseError(), 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(), tm, generate_unaccent_rules::type, TZ, TZ_STRLEN_MAX, and val.

Referenced by make_timestamptz_at_timezone().

pg_conf_load_time()

Datum pg_conf_load_time

(

PG_FUNCTION_ARGS

)

Definition at line 1573 of file timestamp.c.

{
    PG_RETURN_TIMESTAMPTZ(PgReloadTime);
}

References PG_RETURN_TIMESTAMPTZ, and PgReloadTime.

pg_postmaster_start_time()

Datum pg_postmaster_start_time

(

PG_FUNCTION_ARGS

)

Definition at line 1567 of file timestamp.c.

{
    PG_RETURN_TIMESTAMPTZ(PgStartTime);
}

References PG_RETURN_TIMESTAMPTZ, and PgStartTime.

SetEpochTimestamp()

Timestamp SetEpochTimestamp

(

void

)

Definition at line 2117 of file timestamp.c.

{
    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() */

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

Referenced by dttofmtasc_replace(), PGTYPEStimestamp_from_asc(), timestamp_in(), timestamp_part_common(), timestamptz_in(), and timestamptz_part_common().

sql_localtimestamp()

Datum sql_localtimestamp

(

PG_FUNCTION_ARGS

)

Definition at line 1624 of file timestamp.c.

{
    Timestamp   ts;
    int32       typmod = -1;
 
    if (!PG_ARGISNULL(0))
    {
        typmod = PG_GETARG_INT32(0);
        anytimestamp_typmod_check(false, typmod);
    }
 
    ts = timestamptz2timestamp(GetCurrentTransactionStartTimestamp());
    if (typmod >= 0)
        AdjustTimestampForTypmod(&ts, typmod, NULL);
    return TimestampGetDatum(ts);
}

References AdjustTimestampForTypmod(), anytimestamp_typmod_check(), GetCurrentTransactionStartTimestamp(), PG_ARGISNULL, PG_GETARG_INT32, TimestampGetDatum(), and timestamptz2timestamp().

statement_timestamp()

Datum statement_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 1555 of file timestamp.c.

{
    PG_RETURN_TIMESTAMPTZ(GetCurrentStatementStartTimestamp());
}

References GetCurrentStatementStartTimestamp(), and PG_RETURN_TIMESTAMPTZ.

time2t()

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

static

Definition at line 2057 of file timestamp.c.

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

References MINS_PER_HOUR, SECS_PER_MINUTE, and USECS_PER_SEC.

Referenced by tm2timestamp().

time_t_to_timestamptz()

TimestampTz time_t_to_timestamptz

(

pg_time_t

tm

)

Definition at line 1752 of file timestamp.c.

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

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

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

timeofday()

Datum timeofday

(

PG_FUNCTION_ARGS

)

Definition at line 1646 of file timestamp.c.

{
    struct timeval tp;
    char        templ[128];
    char        buf[128];
    pg_time_t   tt;
 
    gettimeofday(&tp, NULL);
    tt = (pg_time_t) tp.tv_sec;
    pg_strftime(templ, sizeof(templ), "%a %b %d %H:%M:%S.%%06d %Y %Z",
                pg_localtime(&tt, session_timezone));
    snprintf(buf, sizeof(buf), templ, tp.tv_usec);
 
    PG_RETURN_TEXT_P(cstring_to_text(buf));
}

References buf, cstring_to_text(), gettimeofday(), pg_localtime(), PG_RETURN_TEXT_P, pg_strftime(), session_timezone, and snprintf.

timestamp2timestamptz()

static TimestampTz timestamp2timestamptz ( Timestamp  timestamp )

static

Definition at line 5635 of file timestamp.c.

{
    return timestamp2timestamptz_opt_overflow(timestamp, NULL);
}

References timestamp2timestamptz_opt_overflow().

Referenced by make_timestamptz(), and timestamp_timestamptz().

timestamp2timestamptz_opt_overflow()

TimestampTz timestamp2timestamptz_opt_overflow	(	Timestamp	timestamp,
		int *	overflow
	)

Definition at line 5583 of file timestamp.c.

{
    TimestampTz result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    int         tz;
 
    if (overflow)
        *overflow = 0;
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
        return timestamp;
 
    /* We don't expect this to fail, but check it pro forma */
    if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) == 0)
    {
        tz = DetermineTimeZoneOffset(tm, session_timezone);
 
        result = dt2local(timestamp, -tz);
 
        if (IS_VALID_TIMESTAMP(result))
        {
            return result;
        }
        else if (overflow)
        {
            if (result < MIN_TIMESTAMP)
            {
                *overflow = -1;
                TIMESTAMP_NOBEGIN(result);
            }
            else
            {
                *overflow = 1;
                TIMESTAMP_NOEND(result);
            }
            return result;
        }
    }
 
    ereport(ERROR,
            (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
             errmsg("timestamp out of range")));
 
    return 0;
}

References DetermineTimeZoneOffset(), dt2local(), ereport, errcode(), errmsg(), ERROR, IS_VALID_TIMESTAMP, MIN_TIMESTAMP, session_timezone, timestamp2tm(), TIMESTAMP_NOBEGIN, TIMESTAMP_NOEND, TIMESTAMP_NOT_FINITE, and tm.

Referenced by timestamp2timestamptz(), and timestamp_cmp_timestamptz_internal().

timestamp2tm()

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

Definition at line 1842 of file timestamp.c.

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

References dt2time(), j2date(), pg_localtime(), POSTGRES_EPOCH_JDATE, SECS_PER_DAY, session_timezone, tm, 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 DetermineTimeZoneAbbrevOffsetTS(), GetCurrentTimeUsec(), JsonEncodeDateTime(), make_timestamptz_at_timezone(), map_sql_value_to_xml_value(), PGTYPEStimestamp_add_interval(), PGTYPEStimestamp_fmt_asc(), PGTYPEStimestamp_to_asc(), timestamp2timestamptz_opt_overflow(), timestamp_age(), timestamp_date(), timestamp_out(), timestamp_part_common(), timestamp_pl_interval(), timestamp_recv(), timestamp_time(), timestamp_to_char(), timestamp_trunc(), timestamp_zone(), timestamptz2timestamp(), timestamptz_age(), timestamptz_date(), timestamptz_out(), timestamptz_part_common(), timestamptz_pl_interval(), timestamptz_recv(), timestamptz_time(), timestamptz_timetz(), timestamptz_to_char(), timestamptz_to_str(), timestamptz_trunc_internal(), timestamptz_zone(), and timetz_zone().

timestamp_age()

Datum timestamp_age

(

PG_FUNCTION_ARGS

)

Definition at line 3657 of file timestamp.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
    Interval   *result;
    fsec_t      fsec1,
                fsec2;
    struct pg_itm 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 */
        tm->tm_usec = 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)
        {
            tm->tm_usec = -tm->tm_usec;
            tm->tm_sec = -tm->tm_sec;
            tm->tm_min = -tm->tm_min;
            tm->tm_hour = -tm->tm_hour;
            tm->tm_mday = -tm->tm_mday;
            tm->tm_mon = -tm->tm_mon;
            tm->tm_year = -tm->tm_year;
        }
 
        /* propagate any negative fields into the next higher field */
        while (tm->tm_usec < 0)
        {
            tm->tm_usec += USECS_PER_SEC;
            tm->tm_sec--;
        }
 
        while (tm->tm_sec < 0)
        {
            tm->tm_sec += SECS_PER_MINUTE;
            tm->tm_min--;
        }
 
        while (tm->tm_min < 0)
        {
            tm->tm_min += MINS_PER_HOUR;
            tm->tm_hour--;
        }
 
        while (tm->tm_hour < 0)
        {
            tm->tm_hour += HOURS_PER_DAY;
            tm->tm_mday--;
        }
 
        while (tm->tm_mday < 0)
        {
            if (dt1 < dt2)
            {
                tm->tm_mday += day_tab[isleap(tm1->tm_year)][tm1->tm_mon - 1];
                tm->tm_mon--;
            }
            else
            {
                tm->tm_mday += day_tab[isleap(tm2->tm_year)][tm2->tm_mon - 1];
                tm->tm_mon--;
            }
        }
 
        while (tm->tm_mon < 0)
        {
            tm->tm_mon += MONTHS_PER_YEAR;
            tm->tm_year--;
        }
 
        /* recover sign if necessary... */
        if (dt1 < dt2)
        {
            tm->tm_usec = -tm->tm_usec;
            tm->tm_sec = -tm->tm_sec;
            tm->tm_min = -tm->tm_min;
            tm->tm_hour = -tm->tm_hour;
            tm->tm_mday = -tm->tm_mday;
            tm->tm_mon = -tm->tm_mon;
            tm->tm_year = -tm->tm_year;
        }
 
        if (itm2interval(tm, result) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
    }
    else
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    PG_RETURN_INTERVAL_P(result);
}

References day_tab, ereport, errcode(), errmsg(), ERROR, HOURS_PER_DAY, isleap, itm2interval(), MINS_PER_HOUR, MONTHS_PER_YEAR, palloc(), PG_GETARG_TIMESTAMP, PG_RETURN_INTERVAL_P, SECS_PER_MINUTE, timestamp2tm(), tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, and USECS_PER_SEC.

timestamp_bin()

Datum timestamp_bin

(

PG_FUNCTION_ARGS

)

Definition at line 3901 of file timestamp.c.

{
    Interval   *stride = PG_GETARG_INTERVAL_P(0);
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(1);
    Timestamp   origin = PG_GETARG_TIMESTAMP(2);
    Timestamp   result,
                tm_diff,
                stride_usecs,
                tm_delta;
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
        PG_RETURN_TIMESTAMP(timestamp);
 
    if (TIMESTAMP_NOT_FINITE(origin))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("origin out of range")));
 
    if (stride->month != 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("timestamps cannot be binned into intervals containing months or years")));
 
    stride_usecs = stride->day * USECS_PER_DAY + stride->time;
 
    if (stride_usecs <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("stride must be greater than zero")));
 
    tm_diff = timestamp - origin;
    tm_delta = tm_diff - tm_diff % stride_usecs;
 
    /*
     * Make sure the returned timestamp is at the start of the bin, even if
     * the origin is in the future.
     */
    if (origin > timestamp && stride_usecs > 1)
        tm_delta -= stride_usecs;
 
    result = origin + tm_delta;
 
    PG_RETURN_TIMESTAMP(result);
}

References Interval::day, ereport, errcode(), errmsg(), ERROR, Interval::month, PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMP, PG_RETURN_TIMESTAMP, Interval::time, TIMESTAMP_NOT_FINITE, and USECS_PER_DAY.

timestamp_cmp()

Datum timestamp_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 2197 of file timestamp.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
 
    PG_RETURN_INT32(timestamp_cmp_internal(dt1, dt2));
}

References PG_GETARG_TIMESTAMP, PG_RETURN_INT32, and timestamp_cmp_internal().

Referenced by compareDatetime(), and gbt_tskey_cmp().

timestamp_cmp_internal()

int timestamp_cmp_internal	(	Timestamp	dt1,
		Timestamp	dt2
	)

Definition at line 2137 of file timestamp.c.

{
    return (dt1 < dt2) ? -1 : ((dt1 > dt2) ? 1 : 0);
}

Referenced by date_cmp_timestamp_internal(), generate_series_timestamp(), generate_series_timestamptz(), timestamp_cmp(), timestamp_eq(), timestamp_fastcmp(), timestamp_ge(), timestamp_gt(), timestamp_larger(), timestamp_le(), timestamp_lt(), timestamp_ne(), and timestamp_smaller().

timestamp_cmp_timestamptz()

Datum timestamp_cmp_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 2327 of file timestamp.c.

{
    Timestamp   timestampVal = PG_GETARG_TIMESTAMP(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
 
    PG_RETURN_INT32(timestamp_cmp_timestamptz_internal(timestampVal, dt2));
}

References PG_GETARG_TIMESTAMP, PG_GETARG_TIMESTAMPTZ, PG_RETURN_INT32, and timestamp_cmp_timestamptz_internal().

timestamp_cmp_timestamptz_internal()

int32 timestamp_cmp_timestamptz_internal	(	Timestamp	timestampVal,
		TimestampTz	dt2
	)

Definition at line 2252 of file timestamp.c.

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

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

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

timestamp_eq()

Datum timestamp_eq

(

PG_FUNCTION_ARGS

)

Definition at line 2143 of file timestamp.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
 
    PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) == 0);
}

References PG_GETARG_TIMESTAMP, PG_RETURN_BOOL, and timestamp_cmp_internal().

Referenced by gbt_tseq().

timestamp_eq_timestamptz()

Datum timestamp_eq_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 2273 of file timestamp.c.

{
    Timestamp   timestampVal = PG_GETARG_TIMESTAMP(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
 
    PG_RETURN_BOOL(timestamp_cmp_timestamptz_internal(timestampVal, dt2) == 0);
}

References PG_GETARG_TIMESTAMP, PG_GETARG_TIMESTAMPTZ, PG_RETURN_BOOL, and timestamp_cmp_timestamptz_internal().

timestamp_fastcmp()

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

static

Definition at line 2208 of file timestamp.c.

{
    Timestamp   a = DatumGetTimestamp(x);
    Timestamp   b = DatumGetTimestamp(y);
 
    return timestamp_cmp_internal(a, b);
}

References a, b, DatumGetTimestamp(), timestamp_cmp_internal(), x, and y.

Referenced by timestamp_sortsupport().

timestamp_finite()

Datum timestamp_finite

(

PG_FUNCTION_ARGS

)

Definition at line 2076 of file timestamp.c.

{
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(0);
 
    PG_RETURN_BOOL(!TIMESTAMP_NOT_FINITE(timestamp));
}

References PG_GETARG_TIMESTAMP, PG_RETURN_BOOL, and TIMESTAMP_NOT_FINITE.

timestamp_ge()

Datum timestamp_ge

(

PG_FUNCTION_ARGS

)

Definition at line 2188 of file timestamp.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
 
    PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) >= 0);
}

References PG_GETARG_TIMESTAMP, PG_RETURN_BOOL, and timestamp_cmp_internal().

Referenced by gbt_tsge().

timestamp_ge_timestamptz()

Datum timestamp_ge_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 2318 of file timestamp.c.

{
    Timestamp   timestampVal = PG_GETARG_TIMESTAMP(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
 
    PG_RETURN_BOOL(timestamp_cmp_timestamptz_internal(timestampVal, dt2) >= 0);
}

References PG_GETARG_TIMESTAMP, PG_GETARG_TIMESTAMPTZ, PG_RETURN_BOOL, and timestamp_cmp_timestamptz_internal().

timestamp_gt()

Datum timestamp_gt

(

PG_FUNCTION_ARGS

)

Definition at line 2170 of file timestamp.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
 
    PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) > 0);
}

References PG_GETARG_TIMESTAMP, PG_RETURN_BOOL, and timestamp_cmp_internal().

Referenced by gbt_tsgt().

timestamp_gt_timestamptz()

Datum timestamp_gt_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 2300 of file timestamp.c.

{
    Timestamp   timestampVal = PG_GETARG_TIMESTAMP(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
 
    PG_RETURN_BOOL(timestamp_cmp_timestamptz_internal(timestampVal, dt2) > 0);
}

References PG_GETARG_TIMESTAMP, PG_GETARG_TIMESTAMPTZ, PG_RETURN_BOOL, and timestamp_cmp_timestamptz_internal().

timestamp_hash()

Datum timestamp_hash

(

PG_FUNCTION_ARGS

)

Definition at line 2236 of file timestamp.c.

{
    return hashint8(fcinfo);
}

References hashint8().

timestamp_hash_extended()

Datum timestamp_hash_extended

(

PG_FUNCTION_ARGS

)

Definition at line 2242 of file timestamp.c.

{
    return hashint8extended(fcinfo);
}

References hashint8extended().

timestamp_in()

Datum timestamp_in

(

PG_FUNCTION_ARGS

)

Definition at line 146 of file timestamp.c.

{
    char       *str = PG_GETARG_CSTRING(0);
#ifdef NOT_USED
    Oid         typelem = PG_GETARG_OID(1);
#endif
    int32       typmod = PG_GETARG_INT32(2);
    Node       *escontext = fcinfo->context;
    Timestamp   result;
    fsec_t      fsec;
    struct pg_tm tt,
               *tm = &tt;
    int         tz;
    int         dtype;
    int         nf;
    int         dterr;
    char       *field[MAXDATEFIELDS];
    int         ftype[MAXDATEFIELDS];
    char        workbuf[MAXDATELEN + MAXDATEFIELDS];
    DateTimeErrorExtra extra;
 
    dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
                          field, ftype, MAXDATEFIELDS, &nf);
    if (dterr == 0)
        dterr = DecodeDateTime(field, ftype, nf,
                               &dtype, tm, &fsec, &tz, &extra);
    if (dterr != 0)
    {
        DateTimeParseError(dterr, &extra, str, "timestamp", escontext);
        PG_RETURN_NULL();
    }
 
    switch (dtype)
    {
        case DTK_DATE:
            if (tm2timestamp(tm, fsec, NULL, &result) != 0)
                ereturn(escontext, (Datum) 0,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range: \"%s\"", str)));
            break;
 
        case DTK_EPOCH:
            result = SetEpochTimestamp();
            break;
 
        case DTK_LATE:
            TIMESTAMP_NOEND(result);
            break;
 
        case DTK_EARLY:
            TIMESTAMP_NOBEGIN(result);
            break;
 
        default:
            elog(ERROR, "unexpected dtype %d while parsing timestamp \"%s\"",
                 dtype, str);
            TIMESTAMP_NOEND(result);
    }
 
    AdjustTimestampForTypmod(&result, typmod, escontext);
 
    PG_RETURN_TIMESTAMP(result);
}

References AdjustTimestampForTypmod(), DateTimeParseError(), DecodeDateTime(), DTK_DATE, DTK_EARLY, DTK_EPOCH, DTK_LATE, elog(), ereturn, errcode(), errmsg(), ERROR, MAXDATEFIELDS, MAXDATELEN, ParseDateTime(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TIMESTAMP, SetEpochTimestamp(), generate_unaccent_rules::str, TIMESTAMP_NOBEGIN, TIMESTAMP_NOEND, tm, and tm2timestamp().

Referenced by moddatetime().

timestamp_izone()

Datum timestamp_izone

(

PG_FUNCTION_ARGS

)

Definition at line 5515 of file timestamp.c.

{
    Interval   *zone = PG_GETARG_INTERVAL_P(0);
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(1);
    TimestampTz result;
    int         tz;
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
        PG_RETURN_TIMESTAMPTZ(timestamp);
 
    if (zone->month != 0 || zone->day != 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("interval time zone \"%s\" must not include months or days",
                        DatumGetCString(DirectFunctionCall1(interval_out,
                                                            PointerGetDatum(zone))))));
 
    tz = zone->time / USECS_PER_SEC;
 
    result = 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);
}                               /* timestamp_izone() */

References DatumGetCString(), DirectFunctionCall1, dt2local(), ereport, errcode(), errmsg(), ERROR, interval_out(), IS_VALID_TIMESTAMP, PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMP, PG_RETURN_TIMESTAMPTZ, PointerGetDatum(), TIMESTAMP_NOT_FINITE, and USECS_PER_SEC.