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/nodeFuncs.h"
#include "nodes/supportnodes.h"
#include "optimizer/optimizer.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/skipsupport.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
struct	IntervalAggState

Macros
#define	SAMESIGN(a, b)   (((a) < 0) == ((b) < 0))
#define	IA_TOTAL_COUNT(ia)    ((ia)->N + (ia)->pInfcount + (ia)->nInfcount)
#define	TIMESTAMP_GT(t1, t2)    DatumGetBool(DirectFunctionCall2(timestamp_gt,t1,t2))
#define	TIMESTAMP_LT(t1, t2)    DatumGetBool(DirectFunctionCall2(timestamp_lt,t1,t2))
#define	INTERVAL_TO_MICROSECONDS(i)   ((((double) (i)->month * DAYS_PER_MONTH + (i)->day)) * USECS_PER_DAY + (i)->time)

Typedefs
typedef struct IntervalAggState	IntervalAggState

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 void	EncodeSpecialInterval (const Interval *interval, char *str)
static void	interval_um_internal (const Interval *interval, Interval *result)
static int32	anytimestamp_typmodin (bool istz, ArrayType *ta)
int32	anytimestamp_typmod_check (bool istz, int32 typmod)
static char *	anytimestamp_typmodout (bool istz, int32 typmod)
Datum	timestamp_in (PG_FUNCTION_ARGS)
Datum	timestamp_out (PG_FUNCTION_ARGS)
Datum	timestamp_recv (PG_FUNCTION_ARGS)
Datum	timestamp_send (PG_FUNCTION_ARGS)
Datum	timestamptypmodin (PG_FUNCTION_ARGS)
Datum	timestamptypmodout (PG_FUNCTION_ARGS)
Datum	timestamp_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 pg_tz *	lookup_timezone (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)
TimestampTz	GetSQLCurrentTimestamp (int32 typmod)
Timestamp	GetSQLLocalTimestamp (int32 typmod)
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)
bool	TimestampDifferenceExceedsSeconds (TimestampTz start_time, TimestampTz stop_time, int threshold_sec)
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)
static Datum	timestamp_decrement (Relation rel, Datum existing, bool *underflow)
static Datum	timestamp_increment (Relation rel, Datum existing, bool *overflow)
Datum	timestamp_skipsupport (PG_FUNCTION_ARGS)
Datum	timestamp_hash (PG_FUNCTION_ARGS)
Datum	timestamp_hash_extended (PG_FUNCTION_ARGS)
Datum	timestamptz_hash (PG_FUNCTION_ARGS)
Datum	timestamptz_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)
static int	interval_sign (const Interval *interval)
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)
static TimestampTz	timestamptz_pl_interval_internal (TimestampTz timestamp, Interval *span, pg_tz *attimezone)
static TimestampTz	timestamptz_mi_interval_internal (TimestampTz timestamp, Interval *span, pg_tz *attimezone)
Datum	timestamptz_pl_interval (PG_FUNCTION_ARGS)
Datum	timestamptz_mi_interval (PG_FUNCTION_ARGS)
Datum	timestamptz_pl_interval_at_zone (PG_FUNCTION_ARGS)
Datum	timestamptz_mi_interval_at_zone (PG_FUNCTION_ARGS)
Datum	interval_um (PG_FUNCTION_ARGS)
Datum	interval_smaller (PG_FUNCTION_ARGS)
Datum	interval_larger (PG_FUNCTION_ARGS)
static void	finite_interval_pl (const Interval *span1, const Interval *span2, Interval *result)
Datum	interval_pl (PG_FUNCTION_ARGS)
static void	finite_interval_mi (const Interval *span1, const Interval *span2, Interval *result)
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)
static IntervalAggState *	makeIntervalAggState (FunctionCallInfo fcinfo)
static void	do_interval_accum (IntervalAggState *state, Interval *newval)
static void	do_interval_discard (IntervalAggState *state, Interval *newval)
Datum	interval_avg_accum (PG_FUNCTION_ARGS)
Datum	interval_avg_combine (PG_FUNCTION_ARGS)
Datum	interval_avg_serialize (PG_FUNCTION_ARGS)
Datum	interval_avg_deserialize (PG_FUNCTION_ARGS)
Datum	interval_avg_accum_inv (PG_FUNCTION_ARGS)
Datum	interval_avg (PG_FUNCTION_ARGS)
Datum	interval_sum (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 float8	NonFiniteIntervalPart (int type, int unit, char *lowunits, bool isNegative)
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)
static Datum	generate_series_timestamptz_internal (FunctionCallInfo fcinfo)
Datum	generate_series_timestamptz (PG_FUNCTION_ARGS)
Datum	generate_series_timestamptz_at_zone (PG_FUNCTION_ARGS)
Datum	generate_series_timestamp_support (PG_FUNCTION_ARGS)
Datum	timestamp_at_local (PG_FUNCTION_ARGS)
Datum	timestamptz_at_local (PG_FUNCTION_ARGS)

Variables
TimestampTz	PgStartTime
TimestampTz	PgReloadTime

Macro Definition Documentation

IA_TOTAL_COUNT

#define IA_TOTAL_COUNT

(

ia

)

((ia)->N + (ia)->pInfcount + (ia)->nInfcount)

Definition at line 89 of file timestamp.c.

INTERVAL_TO_MICROSECONDS

#define INTERVAL_TO_MICROSECONDS

(

i

)

((((double) (i)->month * DAYS_PER_MONTH + (i)->day)) * USECS_PER_DAY + (i)->time)

SAMESIGN

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

Definition at line 51 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))

Typedef Documentation

IntervalAggState

typedef struct IntervalAggState IntervalAggState

Function Documentation

AdjustIntervalForTypmod()

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

static

Definition at line 1350 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)
    };
 
    /* Typmod has no effect on infinite intervals */
    if (INTERVAL_NOT_FINITE(interval))
        return true;
 
    /*
     * 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))
            {
                if (pg_add_s64_overflow(interval->time,
                                        IntervalOffsets[precision],
                                        &interval->time))
                    ereturn(escontext, false,
                            (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                             errmsg("interval out of range")));
                interval->time -= interval->time % IntervalScales[precision];
            }
            else
            {
                if (pg_sub_s64_overflow(interval->time,
                                        IntervalOffsets[precision],
                                        &interval->time))
                    ereturn(escontext, false,
                            (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                             errmsg("interval out of range")));
                interval->time -= interval->time % IntervalScales[precision];
            }
        }
    }
 
    return true;
}

References DAY, elog, ereturn, errcode(), errmsg(), ERROR, HOUR, INT64CONST, INTERVAL_FULL_PRECISION, INTERVAL_FULL_RANGE, INTERVAL_MASK, INTERVAL_NOT_FINITE, INTERVAL_PRECISION, INTERVAL_RANGE, MAX_INTERVAL_PRECISION, MINUTE, MONTH, interval::month, MONTHS_PER_YEAR, pg_add_s64_overflow(), pg_sub_s64_overflow(), 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 368 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(), INT64CONST, MAX_TIMESTAMP_PRECISION, and TIMESTAMP_NOT_FINITE.

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

anytimestamp_typmod_check()

int32 anytimestamp_typmod_check	(	bool	istz,
		int32	typmod
	)

Definition at line 125 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(), executeDateTimeMethod(), and transformSQLValueFunction().

anytimestamp_typmodin()

static int32 anytimestamp_typmodin ( bool  istz, ArrayType *  ta  )

static

Definition at line 104 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 147 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 1621 of file timestamp.c.

{
    PG_RETURN_TIMESTAMPTZ(GetCurrentTimestamp());
}

References GetCurrentTimestamp(), and PG_RETURN_TIMESTAMPTZ.

date2isoweek()

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

Definition at line 5313 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 5368 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 5425 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().

do_interval_accum()

static void do_interval_accum ( IntervalAggState *  state, Interval *  newval  )

static

Definition at line 4007 of file timestamp.c.

{
    /* Infinite inputs are counted separately, and do not affect "N" */
    if (INTERVAL_IS_NOBEGIN(newval))
    {
        state->nInfcount++;
        return;
    }
 
    if (INTERVAL_IS_NOEND(newval))
    {
        state->pInfcount++;
        return;
    }
 
    finite_interval_pl(&state->sumX, newval, &state->sumX);
    state->N++;
}

References finite_interval_pl(), INTERVAL_IS_NOBEGIN, INTERVAL_IS_NOEND, and newval.

Referenced by interval_avg_accum().

do_interval_discard()

static void do_interval_discard ( IntervalAggState *  state, Interval *  newval  )

static

Definition at line 4030 of file timestamp.c.

{
    /* Infinite inputs are counted separately, and do not affect "N" */
    if (INTERVAL_IS_NOBEGIN(newval))
    {
        state->nInfcount--;
        return;
    }
 
    if (INTERVAL_IS_NOEND(newval))
    {
        state->pInfcount--;
        return;
    }
 
    /* Handle the to-be-discarded finite value. */
    state->N--;
    if (state->N > 0)
        finite_interval_mi(&state->sumX, newval, &state->sumX);
    else
    {
        /* All values discarded, reset the state */
        Assert(state->N == 0);
        memset(&state->sumX, 0, sizeof(state->sumX));
    }
}

References Assert(), finite_interval_mi(), INTERVAL_IS_NOBEGIN, INTERVAL_IS_NOEND, and newval.

Referenced by interval_avg_accum_inv().

dt2local()

static Timestamp dt2local ( Timestamp  dt, int  timezone  )

static

Definition at line 2134 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 1883 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().

EncodeSpecialInterval()

static void EncodeSpecialInterval ( const Interval *  interval, char *  str  )

static

Definition at line 1598 of file timestamp.c.

{
    if (INTERVAL_IS_NOBEGIN(interval))
        strcpy(str, EARLY);
    else if (INTERVAL_IS_NOEND(interval))
        strcpy(str, LATE);
    else                        /* shouldn't happen */
        elog(ERROR, "invalid argument for EncodeSpecialInterval");
}

References EARLY, elog, ERROR, INTERVAL_IS_NOBEGIN, INTERVAL_IS_NOEND, LATE, and str.

Referenced by interval_out().

EncodeSpecialTimestamp()

void EncodeSpecialTimestamp	(	Timestamp	dt,
		char *	str
	)

Definition at line 1587 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, 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 6311 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 5763 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 6035 of file timestamp.c.

{
    return timestamptz_part_common(fcinfo, true);
}

References timestamptz_part_common().

finite_interval_mi()

static void finite_interval_mi ( const Interval *  span1, const Interval *  span2, Interval *  result  )

static

Definition at line 3562 of file timestamp.c.

{
    Assert(!INTERVAL_NOT_FINITE(span1));
    Assert(!INTERVAL_NOT_FINITE(span2));
 
    if (pg_sub_s32_overflow(span1->month, span2->month, &result->month) ||
        pg_sub_s32_overflow(span1->day, span2->day, &result->day) ||
        pg_sub_s64_overflow(span1->time, span2->time, &result->time) ||
        INTERVAL_NOT_FINITE(result))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
}

References Assert(), Interval::day, ereport, errcode(), errmsg(), ERROR, INTERVAL_NOT_FINITE, Interval::month, pg_sub_s32_overflow(), pg_sub_s64_overflow(), and Interval::time.

Referenced by do_interval_discard(), and interval_mi().

finite_interval_pl()

static void finite_interval_pl ( const Interval *  span1, const Interval *  span2, Interval *  result  )

static

Definition at line 3506 of file timestamp.c.

{
    Assert(!INTERVAL_NOT_FINITE(span1));
    Assert(!INTERVAL_NOT_FINITE(span2));
 
    if (pg_add_s32_overflow(span1->month, span2->month, &result->month) ||
        pg_add_s32_overflow(span1->day, span2->day, &result->day) ||
        pg_add_s64_overflow(span1->time, span2->time, &result->time) ||
        INTERVAL_NOT_FINITE(result))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
}

References Assert(), Interval::day, ereport, errcode(), errmsg(), ERROR, INTERVAL_NOT_FINITE, Interval::month, pg_add_s32_overflow(), pg_add_s64_overflow(), and Interval::time.

Referenced by do_interval_accum(), interval_avg_combine(), and interval_pl().

float8_timestamptz()

Datum float8_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 726 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 6668 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;
 
        /* 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_sign(&fctx->step);
 
        if (fctx->step_sign == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("step size cannot equal zero")));
 
        if (INTERVAL_NOT_FINITE((&fctx->step)))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("step size cannot be infinite")));
 
        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_NOT_FINITE, interval_sign(), 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, start, generate_series_timestamp_fctx::step, generate_series_timestamp_fctx::step_sign, timestamp_cmp_internal(), timestamp_pl_interval(), TimestampGetDatum(), and FuncCallContext::user_fctx.

generate_series_timestamp_support()

Datum generate_series_timestamp_support

(

PG_FUNCTION_ARGS

)

Definition at line 6849 of file timestamp.c.

{
    Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
    Node       *ret = NULL;
 
    if (IsA(rawreq, SupportRequestRows))
    {
        /* Try to estimate the number of rows returned */
        SupportRequestRows *req = (SupportRequestRows *) rawreq;
 
        if (is_funcclause(req->node))   /* be paranoid */
        {
            List       *args = ((FuncExpr *) req->node)->args;
            Node       *arg1,
                       *arg2,
                       *arg3;
 
            /* We can use estimated argument values here */
            arg1 = estimate_expression_value(req->root, linitial(args));
            arg2 = estimate_expression_value(req->root, lsecond(args));
            arg3 = estimate_expression_value(req->root, lthird(args));
 
            /*
             * If any argument is constant NULL, we can safely assume that
             * zero rows are returned.  Otherwise, if they're all non-NULL
             * constants, we can calculate the number of rows that will be
             * returned.
             */
            if ((IsA(arg1, Const) && ((Const *) arg1)->constisnull) ||
                (IsA(arg2, Const) && ((Const *) arg2)->constisnull) ||
                (IsA(arg3, Const) && ((Const *) arg3)->constisnull))
            {
                req->rows = 0;
                ret = (Node *) req;
            }
            else if (IsA(arg1, Const) && IsA(arg2, Const) && IsA(arg3, Const))
            {
                Timestamp   start,
                            finish;
                Interval   *step;
                Datum       diff;
                double      dstep;
                int64       dummy;
 
                start = DatumGetTimestamp(((Const *) arg1)->constvalue);
                finish = DatumGetTimestamp(((Const *) arg2)->constvalue);
                step = DatumGetIntervalP(((Const *) arg3)->constvalue);
 
                /*
                 * Perform some prechecks which could cause timestamp_mi to
                 * raise an ERROR.  It's much better to just return some
                 * default estimate than error out in a support function.
                 */
                if (!TIMESTAMP_NOT_FINITE(start) && !TIMESTAMP_NOT_FINITE(finish) &&
                    !pg_sub_s64_overflow(finish, start, &dummy))
                {
                    diff = DirectFunctionCall2(timestamp_mi,
                                               TimestampGetDatum(finish),
                                               TimestampGetDatum(start));
 
#define INTERVAL_TO_MICROSECONDS(i) ((((double) (i)->month * DAYS_PER_MONTH + (i)->day)) * USECS_PER_DAY + (i)->time)
 
                    dstep = INTERVAL_TO_MICROSECONDS(step);
 
                    /* This equation works for either sign of step */
                    if (dstep != 0.0)
                    {
                        Interval   *idiff = DatumGetIntervalP(diff);
                        double      ddiff = INTERVAL_TO_MICROSECONDS(idiff);
 
                        req->rows = floor(ddiff / dstep + 1.0);
                        ret = (Node *) req;
                    }
#undef INTERVAL_TO_MICROSECONDS
                }
            }
        }
    }
 
    PG_RETURN_POINTER(ret);
}

References generate_unaccent_rules::args, DatumGetIntervalP(), DatumGetTimestamp(), DirectFunctionCall2, estimate_expression_value(), INTERVAL_TO_MICROSECONDS, is_funcclause(), IsA, linitial, lsecond, lthird, SupportRequestRows::node, PG_GETARG_POINTER, PG_RETURN_POINTER, pg_sub_s64_overflow(), SupportRequestRows::root, SupportRequestRows::rows, start, timestamp_mi(), TIMESTAMP_NOT_FINITE, and TimestampGetDatum().

generate_series_timestamptz()

Datum generate_series_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 6834 of file timestamp.c.

{
    return generate_series_timestamptz_internal(fcinfo);
}

References generate_series_timestamptz_internal().

generate_series_timestamptz_at_zone()

Datum generate_series_timestamptz_at_zone

(

PG_FUNCTION_ARGS

)

Definition at line 6840 of file timestamp.c.

{
    return generate_series_timestamptz_internal(fcinfo);
}

References generate_series_timestamptz_internal().

generate_series_timestamptz_internal()

static Datum generate_series_timestamptz_internal ( FunctionCallInfo  fcinfo )

static

Definition at line 6752 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);
        text       *zone = (PG_NARGS() == 4) ? PG_GETARG_TEXT_PP(3) : NULL;
        MemoryContext oldcontext;
 
        /* 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;
        fctx->attimezone = zone ? lookup_timezone(zone) : session_timezone;
 
        /* Determine sign of the interval */
        fctx->step_sign = interval_sign(&fctx->step);
 
        if (fctx->step_sign == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("step size cannot equal zero")));
 
        if (INTERVAL_NOT_FINITE((&fctx->step)))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("step size cannot be infinite")));
 
        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 = timestamptz_pl_interval_internal(fctx->current,
                                                         &fctx->step,
                                                         fctx->attimezone);
 
        /* 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::attimezone, generate_series_timestamptz_fctx::current, ereport, errcode(), errmsg(), ERROR, generate_series_timestamptz_fctx::finish, INTERVAL_NOT_FINITE, interval_sign(), lookup_timezone(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, palloc(), PG_GETARG_INTERVAL_P, PG_GETARG_TEXT_PP, PG_GETARG_TIMESTAMPTZ, PG_NARGS, session_timezone, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, start, generate_series_timestamptz_fctx::step, generate_series_timestamptz_fctx::step_sign, timestamp_cmp_internal(), timestamptz_pl_interval_internal(), TimestampTzGetDatum(), and FuncCallContext::user_fctx.

Referenced by generate_series_timestamptz(), and generate_series_timestamptz_at_zone().

GetCurrentTimestamp()

TimestampTz GetCurrentTimestamp

(

void

)

Definition at line 1645 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(), asyncQueueFillWarning(), autoprewarm_main(), AutoVacLauncherMain(), BackendStartup(), BackgroundWriterMain(), bbsink_copystream_archive_contents(), bbsink_copystream_end_archive(), bbsink_copystream_new(), bbsink_throttle_begin_backup(), check_log_duration(), CheckPointGuts(), CleanupBackend(), clock_timestamp(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateOverwriteContrecordRecord(), CreateRestartPoint(), dblink_cancel_query(), DetermineSleepTime(), disable_timeout(), disable_timeouts(), do_analyze_rel(), do_start_worker(), enable_startup_progress_timeout(), enable_timeout_after(), enable_timeout_at(), enable_timeout_every(), enable_timeouts(), entry_alloc(), entry_reset(), get_role_password(), GetCurrentTransactionStopTimestamp(), GetReplicationApplyDelay(), handle_sig_alarm(), has_startup_progress_timeout_expired(), heap_vacuum_rel(), initialize_prng(), InitProcessGlobals(), InvalidatePossiblyObsoleteSlot(), KnownAssignedXidsCompress(), launcher_determine_sleep(), libpqsrv_cancel(), LockBufferForCleanup(), log_disconnections(), LogCheckpointEnd(), logicalrep_worker_launch(), LogicalRepApplyLoop(), maybe_start_bgworkers(), pa_send_data(), PerformAuthentication(), PerformWalRecovery(), pgfdw_abort_cleanup_begin(), pgfdw_cancel_query(), pgfdw_exec_cleanup_query(), pgfdw_finish_abort_cleanup(), 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_stat(), pgstat_report_vacuum(), pgstat_reset(), pgstat_reset_after_failure(), pgstat_reset_counters(), pgstat_reset_of_kind(), pgstat_reset_slru(), PostgresMain(), PostgresSingleUserMain(), postmaster_child_launch(), PostmasterMain(), PrepareTransaction(), process_syncing_tables_for_apply(), ProcessConfigFileInternal(), ProcessPendingWrites(), ProcessRepliesIfAny(), ProcessStandbyReplyMessage(), ProcessWalSndrMessage(), ProcSleep(), rebuild_database_list(), RecordTransactionAbort(), RecordTransactionAbortPrepared(), RecordTransactionCommitPrepared(), recoveryApplyDelay(), ReplicationSlotRelease(), reschedule_timeouts(), ResolveRecoveryConflictWithBufferPin(), ResolveRecoveryConflictWithLock(), ResolveRecoveryConflictWithVirtualXIDs(), RestoreSlotFromDisk(), send_feedback(), SetCurrentStatementStartTimestamp(), SetupApplyOrSyncWorker(), StartBackgroundWorker(), StartTransaction(), test_pattern(), test_random(), throttle(), update_synced_slots_inactive_since(), UpdateWorkerStats(), WaitExceedsMaxStandbyDelay(), WaitForWalSummarization(), 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 2168 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().

GetSQLCurrentTimestamp()

TimestampTz GetSQLCurrentTimestamp

(

int32

typmod

)

Definition at line 1663 of file timestamp.c.

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

References AdjustTimestampForTypmod(), and GetCurrentTransactionStartTimestamp().

Referenced by ExecEvalSQLValueFunction().

GetSQLLocalTimestamp()

Timestamp GetSQLLocalTimestamp

(

int32

typmod

)

Definition at line 1677 of file timestamp.c.

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

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

Referenced by ExecEvalSQLValueFunction().

in_range_interval_interval()

Datum in_range_interval_interval

(

PG_FUNCTION_ARGS

)

Definition at line 3935 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 (interval_sign(offset) < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
                 errmsg("invalid preceding or following size in window function")));
 
    /*
     * Deal with cases where both base and offset are infinite, and computing
     * base +/- offset would cause an error.  As for float and numeric types,
     * we assume that all values infinitely precede +infinity and infinitely
     * follow -infinity.  See in_range_float8_float8() for reasoning.
     */
    if (INTERVAL_IS_NOEND(offset) &&
        (sub ? INTERVAL_IS_NOEND(base) : INTERVAL_IS_NOBEGIN(base)))
        PG_RETURN_BOOL(true);
 
    /* 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, interval_cmp_internal(), INTERVAL_IS_NOBEGIN, INTERVAL_IS_NOEND, interval_mi(), interval_pl(), interval_sign(), 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 3894 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 (interval_sign(offset) < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
                 errmsg("invalid preceding or following size in window function")));
 
    /*
     * Deal with cases where both base and offset are infinite, and computing
     * base +/- offset would cause an error.  As for float and numeric types,
     * we assume that all values infinitely precede +infinity and infinitely
     * follow -infinity.  See in_range_float8_float8() for reasoning.
     */
    if (INTERVAL_IS_NOEND(offset) &&
        (sub ? TIMESTAMP_IS_NOEND(base) : TIMESTAMP_IS_NOBEGIN(base)))
        PG_RETURN_BOOL(true);
 
    /* 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, INTERVAL_IS_NOEND, interval_sign(), IntervalPGetDatum(), PG_GETARG_BOOL, PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMP, PG_RETURN_BOOL, TIMESTAMP_IS_NOBEGIN, TIMESTAMP_IS_NOEND, 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 3857 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 (interval_sign(offset) < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
                 errmsg("invalid preceding or following size in window function")));
 
    /*
     * Deal with cases where both base and offset are infinite, and computing
     * base +/- offset would cause an error.  As for float and numeric types,
     * we assume that all values infinitely precede +infinity and infinitely
     * follow -infinity.  See in_range_float8_float8() for reasoning.
     */
    if (INTERVAL_IS_NOEND(offset) &&
        (sub ? TIMESTAMP_IS_NOEND(base) : TIMESTAMP_IS_NOBEGIN(base)))
        PG_RETURN_BOOL(true);
 
    /* We don't currently bother to avoid overflow hazards here */
    if (sub)
        sum = timestamptz_mi_interval_internal(base, offset, NULL);
    else
        sum = timestamptz_pl_interval_internal(base, offset, NULL);
 
    if (less)
        PG_RETURN_BOOL(val <= sum);
    else
        PG_RETURN_BOOL(val >= sum);
}

References ereport, errcode(), errmsg(), ERROR, INTERVAL_IS_NOEND, interval_sign(), PG_GETARG_BOOL, PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMPTZ, PG_RETURN_BOOL, TIMESTAMP_IS_NOBEGIN, TIMESTAMP_IS_NOEND, timestamptz_mi_interval_internal(), timestamptz_pl_interval_internal(), and val.

interval2itm()

void interval2itm	(	Interval	span,
		struct pg_itm *	itm
	)

Definition at line 2047 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_avg()

Datum interval_avg

(

PG_FUNCTION_ARGS

)

Definition at line 4226 of file timestamp.c.

{
    IntervalAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (IntervalAggState *) PG_GETARG_POINTER(0);
 
    /* If there were no non-null inputs, return NULL */
    if (state == NULL || IA_TOTAL_COUNT(state) == 0)
        PG_RETURN_NULL();
 
    /*
     * Aggregating infinities that all have the same sign produces infinity
     * with that sign.  Aggregating infinities with different signs results in
     * an error.
     */
    if (state->pInfcount > 0 || state->nInfcount > 0)
    {
        Interval   *result;
 
        if (state->pInfcount > 0 && state->nInfcount > 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
 
        result = (Interval *) palloc(sizeof(Interval));
        if (state->pInfcount > 0)
            INTERVAL_NOEND(result);
        else
            INTERVAL_NOBEGIN(result);
 
        PG_RETURN_INTERVAL_P(result);
    }
 
    return DirectFunctionCall2(interval_div,
                               IntervalPGetDatum(&state->sumX),
                               Float8GetDatum((double) state->N));
}

References DirectFunctionCall2, ereport, errcode(), errmsg(), ERROR, Float8GetDatum(), IA_TOTAL_COUNT, interval_div(), INTERVAL_NOBEGIN, INTERVAL_NOEND, IntervalPGetDatum(), palloc(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_INTERVAL_P, and PG_RETURN_NULL.

interval_avg_accum()

Datum interval_avg_accum

(

PG_FUNCTION_ARGS

)

Definition at line 4061 of file timestamp.c.

{
    IntervalAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (IntervalAggState *) PG_GETARG_POINTER(0);
 
    /* Create the state data on the first call */
    if (state == NULL)
        state = makeIntervalAggState(fcinfo);
 
    if (!PG_ARGISNULL(1))
        do_interval_accum(state, PG_GETARG_INTERVAL_P(1));
 
    PG_RETURN_POINTER(state);
}

References do_interval_accum(), makeIntervalAggState(), PG_ARGISNULL, PG_GETARG_INTERVAL_P, PG_GETARG_POINTER, and PG_RETURN_POINTER.

interval_avg_accum_inv()

Datum interval_avg_accum_inv

(

PG_FUNCTION_ARGS

)

Definition at line 4208 of file timestamp.c.

{
    IntervalAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (IntervalAggState *) PG_GETARG_POINTER(0);
 
    /* Should not get here with no state */
    if (state == NULL)
        elog(ERROR, "interval_avg_accum_inv called with NULL state");
 
    if (!PG_ARGISNULL(1))
        do_interval_discard(state, PG_GETARG_INTERVAL_P(1));
 
    PG_RETURN_POINTER(state);
}

References do_interval_discard(), elog, ERROR, PG_ARGISNULL, PG_GETARG_INTERVAL_P, PG_GETARG_POINTER, and PG_RETURN_POINTER.

interval_avg_combine()

Datum interval_avg_combine

(

PG_FUNCTION_ARGS

)

Definition at line 4084 of file timestamp.c.

{
    IntervalAggState *state1;
    IntervalAggState *state2;
 
    state1 = PG_ARGISNULL(0) ? NULL : (IntervalAggState *) PG_GETARG_POINTER(0);
    state2 = PG_ARGISNULL(1) ? NULL : (IntervalAggState *) PG_GETARG_POINTER(1);
 
    if (state2 == NULL)
        PG_RETURN_POINTER(state1);
 
    if (state1 == NULL)
    {
        /* manually copy all fields from state2 to state1 */
        state1 = makeIntervalAggState(fcinfo);
 
        state1->N = state2->N;
        state1->pInfcount = state2->pInfcount;
        state1->nInfcount = state2->nInfcount;
 
        state1->sumX.day = state2->sumX.day;
        state1->sumX.month = state2->sumX.month;
        state1->sumX.time = state2->sumX.time;
 
        PG_RETURN_POINTER(state1);
    }
 
    state1->N += state2->N;
    state1->pInfcount += state2->pInfcount;
    state1->nInfcount += state2->nInfcount;
 
    /* Accumulate finite interval values, if any. */
    if (state2->N > 0)
        finite_interval_pl(&state1->sumX, &state2->sumX, &state1->sumX);
 
    PG_RETURN_POINTER(state1);
}

References Interval::day, finite_interval_pl(), makeIntervalAggState(), Interval::month, IntervalAggState::N, IntervalAggState::nInfcount, PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_POINTER, IntervalAggState::pInfcount, IntervalAggState::sumX, and Interval::time.

interval_avg_deserialize()

Datum interval_avg_deserialize

(

PG_FUNCTION_ARGS

)

Definition at line 4165 of file timestamp.c.

{
    bytea      *sstate;
    IntervalAggState *result;
    StringInfoData buf;
 
    if (!AggCheckCallContext(fcinfo, NULL))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    sstate = PG_GETARG_BYTEA_PP(0);
 
    /*
     * Initialize a StringInfo so that we can "receive" it using the standard
     * recv-function infrastructure.
     */
    initReadOnlyStringInfo(&buf, VARDATA_ANY(sstate),
                           VARSIZE_ANY_EXHDR(sstate));
 
    result = (IntervalAggState *) palloc0(sizeof(IntervalAggState));
 
    /* N */
    result->N = pq_getmsgint64(&buf);
 
    /* sumX */
    result->sumX.time = pq_getmsgint64(&buf);
    result->sumX.day = pq_getmsgint(&buf, 4);
    result->sumX.month = pq_getmsgint(&buf, 4);
 
    /* pInfcount */
    result->pInfcount = pq_getmsgint64(&buf);
 
    /* nInfcount */
    result->nInfcount = pq_getmsgint64(&buf);
 
    pq_getmsgend(&buf);
 
    PG_RETURN_POINTER(result);
}

References AggCheckCallContext(), buf, Interval::day, elog, ERROR, initReadOnlyStringInfo(), Interval::month, IntervalAggState::N, IntervalAggState::nInfcount, palloc0(), PG_GETARG_BYTEA_PP, PG_RETURN_POINTER, IntervalAggState::pInfcount, pq_getmsgend(), pq_getmsgint(), pq_getmsgint64(), IntervalAggState::sumX, Interval::time, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

interval_avg_serialize()

Datum interval_avg_serialize

(

PG_FUNCTION_ARGS

)

Definition at line 4127 of file timestamp.c.

{
    IntervalAggState *state;
    StringInfoData buf;
    bytea      *result;
 
    /* Ensure we disallow calling when not in aggregate context */
    if (!AggCheckCallContext(fcinfo, NULL))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    state = (IntervalAggState *) PG_GETARG_POINTER(0);
 
    pq_begintypsend(&buf);
 
    /* N */
    pq_sendint64(&buf, state->N);
 
    /* sumX */
    pq_sendint64(&buf, state->sumX.time);
    pq_sendint32(&buf, state->sumX.day);
    pq_sendint32(&buf, state->sumX.month);
 
    /* pInfcount */
    pq_sendint64(&buf, state->pInfcount);
 
    /* nInfcount */
    pq_sendint64(&buf, state->nInfcount);
 
    result = pq_endtypsend(&buf);
 
    PG_RETURN_BYTEA_P(result);
}

References AggCheckCallContext(), buf, elog, ERROR, PG_GETARG_POINTER, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint32(), and pq_sendint64().

interval_cmp()

Datum interval_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 2636 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_intv_ssup_cmp(), and gbt_intvkey_cmp().

interval_cmp_internal()

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

static

Definition at line 2564 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 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 2542 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(), INT64CONST, interval::month, interval::time, and USECS_PER_DAY.

Referenced by interval_cmp_internal(), interval_hash(), interval_hash_extended(), and interval_sign().

interval_div()

Datum interval_div

(

PG_FUNCTION_ARGS

)

Definition at line 3756 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));
 
    if (factor == 0.0)
        ereport(ERROR,
                (errcode(ERRCODE_DIVISION_BY_ZERO),
                 errmsg("division by zero")));
 
    /*
     * Handle NaN and infinities.
     *
     * We treat "infinity / infinity" as an error, since the interval type has
     * nothing equivalent to NaN.  Otherwise, dividing by infinity is handled
     * by the regular division code, causing all fields to be set to zero.
     */
    if (isnan(factor))
        goto out_of_range;
 
    if (INTERVAL_NOT_FINITE(span))
    {
        if (isinf(factor))
            goto out_of_range;
 
        if (factor < 0.0)
            interval_um_internal(span, result);
        else
            memcpy(result, span, sizeof(Interval));
 
        PG_RETURN_INTERVAL_P(result);
    }
 
    result_double = span->month / factor;
    if (isnan(result_double) || !FLOAT8_FITS_IN_INT32(result_double))
        goto out_of_range;
    result->month = (int32) result_double;
 
    result_double = span->day / factor;
    if (isnan(result_double) || !FLOAT8_FITS_IN_INT32(result_double))
        goto out_of_range;
    result->day = (int32) result_double;
 
    /*
     * 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)
    {
        if (pg_add_s32_overflow(result->day,
                                (int) (sec_remainder / SECS_PER_DAY),
                                &result->day))
            goto out_of_range;
        sec_remainder -= (int) (sec_remainder / SECS_PER_DAY) * SECS_PER_DAY;
    }
 
    /* cascade units down */
    if (pg_add_s32_overflow(result->day, (int32) month_remainder_days,
                            &result->day))
        goto out_of_range;
    result_double = rint(span->time / factor + sec_remainder * USECS_PER_SEC);
    if (isnan(result_double) || !FLOAT8_FITS_IN_INT64(result_double))
        goto out_of_range;
    result->time = (int64) result_double;
 
    if (INTERVAL_NOT_FINITE(result))
        goto out_of_range;
 
    PG_RETURN_INTERVAL_P(result);
 
out_of_range:
    ereport(ERROR,
            errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
            errmsg("interval out of range"));
 
    PG_RETURN_NULL();           /* keep compiler quiet */
}

References Interval::day, DAYS_PER_MONTH, ereport, errcode(), errmsg(), ERROR, FLOAT8_FITS_IN_INT32, FLOAT8_FITS_IN_INT64, INTERVAL_NOT_FINITE, interval_um_internal(), Interval::month, palloc(), pg_add_s32_overflow(), PG_GETARG_FLOAT8, PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, PG_RETURN_NULL, 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 2582 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 2155 of file timestamp.c.

{
    Interval   *interval = PG_GETARG_INTERVAL_P(0);
 
    PG_RETURN_BOOL(!INTERVAL_NOT_FINITE(interval));
}

References INTERVAL_NOT_FINITE, PG_GETARG_INTERVAL_P, and PG_RETURN_BOOL.

interval_ge()

Datum interval_ge

(

PG_FUNCTION_ARGS

)

Definition at line 2627 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 2609 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 2652 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 2670 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 891 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;
 
        case DTK_LATE:
            INTERVAL_NOEND(result);
            break;
 
        case DTK_EARLY:
            INTERVAL_NOBEGIN(result);
            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, DTK_EARLY, DTK_LATE, elog, ereturn, errcode(), errmsg(), ERROR, INTERVAL_FULL_RANGE, INTERVAL_NOBEGIN, INTERVAL_NOEND, INTERVAL_RANGE, itmin2interval(), MAXDATEFIELDS, palloc(), ParseDateTime(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_INTERVAL_P, PG_RETURN_NULL, range(), 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 3061 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;
 
    /* do nothing for infinite intervals */
    if (INTERVAL_NOT_FINITE(result))
        PG_RETURN_INTERVAL_P(result);
 
    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_NOT_FINITE, 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 3019 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;
 
    /* do nothing for infinite intervals */
    if (INTERVAL_NOT_FINITE(result))
        PG_RETURN_INTERVAL_P(result);
 
    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_NOT_FINITE, 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 2939 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;
 
    /* do nothing for infinite intervals */
    if (INTERVAL_NOT_FINITE(result))
        PG_RETURN_INTERVAL_P(result);
 
    /* 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_NOT_FINITE, 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 3492 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 2618 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 2600 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 3577 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));
 
    /*
     * Handle infinities.
     *
     * We treat anything that amounts to "infinity - infinity" as an error,
     * since the interval type has nothing equivalent to NaN.
     */
    if (INTERVAL_IS_NOBEGIN(span1))
    {
        if (INTERVAL_IS_NOBEGIN(span2))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
        else
            INTERVAL_NOBEGIN(result);
    }
    else if (INTERVAL_IS_NOEND(span1))
    {
        if (INTERVAL_IS_NOEND(span2))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
        else
            INTERVAL_NOEND(result);
    }
    else if (INTERVAL_IS_NOBEGIN(span2))
        INTERVAL_NOEND(result);
    else if (INTERVAL_IS_NOEND(span2))
        INTERVAL_NOBEGIN(result);
    else
        finite_interval_mi(span1, span2, result);
 
    PG_RETURN_INTERVAL_P(result);
}

References ereport, errcode(), errmsg(), ERROR, finite_interval_mi(), INTERVAL_IS_NOBEGIN, INTERVAL_IS_NOEND, INTERVAL_NOBEGIN, INTERVAL_NOEND, palloc(), PG_GETARG_INTERVAL_P, and PG_RETURN_INTERVAL_P.

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

interval_mul()

Datum interval_mul

(

PG_FUNCTION_ARGS

)

Definition at line 3626 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));
 
    /*
     * Handle NaN and infinities.
     *
     * We treat "0 * infinity" and "infinity * 0" as errors, since the
     * interval type has nothing equivalent to NaN.
     */
    if (isnan(factor))
        goto out_of_range;
 
    if (INTERVAL_NOT_FINITE(span))
    {
        if (factor == 0.0)
            goto out_of_range;
 
        if (factor < 0.0)
            interval_um_internal(span, result);
        else
            memcpy(result, span, sizeof(Interval));
 
        PG_RETURN_INTERVAL_P(result);
    }
    if (isinf(factor))
    {
        int         isign = interval_sign(span);
 
        if (isign == 0)
            goto out_of_range;
 
        if (factor * isign < 0)
            INTERVAL_NOBEGIN(result);
        else
            INTERVAL_NOEND(result);
 
        PG_RETURN_INTERVAL_P(result);
    }
 
    result_double = span->month * factor;
    if (isnan(result_double) || !FLOAT8_FITS_IN_INT32(result_double))
        goto out_of_range;
    result->month = (int32) result_double;
 
    result_double = span->day * factor;
    if (isnan(result_double) || !FLOAT8_FITS_IN_INT32(result_double))
        goto 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)
    {
        if (pg_add_s32_overflow(result->day,
                                (int) (sec_remainder / SECS_PER_DAY),
                                &result->day))
            goto out_of_range;
        sec_remainder -= (int) (sec_remainder / SECS_PER_DAY) * SECS_PER_DAY;
    }
 
    /* cascade units down */
    if (pg_add_s32_overflow(result->day, (int32) month_remainder_days,
                            &result->day))
        goto out_of_range;
    result_double = rint(span->time * factor + sec_remainder * USECS_PER_SEC);
    if (isnan(result_double) || !FLOAT8_FITS_IN_INT64(result_double))
        goto out_of_range;
    result->time = (int64) result_double;
 
    if (INTERVAL_NOT_FINITE(result))
        goto out_of_range;
 
    PG_RETURN_INTERVAL_P(result);
 
out_of_range:
    ereport(ERROR,
            errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
            errmsg("interval out of range"));
 
    PG_RETURN_NULL();           /* keep compiler quiet */
}

References Interval::day, DAYS_PER_MONTH, ereport, errcode(), errmsg(), ERROR, FLOAT8_FITS_IN_INT32, FLOAT8_FITS_IN_INT64, INTERVAL_NOBEGIN, INTERVAL_NOEND, INTERVAL_NOT_FINITE, interval_sign(), interval_um_internal(), Interval::month, palloc(), pg_add_s32_overflow(), PG_GETARG_FLOAT8, PG_GETARG_INTERVAL_P, PG_RETURN_INTERVAL_P, PG_RETURN_NULL, 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 2591 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 973 of file timestamp.c.

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

References buf, EncodeInterval(), EncodeSpecialInterval(), interval2itm(), INTERVAL_NOT_FINITE, 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 6305 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 6098 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 (INTERVAL_NOT_FINITE(interval))
    {
        double      r = NonFiniteIntervalPart(type, val, lowunits,
                                              INTERVAL_IS_NOBEGIN(interval));
 
        if (r != 0.0)
        {
            if (retnumeric)
            {
                if (r < 0)
                    return DirectFunctionCall3(numeric_in,
                                               CStringGetDatum("-Infinity"),
                                               ObjectIdGetDatum(InvalidOid),
                                               Int32GetDatum(-1));
                else if (r > 0)
                    return DirectFunctionCall3(numeric_in,
                                               CStringGetDatum("Infinity"),
                                               ObjectIdGetDatum(InvalidOid),
                                               Int32GetDatum(-1));
            }
            else
                PG_RETURN_FLOAT8(r);
        }
        else
            PG_RETURN_NULL();
    }
 
    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_WEEK:
                intresult = tm->tm_mday / 7;
                break;
 
            case DTK_MONTH:
                intresult = tm->tm_mon;
                break;
 
            case DTK_QUARTER:
 
                /*
                 * We want to maintain the rule that a field extracted from a
                 * negative interval is the negative of the field's value for
                 * the sign-reversed interval.  The broken-down tm_year and
                 * tm_mon aren't very helpful for that, so work from
                 * interval->month.
                 */
                if (interval->month >= 0)
                    intresult = (tm->tm_mon / 3) + 1;
                else
                    intresult = -(((-interval->month % MONTHS_PER_YEAR) / 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 CStringGetDatum(), DAYS_PER_MONTH, DAYS_PER_YEAR, DecodeSpecial(), DecodeUnits(), DirectFunctionCall3, 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_WEEK, DTK_YEAR, ereport, errcode(), errmsg(), ERROR, format_type_be(), Int32GetDatum(), int64_div_fast_to_numeric(), int64_to_numeric(), INT64CONST, interval2itm(), INTERVAL_IS_NOBEGIN, INTERVAL_NOT_FINITE, InvalidOid, interval::month, MONTHS_PER_YEAR, NonFiniteIntervalPart(), numeric_add_opt_error(), numeric_in(), ObjectIdGetDatum(), pg_add_s64_overflow(), PG_GETARG_INTERVAL_P, PG_GETARG_TEXT_PP, pg_mul_s64_overflow(), PG_RETURN_FLOAT8, PG_RETURN_NULL, 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, 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 3521 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));
 
    /*
     * Handle infinities.
     *
     * We treat anything that amounts to "infinity - infinity" as an error,
     * since the interval type has nothing equivalent to NaN.
     */
    if (INTERVAL_IS_NOBEGIN(span1))
    {
        if (INTERVAL_IS_NOEND(span2))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
        else
            INTERVAL_NOBEGIN(result);
    }
    else if (INTERVAL_IS_NOEND(span1))
    {
        if (INTERVAL_IS_NOBEGIN(span2))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
        else
            INTERVAL_NOEND(result);
    }
    else if (INTERVAL_NOT_FINITE(span2))
        memcpy(result, span2, sizeof(Interval));
    else
        finite_interval_pl(span1, span2, result);
 
    PG_RETURN_INTERVAL_P(result);
}

References ereport, errcode(), errmsg(), ERROR, finite_interval_pl(), INTERVAL_IS_NOBEGIN, INTERVAL_IS_NOEND, INTERVAL_NOBEGIN, INTERVAL_NOEND, INTERVAL_NOT_FINITE, palloc(), PG_GETARG_INTERVAL_P, and PG_RETURN_INTERVAL_P.

Referenced by in_range_interval_interval(), and interval_lerp().

interval_recv()

Datum interval_recv

(

PG_FUNCTION_ARGS

)

Definition at line 997 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 1328 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 1022 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_sign()

static int interval_sign ( const Interval *  interval )

static

Definition at line 2573 of file timestamp.c.

{
    INT128      span = interval_cmp_value(interval);
    INT128      zero = int64_to_int128(0);
 
    return int128_compare(span, zero);
}

References int128_compare(), int64_to_int128(), and interval_cmp_value().

Referenced by generate_series_timestamp(), generate_series_timestamptz_internal(), in_range_interval_interval(), in_range_timestamp_interval(), in_range_timestamptz_interval(), and interval_mul().

interval_smaller()

Datum interval_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 3477 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_sum()

Datum interval_sum

(

PG_FUNCTION_ARGS

)

Definition at line 4266 of file timestamp.c.

{
    IntervalAggState *state;
    Interval   *result;
 
    state = PG_ARGISNULL(0) ? NULL : (IntervalAggState *) PG_GETARG_POINTER(0);
 
    /* If there were no non-null inputs, return NULL */
    if (state == NULL || IA_TOTAL_COUNT(state) == 0)
        PG_RETURN_NULL();
 
    /*
     * Aggregating infinities that all have the same sign produces infinity
     * with that sign.  Aggregating infinities with different signs results in
     * an error.
     */
    if (state->pInfcount > 0 && state->nInfcount > 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
 
    result = (Interval *) palloc(sizeof(Interval));
 
    if (state->pInfcount > 0)
        INTERVAL_NOEND(result);
    else if (state->nInfcount > 0)
        INTERVAL_NOBEGIN(result);
    else
        memcpy(result, &state->sumX, sizeof(Interval));
 
    PG_RETURN_INTERVAL_P(result);
}

References ereport, errcode(), errmsg(), ERROR, IA_TOTAL_COUNT, INTERVAL_NOBEGIN, INTERVAL_NOEND, palloc(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_INTERVAL_P, and PG_RETURN_NULL.

interval_support()

Datum interval_support

(

PG_FUNCTION_ARGS

)

Definition at line 1265 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 5130 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)
    {
        if (INTERVAL_NOT_FINITE(interval))
        {
            /*
             * Errors thrown here for invalid units should exactly match those
             * below, else there will be unexpected discrepancies between
             * finite- and infinite-input cases.
             */
            switch (val)
            {
                case DTK_MILLENNIUM:
                case DTK_CENTURY:
                case DTK_DECADE:
                case DTK_YEAR:
                case DTK_QUARTER:
                case DTK_MONTH:
                case DTK_DAY:
                case DTK_HOUR:
                case DTK_MINUTE:
                case DTK_SECOND:
                case DTK_MILLISEC:
                case DTK_MICROSEC:
                    memcpy(result, interval, sizeof(Interval));
                    PG_RETURN_INTERVAL_P(result);
                    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));
                    result = 0;
            }
        }
 
        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(), INTERVAL_NOT_FINITE, 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, type, UNITS, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

interval_um()

Datum interval_um

(

PG_FUNCTION_ARGS

)

Definition at line 3464 of file timestamp.c.

{
    Interval   *interval = PG_GETARG_INTERVAL_P(0);
    Interval   *result;
 
    result = (Interval *) palloc(sizeof(Interval));
    interval_um_internal(interval, result);
 
    PG_RETURN_INTERVAL_P(result);
}

References interval_um_internal(), palloc(), PG_GETARG_INTERVAL_P, and PG_RETURN_INTERVAL_P.

Referenced by abs_interval().

interval_um_internal()

static void interval_um_internal ( const Interval *  interval, Interval *  result  )

static

Definition at line 3444 of file timestamp.c.

{
    if (INTERVAL_IS_NOBEGIN(interval))
        INTERVAL_NOEND(result);
    else if (INTERVAL_IS_NOEND(interval))
        INTERVAL_NOBEGIN(result);
    else
    {
        /* Negate each field, guarding against overflow */
        if (pg_sub_s64_overflow(INT64CONST(0), interval->time, &result->time) ||
            pg_sub_s32_overflow(0, interval->day, &result->day) ||
            pg_sub_s32_overflow(0, interval->month, &result->month) ||
            INTERVAL_NOT_FINITE(result))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
    }
}

References Interval::day, ereport, errcode(), errmsg(), ERROR, INT64CONST, INTERVAL_IS_NOBEGIN, INTERVAL_IS_NOEND, INTERVAL_NOBEGIN, INTERVAL_NOEND, INTERVAL_NOT_FINITE, Interval::month, interval::month, pg_sub_s32_overflow(), pg_sub_s64_overflow(), Interval::time, and interval::time.

Referenced by interval_div(), interval_mul(), interval_um(), timestamp_mi_interval(), and timestamptz_mi_interval_internal().

intervaltypmodin()

Datum intervaltypmodin

(

PG_FUNCTION_ARGS

)

Definition at line 1047 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 1212 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 1126 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, SECOND, snprintf, and YEAR.

isoweek2date()

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

Definition at line 5282 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 5262 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 5295 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 2077 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;
    if (INTERVAL_NOT_FINITE(span))
        return -1;
    return 0;
}

References Interval::day, if(), INTERVAL_NOT_FINITE, 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 2115 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(), pg_timezone_abbrevs_abbrevs(), and pg_timezone_abbrevs_zone().

lookup_timezone()

static pg_tz * lookup_timezone ( text *  zone )

static

Definition at line 560 of file timestamp.c.

{
    char        tzname[TZ_STRLEN_MAX + 1];
 
    text_to_cstring_buffer(zone, tzname, sizeof(tzname));
 
    return DecodeTimezoneNameToTz(tzname);
}

References DecodeTimezoneNameToTz(), text_to_cstring_buffer(), and TZ_STRLEN_MAX.

Referenced by generate_series_timestamptz_internal(), timestamptz_mi_interval_at_zone(), timestamptz_pl_interval_at_zone(), and timestamptz_trunc_zone().

make_interval()

Datum make_interval

(

PG_FUNCTION_ARGS

)

Definition at line 1530 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 reject any input values that cause
     * integer overflow of the corresponding interval fields.
     */
    if (isinf(secs) || isnan(secs))
        goto out_of_range;
 
    result = (Interval *) palloc(sizeof(Interval));
 
    /* years and months -> months */
    if (pg_mul_s32_overflow(years, MONTHS_PER_YEAR, &result->month) ||
        pg_add_s32_overflow(result->month, months, &result->month))
        goto out_of_range;
 
    /* weeks and days -> days */
    if (pg_mul_s32_overflow(weeks, DAYS_PER_WEEK, &result->day) ||
        pg_add_s32_overflow(result->day, days, &result->day))
        goto out_of_range;
 
    /* hours and mins -> usecs (cannot overflow 64-bit) */
    result->time = hours * USECS_PER_HOUR + mins * USECS_PER_MINUTE;
 
    /* secs -> usecs */
    secs = rint(float8_mul(secs, USECS_PER_SEC));
    if (!FLOAT8_FITS_IN_INT64(secs) ||
        pg_add_s64_overflow(result->time, (int64) secs, &result->time))
        goto out_of_range;
 
    /* make sure that the result is finite */
    if (INTERVAL_NOT_FINITE(result))
        goto out_of_range;
 
    PG_RETURN_INTERVAL_P(result);
 
out_of_range:
    ereport(ERROR,
            errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
            errmsg("interval out of range"));
 
    PG_RETURN_NULL();           /* keep compiler quiet */
}

References Interval::day, days, DAYS_PER_WEEK, ereport, errcode(), errmsg(), ERROR, FLOAT8_FITS_IN_INT64, float8_mul(), INTERVAL_NOT_FINITE, Interval::month, months, MONTHS_PER_YEAR, palloc(), pg_add_s32_overflow(), pg_add_s64_overflow(), PG_GETARG_FLOAT8, PG_GETARG_INT32, pg_mul_s32_overflow(), PG_RETURN_INTERVAL_P, PG_RETURN_NULL, Interval::time, USECS_PER_HOUR, USECS_PER_MINUTE, and USECS_PER_SEC.

make_timestamp()

Datum make_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 645 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 574 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);
 
    if (unlikely(pg_mul_s64_overflow(date, USECS_PER_DAY, &result) ||
                 pg_add_s64_overflow(result, time, &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)));
 
    /* 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, pg_add_s64_overflow(), pg_mul_s64_overflow(), POSTGRES_EPOCH_JDATE, SECS_PER_MINUTE, tm, pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_year, unlikely, 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 665 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 686 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().

makeIntervalAggState()

static IntervalAggState * makeIntervalAggState ( FunctionCallInfo  fcinfo )

static

Definition at line 3985 of file timestamp.c.

{
    IntervalAggState *state;
    MemoryContext agg_context;
    MemoryContext old_context;
 
    if (!AggCheckCallContext(fcinfo, &agg_context))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    old_context = MemoryContextSwitchTo(agg_context);
 
    state = (IntervalAggState *) palloc0(sizeof(IntervalAggState));
 
    MemoryContextSwitchTo(old_context);
 
    return state;
}

References AggCheckCallContext(), elog, ERROR, MemoryContextSwitchTo(), and palloc0().

Referenced by interval_avg_accum(), and interval_avg_combine().

mul_d_interval()

Datum mul_d_interval

(

PG_FUNCTION_ARGS

)

Definition at line 3746 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.

NonFiniteIntervalPart()

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

static

Definition at line 6052 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(INTERVALOID))));
 
    switch (unit)
    {
            /* Oscillating units */
        case DTK_MICROSEC:
        case DTK_MILLISEC:
        case DTK_SECOND:
        case DTK_MINUTE:
        case DTK_WEEK:
        case DTK_MONTH:
        case DTK_QUARTER:
            return 0.0;
 
            /* Monotonically-increasing units */
        case DTK_HOUR:
        case DTK_DAY:
        case DTK_YEAR:
        case DTK_DECADE:
        case DTK_CENTURY:
        case DTK_MILLENNIUM:
        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(INTERVALOID))));
            return 0.0;         /* keep compiler quiet */
    }
}

References 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_WEEK, DTK_YEAR, ereport, errcode(), errmsg(), ERROR, format_type_be(), get_float8_infinity(), RESERV, type, and UNITS.

Referenced by interval_part_common().

NonFiniteTimestampTzPart()

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

static

Definition at line 5442 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, type, and UNITS.

Referenced by timestamp_part_common(), and timestamptz_part_common().

now()

Datum now

(

PG_FUNCTION_ARGS

)

Definition at line 1609 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(), DetermineSlotInvalidationCause(), doLog(), doRetry(), dumpTimestamp(), enable_timeout(), enable_timeout_after(), enable_timeout_at(), enable_timeout_every(), enable_timeouts(), executeMetaCommand(), flushAndSendFeedback(), handle_sig_alarm(), HandleCopyStream(), has_startup_progress_timeout_expired(), initialize_prng(), InvalidatePossiblyObsoleteSlot(), IsCheckpointOnSchedule(), LagTrackerRead(), launch_worker(), libpqsrv_cancel(), LockBufferForCleanup(), logicalrep_worker_launch(), LogicalRepApplyLoop(), LogRecoveryConflict(), maybe_start_bgworkers(), mxid_age(), OutputFsync(), PerformRadiusTransaction(), pg_clock_gettime_ns(), pg_time_now(), pg_time_now_lazy(), pg_timezone_abbrevs_abbrevs(), pg_timezone_abbrevs_zone(), pgfdw_cancel_query(), pgfdw_finish_abort_cleanup(), 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(), ReplicationSlotRelease(), RequestXLogStreaming(), ResolveRecoveryConflictWithLock(), ResolveRecoveryConflictWithVirtualXIDs(), RestoreSlotFromDisk(), schedule_alarm(), send_feedback(), sendFeedback(), ServerLoop(), set_next_rotation_time(), StreamLogicalLog(), SysLoggerMain(), threadRun(), timetz_zone(), update_synced_slots_inactive_since(), WaitForWALToBecomeAvailable(), WalRcvComputeNextWakeup(), WalRcvRunning(), WalRcvStreaming(), WalReceiverMain(), WalSndComputeSleeptime(), WalSndLoop(), WalSndUpdateProgress(), WalSndWaitForWal(), WalSndWriteData(), xid_age(), XLogBackgroundFlush(), XLogWalRcvSendHSFeedback(), and XLogWalRcvSendReply().

overlaps_timestamp()

Datum overlaps_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 2690 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 491 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 try timezone abbreviations and names.
     *
     * 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)
    {
        int         type,
                    val;
        pg_tz      *tzp;
 
        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)));
 
        type = DecodeTimezoneName(tzname, &val, &tzp);
 
        if (type == TZNAME_FIXED_OFFSET)
        {
            /* fixed-offset abbreviation */
            tz = -val;
        }
        else if (type == TZNAME_DYNTZ)
        {
            /* dynamic-offset abbreviation, resolve using specified time */
            tz = DetermineTimeZoneAbbrevOffset(tm, tzname, tzp);
        }
        else
        {
            /* full zone name */
            tz = DetermineTimeZoneOffset(tm, tzp);
        }
    }
 
    return tz;
}

References DecodeTimezone(), DecodeTimezoneName(), DetermineTimeZoneAbbrevOffset(), DetermineTimeZoneOffset(), DTERR_BAD_FORMAT, DTERR_TZDISP_OVERFLOW, ereport, errcode(), errhint(), errmsg(), ERROR, text_to_cstring_buffer(), tm, type, TZ_STRLEN_MAX, TZNAME_DYNTZ, TZNAME_FIXED_OFFSET, and val.

Referenced by make_timestamptz_at_timezone().

pg_conf_load_time()

Datum pg_conf_load_time

(

PG_FUNCTION_ARGS

)

Definition at line 1633 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 1627 of file timestamp.c.

{
    PG_RETURN_TIMESTAMPTZ(PgStartTime);
}

References PG_RETURN_TIMESTAMPTZ, and PgStartTime.

SetEpochTimestamp()

Timestamp SetEpochTimestamp

(

void

)

Definition at line 2190 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().

statement_timestamp()

Datum statement_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 1615 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 2128 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 1820 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 1691 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 6518 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 6466 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 1910 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(), INT64CONST, 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(), executeDateTimeMethod(), 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_internal(), 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 4306 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));
 
    /*
     * Handle infinities.
     *
     * We treat anything that amounts to "infinity - infinity" as an error,
     * since the interval type has nothing equivalent to NaN.
     */
    if (TIMESTAMP_IS_NOBEGIN(dt1))
    {
        if (TIMESTAMP_IS_NOBEGIN(dt2))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
        else
            INTERVAL_NOBEGIN(result);
    }
    else if (TIMESTAMP_IS_NOEND(dt1))
    {
        if (TIMESTAMP_IS_NOEND(dt2))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
        else
            INTERVAL_NOEND(result);
    }
    else if (TIMESTAMP_IS_NOBEGIN(dt2))
        INTERVAL_NOEND(result);
    else if (TIMESTAMP_IS_NOEND(dt2))
        INTERVAL_NOBEGIN(result);
    else 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, INTERVAL_NOBEGIN, INTERVAL_NOEND, isleap, itm2interval(), MINS_PER_HOUR, MONTHS_PER_YEAR, palloc(), PG_GETARG_TIMESTAMP, PG_RETURN_INTERVAL_P, SECS_PER_MINUTE, timestamp2tm(), TIMESTAMP_IS_NOBEGIN, TIMESTAMP_IS_NOEND, tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, and USECS_PER_SEC.

timestamp_at_local()

Datum timestamp_at_local

(

PG_FUNCTION_ARGS

)

Definition at line 6941 of file timestamp.c.

{
    return timestamp_timestamptz(fcinfo);
}

References timestamp_timestamptz().

timestamp_bin()

Datum timestamp_bin

(

PG_FUNCTION_ARGS

)

Definition at line 4606 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,
                stride_usecs,
                tm_diff,
                tm_modulo,
                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 (INTERVAL_NOT_FINITE(stride))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamps cannot be binned into infinite intervals")));
 
    if (stride->month != 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("timestamps cannot be binned into intervals containing months or years")));
 
    if (unlikely(pg_mul_s64_overflow(stride->day, USECS_PER_DAY, &stride_usecs)) ||
        unlikely(pg_add_s64_overflow(stride_usecs, stride->time, &stride_usecs)))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
 
    if (stride_usecs <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("stride must be greater than zero")));
 
    if (unlikely(pg_sub_s64_overflow(timestamp, origin, &tm_diff)))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
 
    /* These calculations cannot overflow */
    tm_modulo = tm_diff % stride_usecs;
    tm_delta = tm_diff - tm_modulo;
    result = origin + tm_delta;
 
    /*
     * We want to round towards -infinity, not 0, when tm_diff is negative and
     * not a multiple of stride_usecs.  This adjustment *can* cause overflow,
     * since the result might now be out of the range origin .. timestamp.
     */
    if (tm_modulo < 0)
    {
        if (unlikely(pg_sub_s64_overflow(result, stride_usecs, &result)) ||
            !IS_VALID_TIMESTAMP(result))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
    }
 
    PG_RETURN_TIMESTAMP(result);
}

References Interval::day, ereport, errcode(), errmsg(), ERROR, INTERVAL_NOT_FINITE, IS_VALID_TIMESTAMP, Interval::month, pg_add_s64_overflow(), PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMP, pg_mul_s64_overflow(), PG_RETURN_TIMESTAMP, pg_sub_s64_overflow(), Interval::time, TIMESTAMP_NOT_FINITE, unlikely, and USECS_PER_DAY.

timestamp_cmp()

Datum timestamp_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 2270 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(), gbt_ts_ssup_cmp(), and gbt_tskey_cmp().

timestamp_cmp_internal()

int timestamp_cmp_internal	(	Timestamp	dt1,
		Timestamp	dt2
	)

Definition at line 2210 of file timestamp.c.

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

Referenced by date_cmp_timestamp_internal(), generate_series_timestamp(), generate_series_timestamptz_internal(), 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 2459 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 2384 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_decrement()

static Datum timestamp_decrement ( Relation  rel, Datum  existing, bool *  underflow  )

static

Definition at line 2310 of file timestamp.c.

{
    Timestamp   texisting = DatumGetTimestamp(existing);
 
    if (texisting == PG_INT64_MIN)
    {
        /* return value is undefined */
        *underflow = true;
        return (Datum) 0;
    }
 
    *underflow = false;
    return TimestampGetDatum(texisting - 1);
}

References DatumGetTimestamp(), PG_INT64_MIN, and TimestampGetDatum().

Referenced by timestamp_skipsupport().

timestamp_eq()

Datum timestamp_eq

(

PG_FUNCTION_ARGS

)

Definition at line 2216 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 2405 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 2281 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 2147 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 2261 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 2450 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 2243 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 2432 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 2356 of file timestamp.c.

{
    return hashint8(fcinfo);
}

References hashint8().

timestamp_hash_extended()

Datum timestamp_hash_extended

(

PG_FUNCTION_ARGS

)

Definition at line 2362 of file timestamp.c.

{
    return hashint8extended(fcinfo);
}

References hashint8extended().

timestamp_in()

Datum timestamp_in

(

PG_FUNCTION_ARGS

)

Definition at line 166 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(), str, TIMESTAMP_NOBEGIN, TIMESTAMP_NOEND, tm, and tm2timestamp().

Referenced by moddatetime().

timestamp_increment()

static Datum timestamp_increment ( Relation  rel, Datum  existing, bool *  overflow  )

static

Definition at line 2327 of file timestamp.c.

{
    Timestamp   texisting = DatumGetTimestamp(existing);
 
    if (texisting == PG_INT64_MAX)
    {
        /* return value is undefined */
        *overflow = true;
        return (Datum) 0;
    }
 
    *overflow = false;
    return TimestampGetDatum(texisting + 1);
}

References DatumGetTimestamp(), PG_INT64_MAX, and TimestampGetDatum().

Referenced by timestamp_skipsupport().

timestamp_izone()

Datum timestamp_izone

(

PG_FUNCTION_ARGS

)

Definition at line 6391 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 (INTERVAL_NOT_FINITE(zone))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("interval time zone \"%s\" must be finite",
                        DatumGetCString(DirectFunctionCall1(interval_out,
                                                            PointerGetDatum(zone))))));
 
    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_NOT_FINITE, interval_out(), IS_VALID_TIMESTAMP, PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMP, PG_RETURN_TIMESTAMPTZ, PointerGetDatum(), TIMESTAMP_NOT_FINITE, and USECS_PER_SEC.

timestamp_larger()

Datum timestamp_larger

(

PG_FUNCTION_ARGS

)

Definition at line 2830 of file timestamp.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
    Timestamp   result;
 
    if (timestamp_cmp_internal(dt1, dt2) > 0)
        result = dt1;
    else
        result = dt2;
    PG_RETURN_TIMESTAMP(result);
}

References PG_GETARG_TIMESTAMP, PG_RETURN_TIMESTAMP, and timestamp_cmp_internal().

timestamp_le()

Datum timestamp_le

(

PG_FUNCTION_ARGS

)

Definition at line 2252 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_tsle().

timestamp_le_timestamptz()

Datum timestamp_le_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 2441 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_lt()

Datum timestamp_lt

(

PG_FUNCTION_ARGS

)

Definition at line 2234 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_tslt().

timestamp_lt_timestamptz()

Datum timestamp_lt_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 2423 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_mi()

Datum timestamp_mi

(

PG_FUNCTION_ARGS

)

Definition at line 2845 of file timestamp.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
    Interval   *result;
 
    result = (Interval *) palloc(sizeof(Interval));
 
    /*
     * Handle infinities.
     *
     * We treat anything that amounts to "infinity - infinity" as an error,
     * since the interval type has nothing equivalent to NaN.
     */
    if (TIMESTAMP_NOT_FINITE(dt1) || TIMESTAMP_NOT_FINITE(dt2))
    {
        if (TIMESTAMP_IS_NOBEGIN(dt1))
        {
            if (TIMESTAMP_IS_NOBEGIN(dt2))
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("interval out of range")));
            else
                INTERVAL_NOBEGIN(result);
        }
        else if (TIMESTAMP_IS_NOEND(dt1))
        {
            if (TIMESTAMP_IS_NOEND(dt2))
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("interval out of range")));
            else
                INTERVAL_NOEND(result);
        }
        else if (TIMESTAMP_IS_NOBEGIN(dt2))
            INTERVAL_NOEND(result);
        else                    /* TIMESTAMP_IS_NOEND(dt2) */
            INTERVAL_NOBEGIN(result);
 
        PG_RETURN_INTERVAL_P(result);
    }
 
    if (unlikely(pg_sub_s64_overflow(dt1, dt2, &result->time)))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
 
    result->month = 0;
    result->day = 0;
 
    /*----------
     *  This is wrong, but removing it breaks a lot of regression tests.
     *  For example:
     *
     *  test=> SET timezone = 'EST5EDT';
     *  test=> SELECT
     *  test-> ('2005-10-30 13:22:00-05'::timestamptz -
     *  test(>  '2005-10-29 13:22:00-04'::timestamptz);
     *  ?column?
     *  ----------------
     *   1 day 01:00:00
     *   (1 row)
     *
     *  so adding that to the first timestamp gets:
     *
     *   test=> SELECT
     *   test-> ('2005-10-29 13:22:00-04'::timestamptz +
     *   test(> ('2005-10-30 13:22:00-05'::timestamptz -
     *   test(>  '2005-10-29 13:22:00-04'::timestamptz)) at time zone 'EST';
     *      timezone
     *  --------------------
     *  2005-10-30 14:22:00
     *  (1 row)
     *----------
     */
    result = DatumGetIntervalP(DirectFunctionCall1(interval_justify_hours,
                                                   IntervalPGetDatum(result)));
 
    PG_RETURN_INTERVAL_P(result);
}

References DatumGetIntervalP(), Interval::day, DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, interval_justify_hours(), INTERVAL_NOBEGIN, INTERVAL_NOEND, IntervalPGetDatum(), Interval::month, palloc(), PG_GETARG_TIMESTAMP, PG_RETURN_INTERVAL_P, pg_sub_s64_overflow(), Interval::time, TIMESTAMP_IS_NOBEGIN, TIMESTAMP_IS_NOEND, TIMESTAMP_NOT_FINITE, and unlikely.

Referenced by gbt_ts_dist(), generate_series_timestamp_support(), ts_dist(), and tstz_dist().

timestamp_mi_interval()

Datum timestamp_mi_interval

(

PG_FUNCTION_ARGS

)

Definition at line 3225 of file timestamp.c.

{
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    Interval    tspan;
 
    interval_um_internal(span, &tspan);
 
    return DirectFunctionCall2(timestamp_pl_interval,
                               TimestampGetDatum(timestamp),
                               PointerGetDatum(&tspan));
}

References DirectFunctionCall2, interval_um_internal(), PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMP, PointerGetDatum(), timestamp_pl_interval(), and TimestampGetDatum().

Referenced by date_mi_interval(), and in_range_timestamp_interval().

timestamp_ne()

Datum timestamp_ne

(

PG_FUNCTION_ARGS

)

Definition at line 2225 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().

timestamp_ne_timestamptz()

Datum timestamp_ne_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 2414 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_out()

Datum timestamp_out

(

PG_FUNCTION_ARGS

)

Definition at line 234 of file timestamp.c.

{
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(0);
    char       *result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    char        buf[MAXDATELEN + 1];
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
        EncodeSpecialTimestamp(timestamp, buf);
    else if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) == 0)
        EncodeDateTime(tm, fsec, false, 0, NULL, DateStyle, buf);
    else
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    result = pstrdup(buf);
    PG_RETURN_CSTRING(result);
}

References buf, DateStyle, EncodeDateTime(), EncodeSpecialTimestamp(), ereport, errcode(), errmsg(), ERROR, MAXDATELEN, PG_GETARG_TIMESTAMP, PG_RETURN_CSTRING, pstrdup(), timestamp2tm(), TIMESTAMP_NOT_FINITE, and tm.

Referenced by ExecGetJsonValueItemString().

timestamp_part()

Datum timestamp_part

(

PG_FUNCTION_ARGS

)

Definition at line 5757 of file timestamp.c.

{
    return timestamp_part_common(fcinfo, false);
}

References timestamp_part_common().

timestamp_part_common()

static Datum timestamp_part_common ( PG_FUNCTION_ARGS  , bool  retnumeric  )

static

Definition at line 5499 of file timestamp.c.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(1);
    int64       intresult;
    Timestamp   epoch;
    int         type,
                val;
    char       *lowunits;
    fsec_t      fsec;
    struct pg_tm tt,
               *tm = &tt;
 
    lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
                                            VARSIZE_ANY_EXHDR(units),
                                            false);
 
    type = DecodeUnits(0, lowunits, &val);
    if (type == UNKNOWN_FIELD)
        type = DecodeSpecial(0, lowunits, &val);
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
    {
        double      r = NonFiniteTimestampTzPart(type, val, lowunits,
                                                 TIMESTAMP_IS_NOBEGIN(timestamp),
                                                 false);
 
        if (r != 0.0)
        {
            if (retnumeric)
            {
                if (r < 0)
                    return DirectFunctionCall3(numeric_in,
                                               CStringGetDatum("-Infinity"),
                                               ObjectIdGetDatum(InvalidOid),
                                               Int32GetDatum(-1));
                else if (r > 0)
                    return DirectFunctionCall3(numeric_in,
                                               CStringGetDatum("Infinity"),
                                               ObjectIdGetDatum(InvalidOid),
                                               Int32GetDatum(-1));
            }
            else
                PG_RETURN_FLOAT8(r);
        }
        else
            PG_RETURN_NULL();
    }
 
    if (type == UNITS)
    {
        if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
 
        switch (val)
        {
            case DTK_MICROSEC:
                intresult = tm->tm_sec * INT64CONST(1000000) + fsec;
                break;
 
            case DTK_MILLISEC:
                if (retnumeric)
                    /*---
                     * tm->tm_sec * 1000 + fsec / 1000
                     * = (tm->tm_sec * 1'000'000 + fsec) / 1000
                     */
                    PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + fsec, 3));
                else
                    PG_RETURN_FLOAT8(tm->tm_sec * 1000.0 + fsec / 1000.0);
                break;
 
            case DTK_SECOND:
                if (retnumeric)
                    /*---
                     * tm->tm_sec + fsec / 1'000'000
                     * = (tm->tm_sec * 1'000'000 + fsec) / 1'000'000
                     */
                    PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + fsec, 6));
                else
                    PG_RETURN_FLOAT8(tm->tm_sec + fsec / 1000000.0);
                break;
 
            case DTK_MINUTE:
                intresult = tm->tm_min;
                break;
 
            case DTK_HOUR:
                intresult = tm->tm_hour;
                break;
 
            case DTK_DAY:
                intresult = tm->tm_mday;
                break;
 
            case DTK_MONTH:
                intresult = tm->tm_mon;
                break;
 
            case DTK_QUARTER:
                intresult = (tm->tm_mon - 1) / 3 + 1;
                break;
 
            case DTK_WEEK:
                intresult = date2isoweek(tm->tm_year, tm->tm_mon, tm->tm_mday);
                break;
 
            case DTK_YEAR:
                if (tm->tm_year > 0)
                    intresult = tm->tm_year;
                else
                    /* there is no year 0, just 1 BC and 1 AD */
                    intresult = tm->tm_year - 1;
                break;
 
            case DTK_DECADE:
 
                /*
                 * what is a decade wrt dates? let us assume that decade 199
                 * is 1990 thru 1999... decade 0 starts on year 1 BC, and -1
                 * is 11 BC thru 2 BC...
                 */
                if (tm->tm_year >= 0)
                    intresult = tm->tm_year / 10;
                else
                    intresult = -((8 - (tm->tm_year - 1)) / 10);
                break;
 
            case DTK_CENTURY:
 
                /* ----
                 * centuries AD, c>0: year in [ (c-1)* 100 + 1 : c*100 ]
                 * centuries BC, c<0: year in [ c*100 : (c+1) * 100 - 1]
                 * there is no number 0 century.
                 * ----
                 */
                if (tm->tm_year > 0)
                    intresult = (tm->tm_year + 99) / 100;
                else
                    /* caution: C division may have negative remainder */
                    intresult = -((99 - (tm->tm_year - 1)) / 100);
                break;
 
            case DTK_MILLENNIUM:
                /* see comments above. */
                if (tm->tm_year > 0)
                    intresult = (tm->tm_year + 999) / 1000;
                else
                    intresult = -((999 - (tm->tm_year - 1)) / 1000);
                break;
 
            case DTK_JULIAN:
                if (retnumeric)
                    PG_RETURN_NUMERIC(numeric_add_opt_error(int64_to_numeric(date2j(tm->tm_year, tm->tm_mon, tm->tm_mday)),
                                                            numeric_div_opt_error(int64_to_numeric(((((tm->tm_hour * MINS_PER_HOUR) + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) * INT64CONST(1000000) + fsec),
                                                                                  int64_to_numeric(SECS_PER_DAY * INT64CONST(1000000)),
                                                                                  NULL),
                                                            NULL));
                else
                    PG_RETURN_FLOAT8(date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) +
                                     ((((tm->tm_hour * MINS_PER_HOUR) + tm->tm_min) * SECS_PER_MINUTE) +
                                      tm->tm_sec + (fsec / 1000000.0)) / (double) SECS_PER_DAY);
                break;
 
            case DTK_ISOYEAR:
                intresult = date2isoyear(tm->tm_year, tm->tm_mon, tm->tm_mday);
                /* Adjust BC years */
                if (intresult <= 0)
                    intresult -= 1;
                break;
 
            case DTK_DOW:
            case DTK_ISODOW:
                intresult = j2day(date2j(tm->tm_year, tm->tm_mon, tm->tm_mday));
                if (val == DTK_ISODOW && intresult == 0)
                    intresult = 7;
                break;
 
            case DTK_DOY:
                intresult = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday)
                             - date2j(tm->tm_year, 1, 1) + 1);
                break;
 
            case DTK_TZ:
            case DTK_TZ_MINUTE:
            case DTK_TZ_HOUR:
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("unit \"%s\" not supported for type %s",
                                lowunits, format_type_be(TIMESTAMPOID))));
                intresult = 0;
        }
    }
    else if (type == RESERV)
    {
        switch (val)
        {
            case DTK_EPOCH:
                epoch = SetEpochTimestamp();
                /* (timestamp - epoch) / 1000000 */
                if (retnumeric)
                {
                    Numeric     result;
 
                    if (timestamp < (PG_INT64_MAX + epoch))
                        result = int64_div_fast_to_numeric(timestamp - epoch, 6);
                    else
                    {
                        result = numeric_div_opt_error(numeric_sub_opt_error(int64_to_numeric(timestamp),
                                                                             int64_to_numeric(epoch),
                                                                             NULL),
                                                       int64_to_numeric(1000000),
                                                       NULL);
                        result = DatumGetNumeric(DirectFunctionCall2(numeric_round,
                                                                     NumericGetDatum(result),
                                                                     Int32GetDatum(6)));
                    }
                    PG_RETURN_NUMERIC(result);
                }
                else
                {
                    float8      result;
 
                    /* try to avoid precision loss in subtraction */
                    if (timestamp < (PG_INT64_MAX + epoch))
                        result = (timestamp - epoch) / 1000000.0;
                    else
                        result = ((float8) timestamp - epoch) / 1000000.0;
                    PG_RETURN_FLOAT8(result);
                }
                break;
 
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("unit \"%s\" not supported for type %s",
                                lowunits, format_type_be(TIMESTAMPOID))));
                intresult = 0;
        }
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unit \"%s\" not recognized for type %s",
                        lowunits, format_type_be(TIMESTAMPOID))));
        intresult = 0;
    }
 
    if (retnumeric)
        PG_RETURN_NUMERIC(int64_to_numeric(intresult));
    else
        PG_RETURN_FLOAT8(intresult);
}

References CStringGetDatum(), date2isoweek(), date2isoyear(), date2j(), DatumGetNumeric(), DecodeSpecial(), DecodeUnits(), DirectFunctionCall2, DirectFunctionCall3, downcase_truncate_identifier(), 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, epoch, ereport, errcode(), errmsg(), ERROR, format_type_be(), Int32GetDatum(), int64_div_fast_to_numeric(), int64_to_numeric(), INT64CONST, InvalidOid, j2day(), MINS_PER_HOUR, NonFiniteTimestampTzPart(), numeric_add_opt_error(), numeric_div_opt_error(), numeric_in(), numeric_round(), numeric_sub_opt_error(), NumericGetDatum(), ObjectIdGetDatum(), PG_GETARG_TEXT_PP, PG_GETARG_TIMESTAMP, PG_INT64_MAX, PG_RETURN_FLOAT8, PG_RETURN_NULL, PG_RETURN_NUMERIC, RESERV, SECS_PER_DAY, SECS_PER_MINUTE, SetEpochTimestamp(), timestamp2tm(), TIMESTAMP_IS_NOBEGIN, TIMESTAMP_NOT_FINITE, 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, type, UNITS, UNKNOWN_FIELD, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by extract_timestamp(), and timestamp_part().

timestamp_pl_interval()

Datum timestamp_pl_interval

(

PG_FUNCTION_ARGS

)

Definition at line 3108 of file timestamp.c.

{
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    Timestamp   result;
 
    /*
     * Handle infinities.
     *
     * We treat anything that amounts to "infinity - infinity" as an error,
     * since the timestamp type has nothing equivalent to NaN.
     */
    if (INTERVAL_IS_NOBEGIN(span))
    {
        if (TIMESTAMP_IS_NOEND(timestamp))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
        else
            TIMESTAMP_NOBEGIN(result);
    }
    else if (INTERVAL_IS_NOEND(span))
    {
        if (TIMESTAMP_IS_NOBEGIN(timestamp))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
        else
            TIMESTAMP_NOEND(result);
    }
    else if (TIMESTAMP_NOT_FINITE(timestamp))
        result = timestamp;
    else
    {
        if (span->month != 0)
        {
            struct pg_tm tt,
                       *tm = &tt;
            fsec_t      fsec;
 
            if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
 
            if (pg_add_s32_overflow(tm->tm_mon, span->month, &tm->tm_mon))
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
            if (tm->tm_mon > MONTHS_PER_YEAR)
            {
                tm->tm_year += (tm->tm_mon - 1) / MONTHS_PER_YEAR;
                tm->tm_mon = ((tm->tm_mon - 1) % MONTHS_PER_YEAR) + 1;
            }
            else if (tm->tm_mon < 1)
            {
                tm->tm_year += tm->tm_mon / MONTHS_PER_YEAR - 1;
                tm->tm_mon = tm->tm_mon % MONTHS_PER_YEAR + MONTHS_PER_YEAR;
            }
 
            /* adjust for end of month boundary problems... */
            if (tm->tm_mday > day_tab[isleap(tm->tm_year)][tm->tm_mon - 1])
                tm->tm_mday = (day_tab[isleap(tm->tm_year)][tm->tm_mon - 1]);
 
            if (tm2timestamp(tm, fsec, NULL, &timestamp) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
        }
 
        if (span->day != 0)
        {
            struct pg_tm tt,
                       *tm = &tt;
            fsec_t      fsec;
            int         julian;
 
            if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
 
            /*
             * Add days by converting to and from Julian.  We need an overflow
             * check here since j2date expects a non-negative integer input.
             */
            julian = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday);
            if (pg_add_s32_overflow(julian, span->day, &julian) ||
                julian < 0)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
            j2date(julian, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
 
            if (tm2timestamp(tm, fsec, NULL, &timestamp) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
        }
 
        if (pg_add_s64_overflow(timestamp, span->time, &timestamp))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
 
        if (!IS_VALID_TIMESTAMP(timestamp))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
 
        result = timestamp;
    }
 
    PG_RETURN_TIMESTAMP(result);
}

References date2j(), Interval::day, day_tab, ereport, errcode(), errmsg(), ERROR, INTERVAL_IS_NOBEGIN, INTERVAL_IS_NOEND, IS_VALID_TIMESTAMP, isleap, j2date(), Interval::month, MONTHS_PER_YEAR, pg_add_s32_overflow(), pg_add_s64_overflow(), PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMP, PG_RETURN_TIMESTAMP, Interval::time, timestamp2tm(), TIMESTAMP_IS_NOBEGIN, TIMESTAMP_IS_NOEND, TIMESTAMP_NOBEGIN, TIMESTAMP_NOEND, TIMESTAMP_NOT_FINITE, tm, tm2timestamp(), pg_tm::tm_mday, pg_tm::tm_mon, and pg_tm::tm_year.

Referenced by date_pl_interval(), generate_series_timestamp(), in_range_timestamp_interval(), and timestamp_mi_interval().

timestamp_recv()

Datum timestamp_recv

(

PG_FUNCTION_ARGS

)

Definition at line 260 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);
    Timestamp   timestamp;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
 
    timestamp = (Timestamp) pq_getmsgint64(buf);
 
    /* range check: see if timestamp_out would like it */
    if (TIMESTAMP_NOT_FINITE(timestamp))
         /* ok */ ;
    else if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0 ||
             !IS_VALID_TIMESTAMP(timestamp))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    AdjustTimestampForTypmod(&timestamp, typmod, NULL);
 
    PG_RETURN_TIMESTAMP(timestamp);
}

References AdjustTimestampForTypmod(), buf, ereport, errcode(), errmsg(), ERROR, IS_VALID_TIMESTAMP, PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_TIMESTAMP, pq_getmsgint64(), timestamp2tm(), TIMESTAMP_NOT_FINITE, and tm.

timestamp_scale()

Datum timestamp_scale

(

PG_FUNCTION_ARGS

)

Definition at line 347 of file timestamp.c.

{
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(0);
    int32       typmod = PG_GETARG_INT32(1);
    Timestamp   result;
 
    result = timestamp;
 
    AdjustTimestampForTypmod(&result, typmod, NULL);
 
    PG_RETURN_TIMESTAMP(result);
}

References AdjustTimestampForTypmod(), PG_GETARG_INT32, PG_GETARG_TIMESTAMP, and PG_RETURN_TIMESTAMP.

timestamp_send()

Datum timestamp_send

(

PG_FUNCTION_ARGS

)

Definition at line 293 of file timestamp.c.

{
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendint64(&buf, timestamp);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

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

timestamp_skipsupport()

Datum timestamp_skipsupport

(

PG_FUNCTION_ARGS

)

Definition at line 2343 of file timestamp.c.

{
    SkipSupport sksup = (SkipSupport) PG_GETARG_POINTER(0);
 
    sksup->decrement = timestamp_decrement;
    sksup->increment = timestamp_increment;
    sksup->low_elem = TimestampGetDatum(PG_INT64_MIN);
    sksup->high_elem = TimestampGetDatum(PG_INT64_MAX);
 
    PG_RETURN_VOID();
}

References SkipSupportData::decrement, SkipSupportData::high_elem, SkipSupportData::increment, SkipSupportData::low_elem, PG_GETARG_POINTER, PG_INT64_MAX, PG_INT64_MIN, PG_RETURN_VOID, timestamp_decrement(), timestamp_increment(), and TimestampGetDatum().

timestamp_smaller()

Datum timestamp_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 2815 of file timestamp.c.

{
    Timestamp   dt1 = PG_GETARG_TIMESTAMP(0);
    Timestamp   dt2 = PG_GETARG_TIMESTAMP(1);
    Timestamp   result;
 
    /* use timestamp_cmp_internal to be sure this agrees with comparisons */
    if (timestamp_cmp_internal(dt1, dt2) < 0)
        result = dt1;
    else
        result = dt2;
    PG_RETURN_TIMESTAMP(result);
}

References PG_GETARG_TIMESTAMP, PG_RETURN_TIMESTAMP, and timestamp_cmp_internal().

timestamp_sortsupport()

Datum timestamp_sortsupport

(

PG_FUNCTION_ARGS

)

Definition at line 2291 of file timestamp.c.

{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
 
#if SIZEOF_DATUM >= 8
 
    /*
     * If this build has pass-by-value timestamps, then we can use a standard
     * comparator function.
     */
    ssup->comparator = ssup_datum_signed_cmp;
#else
    ssup->comparator = timestamp_fastcmp;
#endif
    PG_RETURN_VOID();
}

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

timestamp_support()

Datum timestamp_support

(

PG_FUNCTION_ARGS

)

Definition at line 327 of file timestamp.c.

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

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

timestamp_timestamptz()

Datum timestamp_timestamptz

(

PG_FUNCTION_ARGS

)

Definition at line 6448 of file timestamp.c.

{
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(0);
 
    PG_RETURN_TIMESTAMPTZ(timestamp2timestamptz(timestamp));
}

References PG_GETARG_TIMESTAMP, PG_RETURN_TIMESTAMPTZ, and timestamp2timestamptz().

Referenced by executeDateTimeMethod(), and timestamp_at_local().

timestamp_trunc()

Datum timestamp_trunc

(

PG_FUNCTION_ARGS

)

Definition at line 4677 of file timestamp.c.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(1);
    Timestamp   result;
    int         type,
                val;
    char       *lowunits;
    fsec_t      fsec;
    struct pg_tm tt,
               *tm = &tt;
 
    lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
                                            VARSIZE_ANY_EXHDR(units),
                                            false);
 
    type = DecodeUnits(0, lowunits, &val);
 
    if (type == UNITS)
    {
        if (TIMESTAMP_NOT_FINITE(timestamp))
        {
            /*
             * Errors thrown here for invalid units should exactly match those
             * below, else there will be unexpected discrepancies between
             * finite- and infinite-input cases.
             */
            switch (val)
            {
                case DTK_WEEK:
                case DTK_MILLENNIUM:
                case DTK_CENTURY:
                case DTK_DECADE:
                case DTK_YEAR:
                case DTK_QUARTER:
                case DTK_MONTH:
                case DTK_DAY:
                case DTK_HOUR:
                case DTK_MINUTE:
                case DTK_SECOND:
                case DTK_MILLISEC:
                case DTK_MICROSEC:
                    PG_RETURN_TIMESTAMP(timestamp);
                    break;
                default:
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("unit \"%s\" not supported for type %s",
                                    lowunits, format_type_be(TIMESTAMPOID))));
                    result = 0;
            }
        }
 
        if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
 
        switch (val)
        {
            case DTK_WEEK:
                {
                    int         woy;
 
                    woy = date2isoweek(tm->tm_year, tm->tm_mon, tm->tm_mday);
 
                    /*
                     * If it is week 52/53 and the month is January, then the
                     * week must belong to the previous year. Also, some
                     * December dates belong to the next year.
                     */
                    if (woy >= 52 && tm->tm_mon == 1)
                        --tm->tm_year;
                    if (woy <= 1 && tm->tm_mon == MONTHS_PER_YEAR)
                        ++tm->tm_year;
                    isoweek2date(woy, &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
                    tm->tm_hour = 0;
                    tm->tm_min = 0;
                    tm->tm_sec = 0;
                    fsec = 0;
                    break;
                }
            case DTK_MILLENNIUM:
                /* see comments in timestamptz_trunc */
                if (tm->tm_year > 0)
                    tm->tm_year = ((tm->tm_year + 999) / 1000) * 1000 - 999;
                else
                    tm->tm_year = -((999 - (tm->tm_year - 1)) / 1000) * 1000 + 1;
                /* FALL THRU */
            case DTK_CENTURY:
                /* see comments in timestamptz_trunc */
                if (tm->tm_year > 0)
                    tm->tm_year = ((tm->tm_year + 99) / 100) * 100 - 99;
                else
                    tm->tm_year = -((99 - (tm->tm_year - 1)) / 100) * 100 + 1;
                /* FALL THRU */
            case DTK_DECADE:
                /* see comments in timestamptz_trunc */
                if (val != DTK_MILLENNIUM && val != DTK_CENTURY)
                {
                    if (tm->tm_year > 0)
                        tm->tm_year = (tm->tm_year / 10) * 10;
                    else
                        tm->tm_year = -((8 - (tm->tm_year - 1)) / 10) * 10;
                }
                /* FALL THRU */
            case DTK_YEAR:
                tm->tm_mon = 1;
                /* FALL THRU */
            case DTK_QUARTER:
                tm->tm_mon = (3 * ((tm->tm_mon - 1) / 3)) + 1;
                /* FALL THRU */
            case DTK_MONTH:
                tm->tm_mday = 1;
                /* 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:
                fsec = 0;
                break;
 
            case DTK_MILLISEC:
                fsec = (fsec / 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(TIMESTAMPOID))));
                result = 0;
        }
 
        if (tm2timestamp(tm, fsec, NULL, &result) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unit \"%s\" not recognized for type %s",
                        lowunits, format_type_be(TIMESTAMPOID))));
        result = 0;
    }
 
    PG_RETURN_TIMESTAMP(result);
}

References date2isoweek(), 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(), errmsg(), ERROR, format_type_be(), isoweek2date(), MONTHS_PER_YEAR, PG_GETARG_TEXT_PP, PG_GETARG_TIMESTAMP, PG_RETURN_TIMESTAMP, timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, tm2timestamp(), pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, type, UNITS, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

timestamp_zone()

Datum timestamp_zone

(

PG_FUNCTION_ARGS

)

Definition at line 6326 of file timestamp.c.

{
    text       *zone = PG_GETARG_TEXT_PP(0);
    Timestamp   timestamp = PG_GETARG_TIMESTAMP(1);
    TimestampTz result;
    int         tz;
    char        tzname[TZ_STRLEN_MAX + 1];
    int         type,
                val;
    pg_tz      *tzp;
    struct pg_tm tm;
    fsec_t      fsec;
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
        PG_RETURN_TIMESTAMPTZ(timestamp);
 
    /*
     * Look up the requested timezone.
     */
    text_to_cstring_buffer(zone, tzname, sizeof(tzname));
 
    type = DecodeTimezoneName(tzname, &val, &tzp);
 
    if (type == TZNAME_FIXED_OFFSET)
    {
        /* fixed-offset abbreviation */
        tz = val;
        result = dt2local(timestamp, tz);
    }
    else if (type == TZNAME_DYNTZ)
    {
        /* dynamic-offset abbreviation, resolve using specified time */
        if (timestamp2tm(timestamp, NULL, &tm, &fsec, NULL, tzp) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
        tz = -DetermineTimeZoneAbbrevOffset(&tm, tzname, tzp);
        result = dt2local(timestamp, tz);
    }
    else
    {
        /* full zone name, rotate to that zone */
        if (timestamp2tm(timestamp, NULL, &tm, &fsec, NULL, tzp) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
        tz = DetermineTimeZoneOffset(&tm, tzp);
        if (tm2timestamp(&tm, fsec, &tz, &result) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
    }
 
    if (!IS_VALID_TIMESTAMP(result))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    PG_RETURN_TIMESTAMPTZ(result);
}

References DecodeTimezoneName(), DetermineTimeZoneAbbrevOffset(), DetermineTimeZoneOffset(), dt2local(), ereport, errcode(), errmsg(), ERROR, IS_VALID_TIMESTAMP, PG_GETARG_TEXT_PP, PG_GETARG_TIMESTAMP, PG_RETURN_TIMESTAMPTZ, text_to_cstring_buffer(), timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, tm2timestamp(), type, TZ_STRLEN_MAX, TZNAME_DYNTZ, TZNAME_FIXED_OFFSET, and val.

TimestampDifference()

void TimestampDifference	(	TimestampTz	start_time,
		TimestampTz	stop_time,
		long *	secs,
		int *	microsecs
	)

Definition at line 1721 of file timestamp.c.

{
    TimestampTz diff = stop_time - start_time;
 
    if (diff <= 0)
    {
        *secs = 0;
        *microsecs = 0;
    }
    else
    {
        *secs = (long) (diff / USECS_PER_SEC);
        *microsecs = (int) (diff % USECS_PER_SEC);
    }
}

References start_time, and USECS_PER_SEC.

Referenced by check_log_duration(), has_startup_progress_timeout_expired(), heap_vacuum_rel(), InvalidatePossiblyObsoleteSlot(), launcher_determine_sleep(), log_disconnections(), LogRecoveryConflict(), pgstat_report_activity(), pgstat_update_dbstats(), ProcSleep(), schedule_alarm(), and TimestampDifferenceExceedsSeconds().

TimestampDifferenceExceeds()

bool TimestampDifferenceExceeds	(	TimestampTz	start_time,
		TimestampTz	stop_time,
		int	msec
	)

Definition at line 1781 of file timestamp.c.

{
    TimestampTz diff = stop_time - start_time;
 
    return (diff >= msec * INT64CONST(1000));
}

References INT64CONST, and start_time.

Referenced by asyncQueueFillWarning(), AutoVacLauncherMain(), do_analyze_rel(), do_start_worker(), heap_vacuum_rel(), LockBufferForCleanup(), logicalrep_worker_launch(), maybe_start_bgworkers(), pa_send_data(), pgstat_report_stat(), process_syncing_tables_for_apply(), ProcSleep(), ResolveRecoveryConflictWithVirtualXIDs(), send_feedback(), WaitForWALToBecomeAvailable(), WalSndLoop(), WalSndUpdateProgress(), WalSndWaitForWal(), and XLogBackgroundFlush().

TimestampDifferenceExceedsSeconds()

bool TimestampDifferenceExceedsSeconds	(	TimestampTz	start_time,
		TimestampTz	stop_time,
		int	threshold_sec
	)

Definition at line 1795 of file timestamp.c.

{
    long        secs;
    int         usecs;
 
    /* Calculate the difference in seconds */
    TimestampDifference(start_time, stop_time, &secs, &usecs);
 
    return (secs >= threshold_sec);
}

References start_time, and TimestampDifference().

Referenced by DetermineSlotInvalidationCause().

TimestampDifferenceMilliseconds()

long TimestampDifferenceMilliseconds	(	TimestampTz	start_time,
		TimestampTz	stop_time
	)

Definition at line 1757 of file timestamp.c.

{
    TimestampTz diff;
 
    /* Deal with zero or negative elapsed time quickly. */
    if (start_time >= stop_time)
        return 0;
    /* To not fail with timestamp infinities, we must detect overflow. */
    if (pg_sub_s64_overflow(stop_time, start_time, &diff))
        return (long) INT_MAX;
    if (diff >= (INT_MAX * INT64CONST(1000) - 999))
        return (long) INT_MAX;
    else
        return (long) ((diff + 999) / 1000);
}

References INT64CONST, pg_sub_s64_overflow(), and start_time.

Referenced by ApplyLauncherMain(), autoprewarm_main(), bbsink_copystream_archive_contents(), DetermineSleepTime(), do_analyze_rel(), GetReplicationApplyDelay(), GetReplicationTransferLatency(), libpqsrv_cancel(), LogCheckpointEnd(), pgfdw_get_cleanup_result(), pgstat_report_analyze(), pgstat_report_vacuum(), recoveryApplyDelay(), WaitForWalSummarization(), WaitForWALToBecomeAvailable(), WalReceiverMain(), and WalSndComputeSleeptime().

TimestampTimestampTzRequiresRewrite()

bool TimestampTimestampTzRequiresRewrite

(

void

)

Definition at line 6435 of file timestamp.c.

{
    long        offset;
 
    if (pg_get_timezone_offset(session_timezone, &offset) && offset == 0)
        return false;
    return true;
}

References pg_get_timezone_offset(), and session_timezone.

Referenced by ATColumnChangeRequiresRewrite().

timestamptypmodin()

Datum timestamptypmodin

(

PG_FUNCTION_ARGS

)

Definition at line 304 of file timestamp.c.

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

References anytimestamp_typmodin(), PG_GETARG_ARRAYTYPE_P, and PG_RETURN_INT32.

timestamptypmodout()

Datum timestamptypmodout

(

PG_FUNCTION_ARGS

)

Definition at line 312 of file timestamp.c.

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

References anytimestamp_typmodout(), PG_GETARG_INT32, and PG_RETURN_CSTRING.

timestamptz2timestamp()

static Timestamp timestamptz2timestamp ( TimestampTz  timestamp )

static

Definition at line 6535 of file timestamp.c.

{
    Timestamp   result;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    int         tz;
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
        result = timestamp;
    else
    {
        if (timestamp2tm(timestamp, &tz, tm, &fsec, NULL, NULL) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
        if (tm2timestamp(tm, fsec, NULL, &result) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
    }
    return result;
}

References ereport, errcode(), errmsg(), ERROR, timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, and tm2timestamp().

Referenced by GetSQLLocalTimestamp(), and timestamptz_timestamp().

timestamptz_age()

Datum timestamptz_age

(

PG_FUNCTION_ARGS

)

Definition at line 4452 of file timestamp.c.

{
    TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
    TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(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;
    int         tz1;
    int         tz2;
 
    result = (Interval *) palloc(sizeof(Interval));
 
    /*
     * Handle infinities.
     *
     * We treat anything that amounts to "infinity - infinity" as an error,
     * since the interval type has nothing equivalent to NaN.
     */
    if (TIMESTAMP_IS_NOBEGIN(dt1))
    {
        if (TIMESTAMP_IS_NOBEGIN(dt2))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
        else
            INTERVAL_NOBEGIN(result);
    }
    else if (TIMESTAMP_IS_NOEND(dt1))
    {
        if (TIMESTAMP_IS_NOEND(dt2))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("interval out of range")));
        else
            INTERVAL_NOEND(result);
    }
    else if (TIMESTAMP_IS_NOBEGIN(dt2))
        INTERVAL_NOEND(result);
    else if (TIMESTAMP_IS_NOEND(dt2))
        INTERVAL_NOBEGIN(result);
    else if (timestamp2tm(dt1, &tz1, tm1, &fsec1, NULL, NULL) == 0 &&
             timestamp2tm(dt2, &tz2, 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--;
        }
 
        /*
         * Note: we deliberately ignore any difference between tz1 and tz2.
         */
 
        /* 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, INTERVAL_NOBEGIN, INTERVAL_NOEND, isleap, itm2interval(), MINS_PER_HOUR, MONTHS_PER_YEAR, palloc(), PG_GETARG_TIMESTAMPTZ, PG_RETURN_INTERVAL_P, SECS_PER_MINUTE, timestamp2tm(), TIMESTAMP_IS_NOBEGIN, TIMESTAMP_IS_NOEND, tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, and USECS_PER_SEC.

timestamptz_at_local()

Datum timestamptz_at_local

(

PG_FUNCTION_ARGS

)

Definition at line 6947 of file timestamp.c.

{
    return timestamptz_timestamp(fcinfo);
}

References timestamptz_timestamp().

timestamptz_bin()

Datum timestamptz_bin

(

PG_FUNCTION_ARGS

)

Definition at line 4841 of file timestamp.c.

{
    Interval   *stride = PG_GETARG_INTERVAL_P(0);
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1);
    TimestampTz origin = PG_GETARG_TIMESTAMPTZ(2);
    TimestampTz result,
                stride_usecs,
                tm_diff,
                tm_modulo,
                tm_delta;
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
        PG_RETURN_TIMESTAMPTZ(timestamp);
 
    if (TIMESTAMP_NOT_FINITE(origin))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("origin out of range")));
 
    if (INTERVAL_NOT_FINITE(stride))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamps cannot be binned into infinite intervals")));
 
    if (stride->month != 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("timestamps cannot be binned into intervals containing months or years")));
 
    if (unlikely(pg_mul_s64_overflow(stride->day, USECS_PER_DAY, &stride_usecs)) ||
        unlikely(pg_add_s64_overflow(stride_usecs, stride->time, &stride_usecs)))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
 
    if (stride_usecs <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("stride must be greater than zero")));
 
    if (unlikely(pg_sub_s64_overflow(timestamp, origin, &tm_diff)))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("interval out of range")));
 
    /* These calculations cannot overflow */
    tm_modulo = tm_diff % stride_usecs;
    tm_delta = tm_diff - tm_modulo;
    result = origin + tm_delta;
 
    /*
     * We want to round towards -infinity, not 0, when tm_diff is negative and
     * not a multiple of stride_usecs.  This adjustment *can* cause overflow,
     * since the result might now be out of the range origin .. timestamp.
     */
    if (tm_modulo < 0)
    {
        if (unlikely(pg_sub_s64_overflow(result, stride_usecs, &result)) ||
            !IS_VALID_TIMESTAMP(result))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
    }
 
    PG_RETURN_TIMESTAMPTZ(result);
}

References Interval::day, ereport, errcode(), errmsg(), ERROR, INTERVAL_NOT_FINITE, IS_VALID_TIMESTAMP, Interval::month, pg_add_s64_overflow(), PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMPTZ, pg_mul_s64_overflow(), PG_RETURN_TIMESTAMPTZ, pg_sub_s64_overflow(), Interval::time, TIMESTAMP_NOT_FINITE, unlikely, and USECS_PER_DAY.

timestamptz_cmp_timestamp()

Datum timestamptz_cmp_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 2522 of file timestamp.c.

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

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

timestamptz_eq_timestamp()

Datum timestamptz_eq_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 2468 of file timestamp.c.

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

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

timestamptz_ge_timestamp()

Datum timestamptz_ge_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 2513 of file timestamp.c.

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

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

timestamptz_gt_timestamp()

Datum timestamptz_gt_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 2495 of file timestamp.c.

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

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

timestamptz_hash()

Datum timestamptz_hash

(

PG_FUNCTION_ARGS

)

Definition at line 2368 of file timestamp.c.

{
    return hashint8(fcinfo);
}

References hashint8().

timestamptz_hash_extended()

Datum timestamptz_hash_extended

(

PG_FUNCTION_ARGS

)

Definition at line 2374 of file timestamp.c.

{
    return hashint8extended(fcinfo);
}

References hashint8extended().

timestamptz_in()

Datum timestamptz_in

(

PG_FUNCTION_ARGS

)

Definition at line 418 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;
    TimestampTz 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 with time zone",
                           escontext);
        PG_RETURN_NULL();
    }
 
    switch (dtype)
    {
        case DTK_DATE:
            if (tm2timestamp(tm, fsec, &tz, &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 timestamptz \"%s\"",
                 dtype, str);
            TIMESTAMP_NOEND(result);
    }
 
    AdjustTimestampForTypmod(&result, typmod, escontext);
 
    PG_RETURN_TIMESTAMPTZ(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_TIMESTAMPTZ, SetEpochTimestamp(), str, TIMESTAMP_NOBEGIN, TIMESTAMP_NOEND, tm, and tm2timestamp().

Referenced by AlterRole(), CreateRole(), moddatetime(), and validateRecoveryParameters().

timestamptz_izone()

Datum timestamptz_izone

(

PG_FUNCTION_ARGS

)

Definition at line 6628 of file timestamp.c.

{
    Interval   *zone = PG_GETARG_INTERVAL_P(0);
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1);
    Timestamp   result;
    int         tz;
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
        PG_RETURN_TIMESTAMP(timestamp);
 
    if (INTERVAL_NOT_FINITE(zone))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("interval time zone \"%s\" must be finite",
                        DatumGetCString(DirectFunctionCall1(interval_out,
                                                            PointerGetDatum(zone))))));
 
    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_TIMESTAMP(result);
}

References DatumGetCString(), DirectFunctionCall1, dt2local(), ereport, errcode(), errmsg(), ERROR, INTERVAL_NOT_FINITE, interval_out(), IS_VALID_TIMESTAMP, PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMPTZ, PG_RETURN_TIMESTAMP, PointerGetDatum(), TIMESTAMP_NOT_FINITE, and USECS_PER_SEC.

timestamptz_le_timestamp()

Datum timestamptz_le_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 2504 of file timestamp.c.

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

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

timestamptz_lt_timestamp()

Datum timestamptz_lt_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 2486 of file timestamp.c.

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

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

timestamptz_mi_interval()

Datum timestamptz_mi_interval

(

PG_FUNCTION_ARGS

)

Definition at line 3407 of file timestamp.c.

{
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
 
    PG_RETURN_TIMESTAMP(timestamptz_mi_interval_internal(timestamp, span, NULL));
}

References PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMPTZ, PG_RETURN_TIMESTAMP, and timestamptz_mi_interval_internal().

timestamptz_mi_interval_at_zone()

Datum timestamptz_mi_interval_at_zone

(

PG_FUNCTION_ARGS

)

Definition at line 3430 of file timestamp.c.

{
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    text       *zone = PG_GETARG_TEXT_PP(2);
    pg_tz      *attimezone = lookup_timezone(zone);
 
    PG_RETURN_TIMESTAMP(timestamptz_mi_interval_internal(timestamp, span, attimezone));
}

References lookup_timezone(), PG_GETARG_INTERVAL_P, PG_GETARG_TEXT_PP, PG_GETARG_TIMESTAMPTZ, PG_RETURN_TIMESTAMP, and timestamptz_mi_interval_internal().

timestamptz_mi_interval_internal()

static TimestampTz timestamptz_mi_interval_internal ( TimestampTz  timestamp, Interval *  span, pg_tz *  attimezone  )

static

Definition at line 3383 of file timestamp.c.

{
    Interval    tspan;
 
    interval_um_internal(span, &tspan);
 
    return timestamptz_pl_interval_internal(timestamp, &tspan, attimezone);
}

References interval_um_internal(), and timestamptz_pl_interval_internal().

Referenced by in_range_timestamptz_interval(), timestamptz_mi_interval(), and timestamptz_mi_interval_at_zone().

timestamptz_ne_timestamp()

Datum timestamptz_ne_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 2477 of file timestamp.c.

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

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

timestamptz_out()

Datum timestamptz_out

(

PG_FUNCTION_ARGS

)

Definition at line 776 of file timestamp.c.

{
    TimestampTz dt = PG_GETARG_TIMESTAMPTZ(0);
    char       *result;
    int         tz;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    const char *tzn;
    char        buf[MAXDATELEN + 1];
 
    if (TIMESTAMP_NOT_FINITE(dt))
        EncodeSpecialTimestamp(dt, buf);
    else if (timestamp2tm(dt, &tz, tm, &fsec, &tzn, NULL) == 0)
        EncodeDateTime(tm, fsec, true, tz, tzn, DateStyle, buf);
    else
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    result = pstrdup(buf);
    PG_RETURN_CSTRING(result);
}

References buf, DateStyle, EncodeDateTime(), EncodeSpecialTimestamp(), ereport, errcode(), errmsg(), ERROR, MAXDATELEN, PG_GETARG_TIMESTAMPTZ, PG_RETURN_CSTRING, pstrdup(), timestamp2tm(), TIMESTAMP_NOT_FINITE, and tm.

Referenced by ExecGetJsonValueItemString().

timestamptz_part()

Datum timestamptz_part

(

PG_FUNCTION_ARGS

)

Definition at line 6029 of file timestamp.c.

{
    return timestamptz_part_common(fcinfo, false);
}

References timestamptz_part_common().

timestamptz_part_common()

static Datum timestamptz_part_common ( PG_FUNCTION_ARGS  , bool  retnumeric  )

static

Definition at line 5772 of file timestamp.c.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1);
    int64       intresult;
    Timestamp   epoch;
    int         tz;
    int         type,
                val;
    char       *lowunits;
    fsec_t      fsec;
    struct pg_tm tt,
               *tm = &tt;
 
    lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
                                            VARSIZE_ANY_EXHDR(units),
                                            false);
 
    type = DecodeUnits(0, lowunits, &val);
    if (type == UNKNOWN_FIELD)
        type = DecodeSpecial(0, lowunits, &val);
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
    {
        double      r = NonFiniteTimestampTzPart(type, val, lowunits,
                                                 TIMESTAMP_IS_NOBEGIN(timestamp),
                                                 true);
 
        if (r != 0.0)
        {
            if (retnumeric)
            {
                if (r < 0)
                    return DirectFunctionCall3(numeric_in,
                                               CStringGetDatum("-Infinity"),
                                               ObjectIdGetDatum(InvalidOid),
                                               Int32GetDatum(-1));
                else if (r > 0)
                    return DirectFunctionCall3(numeric_in,
                                               CStringGetDatum("Infinity"),
                                               ObjectIdGetDatum(InvalidOid),
                                               Int32GetDatum(-1));
            }
            else
                PG_RETURN_FLOAT8(r);
        }
        else
            PG_RETURN_NULL();
    }
 
    if (type == UNITS)
    {
        if (timestamp2tm(timestamp, &tz, tm, &fsec, NULL, NULL) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
 
        switch (val)
        {
            case DTK_TZ:
                intresult = -tz;
                break;
 
            case DTK_TZ_MINUTE:
                intresult = (-tz / SECS_PER_MINUTE) % MINS_PER_HOUR;
                break;
 
            case DTK_TZ_HOUR:
                intresult = -tz / SECS_PER_HOUR;
                break;
 
            case DTK_MICROSEC:
                intresult = tm->tm_sec * INT64CONST(1000000) + fsec;
                break;
 
            case DTK_MILLISEC:
                if (retnumeric)
                    /*---
                     * tm->tm_sec * 1000 + fsec / 1000
                     * = (tm->tm_sec * 1'000'000 + fsec) / 1000
                     */
                    PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + fsec, 3));
                else
                    PG_RETURN_FLOAT8(tm->tm_sec * 1000.0 + fsec / 1000.0);
                break;
 
            case DTK_SECOND:
                if (retnumeric)
                    /*---
                     * tm->tm_sec + fsec / 1'000'000
                     * = (tm->tm_sec * 1'000'000 + fsec) / 1'000'000
                     */
                    PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + fsec, 6));
                else
                    PG_RETURN_FLOAT8(tm->tm_sec + fsec / 1000000.0);
                break;
 
            case DTK_MINUTE:
                intresult = tm->tm_min;
                break;
 
            case DTK_HOUR:
                intresult = tm->tm_hour;
                break;
 
            case DTK_DAY:
                intresult = tm->tm_mday;
                break;
 
            case DTK_MONTH:
                intresult = tm->tm_mon;
                break;
 
            case DTK_QUARTER:
                intresult = (tm->tm_mon - 1) / 3 + 1;
                break;
 
            case DTK_WEEK:
                intresult = date2isoweek(tm->tm_year, tm->tm_mon, tm->tm_mday);
                break;
 
            case DTK_YEAR:
                if (tm->tm_year > 0)
                    intresult = tm->tm_year;
                else
                    /* there is no year 0, just 1 BC and 1 AD */
                    intresult = tm->tm_year - 1;
                break;
 
            case DTK_DECADE:
                /* see comments in timestamp_part */
                if (tm->tm_year > 0)
                    intresult = tm->tm_year / 10;
                else
                    intresult = -((8 - (tm->tm_year - 1)) / 10);
                break;
 
            case DTK_CENTURY:
                /* see comments in timestamp_part */
                if (tm->tm_year > 0)
                    intresult = (tm->tm_year + 99) / 100;
                else
                    intresult = -((99 - (tm->tm_year - 1)) / 100);
                break;
 
            case DTK_MILLENNIUM:
                /* see comments in timestamp_part */
                if (tm->tm_year > 0)
                    intresult = (tm->tm_year + 999) / 1000;
                else
                    intresult = -((999 - (tm->tm_year - 1)) / 1000);
                break;
 
            case DTK_JULIAN:
                if (retnumeric)
                    PG_RETURN_NUMERIC(numeric_add_opt_error(int64_to_numeric(date2j(tm->tm_year, tm->tm_mon, tm->tm_mday)),
                                                            numeric_div_opt_error(int64_to_numeric(((((tm->tm_hour * MINS_PER_HOUR) + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) * INT64CONST(1000000) + fsec),
                                                                                  int64_to_numeric(SECS_PER_DAY * INT64CONST(1000000)),
                                                                                  NULL),
                                                            NULL));
                else
                    PG_RETURN_FLOAT8(date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) +
                                     ((((tm->tm_hour * MINS_PER_HOUR) + tm->tm_min) * SECS_PER_MINUTE) +
                                      tm->tm_sec + (fsec / 1000000.0)) / (double) SECS_PER_DAY);
                break;
 
            case DTK_ISOYEAR:
                intresult = date2isoyear(tm->tm_year, tm->tm_mon, tm->tm_mday);
                /* Adjust BC years */
                if (intresult <= 0)
                    intresult -= 1;
                break;
 
            case DTK_DOW:
            case DTK_ISODOW:
                intresult = j2day(date2j(tm->tm_year, tm->tm_mon, tm->tm_mday));
                if (val == DTK_ISODOW && intresult == 0)
                    intresult = 7;
                break;
 
            case DTK_DOY:
                intresult = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday)
                             - date2j(tm->tm_year, 1, 1) + 1);
                break;
 
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("unit \"%s\" not supported for type %s",
                                lowunits, format_type_be(TIMESTAMPTZOID))));
                intresult = 0;
        }
    }
    else if (type == RESERV)
    {
        switch (val)
        {
            case DTK_EPOCH:
                epoch = SetEpochTimestamp();
                /* (timestamp - epoch) / 1000000 */
                if (retnumeric)
                {
                    Numeric     result;
 
                    if (timestamp < (PG_INT64_MAX + epoch))
                        result = int64_div_fast_to_numeric(timestamp - epoch, 6);
                    else
                    {
                        result = numeric_div_opt_error(numeric_sub_opt_error(int64_to_numeric(timestamp),
                                                                             int64_to_numeric(epoch),
                                                                             NULL),
                                                       int64_to_numeric(1000000),
                                                       NULL);
                        result = DatumGetNumeric(DirectFunctionCall2(numeric_round,
                                                                     NumericGetDatum(result),
                                                                     Int32GetDatum(6)));
                    }
                    PG_RETURN_NUMERIC(result);
                }
                else
                {
                    float8      result;
 
                    /* try to avoid precision loss in subtraction */
                    if (timestamp < (PG_INT64_MAX + epoch))
                        result = (timestamp - epoch) / 1000000.0;
                    else
                        result = ((float8) timestamp - epoch) / 1000000.0;
                    PG_RETURN_FLOAT8(result);
                }
                break;
 
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("unit \"%s\" not supported for type %s",
                                lowunits, format_type_be(TIMESTAMPTZOID))));
                intresult = 0;
        }
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unit \"%s\" not recognized for type %s",
                        lowunits, format_type_be(TIMESTAMPTZOID))));
 
        intresult = 0;
    }
 
    if (retnumeric)
        PG_RETURN_NUMERIC(int64_to_numeric(intresult));
    else
        PG_RETURN_FLOAT8(intresult);
}

References CStringGetDatum(), date2isoweek(), date2isoyear(), date2j(), DatumGetNumeric(), DecodeSpecial(), DecodeUnits(), DirectFunctionCall2, DirectFunctionCall3, downcase_truncate_identifier(), 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, epoch, ereport, errcode(), errmsg(), ERROR, format_type_be(), Int32GetDatum(), int64_div_fast_to_numeric(), int64_to_numeric(), INT64CONST, InvalidOid, j2day(), MINS_PER_HOUR, NonFiniteTimestampTzPart(), numeric_add_opt_error(), numeric_div_opt_error(), numeric_in(), numeric_round(), numeric_sub_opt_error(), NumericGetDatum(), ObjectIdGetDatum(), PG_GETARG_TEXT_PP, PG_GETARG_TIMESTAMPTZ, PG_INT64_MAX, PG_RETURN_FLOAT8, PG_RETURN_NULL, PG_RETURN_NUMERIC, RESERV, SECS_PER_DAY, SECS_PER_HOUR, SECS_PER_MINUTE, SetEpochTimestamp(), timestamp2tm(), TIMESTAMP_IS_NOBEGIN, TIMESTAMP_NOT_FINITE, 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, type, UNITS, UNKNOWN_FIELD, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by extract_timestamptz(), and timestamptz_part().

timestamptz_pl_interval()

Datum timestamptz_pl_interval

(

PG_FUNCTION_ARGS

)

Definition at line 3398 of file timestamp.c.

{
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
 
    PG_RETURN_TIMESTAMP(timestamptz_pl_interval_internal(timestamp, span, NULL));
}

References PG_GETARG_INTERVAL_P, PG_GETARG_TIMESTAMPTZ, PG_RETURN_TIMESTAMP, and timestamptz_pl_interval_internal().

Referenced by uuidv7_interval().

timestamptz_pl_interval_at_zone()

Datum timestamptz_pl_interval_at_zone

(

PG_FUNCTION_ARGS

)

Definition at line 3419 of file timestamp.c.

{
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0);
    Interval   *span = PG_GETARG_INTERVAL_P(1);
    text       *zone = PG_GETARG_TEXT_PP(2);
    pg_tz      *attimezone = lookup_timezone(zone);
 
    PG_RETURN_TIMESTAMP(timestamptz_pl_interval_internal(timestamp, span, attimezone));
}

References lookup_timezone(), PG_GETARG_INTERVAL_P, PG_GETARG_TEXT_PP, PG_GETARG_TIMESTAMPTZ, PG_RETURN_TIMESTAMP, and timestamptz_pl_interval_internal().

timestamptz_pl_interval_internal()

static TimestampTz timestamptz_pl_interval_internal ( TimestampTz  timestamp, Interval *  span, pg_tz *  attimezone  )

static

Definition at line 3251 of file timestamp.c.

{
    TimestampTz result;
    int         tz;
 
    /*
     * Handle infinities.
     *
     * We treat anything that amounts to "infinity - infinity" as an error,
     * since the timestamptz type has nothing equivalent to NaN.
     */
    if (INTERVAL_IS_NOBEGIN(span))
    {
        if (TIMESTAMP_IS_NOEND(timestamp))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
        else
            TIMESTAMP_NOBEGIN(result);
    }
    else if (INTERVAL_IS_NOEND(span))
    {
        if (TIMESTAMP_IS_NOBEGIN(timestamp))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
        else
            TIMESTAMP_NOEND(result);
    }
    else if (TIMESTAMP_NOT_FINITE(timestamp))
        result = timestamp;
    else
    {
        /* Use session timezone if caller asks for default */
        if (attimezone == NULL)
            attimezone = session_timezone;
 
        if (span->month != 0)
        {
            struct pg_tm tt,
                       *tm = &tt;
            fsec_t      fsec;
 
            if (timestamp2tm(timestamp, &tz, tm, &fsec, NULL, attimezone) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
 
            if (pg_add_s32_overflow(tm->tm_mon, span->month, &tm->tm_mon))
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
            if (tm->tm_mon > MONTHS_PER_YEAR)
            {
                tm->tm_year += (tm->tm_mon - 1) / MONTHS_PER_YEAR;
                tm->tm_mon = ((tm->tm_mon - 1) % MONTHS_PER_YEAR) + 1;
            }
            else if (tm->tm_mon < 1)
            {
                tm->tm_year += tm->tm_mon / MONTHS_PER_YEAR - 1;
                tm->tm_mon = tm->tm_mon % MONTHS_PER_YEAR + MONTHS_PER_YEAR;
            }
 
            /* adjust for end of month boundary problems... */
            if (tm->tm_mday > day_tab[isleap(tm->tm_year)][tm->tm_mon - 1])
                tm->tm_mday = (day_tab[isleap(tm->tm_year)][tm->tm_mon - 1]);
 
            tz = DetermineTimeZoneOffset(tm, attimezone);
 
            if (tm2timestamp(tm, fsec, &tz, &timestamp) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
        }
 
        if (span->day != 0)
        {
            struct pg_tm tt,
                       *tm = &tt;
            fsec_t      fsec;
            int         julian;
 
            if (timestamp2tm(timestamp, &tz, tm, &fsec, NULL, attimezone) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
 
            /*
             * Add days by converting to and from Julian.  We need an overflow
             * check here since j2date expects a non-negative integer input.
             * In practice though, it will give correct answers for small
             * negative Julian dates; we should allow -1 to avoid
             * timezone-dependent failures, as discussed in timestamp.h.
             */
            julian = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday);
            if (pg_add_s32_overflow(julian, span->day, &julian) ||
                julian < -1)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
            j2date(julian, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
 
            tz = DetermineTimeZoneOffset(tm, attimezone);
 
            if (tm2timestamp(tm, fsec, &tz, &timestamp) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
        }
 
        if (pg_add_s64_overflow(timestamp, span->time, &timestamp))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
 
        if (!IS_VALID_TIMESTAMP(timestamp))
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
 
        result = timestamp;
    }
 
    return result;
}

References date2j(), Interval::day, day_tab, DetermineTimeZoneOffset(), ereport, errcode(), errmsg(), ERROR, INTERVAL_IS_NOBEGIN, INTERVAL_IS_NOEND, IS_VALID_TIMESTAMP, isleap, j2date(), Interval::month, MONTHS_PER_YEAR, pg_add_s32_overflow(), pg_add_s64_overflow(), session_timezone, Interval::time, timestamp2tm(), TIMESTAMP_IS_NOBEGIN, TIMESTAMP_IS_NOEND, TIMESTAMP_NOBEGIN, TIMESTAMP_NOEND, TIMESTAMP_NOT_FINITE, tm, tm2timestamp(), pg_tm::tm_mday, pg_tm::tm_mon, and pg_tm::tm_year.

Referenced by generate_series_timestamptz_internal(), in_range_timestamptz_interval(), timestamptz_mi_interval_internal(), timestamptz_pl_interval(), and timestamptz_pl_interval_at_zone().

timestamptz_recv()

Datum timestamptz_recv

(

PG_FUNCTION_ARGS

)

Definition at line 804 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);
    TimestampTz timestamp;
    int         tz;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
 
    timestamp = (TimestampTz) pq_getmsgint64(buf);
 
    /* range check: see if timestamptz_out would like it */
    if (TIMESTAMP_NOT_FINITE(timestamp))
         /* ok */ ;
    else if (timestamp2tm(timestamp, &tz, tm, &fsec, NULL, NULL) != 0 ||
             !IS_VALID_TIMESTAMP(timestamp))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    AdjustTimestampForTypmod(&timestamp, typmod, NULL);
 
    PG_RETURN_TIMESTAMPTZ(timestamp);
}

References AdjustTimestampForTypmod(), buf, ereport, errcode(), errmsg(), ERROR, IS_VALID_TIMESTAMP, PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_TIMESTAMPTZ, pq_getmsgint64(), timestamp2tm(), TIMESTAMP_NOT_FINITE, and tm.

timestamptz_scale()

Datum timestamptz_scale

(

PG_FUNCTION_ARGS

)

Definition at line 870 of file timestamp.c.

{
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0);
    int32       typmod = PG_GETARG_INT32(1);
    TimestampTz result;
 
    result = timestamp;
 
    AdjustTimestampForTypmod(&result, typmod, NULL);
 
    PG_RETURN_TIMESTAMPTZ(result);
}

References AdjustTimestampForTypmod(), PG_GETARG_INT32, PG_GETARG_TIMESTAMPTZ, and PG_RETURN_TIMESTAMPTZ.

timestamptz_send()

Datum timestamptz_send

(

PG_FUNCTION_ARGS

)

Definition at line 838 of file timestamp.c.

{
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendint64(&buf, timestamp);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

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

timestamptz_timestamp()

Datum timestamptz_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 6527 of file timestamp.c.

{
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0);
 
    PG_RETURN_TIMESTAMP(timestamptz2timestamp(timestamp));
}

References PG_GETARG_TIMESTAMPTZ, PG_RETURN_TIMESTAMP, and timestamptz2timestamp().

Referenced by executeDateTimeMethod(), and timestamptz_at_local().

timestamptz_to_str()

const char * timestamptz_to_str

(

TimestampTz

t

)

Definition at line 1862 of file timestamp.c.

{
    static char buf[MAXDATELEN + 1];
    int         tz;
    struct pg_tm tt,
               *tm = &tt;
    fsec_t      fsec;
    const char *tzn;
 
    if (TIMESTAMP_NOT_FINITE(t))
        EncodeSpecialTimestamp(t, buf);
    else if (timestamp2tm(t, &tz, tm, &fsec, &tzn, NULL) == 0)
        EncodeDateTime(tm, fsec, true, tz, tzn, USE_ISO_DATES, buf);
    else
        strlcpy(buf, "(timestamp out of range)", sizeof(buf));
 
    return buf;
}

References buf, EncodeDateTime(), EncodeSpecialTimestamp(), MAXDATELEN, strlcpy(), timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, and USE_ISO_DATES.

Referenced by CreateRestartPoint(), errdetail_apply_conflict(), getRecoveryStopReason(), InitWalRecovery(), PerformWalRecovery(), pg_decode_commit_prepared_txn(), pg_decode_commit_txn(), pg_decode_prepare_txn(), pg_decode_rollback_prepared_txn(), pg_decode_stream_commit(), pg_decode_stream_prepare(), ProcessStandbyHSFeedbackMessage(), ProcessStandbyReplyMessage(), ProcessWalSndrMessage(), recoveryStopsAfter(), recoveryStopsBefore(), xact_desc_abort(), xact_desc_commit(), xact_desc_prepare(), xlog_desc(), and xlogrecovery_redo().

timestamptz_to_time_t()

pg_time_t timestamptz_to_time_t

(

TimestampTz

t

)

Definition at line 1842 of file timestamp.c.

{
    pg_time_t   result;
 
    result = (pg_time_t) (t / USECS_PER_SEC +
                          ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY));
 
    return result;
}

References POSTGRES_EPOCH_JDATE, SECS_PER_DAY, UNIX_EPOCH_JDATE, and USECS_PER_SEC.

Referenced by DetermineTimeZoneAbbrevOffsetTS(), InitProcessGlobals(), and pg_timezone_abbrevs_zone().

timestamptz_trunc()

Datum timestamptz_trunc

(

PG_FUNCTION_ARGS

)

Definition at line 5093 of file timestamp.c.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1);
    TimestampTz result;
 
    result = timestamptz_trunc_internal(units, timestamp, session_timezone);
 
    PG_RETURN_TIMESTAMPTZ(result);
}

References PG_GETARG_TEXT_PP, PG_GETARG_TIMESTAMPTZ, PG_RETURN_TIMESTAMPTZ, session_timezone, and timestamptz_trunc_internal().

timestamptz_trunc_internal()

static TimestampTz timestamptz_trunc_internal ( text *  units, TimestampTz  timestamp, pg_tz *  tzp  )

static

Definition at line 4915 of file timestamp.c.

{
    TimestampTz result;
    int         tz;
    int         type,
                val;
    bool        redotz = false;
    char       *lowunits;
    fsec_t      fsec;
    struct pg_tm tt,
               *tm = &tt;
 
    lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
                                            VARSIZE_ANY_EXHDR(units),
                                            false);
 
    type = DecodeUnits(0, lowunits, &val);
 
    if (type == UNITS)
    {
        if (TIMESTAMP_NOT_FINITE(timestamp))
        {
            /*
             * Errors thrown here for invalid units should exactly match those
             * below, else there will be unexpected discrepancies between
             * finite- and infinite-input cases.
             */
            switch (val)
            {
                case DTK_WEEK:
                case DTK_MILLENNIUM:
                case DTK_CENTURY:
                case DTK_DECADE:
                case DTK_YEAR:
                case DTK_QUARTER:
                case DTK_MONTH:
                case DTK_DAY:
                case DTK_HOUR:
                case DTK_MINUTE:
                case DTK_SECOND:
                case DTK_MILLISEC:
                case DTK_MICROSEC:
                    PG_RETURN_TIMESTAMPTZ(timestamp);
                    break;
 
                default:
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("unit \"%s\" not supported for type %s",
                                    lowunits, format_type_be(TIMESTAMPTZOID))));
                    result = 0;
            }
        }
 
        if (timestamp2tm(timestamp, &tz, tm, &fsec, NULL, tzp) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
 
        switch (val)
        {
            case DTK_WEEK:
                {
                    int         woy;
 
                    woy = date2isoweek(tm->tm_year, tm->tm_mon, tm->tm_mday);
 
                    /*
                     * If it is week 52/53 and the month is January, then the
                     * week must belong to the previous year. Also, some
                     * December dates belong to the next year.
                     */
                    if (woy >= 52 && tm->tm_mon == 1)
                        --tm->tm_year;
                    if (woy <= 1 && tm->tm_mon == MONTHS_PER_YEAR)
                        ++tm->tm_year;
                    isoweek2date(woy, &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
                    tm->tm_hour = 0;
                    tm->tm_min = 0;
                    tm->tm_sec = 0;
                    fsec = 0;
                    redotz = true;
                    break;
                }
                /* one may consider DTK_THOUSAND and DTK_HUNDRED... */
            case DTK_MILLENNIUM:
 
                /*
                 * truncating to the millennium? what is this supposed to
                 * mean? let us put the first year of the millennium... i.e.
                 * -1000, 1, 1001, 2001...
                 */
                if (tm->tm_year > 0)
                    tm->tm_year = ((tm->tm_year + 999) / 1000) * 1000 - 999;
                else
                    tm->tm_year = -((999 - (tm->tm_year - 1)) / 1000) * 1000 + 1;
                /* FALL THRU */
            case DTK_CENTURY:
                /* truncating to the century? as above: -100, 1, 101... */
                if (tm->tm_year > 0)
                    tm->tm_year = ((tm->tm_year + 99) / 100) * 100 - 99;
                else
                    tm->tm_year = -((99 - (tm->tm_year - 1)) / 100) * 100 + 1;
                /* FALL THRU */
            case DTK_DECADE:
 
                /*
                 * truncating to the decade? first year of the decade. must
                 * not be applied if year was truncated before!
                 */
                if (val != DTK_MILLENNIUM && val != DTK_CENTURY)
                {
                    if (tm->tm_year > 0)
                        tm->tm_year = (tm->tm_year / 10) * 10;
                    else
                        tm->tm_year = -((8 - (tm->tm_year - 1)) / 10) * 10;
                }
                /* FALL THRU */
            case DTK_YEAR:
                tm->tm_mon = 1;
                /* FALL THRU */
            case DTK_QUARTER:
                tm->tm_mon = (3 * ((tm->tm_mon - 1) / 3)) + 1;
                /* FALL THRU */
            case DTK_MONTH:
                tm->tm_mday = 1;
                /* FALL THRU */
            case DTK_DAY:
                tm->tm_hour = 0;
                redotz = true;  /* for all cases >= DAY */
                /* FALL THRU */
            case DTK_HOUR:
                tm->tm_min = 0;
                /* FALL THRU */
            case DTK_MINUTE:
                tm->tm_sec = 0;
                /* FALL THRU */
            case DTK_SECOND:
                fsec = 0;
                break;
            case DTK_MILLISEC:
                fsec = (fsec / 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(TIMESTAMPTZOID))));
                result = 0;
        }
 
        if (redotz)
            tz = DetermineTimeZoneOffset(tm, tzp);
 
        if (tm2timestamp(tm, fsec, &tz, &result) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unit \"%s\" not recognized for type %s",
                        lowunits, format_type_be(TIMESTAMPTZOID))));
        result = 0;
    }
 
    return result;
}

References date2isoweek(), DecodeUnits(), DetermineTimeZoneOffset(), 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(), errmsg(), ERROR, format_type_be(), isoweek2date(), MONTHS_PER_YEAR, PG_RETURN_TIMESTAMPTZ, timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, tm2timestamp(), pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, type, UNITS, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by timestamptz_trunc(), and timestamptz_trunc_zone().

timestamptz_trunc_zone()

Datum timestamptz_trunc_zone

(

PG_FUNCTION_ARGS

)

Definition at line 5108 of file timestamp.c.

{
    text       *units = PG_GETARG_TEXT_PP(0);
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1);
    text       *zone = PG_GETARG_TEXT_PP(2);
    TimestampTz result;
    pg_tz      *tzp;
 
    /*
     * Look up the requested timezone.
     */
    tzp = lookup_timezone(zone);
 
    result = timestamptz_trunc_internal(units, timestamp, tzp);
 
    PG_RETURN_TIMESTAMPTZ(result);
}

References lookup_timezone(), PG_GETARG_TEXT_PP, PG_GETARG_TIMESTAMPTZ, PG_RETURN_TIMESTAMPTZ, and timestamptz_trunc_internal().

timestamptz_zone()

Datum timestamptz_zone

(

PG_FUNCTION_ARGS

)

Definition at line 6564 of file timestamp.c.

{
    text       *zone = PG_GETARG_TEXT_PP(0);
    TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1);
    Timestamp   result;
    int         tz;
    char        tzname[TZ_STRLEN_MAX + 1];
    int         type,
                val;
    pg_tz      *tzp;
 
    if (TIMESTAMP_NOT_FINITE(timestamp))
        PG_RETURN_TIMESTAMP(timestamp);
 
    /*
     * Look up the requested timezone.
     */
    text_to_cstring_buffer(zone, tzname, sizeof(tzname));
 
    type = DecodeTimezoneName(tzname, &val, &tzp);
 
    if (type == TZNAME_FIXED_OFFSET)
    {
        /* fixed-offset abbreviation */
        tz = -val;
        result = dt2local(timestamp, tz);
    }
    else if (type == TZNAME_DYNTZ)
    {
        /* dynamic-offset abbreviation, resolve using specified time */
        int         isdst;
 
        tz = DetermineTimeZoneAbbrevOffsetTS(timestamp, tzname, tzp, &isdst);
        result = dt2local(timestamp, tz);
    }
    else
    {
        /* full zone name, rotate from that zone */
        struct pg_tm tm;
        fsec_t      fsec;
 
        if (timestamp2tm(timestamp, &tz, &tm, &fsec, NULL, tzp) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
        if (tm2timestamp(&tm, fsec, NULL, &result) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("timestamp out of range")));
    }
 
    if (!IS_VALID_TIMESTAMP(result))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    PG_RETURN_TIMESTAMP(result);
}

References DecodeTimezoneName(), DetermineTimeZoneAbbrevOffsetTS(), dt2local(), ereport, errcode(), errmsg(), ERROR, IS_VALID_TIMESTAMP, PG_GETARG_TEXT_PP, PG_GETARG_TIMESTAMPTZ, PG_RETURN_TIMESTAMP, text_to_cstring_buffer(), timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, tm2timestamp(), type, TZ_STRLEN_MAX, TZNAME_DYNTZ, TZNAME_FIXED_OFFSET, and val.

timestamptztypmodin()

Datum timestamptztypmodin

(

PG_FUNCTION_ARGS

)

Definition at line 849 of file timestamp.c.

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

References anytimestamp_typmodin(), PG_GETARG_ARRAYTYPE_P, and PG_RETURN_INT32.

timestamptztypmodout()

Datum timestamptztypmodout

(

PG_FUNCTION_ARGS

)

Definition at line 857 of file timestamp.c.

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

References anytimestamp_typmodout(), PG_GETARG_INT32, and PG_RETURN_CSTRING.

tm2timestamp()

int tm2timestamp	(	struct pg_tm *	tm,
		fsec_t	fsec,
		int *	tzp,
		Timestamp *	result
	)

Definition at line 2006 of file timestamp.c.

{
    TimeOffset  date;
    TimeOffset  time;
 
    /* Prevent overflow in Julian-day routines */
    if (!IS_VALID_JULIAN(tm->tm_year, tm->tm_mon, tm->tm_mday))
    {
        *result = 0;            /* keep compiler quiet */
        return -1;
    }
 
    date = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - POSTGRES_EPOCH_JDATE;
    time = time2t(tm->tm_hour, tm->tm_min, tm->tm_sec, fsec);
 
    if (unlikely(pg_mul_s64_overflow(date, USECS_PER_DAY, result) ||
                 pg_add_s64_overflow(*result, time, result)))
    {
        *result = 0;            /* keep compiler quiet */
        return -1;
    }
    if (tzp != NULL)
        *result = dt2local(*result, -(*tzp));
 
    /* final range check catches just-out-of-range timestamps */
    if (!IS_VALID_TIMESTAMP(*result))
    {
        *result = 0;            /* keep compiler quiet */
        return -1;
    }
 
    return 0;
}

References date2j(), dt2local(), IS_VALID_JULIAN, IS_VALID_TIMESTAMP, pg_add_s64_overflow(), pg_mul_s64_overflow(), POSTGRES_EPOCH_JDATE, time2t(), 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, unlikely, and USECS_PER_DAY.

Referenced by check_recovery_target_time(), parse_datetime(), PGTYPEStimestamp_add_interval(), PGTYPEStimestamp_current(), PGTYPEStimestamp_defmt_scan(), PGTYPEStimestamp_from_asc(), SetEpochTimestamp(), timestamp_in(), timestamp_pl_interval(), timestamp_trunc(), timestamp_zone(), timestamptz2timestamp(), timestamptz_in(), timestamptz_pl_interval_internal(), timestamptz_trunc_internal(), timestamptz_zone(), and to_timestamp().

Variable Documentation

PgReloadTime

TimestampTz PgReloadTime

Definition at line 57 of file timestamp.c.

Referenced by pg_conf_load_time(), and ProcessConfigFileInternal().

PgStartTime

TimestampTz PgStartTime

Definition at line 54 of file timestamp.c.

Referenced by pg_postmaster_start_time(), PostgresSingleUserMain(), and PostmasterMain().