| /*------------------------------------------------------------------------- |
| * |
| * timestamp.c |
| * Functions for the built-in SQL92 types "timestamp" and "interval". |
| * |
| * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group |
| * Portions Copyright (c) 1994, Regents of the University of California |
| * |
| * |
| * IDENTIFICATION |
| * $PostgreSQL: pgsql/src/backend/utils/adt/timestamp.c,v 1.200 2009/06/01 23:55:15 tgl Exp $ |
| * |
| *------------------------------------------------------------------------- |
| */ |
| |
| #include "postgres.h" |
| |
| #include <ctype.h> |
| #include <math.h> |
| #include <float.h> |
| #include <limits.h> |
| #include <sys/time.h> |
| |
| #include "access/hash.h" |
| #include "access/xact.h" |
| #include "catalog/pg_type.h" |
| #include "funcapi.h" |
| #include "libpq/pqformat.h" |
| #include "miscadmin.h" |
| #include "parser/scansup.h" |
| #include "utils/array.h" |
| #include "utils/builtins.h" |
| #include "utils/datetime.h" |
| |
| /* |
| * gcc's -ffast-math switch breaks routines that expect exact results from |
| * expressions like timeval / SECS_PER_HOUR, where timeval is double. |
| */ |
| #ifdef __FAST_MATH__ |
| #error -ffast-math is known to break this code |
| #endif |
| |
| |
| /* Set at postmaster start */ |
| TimestampTz PgStartTime; |
| |
| /* Set at configuration reload */ |
| TimestampTz PgReloadTime; |
| |
| typedef struct |
| { |
| Timestamp current; |
| Timestamp finish; |
| Interval step; |
| int step_sign; |
| } generate_series_timestamp_fctx; |
| |
| typedef struct |
| { |
| TimestampTz current; |
| TimestampTz finish; |
| Interval step; |
| int step_sign; |
| } generate_series_timestamptz_fctx; |
| |
| |
| static TimeOffset time2t(const int hour, const int min, const int sec, const fsec_t fsec); |
| static void EncodeSpecialTimestamp(Timestamp dt, char *str); |
| static Timestamp dt2local(Timestamp dt, int timezone); |
| static void AdjustTimestampForTypmod(Timestamp *time, int32 typmod); |
| static void AdjustIntervalForTypmod(Interval *interval, int32 typmod); |
| static TimestampTz timestamp2timestamptz(Timestamp timestamp); |
| static ArrayType *interval_amalg_demalg(ArrayType *aTransArray, |
| ArrayType *bTransArray, |
| bool is_amalg); |
| |
| |
| /* common code for timestamptypmodin and timestamptztypmodin */ |
| static int32 |
| anytimestamp_typmodin(bool istz, ArrayType *ta) |
| { |
| int32 typmod; |
| int32 *tl; |
| int n; |
| |
| tl = ArrayGetIntegerTypmods(ta, &n); |
| |
| /* |
| * we're not too tense about good error message here because grammar |
| * shouldn't allow wrong number of modifiers for TIMESTAMP |
| */ |
| if (n != 1) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("invalid type modifier"), |
| errOmitLocation(true), |
| errOmitLocation(true))); |
| |
| if (*tl < 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("TIMESTAMP(%d)%s precision must not be negative", |
| *tl, (istz ? " WITH TIME ZONE" : "")), |
| errOmitLocation(true))); |
| if (*tl > MAX_TIMESTAMP_PRECISION) |
| { |
| ereport(WARNING, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("TIMESTAMP(%d)%s precision reduced to maximum allowed, %d", |
| *tl, (istz ? " WITH TIME ZONE" : ""), |
| MAX_TIMESTAMP_PRECISION), |
| errOmitLocation(true))); |
| typmod = MAX_TIMESTAMP_PRECISION; |
| } |
| else |
| typmod = *tl; |
| |
| return typmod; |
| } |
| |
| /* common code for timestamptypmodout and timestamptztypmodout */ |
| static char * |
| anytimestamp_typmodout(bool istz, int32 typmod) |
| { |
| char *res = (char *) palloc(64); |
| const char *tz = istz ? " with time zone" : " without time zone"; |
| |
| if (typmod >= 0) |
| snprintf(res, 64, "(%d)%s", (int) typmod, tz); |
| else |
| snprintf(res, 64, "%s", tz); |
| |
| return res; |
| } |
| |
| |
| /***************************************************************************** |
| * USER I/O ROUTINES * |
| *****************************************************************************/ |
| |
| /* timestamp_in() |
| * Convert a string to internal form. |
| */ |
| Datum |
| timestamp_in(PG_FUNCTION_ARGS) |
| { |
| char *str = PG_GETARG_CSTRING(0); |
| |
| #ifdef NOT_USED |
| Oid typelem = PG_GETARG_OID(1); |
| #endif |
| int32 typmod = PG_GETARG_INT32(2); |
| Timestamp result; |
| fsec_t fsec; |
| struct pg_tm tt, |
| *tm = &tt; |
| int tz; |
| int dtype = 0; |
| int nf; |
| int dterr; |
| char *field[MAXDATEFIELDS]; |
| int ftype[MAXDATEFIELDS]; |
| char workbuf[MAXDATELEN + MAXDATEFIELDS]; |
| |
| dterr = ParseDateTime(str, workbuf, sizeof(workbuf), |
| field, ftype, MAXDATEFIELDS, &nf); |
| if (dterr == 0) |
| dterr = DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tz); |
| if (dterr != 0) |
| DateTimeParseError(dterr, str, "timestamp"); |
| |
| switch (dtype) |
| { |
| case DTK_DATE: |
| if (tm2timestamp(tm, fsec, NULL, &result) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range: \"%s\"", str), |
| errOmitLocation(true))); |
| break; |
| |
| case DTK_EPOCH: |
| result = SetEpochTimestamp(); |
| break; |
| |
| case DTK_LATE: |
| TIMESTAMP_NOEND(result); |
| break; |
| |
| case DTK_EARLY: |
| TIMESTAMP_NOBEGIN(result); |
| break; |
| |
| case DTK_INVALID: |
| ereport(ERROR, |
| (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), |
| errmsg("date/time value \"%s\" is no longer supported", str), |
| errOmitLocation(true))); |
| |
| TIMESTAMP_NOEND(result); |
| break; |
| |
| default: |
| elog(ERROR, "unexpected dtype %d while parsing timestamp \"%s\"", |
| dtype, str); |
| TIMESTAMP_NOEND(result); |
| } |
| |
| AdjustTimestampForTypmod(&result, typmod); |
| |
| PG_RETURN_TIMESTAMP(result); |
| } |
| |
| /* timestamp_out() |
| * Convert a timestamp to external form. |
| */ |
| Datum |
| timestamp_out(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestamp = PG_GETARG_TIMESTAMP(0); |
| char *result; |
| struct pg_tm tt, |
| *tm = &tt; |
| fsec_t fsec; |
| char *tzn = NULL; |
| 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, NULL, &tzn, DateStyle, buf); |
| else |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| result = pstrdup(buf); |
| PG_RETURN_CSTRING(result); |
| } |
| |
| /* |
| * timestamp_recv - converts external binary format to timestamp |
| * |
| * We make no attempt to provide compatibility between int and float |
| * timestamp representations ... |
| */ |
| Datum |
| timestamp_recv(PG_FUNCTION_ARGS) |
| { |
| 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; |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| timestamp = (Timestamp) pq_getmsgint64(buf); |
| #else |
| timestamp = (Timestamp) pq_getmsgfloat8(buf); |
| #endif |
| |
| /* rangecheck: see if timestamp_out would like it */ |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| /* ok */ ; |
| else if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| AdjustTimestampForTypmod(×tamp, typmod); |
| |
| PG_RETURN_TIMESTAMP(timestamp); |
| } |
| |
| /* |
| * timestamp_send - converts timestamp to binary format |
| */ |
| Datum |
| timestamp_send(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestamp = PG_GETARG_TIMESTAMP(0); |
| StringInfoData buf; |
| |
| pq_begintypsend(&buf); |
| #ifdef HAVE_INT64_TIMESTAMP |
| pq_sendint64(&buf, timestamp); |
| #else |
| pq_sendfloat8(&buf, timestamp); |
| #endif |
| PG_RETURN_BYTEA_P(pq_endtypsend(&buf)); |
| } |
| |
| Datum |
| timestamptypmodin(PG_FUNCTION_ARGS) |
| { |
| ArrayType *ta = PG_GETARG_ARRAYTYPE_P(0); |
| |
| PG_RETURN_INT32(anytimestamp_typmodin(false, ta)); |
| } |
| |
| Datum |
| timestamptypmodout(PG_FUNCTION_ARGS) |
| { |
| int32 typmod = PG_GETARG_INT32(0); |
| |
| PG_RETURN_CSTRING(anytimestamp_typmodout(false, typmod)); |
| } |
| |
| |
| /* timestamp_scale() |
| * Adjust time type for specified scale factor. |
| * Used by PostgreSQL type system to stuff columns. |
| */ |
| Datum |
| timestamp_scale(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestamp = PG_GETARG_TIMESTAMP(0); |
| int32 typmod = PG_GETARG_INT32(1); |
| Timestamp result; |
| |
| result = timestamp; |
| |
| AdjustTimestampForTypmod(&result, typmod); |
| |
| PG_RETURN_TIMESTAMP(result); |
| } |
| |
| static void |
| AdjustTimestampForTypmod(Timestamp *time, int32 typmod) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| 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) |
| }; |
| #else |
| static const double TimestampScales[MAX_TIMESTAMP_PRECISION + 1] = { |
| 1, |
| 10, |
| 100, |
| 1000, |
| 10000, |
| 100000, |
| 1000000 |
| }; |
| #endif |
| |
| if (!TIMESTAMP_NOT_FINITE(*time) |
| && (typmod != -1) && (typmod != MAX_TIMESTAMP_PRECISION)) |
| { |
| if (typmod < 0 || typmod > MAX_TIMESTAMP_PRECISION) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("timestamp(%d) precision must be between %d and %d", |
| typmod, 0, MAX_TIMESTAMP_PRECISION), |
| errOmitLocation(true))); |
| |
| /* |
| * Note: this round-to-nearest code is not completely consistent about |
| * rounding values that are exactly halfway between integral values. |
| * On most platforms, rint() will implement round-to-nearest-even, but |
| * the integer code always rounds up (away from zero). Is it worth |
| * trying to be consistent? |
| */ |
| #ifdef HAVE_INT64_TIMESTAMP |
| if (*time >= INT64CONST(0)) |
| { |
| *time = ((*time + TimestampOffsets[typmod]) / TimestampScales[typmod]) * |
| TimestampScales[typmod]; |
| } |
| else |
| { |
| *time = -((((-*time) + TimestampOffsets[typmod]) / TimestampScales[typmod]) |
| * TimestampScales[typmod]); |
| } |
| #else |
| *time = rint((double) *time * TimestampScales[typmod]) / TimestampScales[typmod]; |
| #endif |
| } |
| } |
| |
| |
| /* timestamptz_in() |
| * Convert a string to internal form. |
| */ |
| Datum |
| timestamptz_in(PG_FUNCTION_ARGS) |
| { |
| char *str = PG_GETARG_CSTRING(0); |
| |
| #ifdef NOT_USED |
| Oid typelem = PG_GETARG_OID(1); |
| #endif |
| int32 typmod = PG_GETARG_INT32(2); |
| TimestampTz result; |
| fsec_t fsec; |
| struct pg_tm tt, |
| *tm = &tt; |
| int tz; |
| int dtype = 0; |
| int nf; |
| int dterr; |
| char *field[MAXDATEFIELDS]; |
| int ftype[MAXDATEFIELDS]; |
| char workbuf[MAXDATELEN + MAXDATEFIELDS]; |
| |
| dterr = ParseDateTime(str, workbuf, sizeof(workbuf), |
| field, ftype, MAXDATEFIELDS, &nf); |
| if (dterr == 0) |
| dterr = DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tz); |
| if (dterr != 0) |
| DateTimeParseError(dterr, str, "timestamp with time zone"); |
| |
| switch (dtype) |
| { |
| case DTK_DATE: |
| if (tm2timestamp(tm, fsec, &tz, &result) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range: \"%s\"", str), |
| errOmitLocation(true))); |
| break; |
| |
| case DTK_EPOCH: |
| result = SetEpochTimestamp(); |
| break; |
| |
| case DTK_LATE: |
| TIMESTAMP_NOEND(result); |
| break; |
| |
| case DTK_EARLY: |
| TIMESTAMP_NOBEGIN(result); |
| break; |
| |
| case DTK_INVALID: |
| ereport(ERROR, |
| (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), |
| errmsg("date/time value \"%s\" is no longer supported", str), |
| errOmitLocation(true))); |
| |
| TIMESTAMP_NOEND(result); |
| break; |
| |
| default: |
| elog(ERROR, "unexpected dtype %d while parsing timestamptz \"%s\"", |
| dtype, str); |
| TIMESTAMP_NOEND(result); |
| } |
| |
| AdjustTimestampForTypmod(&result, typmod); |
| |
| PG_RETURN_TIMESTAMPTZ(result); |
| } |
| |
| /* timestamptz_out() |
| * Convert a timestamp to external form. |
| */ |
| Datum |
| timestamptz_out(PG_FUNCTION_ARGS) |
| { |
| TimestampTz dt = PG_GETARG_TIMESTAMPTZ(0); |
| char *result; |
| int tz; |
| struct pg_tm tt, |
| *tm = &tt; |
| fsec_t fsec; |
| 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, &tz, &tzn, DateStyle, buf); |
| else |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| result = pstrdup(buf); |
| PG_RETURN_CSTRING(result); |
| } |
| |
| /* |
| * timestamptz_recv - converts external binary format to timestamptz |
| * |
| * We make no attempt to provide compatibility between int and float |
| * timestamp representations ... |
| */ |
| Datum |
| timestamptz_recv(PG_FUNCTION_ARGS) |
| { |
| 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; |
| char *tzn; |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| timestamp = (TimestampTz) pq_getmsgint64(buf); |
| #else |
| timestamp = (TimestampTz) pq_getmsgfloat8(buf); |
| #endif |
| |
| /* rangecheck: see if timestamptz_out would like it */ |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| /* ok */ ; |
| else if (timestamp2tm(timestamp, &tz, tm, &fsec, &tzn, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| AdjustTimestampForTypmod(×tamp, typmod); |
| |
| PG_RETURN_TIMESTAMPTZ(timestamp); |
| } |
| |
| /* |
| * timestamptz_send - converts timestamptz to binary format |
| */ |
| Datum |
| timestamptz_send(PG_FUNCTION_ARGS) |
| { |
| TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0); |
| StringInfoData buf; |
| |
| pq_begintypsend(&buf); |
| #ifdef HAVE_INT64_TIMESTAMP |
| pq_sendint64(&buf, timestamp); |
| #else |
| pq_sendfloat8(&buf, timestamp); |
| #endif |
| PG_RETURN_BYTEA_P(pq_endtypsend(&buf)); |
| } |
| |
| Datum |
| timestamptztypmodin(PG_FUNCTION_ARGS) |
| { |
| ArrayType *ta = PG_GETARG_ARRAYTYPE_P(0); |
| |
| PG_RETURN_INT32(anytimestamp_typmodin(true, ta)); |
| } |
| |
| Datum |
| timestamptztypmodout(PG_FUNCTION_ARGS) |
| { |
| int32 typmod = PG_GETARG_INT32(0); |
| |
| PG_RETURN_CSTRING(anytimestamp_typmodout(true, typmod)); |
| } |
| |
| |
| /* timestamptz_scale() |
| * Adjust time type for specified scale factor. |
| * Used by PostgreSQL type system to stuff columns. |
| */ |
| Datum |
| timestamptz_scale(PG_FUNCTION_ARGS) |
| { |
| TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0); |
| int32 typmod = PG_GETARG_INT32(1); |
| TimestampTz result; |
| |
| result = timestamp; |
| |
| AdjustTimestampForTypmod(&result, typmod); |
| |
| PG_RETURN_TIMESTAMPTZ(result); |
| } |
| |
| |
| /* interval_in() |
| * Convert a string to internal form. |
| * |
| * External format(s): |
| * Uses the generic date/time parsing and decoding routines. |
| */ |
| Datum |
| interval_in(PG_FUNCTION_ARGS) |
| { |
| char *str = PG_GETARG_CSTRING(0); |
| |
| #ifdef NOT_USED |
| Oid typelem = PG_GETARG_OID(1); |
| #endif |
| int32 typmod = PG_GETARG_INT32(2); |
| Interval *result; |
| fsec_t fsec; |
| struct pg_tm tt, |
| *tm = &tt; |
| int dtype; |
| int nf; |
| int range; |
| int dterr; |
| char *field[MAXDATEFIELDS]; |
| int ftype[MAXDATEFIELDS]; |
| char workbuf[256]; |
| |
| tm->tm_year = 0; |
| tm->tm_mon = 0; |
| tm->tm_mday = 0; |
| tm->tm_hour = 0; |
| tm->tm_min = 0; |
| tm->tm_sec = 0; |
| fsec = 0; |
| |
| if (typmod >= 0) |
| range = INTERVAL_RANGE(typmod); |
| else |
| range = INTERVAL_FULL_RANGE; |
| |
| dterr = ParseDateTime(str, workbuf, sizeof(workbuf), field, |
| ftype, MAXDATEFIELDS, &nf); |
| if (dterr == 0) |
| dterr = DecodeInterval(field, ftype, nf, range, |
| &dtype, tm, &fsec); |
| |
| /* if those functions think it's a bad format, try ISO8601 style */ |
| if (dterr == DTERR_BAD_FORMAT) |
| dterr = DecodeISO8601Interval(str, |
| &dtype, tm, &fsec); |
| |
| if (dterr != 0) |
| { |
| if (dterr == DTERR_FIELD_OVERFLOW) |
| dterr = DTERR_INTERVAL_OVERFLOW; |
| DateTimeParseError(dterr, str, "interval"); |
| } |
| |
| result = (Interval *) palloc(sizeof(Interval)); |
| |
| switch (dtype) |
| { |
| case DTK_DELTA: |
| if (tm2interval(tm, fsec, result) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("interval out of range"), |
| errOmitLocation(true))); |
| break; |
| |
| case DTK_INVALID: |
| ereport(ERROR, |
| (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), |
| errmsg("date/time value \"%s\" is no longer supported", str), |
| errOmitLocation(true))); |
| break; |
| |
| default: |
| elog(ERROR, "unexpected dtype %d while parsing interval \"%s\"", |
| dtype, str); |
| } |
| |
| AdjustIntervalForTypmod(result, typmod); |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| /* interval_out() |
| * Convert a time span to external form. |
| */ |
| Datum |
| interval_out(PG_FUNCTION_ARGS) |
| { |
| Interval *span = PG_GETARG_INTERVAL_P(0); |
| char *result; |
| struct pg_tm tt, |
| *tm = &tt; |
| fsec_t fsec; |
| char buf[MAXDATELEN + 1]; |
| |
| if (interval2tm(*span, tm, &fsec) != 0) |
| elog(ERROR, "could not convert interval to tm"); |
| |
| EncodeInterval(tm, fsec, IntervalStyle, buf); |
| |
| result = pstrdup(buf); |
| PG_RETURN_CSTRING(result); |
| } |
| |
| /* |
| * interval_recv - converts external binary format to interval |
| */ |
| Datum |
| interval_recv(PG_FUNCTION_ARGS) |
| { |
| 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)); |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| interval->time = pq_getmsgint64(buf); |
| #else |
| interval->time = pq_getmsgfloat8(buf); |
| #endif |
| interval->day = pq_getmsgint(buf, sizeof(interval->day)); |
| interval->month = pq_getmsgint(buf, sizeof(interval->month)); |
| |
| AdjustIntervalForTypmod(interval, typmod); |
| |
| PG_RETURN_INTERVAL_P(interval); |
| } |
| |
| /* |
| * interval_send - converts interval to binary format |
| */ |
| Datum |
| interval_send(PG_FUNCTION_ARGS) |
| { |
| Interval *interval = PG_GETARG_INTERVAL_P(0); |
| StringInfoData buf; |
| |
| pq_begintypsend(&buf); |
| #ifdef HAVE_INT64_TIMESTAMP |
| pq_sendint64(&buf, interval->time); |
| #else |
| pq_sendfloat8(&buf, interval->time); |
| #endif |
| pq_sendint(&buf, interval->day, sizeof(interval->day)); |
| pq_sendint(&buf, interval->month, sizeof(interval->month)); |
| PG_RETURN_BYTEA_P(pq_endtypsend(&buf)); |
| } |
| |
| Datum |
| intervaltypmodin(PG_FUNCTION_ARGS) |
| { |
| 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"), |
| errOmitLocation(true))); |
| } |
| } |
| |
| 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]), |
| errOmitLocation(true))); |
| 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), |
| errOmitLocation(true))); |
| 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"), |
| errOmitLocation(true))); |
| typmod = 0; /* keep compiler quiet */ |
| } |
| |
| PG_RETURN_INT32(typmod); |
| } |
| |
| Datum |
| intervaltypmodout(PG_FUNCTION_ARGS) |
| { |
| 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); |
| } |
| |
| |
| /* interval_scale() |
| * Adjust interval type for specified fields. |
| * Used by PostgreSQL type system to stuff columns. |
| */ |
| Datum |
| interval_scale(PG_FUNCTION_ARGS) |
| { |
| Interval *interval = PG_GETARG_INTERVAL_P(0); |
| int32 typmod = PG_GETARG_INT32(1); |
| Interval *result; |
| |
| result = palloc(sizeof(Interval)); |
| *result = *interval; |
| |
| AdjustIntervalForTypmod(result, typmod); |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| /* |
| * Adjust interval for specified precision, in both YEAR to SECOND |
| * range and sub-second precision. |
| */ |
| static void |
| AdjustIntervalForTypmod(Interval *interval, int32 typmod) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| 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) |
| }; |
| #else |
| static const double IntervalScales[MAX_INTERVAL_PRECISION + 1] = { |
| 1, |
| 10, |
| 100, |
| 1000, |
| 10000, |
| 100000, |
| 1000000 |
| }; |
| #endif |
| |
| /* |
| * 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>.) |
| * |
| * 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)) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| interval->time = (interval->time / USECS_PER_HOUR) * |
| USECS_PER_HOUR; |
| #else |
| interval->time = ((int) (interval->time / SECS_PER_HOUR)) * (double) SECS_PER_HOUR; |
| #endif |
| } |
| else if (range == INTERVAL_MASK(MINUTE)) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| interval->time = (interval->time / USECS_PER_MINUTE) * |
| USECS_PER_MINUTE; |
| #else |
| interval->time = ((int) (interval->time / SECS_PER_MINUTE)) * (double) SECS_PER_MINUTE; |
| #endif |
| } |
| 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))) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| interval->time = (interval->time / USECS_PER_HOUR) * |
| USECS_PER_HOUR; |
| #else |
| interval->time = ((int) (interval->time / SECS_PER_HOUR)) * (double) SECS_PER_HOUR; |
| #endif |
| } |
| /* DAY TO MINUTE */ |
| else if (range == (INTERVAL_MASK(DAY) | |
| INTERVAL_MASK(HOUR) | |
| INTERVAL_MASK(MINUTE))) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| interval->time = (interval->time / USECS_PER_MINUTE) * |
| USECS_PER_MINUTE; |
| #else |
| interval->time = ((int) (interval->time / SECS_PER_MINUTE)) * (double) SECS_PER_MINUTE; |
| #endif |
| } |
| /* 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))) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| interval->time = (interval->time / USECS_PER_MINUTE) * |
| USECS_PER_MINUTE; |
| #else |
| interval->time = ((int) (interval->time / SECS_PER_MINUTE)) * (double) SECS_PER_MINUTE; |
| #endif |
| } |
| /* 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 subsecond precision? */ |
| if (precision != INTERVAL_FULL_PRECISION) |
| { |
| if (precision < 0 || precision > MAX_INTERVAL_PRECISION) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("interval(%d) precision must be between %d and %d", |
| precision, 0, MAX_INTERVAL_PRECISION), |
| errOmitLocation(true))); |
| |
| /* |
| * Note: this round-to-nearest code is not completely consistent |
| * about rounding values that are exactly halfway between integral |
| * values. On most platforms, rint() will implement |
| * round-to-nearest-even, but the integer code always rounds up |
| * (away from zero). Is it worth trying to be consistent? |
| */ |
| #ifdef HAVE_INT64_TIMESTAMP |
| if (interval->time >= INT64CONST(0)) |
| { |
| interval->time = ((interval->time + |
| IntervalOffsets[precision]) / |
| IntervalScales[precision]) * |
| IntervalScales[precision]; |
| } |
| else |
| { |
| interval->time = -(((-interval->time + |
| IntervalOffsets[precision]) / |
| IntervalScales[precision]) * |
| IntervalScales[precision]); |
| } |
| #else |
| interval->time = rint(((double) interval->time) * |
| IntervalScales[precision]) / |
| IntervalScales[precision]; |
| #endif |
| } |
| } |
| } |
| |
| |
| /* EncodeSpecialTimestamp() |
| * Convert reserved timestamp data type to string. |
| */ |
| static void |
| EncodeSpecialTimestamp(Timestamp dt, char *str) |
| { |
| if (TIMESTAMP_IS_NOBEGIN(dt)) |
| strcpy(str, EARLY); |
| else if (TIMESTAMP_IS_NOEND(dt)) |
| strcpy(str, LATE); |
| else /* shouldn't happen */ |
| elog(ERROR, "invalid argument for EncodeSpecialTimestamp"); |
| } |
| |
| Datum |
| now(PG_FUNCTION_ARGS) |
| { |
| PG_RETURN_TIMESTAMPTZ(GetCurrentTransactionStartTimestamp()); |
| } |
| |
| Datum |
| statement_timestamp(PG_FUNCTION_ARGS) |
| { |
| PG_RETURN_TIMESTAMPTZ(GetCurrentStatementStartTimestamp()); |
| } |
| |
| Datum |
| clock_timestamp(PG_FUNCTION_ARGS) |
| { |
| PG_RETURN_TIMESTAMPTZ(GetCurrentTimestamp()); |
| } |
| |
| Datum |
| pg_postmaster_start_time(PG_FUNCTION_ARGS) |
| { |
| PG_RETURN_TIMESTAMPTZ(PgStartTime); |
| } |
| |
| /* Old version */ |
| Datum |
| pgsql_postmaster_start_time(PG_FUNCTION_ARGS) |
| { |
| PG_RETURN_TIMESTAMPTZ(PgStartTime); |
| } |
| |
| Datum |
| pg_conf_load_time(PG_FUNCTION_ARGS) |
| { |
| PG_RETURN_TIMESTAMPTZ(PgReloadTime); |
| } |
| |
| /* |
| * GetCurrentTimestamp -- get the current operating system time |
| * |
| * Result is in the form of a TimestampTz value, and is expressed to the |
| * full precision of the gettimeofday() syscall |
| */ |
| TimestampTz |
| GetCurrentTimestamp(void) |
| { |
| TimestampTz result; |
| struct timeval tp; |
| |
| gettimeofday(&tp, NULL); |
| |
| result = (TimestampTz) tp.tv_sec - |
| ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY); |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = (result * USECS_PER_SEC) + tp.tv_usec; |
| #else |
| result = result + (tp.tv_usec / 1000000.0); |
| #endif |
| |
| return result; |
| } |
| |
| /* |
| * TimestampDifference -- convert the difference between two timestamps |
| * into integer seconds and microseconds |
| * |
| * Both inputs must be ordinary finite timestamps (in current usage, |
| * they'll be results from GetCurrentTimestamp()). |
| * |
| * We expect start_time <= stop_time. If not, we return zeroes; for current |
| * callers there is no need to be tense about which way division rounds on |
| * negative inputs. |
| */ |
| void |
| TimestampDifference(TimestampTz start_time, TimestampTz stop_time, |
| long *secs, int *microsecs) |
| { |
| TimestampTz diff = stop_time - start_time; |
| |
| if (diff <= 0) |
| { |
| *secs = 0; |
| *microsecs = 0; |
| } |
| else |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| *secs = (long) (diff / USECS_PER_SEC); |
| *microsecs = (int) (diff % USECS_PER_SEC); |
| #else |
| *secs = (long) diff; |
| *microsecs = (int) ((diff - *secs) * 1000000.0); |
| #endif |
| } |
| } |
| |
| /* |
| * TimestampDifferenceExceeds -- report whether the difference between two |
| * timestamps is >= a threshold (expressed in milliseconds) |
| * |
| * Both inputs must be ordinary finite timestamps (in current usage, |
| * they'll be results from GetCurrentTimestamp()). |
| */ |
| bool |
| TimestampDifferenceExceeds(TimestampTz start_time, |
| TimestampTz stop_time, |
| int msec) |
| { |
| TimestampTz diff = stop_time - start_time; |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| return (diff >= msec * INT64CONST(1000)); |
| #else |
| return (diff * 1000.0 >= msec); |
| #endif |
| } |
| |
| /* |
| * Convert a time_t to TimestampTz. |
| * |
| * We do not use time_t internally in Postgres, but this is provided for use |
| * by functions that need to interpret, say, a stat(2) result. |
| * |
| * To avoid having the function's ABI vary depending on the width of time_t, |
| * we declare the argument as pg_time_t, which is cast-compatible with |
| * time_t but always 64 bits wide (unless the platform has no 64-bit type). |
| * This detail should be invisible to callers, at least at source code level. |
| */ |
| TimestampTz |
| time_t_to_timestamptz(pg_time_t tm) |
| { |
| TimestampTz result; |
| |
| result = (TimestampTz) tm - |
| ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY); |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| result *= USECS_PER_SEC; |
| #endif |
| |
| return result; |
| } |
| |
| /* |
| * Convert a TimestampTz to time_t. |
| * |
| * This too is just marginally useful, but some places need it. |
| * |
| * To avoid having the function's ABI vary depending on the width of time_t, |
| * we declare the result as pg_time_t, which is cast-compatible with |
| * time_t but always 64 bits wide (unless the platform has no 64-bit type). |
| * This detail should be invisible to callers, at least at source code level. |
| */ |
| pg_time_t |
| timestamptz_to_time_t(TimestampTz t) |
| { |
| pg_time_t result; |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = (pg_time_t) (t / USECS_PER_SEC + |
| ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY)); |
| #else |
| result = (pg_time_t) (t + |
| ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY)); |
| #endif |
| |
| return result; |
| } |
| |
| /* |
| * Produce a C-string representation of a TimestampTz. |
| * |
| * This is mostly for use in emitting messages. The primary difference |
| * from timestamptz_out is that we force the output format to ISO. Note |
| * also that the result is in a static buffer, not pstrdup'd. |
| */ |
| const char * |
| timestamptz_to_str(TimestampTz t) |
| { |
| static char buf[MAXDATELEN + 1]; |
| int tz; |
| struct pg_tm tt, |
| *tm = &tt; |
| fsec_t fsec; |
| char *tzn; |
| |
| if (TIMESTAMP_NOT_FINITE(t)) |
| EncodeSpecialTimestamp(t, buf); |
| else if (timestamp2tm(t, &tz, tm, &fsec, &tzn, NULL) == 0) |
| EncodeDateTime(tm, fsec, &tz, &tzn, USE_ISO_DATES, buf); |
| else |
| strlcpy(buf, "(timestamp out of range)", sizeof(buf)); |
| |
| return buf; |
| } |
| |
| |
| void |
| dt2time(Timestamp jd, int *hour, int *min, int *sec, fsec_t *fsec) |
| { |
| TimeOffset time; |
| |
| time = jd; |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| *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); |
| #else |
| *hour = time / SECS_PER_HOUR; |
| time -= (*hour) * SECS_PER_HOUR; |
| *min = time / SECS_PER_MINUTE; |
| time -= (*min) * SECS_PER_MINUTE; |
| *sec = time; |
| *fsec = time - *sec; |
| #endif |
| } /* dt2time() */ |
| |
| |
| /* |
| * timestamp2tm() - Convert timestamp data type to POSIX time structure. |
| * |
| * Note that year is _not_ 1900-based, but is an explicit full value. |
| * Also, month is one-based, _not_ zero-based. |
| * Returns: |
| * 0 on success |
| * -1 on out of range |
| * |
| * If attimezone is NULL, the global timezone (including possibly brute forced |
| * timezone) will be used. |
| */ |
| int |
| timestamp2tm(Timestamp dt, int *tzp, struct pg_tm * tm, fsec_t *fsec, char **tzn, pg_tz *attimezone) |
| { |
| Timestamp date; |
| Timestamp time; |
| pg_time_t utime; |
| |
| /* |
| * If HasCTZSet is true then we have a brute force time zone specified. Go |
| * ahead and rotate to the local time zone since we will later bypass any |
| * calls which adjust the tm fields. |
| */ |
| if (attimezone == NULL && HasCTZSet && tzp != NULL) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| dt -= CTimeZone * USECS_PER_SEC; |
| #else |
| dt -= CTimeZone; |
| #endif |
| } |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| 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); |
| #else |
| time = dt; |
| TMODULO(time, date, (double) SECS_PER_DAY); |
| |
| if (time < 0) |
| { |
| time += SECS_PER_DAY; |
| date -= 1; |
| } |
| |
| /* add offset to go from J2000 back to standard Julian date */ |
| date += POSTGRES_EPOCH_JDATE; |
| |
| recalc_d: |
| /* 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); |
| recalc_t: |
| dt2time(time, &tm->tm_hour, &tm->tm_min, &tm->tm_sec, fsec); |
| |
| *fsec = TSROUND(*fsec); |
| /* roundoff may need to propagate to higher-order fields */ |
| if (*fsec >= 1.0) |
| { |
| time = ceil(time); |
| if (time >= (double) SECS_PER_DAY) |
| { |
| time = 0; |
| date += 1; |
| goto recalc_d; |
| } |
| goto recalc_t; |
| } |
| #endif |
| |
| /* 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; |
| } |
| |
| /* |
| * We have a brute force time zone per SQL99? Then use it without change |
| * since we have already rotated to the time zone. |
| */ |
| if (attimezone == NULL && HasCTZSet) |
| { |
| *tzp = CTimeZone; |
| tm->tm_isdst = 0; |
| tm->tm_gmtoff = CTimeZone; |
| 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. |
| */ |
| #ifdef HAVE_INT64_TIMESTAMP |
| dt = (dt - *fsec) / USECS_PER_SEC + |
| (POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY; |
| #else |
| dt = rint(dt - *fsec + |
| (POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY); |
| #endif |
| utime = (pg_time_t) dt; |
| if ((Timestamp) utime == dt) |
| { |
| struct pg_tm *tx = pg_localtime(&utime, |
| attimezone ? attimezone : session_timezone); |
| |
| 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 = (char *) 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; |
| } |
| |
| |
| /* tm2timestamp() |
| * Convert a tm structure to a timestamp data type. |
| * Note that year is _not_ 1900-based, but is an explicit full value. |
| * Also, month is one-based, _not_ zero-based. |
| * |
| * Returns -1 on failure (value out of range). |
| */ |
| int |
| tm2timestamp(struct pg_tm * tm, fsec_t fsec, int *tzp, Timestamp *result) |
| { |
| TimeOffset date; |
| TimeOffset time; |
| |
| /* Julian day routines are not correct for negative Julian days */ |
| 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); |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| *result = date * USECS_PER_DAY + time; |
| /* check for major overflow */ |
| if ((*result - time) / USECS_PER_DAY != date) |
| { |
| *result = 0; /* keep compiler quiet */ |
| return -1; |
| } |
| /* check for just-barely overflow (okay except time-of-day wraps) */ |
| if ((*result < 0 && date >= 0) || |
| (*result >= 0 && date < 0)) |
| { |
| *result = 0; /* keep compiler quiet */ |
| return -1; |
| } |
| #else |
| *result = date * SECS_PER_DAY + time; |
| #endif |
| if (tzp != NULL) |
| *result = dt2local(*result, -(*tzp)); |
| |
| return 0; |
| } |
| |
| |
| /* interval2tm() |
| * Convert a interval data type to a tm structure. |
| */ |
| int |
| interval2tm(Interval span, struct pg_tm * tm, fsec_t *fsec) |
| { |
| TimeOffset time; |
| TimeOffset tfrac; |
| |
| tm->tm_year = span.month / MONTHS_PER_YEAR; |
| tm->tm_mon = span.month % MONTHS_PER_YEAR; |
| tm->tm_mday = span.day; |
| time = span.time; |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| tfrac = time / USECS_PER_HOUR; |
| time -= tfrac * USECS_PER_HOUR; |
| tm->tm_hour = tfrac; /* could overflow ... */ |
| tfrac = time / USECS_PER_MINUTE; |
| time -= tfrac * USECS_PER_MINUTE; |
| tm->tm_min = tfrac; |
| tfrac = time / USECS_PER_SEC; |
| *fsec = time - (tfrac * USECS_PER_SEC); |
| tm->tm_sec = tfrac; |
| #else |
| recalc: |
| TMODULO(time, tfrac, (double) SECS_PER_HOUR); |
| tm->tm_hour = tfrac; /* could overflow ... */ |
| TMODULO(time, tfrac, (double) SECS_PER_MINUTE); |
| tm->tm_min = tfrac; |
| TMODULO(time, tfrac, 1.0); |
| tm->tm_sec = tfrac; |
| time = TSROUND(time); |
| /* roundoff may need to propagate to higher-order fields */ |
| if (time >= 1.0) |
| { |
| time = ceil(span.time); |
| goto recalc; |
| } |
| *fsec = time; |
| #endif |
| |
| return 0; |
| } |
| |
| int |
| tm2interval(struct pg_tm * tm, fsec_t fsec, Interval *span) |
| { |
| span->month = tm->tm_year * MONTHS_PER_YEAR + tm->tm_mon; |
| span->day = tm->tm_mday; |
| #ifdef HAVE_INT64_TIMESTAMP |
| span->time = (((((tm->tm_hour * INT64CONST(60)) + |
| tm->tm_min) * INT64CONST(60)) + |
| tm->tm_sec) * USECS_PER_SEC) + fsec; |
| #else |
| span->time = (((tm->tm_hour * (double) MINS_PER_HOUR) + |
| tm->tm_min) * (double) SECS_PER_MINUTE) + |
| tm->tm_sec + fsec; |
| #endif |
| |
| return 0; |
| } |
| |
| static TimeOffset |
| time2t(const int hour, const int min, const int sec, const fsec_t fsec) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| return (((((hour * MINS_PER_HOUR) + min) * SECS_PER_MINUTE) + sec) * USECS_PER_SEC) + fsec; |
| #else |
| return (((hour * MINS_PER_HOUR) + min) * SECS_PER_MINUTE) + sec + fsec; |
| #endif |
| } |
| |
| static Timestamp |
| dt2local(Timestamp dt, int tz) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| dt -= (tz * USECS_PER_SEC); |
| #else |
| dt -= tz; |
| #endif |
| return dt; |
| } |
| |
| |
| /***************************************************************************** |
| * PUBLIC ROUTINES * |
| *****************************************************************************/ |
| |
| |
| Datum |
| timestamp_finite(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestamp = PG_GETARG_TIMESTAMP(0); |
| |
| PG_RETURN_BOOL(!TIMESTAMP_NOT_FINITE(timestamp)); |
| } |
| |
| Datum |
| interval_finite(PG_FUNCTION_ARGS) |
| { |
| PG_RETURN_BOOL(true); |
| } |
| |
| |
| /*---------------------------------------------------------- |
| * Relational operators for timestamp. |
| *---------------------------------------------------------*/ |
| |
| void |
| GetEpochTime(struct pg_tm * tm) |
| { |
| struct pg_tm *t0; |
| pg_time_t epoch = 0; |
| |
| t0 = pg_gmtime(&epoch); |
| |
| tm->tm_year = t0->tm_year; |
| tm->tm_mon = t0->tm_mon; |
| tm->tm_mday = t0->tm_mday; |
| tm->tm_hour = t0->tm_hour; |
| tm->tm_min = t0->tm_min; |
| tm->tm_sec = t0->tm_sec; |
| |
| tm->tm_year += 1900; |
| tm->tm_mon++; |
| } |
| |
| Timestamp |
| SetEpochTimestamp(void) |
| { |
| 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() */ |
| |
| /* |
| * We are currently sharing some code between timestamp and timestamptz. |
| * The comparison functions are among them. - thomas 2001-09-25 |
| * |
| * timestamp_relop - is timestamp1 relop timestamp2 |
| * |
| * collate invalid timestamp at the end |
| */ |
| int |
| timestamp_cmp_internal(Timestamp dt1, Timestamp dt2) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| return (dt1 < dt2) ? -1 : ((dt1 > dt2) ? 1 : 0); |
| #else |
| |
| /* |
| * When using float representation, we have to be wary of NaNs. |
| * |
| * We consider all NANs to be equal and larger than any non-NAN. This is |
| * somewhat arbitrary; the important thing is to have a consistent sort |
| * order. |
| */ |
| if (isnan(dt1)) |
| { |
| if (isnan(dt2)) |
| return 0; /* NAN = NAN */ |
| else |
| return 1; /* NAN > non-NAN */ |
| } |
| else if (isnan(dt2)) |
| { |
| return -1; /* non-NAN < NAN */ |
| } |
| else |
| { |
| if (dt1 > dt2) |
| return 1; |
| else if (dt1 < dt2) |
| return -1; |
| else |
| return 0; |
| } |
| #endif |
| } |
| |
| Datum |
| timestamp_eq(PG_FUNCTION_ARGS) |
| { |
| Timestamp dt1 = PG_GETARG_TIMESTAMP(0); |
| Timestamp dt2 = PG_GETARG_TIMESTAMP(1); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) == 0); |
| } |
| |
| Datum |
| timestamp_ne(PG_FUNCTION_ARGS) |
| { |
| Timestamp dt1 = PG_GETARG_TIMESTAMP(0); |
| Timestamp dt2 = PG_GETARG_TIMESTAMP(1); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) != 0); |
| } |
| |
| Datum |
| timestamp_lt(PG_FUNCTION_ARGS) |
| { |
| Timestamp dt1 = PG_GETARG_TIMESTAMP(0); |
| Timestamp dt2 = PG_GETARG_TIMESTAMP(1); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) < 0); |
| } |
| |
| Datum |
| timestamp_gt(PG_FUNCTION_ARGS) |
| { |
| Timestamp dt1 = PG_GETARG_TIMESTAMP(0); |
| Timestamp dt2 = PG_GETARG_TIMESTAMP(1); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) > 0); |
| } |
| |
| Datum |
| timestamp_le(PG_FUNCTION_ARGS) |
| { |
| Timestamp dt1 = PG_GETARG_TIMESTAMP(0); |
| Timestamp dt2 = PG_GETARG_TIMESTAMP(1); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) <= 0); |
| } |
| |
| Datum |
| timestamp_ge(PG_FUNCTION_ARGS) |
| { |
| Timestamp dt1 = PG_GETARG_TIMESTAMP(0); |
| Timestamp dt2 = PG_GETARG_TIMESTAMP(1); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) >= 0); |
| } |
| |
| Datum |
| timestamp_cmp(PG_FUNCTION_ARGS) |
| { |
| Timestamp dt1 = PG_GETARG_TIMESTAMP(0); |
| Timestamp dt2 = PG_GETARG_TIMESTAMP(1); |
| |
| PG_RETURN_INT32(timestamp_cmp_internal(dt1, dt2)); |
| } |
| |
| Datum |
| timestamp_hash(PG_FUNCTION_ARGS) |
| { |
| /* We can use either hashint8 or hashfloat8 directly */ |
| #ifdef HAVE_INT64_TIMESTAMP |
| return hashint8(fcinfo); |
| #else |
| return hashfloat8(fcinfo); |
| #endif |
| } |
| |
| |
| /* |
| * Crosstype comparison functions for timestamp vs timestamptz |
| */ |
| |
| Datum |
| timestamp_eq_timestamptz(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(0); |
| TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1); |
| TimestampTz dt1; |
| |
| dt1 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) == 0); |
| } |
| |
| Datum |
| timestamp_ne_timestamptz(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(0); |
| TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1); |
| TimestampTz dt1; |
| |
| dt1 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) != 0); |
| } |
| |
| Datum |
| timestamp_lt_timestamptz(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(0); |
| TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1); |
| TimestampTz dt1; |
| |
| dt1 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) < 0); |
| } |
| |
| Datum |
| timestamp_gt_timestamptz(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(0); |
| TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1); |
| TimestampTz dt1; |
| |
| dt1 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) > 0); |
| } |
| |
| Datum |
| timestamp_le_timestamptz(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(0); |
| TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1); |
| TimestampTz dt1; |
| |
| dt1 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) <= 0); |
| } |
| |
| Datum |
| timestamp_ge_timestamptz(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(0); |
| TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1); |
| TimestampTz dt1; |
| |
| dt1 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) >= 0); |
| } |
| |
| Datum |
| timestamp_cmp_timestamptz(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(0); |
| TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1); |
| TimestampTz dt1; |
| |
| dt1 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_INT32(timestamp_cmp_internal(dt1, dt2)); |
| } |
| |
| Datum |
| timestamptz_eq_timestamp(PG_FUNCTION_ARGS) |
| { |
| TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0); |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(1); |
| TimestampTz dt2; |
| |
| dt2 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) == 0); |
| } |
| |
| Datum |
| timestamptz_ne_timestamp(PG_FUNCTION_ARGS) |
| { |
| TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0); |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(1); |
| TimestampTz dt2; |
| |
| dt2 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) != 0); |
| } |
| |
| Datum |
| timestamptz_lt_timestamp(PG_FUNCTION_ARGS) |
| { |
| TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0); |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(1); |
| TimestampTz dt2; |
| |
| dt2 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) < 0); |
| } |
| |
| Datum |
| timestamptz_gt_timestamp(PG_FUNCTION_ARGS) |
| { |
| TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0); |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(1); |
| TimestampTz dt2; |
| |
| dt2 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) > 0); |
| } |
| |
| Datum |
| timestamptz_le_timestamp(PG_FUNCTION_ARGS) |
| { |
| TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0); |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(1); |
| TimestampTz dt2; |
| |
| dt2 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) <= 0); |
| } |
| |
| Datum |
| timestamptz_ge_timestamp(PG_FUNCTION_ARGS) |
| { |
| TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0); |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(1); |
| TimestampTz dt2; |
| |
| dt2 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_BOOL(timestamp_cmp_internal(dt1, dt2) >= 0); |
| } |
| |
| Datum |
| timestamptz_cmp_timestamp(PG_FUNCTION_ARGS) |
| { |
| TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0); |
| Timestamp timestampVal = PG_GETARG_TIMESTAMP(1); |
| TimestampTz dt2; |
| |
| dt2 = timestamp2timestamptz(timestampVal); |
| |
| PG_RETURN_INT32(timestamp_cmp_internal(dt1, dt2)); |
| } |
| |
| |
| /* |
| * interval_relop - is interval1 relop interval2 |
| * |
| * collate invalid interval at the end |
| */ |
| static inline TimeOffset |
| interval_cmp_value(const Interval *interval) |
| { |
| TimeOffset span; |
| |
| span = interval->time; |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| span += interval->month * INT64CONST(30) * USECS_PER_DAY; |
| span += interval->day * INT64CONST(24) * USECS_PER_HOUR; |
| #else |
| span += interval->month * ((double) DAYS_PER_MONTH * SECS_PER_DAY); |
| span += interval->day * ((double) HOURS_PER_DAY * SECS_PER_HOUR); |
| #endif |
| |
| return span; |
| } |
| |
| static int |
| interval_cmp_internal(Interval *interval1, Interval *interval2) |
| { |
| TimeOffset span1 = interval_cmp_value(interval1); |
| TimeOffset span2 = interval_cmp_value(interval2); |
| |
| return ((span1 < span2) ? -1 : (span1 > span2) ? 1 : 0); |
| } |
| |
| Datum |
| interval_eq(PG_FUNCTION_ARGS) |
| { |
| Interval *interval1 = PG_GETARG_INTERVAL_P(0); |
| Interval *interval2 = PG_GETARG_INTERVAL_P(1); |
| |
| PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) == 0); |
| } |
| |
| Datum |
| interval_ne(PG_FUNCTION_ARGS) |
| { |
| Interval *interval1 = PG_GETARG_INTERVAL_P(0); |
| Interval *interval2 = PG_GETARG_INTERVAL_P(1); |
| |
| PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) != 0); |
| } |
| |
| Datum |
| interval_lt(PG_FUNCTION_ARGS) |
| { |
| Interval *interval1 = PG_GETARG_INTERVAL_P(0); |
| Interval *interval2 = PG_GETARG_INTERVAL_P(1); |
| |
| PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) < 0); |
| } |
| |
| Datum |
| interval_gt(PG_FUNCTION_ARGS) |
| { |
| Interval *interval1 = PG_GETARG_INTERVAL_P(0); |
| Interval *interval2 = PG_GETARG_INTERVAL_P(1); |
| |
| PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) > 0); |
| } |
| |
| Datum |
| interval_le(PG_FUNCTION_ARGS) |
| { |
| Interval *interval1 = PG_GETARG_INTERVAL_P(0); |
| Interval *interval2 = PG_GETARG_INTERVAL_P(1); |
| |
| PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) <= 0); |
| } |
| |
| Datum |
| interval_ge(PG_FUNCTION_ARGS) |
| { |
| Interval *interval1 = PG_GETARG_INTERVAL_P(0); |
| Interval *interval2 = PG_GETARG_INTERVAL_P(1); |
| |
| PG_RETURN_BOOL(interval_cmp_internal(interval1, interval2) >= 0); |
| } |
| |
| Datum |
| interval_cmp(PG_FUNCTION_ARGS) |
| { |
| Interval *interval1 = PG_GETARG_INTERVAL_P(0); |
| Interval *interval2 = PG_GETARG_INTERVAL_P(1); |
| |
| PG_RETURN_INT32(interval_cmp_internal(interval1, interval2)); |
| } |
| |
| /* |
| * Hashing for intervals |
| * |
| * We must produce equal hashvals for values that interval_cmp_internal() |
| * considers equal. So, compute the net span the same way it does, |
| * and then hash that, using either int64 or float8 hashing. |
| */ |
| Datum |
| interval_hash(PG_FUNCTION_ARGS) |
| { |
| Interval *interval = PG_GETARG_INTERVAL_P(0); |
| TimeOffset span = interval_cmp_value(interval); |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| return DirectFunctionCall1(hashint8, Int64GetDatumFast(span)); |
| #else |
| return DirectFunctionCall1(hashfloat8, Float8GetDatumFast(span)); |
| #endif |
| } |
| |
| /* overlaps_timestamp() --- implements the SQL92 OVERLAPS operator. |
| * |
| * Algorithm is per SQL92 spec. This is much harder than you'd think |
| * because the spec requires us to deliver a non-null answer in some cases |
| * where some of the inputs are null. |
| */ |
| Datum |
| overlaps_timestamp(PG_FUNCTION_ARGS) |
| { |
| /* |
| * 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 nonnull, else null". |
| */ |
| if (te1IsNull || te2IsNull) |
| PG_RETURN_NULL(); |
| PG_RETURN_BOOL(true); |
| } |
| |
| #undef TIMESTAMP_GT |
| #undef TIMESTAMP_LT |
| } |
| |
| |
| /*---------------------------------------------------------- |
| * "Arithmetic" operators on date/times. |
| *---------------------------------------------------------*/ |
| |
| Datum |
| timestamp_smaller(PG_FUNCTION_ARGS) |
| { |
| 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); |
| } |
| |
| Datum |
| timestamp_larger(PG_FUNCTION_ARGS) |
| { |
| 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); |
| } |
| |
| |
| Datum |
| timestamp_mi(PG_FUNCTION_ARGS) |
| { |
| Timestamp dt1 = PG_GETARG_TIMESTAMP(0); |
| Timestamp dt2 = PG_GETARG_TIMESTAMP(1); |
| Interval *result; |
| |
| result = (Interval *) palloc(sizeof(Interval)); |
| |
| if (TIMESTAMP_NOT_FINITE(dt1) || TIMESTAMP_NOT_FINITE(dt2)) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("cannot subtract infinite timestamps"), |
| errOmitLocation(true))); |
| |
| result->time = dt1 - dt2; |
| |
| 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); |
| } |
| |
| /* |
| * interval_justify_interval() |
| * |
| * Adjust interval so 'month', 'day', and 'time' portions are within |
| * customary bounds. Specifically: |
| * |
| * 0 <= abs(time) < 24 hours |
| * 0 <= abs(day) < 30 days |
| * |
| * Also, the sign bit on all three fields is made equal, so either |
| * all three fields are negative or all are positive. |
| */ |
| Datum |
| interval_justify_interval(PG_FUNCTION_ARGS) |
| { |
| 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; |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| TMODULO(result->time, wholeday, USECS_PER_DAY); |
| #else |
| TMODULO(result->time, wholeday, (double) SECS_PER_DAY); |
| #endif |
| result->day += wholeday; /* could overflow... */ |
| |
| wholemonth = result->day / DAYS_PER_MONTH; |
| result->day -= wholemonth * DAYS_PER_MONTH; |
| result->month += wholemonth; |
| |
| if (result->month > 0 && |
| (result->day < 0 || (result->day == 0 && result->time < 0))) |
| { |
| result->day += DAYS_PER_MONTH; |
| result->month--; |
| } |
| else if (result->month < 0 && |
| (result->day > 0 || (result->day == 0 && result->time > 0))) |
| { |
| result->day -= DAYS_PER_MONTH; |
| result->month++; |
| } |
| |
| if (result->day > 0 && result->time < 0) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| result->time += USECS_PER_DAY; |
| #else |
| result->time += (double) SECS_PER_DAY; |
| #endif |
| result->day--; |
| } |
| else if (result->day < 0 && result->time > 0) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| result->time -= USECS_PER_DAY; |
| #else |
| result->time -= (double) SECS_PER_DAY; |
| #endif |
| result->day++; |
| } |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| /* |
| * interval_justify_hours() |
| * |
| * Adjust interval so 'time' contains less than a whole day, adding |
| * the excess to 'day'. This is useful for |
| * situations (such as non-TZ) where '1 day' = '24 hours' is valid, |
| * e.g. interval subtraction and division. |
| */ |
| Datum |
| interval_justify_hours(PG_FUNCTION_ARGS) |
| { |
| 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; |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| TMODULO(result->time, wholeday, USECS_PER_DAY); |
| #else |
| TMODULO(result->time, wholeday, (double) SECS_PER_DAY); |
| #endif |
| result->day += wholeday; /* could overflow... */ |
| |
| if (result->day > 0 && result->time < 0) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| result->time += USECS_PER_DAY; |
| #else |
| result->time += (double) SECS_PER_DAY; |
| #endif |
| result->day--; |
| } |
| else if (result->day < 0 && result->time > 0) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| result->time -= USECS_PER_DAY; |
| #else |
| result->time -= (double) SECS_PER_DAY; |
| #endif |
| result->day++; |
| } |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| /* |
| * interval_justify_days() |
| * |
| * Adjust interval so 'day' contains less than 30 days, adding |
| * the excess to 'month'. |
| */ |
| Datum |
| interval_justify_days(PG_FUNCTION_ARGS) |
| { |
| Interval *span = PG_GETARG_INTERVAL_P(0); |
| Interval *result; |
| int32 wholemonth; |
| |
| result = (Interval *) palloc(sizeof(Interval)); |
| result->month = span->month; |
| result->day = span->day; |
| result->time = span->time; |
| |
| wholemonth = result->day / DAYS_PER_MONTH; |
| result->day -= wholemonth * DAYS_PER_MONTH; |
| result->month += wholemonth; |
| |
| if (result->month > 0 && result->day < 0) |
| { |
| result->day += DAYS_PER_MONTH; |
| result->month--; |
| } |
| else if (result->month < 0 && result->day > 0) |
| { |
| result->day -= DAYS_PER_MONTH; |
| result->month++; |
| } |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| /* timestamp_pl_interval() |
| * Add a interval to a timestamp data type. |
| * Note that interval has provisions for qualitative year/month and day |
| * units, so try to do the right thing with them. |
| * To add a month, increment the month, and use the same day of month. |
| * Then, if the next month has fewer days, set the day of month |
| * to the last day of month. |
| * To add a day, increment the mday, and use the same time of day. |
| * Lastly, add in the "quantitative time". |
| */ |
| Datum |
| timestamp_pl_interval(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestamp = PG_GETARG_TIMESTAMP(0); |
| Interval *span = PG_GETARG_INTERVAL_P(1); |
| Timestamp result; |
| |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| result = timestamp; |
| else |
| { |
| if (span->month != 0) |
| { |
| struct pg_tm tt, |
| *tm = &tt; |
| fsec_t fsec = 0; |
| |
| if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| tm->tm_mon += span->month; |
| 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, ×tamp) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| } |
| |
| if (span->day != 0) |
| { |
| struct pg_tm tt, |
| *tm = &tt; |
| fsec_t fsec = 0; |
| 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"), |
| errOmitLocation(true))); |
| |
| /* Add days by converting to and from julian */ |
| julian = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) + span->day; |
| j2date(julian, &tm->tm_year, &tm->tm_mon, &tm->tm_mday); |
| |
| if (tm2timestamp(tm, fsec, NULL, ×tamp) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| } |
| |
| timestamp += span->time; |
| result = timestamp; |
| } |
| |
| PG_RETURN_TIMESTAMP(result); |
| } |
| |
| Datum |
| timestamp_mi_interval(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestamp = PG_GETARG_TIMESTAMP(0); |
| Interval *span = PG_GETARG_INTERVAL_P(1); |
| Interval tspan; |
| |
| tspan.month = -span->month; |
| tspan.day = -span->day; |
| tspan.time = -span->time; |
| |
| return DirectFunctionCall2(timestamp_pl_interval, |
| TimestampGetDatum(timestamp), |
| PointerGetDatum(&tspan)); |
| } |
| |
| |
| /* timestamptz_pl_interval() |
| * Add a interval to a timestamp with time zone data type. |
| * Note that interval has provisions for qualitative year/month |
| * units, so try to do the right thing with them. |
| * To add a month, increment the month, and use the same day of month. |
| * Then, if the next month has fewer days, set the day of month |
| * to the last day of month. |
| * Lastly, add in the "quantitative time". |
| */ |
| Datum |
| timestamptz_pl_interval(PG_FUNCTION_ARGS) |
| { |
| TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0); |
| Interval *span = PG_GETARG_INTERVAL_P(1); |
| TimestampTz result; |
| int tz; |
| char *tzn; |
| |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| result = timestamp; |
| else |
| { |
| if (span->month != 0) |
| { |
| struct pg_tm tt, |
| *tm = &tt; |
| fsec_t fsec = 0; |
| |
| if (timestamp2tm(timestamp, &tz, tm, &fsec, &tzn, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| tm->tm_mon += span->month; |
| 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, session_timezone); |
| |
| if (tm2timestamp(tm, fsec, &tz, ×tamp) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| } |
| |
| if (span->day != 0) |
| { |
| struct pg_tm tt, |
| *tm = &tt; |
| fsec_t fsec = 0; |
| int julian; |
| |
| if (timestamp2tm(timestamp, &tz, tm, &fsec, &tzn, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| /* Add days by converting to and from julian */ |
| julian = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) + span->day; |
| j2date(julian, &tm->tm_year, &tm->tm_mon, &tm->tm_mday); |
| |
| tz = DetermineTimeZoneOffset(tm, session_timezone); |
| |
| if (tm2timestamp(tm, fsec, &tz, ×tamp) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| } |
| |
| timestamp += span->time; |
| result = timestamp; |
| } |
| |
| PG_RETURN_TIMESTAMP(result); |
| } |
| |
| Datum |
| timestamptz_mi_interval(PG_FUNCTION_ARGS) |
| { |
| TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0); |
| Interval *span = PG_GETARG_INTERVAL_P(1); |
| Interval tspan; |
| |
| tspan.month = -span->month; |
| tspan.day = -span->day; |
| tspan.time = -span->time; |
| |
| return DirectFunctionCall2(timestamptz_pl_interval, |
| TimestampGetDatum(timestamp), |
| PointerGetDatum(&tspan)); |
| } |
| |
| |
| Datum |
| interval_um(PG_FUNCTION_ARGS) |
| { |
| Interval *interval = PG_GETARG_INTERVAL_P(0); |
| Interval *result; |
| |
| result = (Interval *) palloc(sizeof(Interval)); |
| |
| result->time = -interval->time; |
| result->day = -interval->day; |
| result->month = -interval->month; |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| |
| Datum |
| interval_smaller(PG_FUNCTION_ARGS) |
| { |
| Interval *interval1 = PG_GETARG_INTERVAL_P(0); |
| Interval *interval2 = PG_GETARG_INTERVAL_P(1); |
| Interval *result; |
| |
| /* use interval_cmp_internal to be sure this agrees with comparisons */ |
| if (interval_cmp_internal(interval1, interval2) < 0) |
| result = interval1; |
| else |
| result = interval2; |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| Datum |
| interval_larger(PG_FUNCTION_ARGS) |
| { |
| Interval *interval1 = PG_GETARG_INTERVAL_P(0); |
| Interval *interval2 = PG_GETARG_INTERVAL_P(1); |
| Interval *result; |
| |
| if (interval_cmp_internal(interval1, interval2) > 0) |
| result = interval1; |
| else |
| result = interval2; |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| Datum |
| interval_pl(PG_FUNCTION_ARGS) |
| { |
| Interval *span1 = PG_GETARG_INTERVAL_P(0); |
| Interval *span2 = PG_GETARG_INTERVAL_P(1); |
| Interval *result; |
| |
| result = (Interval *) palloc(sizeof(Interval)); |
| |
| result->month = span1->month + span2->month; |
| result->day = span1->day + span2->day; |
| result->time = span1->time + span2->time; |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| Datum |
| interval_mi(PG_FUNCTION_ARGS) |
| { |
| Interval *span1 = PG_GETARG_INTERVAL_P(0); |
| Interval *span2 = PG_GETARG_INTERVAL_P(1); |
| Interval *result; |
| |
| result = (Interval *) palloc(sizeof(Interval)); |
| |
| result->month = span1->month - span2->month; |
| result->day = span1->day - span2->day; |
| result->time = span1->time - span2->time; |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| Datum |
| interval_mul(PG_FUNCTION_ARGS) |
| { |
| Interval *span = PG_GETARG_INTERVAL_P(0); |
| float8 factor = PG_GETARG_FLOAT8(1); |
| double month_remainder_days, |
| sec_remainder; |
| int32 orig_month = span->month, |
| orig_day = span->day; |
| Interval *result; |
| |
| result = (Interval *) palloc(sizeof(Interval)); |
| |
| result->month = (int32) (span->month * factor); |
| result->day = (int32) (span->day * factor); |
| |
| /* |
| * 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 nonintegral. 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 inprecise, so these |
| * calculations are crafted to produce the most reliable result possible. |
| * TSROUND() is needed to more accurately produce whole numbers where |
| * appropriate. |
| */ |
| month_remainder_days = (orig_month * factor - result->month) * DAYS_PER_MONTH; |
| month_remainder_days = TSROUND(month_remainder_days); |
| sec_remainder = (orig_day * factor - result->day + |
| month_remainder_days - (int) month_remainder_days) * SECS_PER_DAY; |
| sec_remainder = TSROUND(sec_remainder); |
| |
| /* |
| * Might have 24:00:00 hours due to rounding, or >24 hours because of time |
| * cascade from months and days. It might still be >24 if the combination |
| * of cascade and the seconds factor operation itself. |
| */ |
| if (Abs(sec_remainder) >= SECS_PER_DAY) |
| { |
| result->day += (int) (sec_remainder / SECS_PER_DAY); |
| sec_remainder -= (int) (sec_remainder / SECS_PER_DAY) * SECS_PER_DAY; |
| } |
| |
| /* cascade units down */ |
| result->day += (int32) month_remainder_days; |
| #ifdef HAVE_INT64_TIMESTAMP |
| result->time = rint(span->time * factor + sec_remainder * USECS_PER_SEC); |
| #else |
| result->time = span->time * factor + sec_remainder; |
| #endif |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| Datum |
| mul_d_interval(PG_FUNCTION_ARGS) |
| { |
| /* 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); |
| } |
| |
| Datum |
| interval_div(PG_FUNCTION_ARGS) |
| { |
| Interval *span = PG_GETARG_INTERVAL_P(0); |
| float8 factor = PG_GETARG_FLOAT8(1); |
| double month_remainder_days, |
| sec_remainder; |
| int32 orig_month = span->month, |
| orig_day = span->day; |
| Interval *result; |
| |
| result = (Interval *) palloc(sizeof(Interval)); |
| |
| if (factor == 0.0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DIVISION_BY_ZERO), |
| errmsg("division by zero"), |
| errOmitLocation(true))); |
| |
| result->month = (int32) (span->month / factor); |
| result->day = (int32) (span->day / factor); |
| |
| /* |
| * Fractional months full days into days. See comment in interval_mul(). |
| */ |
| month_remainder_days = (orig_month / factor - result->month) * DAYS_PER_MONTH; |
| month_remainder_days = TSROUND(month_remainder_days); |
| sec_remainder = (orig_day / factor - result->day + |
| month_remainder_days - (int) month_remainder_days) * SECS_PER_DAY; |
| sec_remainder = TSROUND(sec_remainder); |
| if (Abs(sec_remainder) >= SECS_PER_DAY) |
| { |
| result->day += (int) (sec_remainder / SECS_PER_DAY); |
| sec_remainder -= (int) (sec_remainder / SECS_PER_DAY) * SECS_PER_DAY; |
| } |
| |
| /* cascade units down */ |
| result->day += (int32) month_remainder_days; |
| #ifdef HAVE_INT64_TIMESTAMP |
| result->time = rint(span->time / factor + sec_remainder * USECS_PER_SEC); |
| #else |
| /* See TSROUND comment in interval_mul(). */ |
| result->time = span->time / factor + sec_remainder; |
| #endif |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| /* |
| * interval_accum and interval_avg implement the AVG(interval) aggregate. |
| * |
| * The transition datatype for this aggregate is a 2-element array of |
| * intervals, where the first is the running sum and the second contains |
| * the number of values so far in its 'time' field. This is a bit ugly |
| * but it beats inventing a specialized datatype for the purpose. |
| */ |
| |
| Datum |
| interval_accum(PG_FUNCTION_ARGS) |
| { |
| ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0); |
| Interval *newval = PG_GETARG_INTERVAL_P(1); |
| Datum *transdatums; |
| int ndatums; |
| Interval sumX, |
| N; |
| Interval *newsum; |
| ArrayType *result; |
| |
| deconstruct_array(transarray, |
| INTERVALOID, sizeof(Interval), false, 'd', |
| &transdatums, NULL, &ndatums); |
| if (ndatums != 2) |
| elog(ERROR, "expected 2-element interval array"); |
| |
| /* |
| * XXX memcpy, instead of just extracting a pointer, to work around buggy |
| * array code: it won't ensure proper alignment of Interval objects on |
| * machines where double requires 8-byte alignment. That should be fixed, |
| * but in the meantime... |
| * |
| * Note: must use DatumGetPointer here, not DatumGetIntervalP, else some |
| * compilers optimize into double-aligned load/store anyway. |
| */ |
| memcpy((void *) &sumX, DatumGetPointer(transdatums[0]), sizeof(Interval)); |
| memcpy((void *) &N, DatumGetPointer(transdatums[1]), sizeof(Interval)); |
| |
| newsum = DatumGetIntervalP(DirectFunctionCall2(interval_pl, |
| IntervalPGetDatum(&sumX), |
| IntervalPGetDatum(newval))); |
| N.time += 1; |
| |
| transdatums[0] = IntervalPGetDatum(newsum); |
| transdatums[1] = IntervalPGetDatum(&N); |
| |
| result = construct_array(transdatums, 2, |
| INTERVALOID, sizeof(Interval), false, 'd'); |
| |
| PG_RETURN_ARRAYTYPE_P(result); |
| } |
| |
| Datum |
| interval_avg(PG_FUNCTION_ARGS) |
| { |
| ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0); |
| Datum *transdatums; |
| int ndatums; |
| Interval sumX, |
| N; |
| |
| deconstruct_array(transarray, |
| INTERVALOID, sizeof(Interval), false, 'd', |
| &transdatums, NULL, &ndatums); |
| if (ndatums != 2) |
| elog(ERROR, "expected 2-element interval array"); |
| |
| /* |
| * XXX memcpy, instead of just extracting a pointer, to work around buggy |
| * array code: it won't ensure proper alignment of Interval objects on |
| * machines where double requires 8-byte alignment. That should be fixed, |
| * but in the meantime... |
| * |
| * Note: must use DatumGetPointer here, not DatumGetIntervalP, else some |
| * compilers optimize into double-aligned load/store anyway. |
| */ |
| memcpy((void *) &sumX, DatumGetPointer(transdatums[0]), sizeof(Interval)); |
| memcpy((void *) &N, DatumGetPointer(transdatums[1]), sizeof(Interval)); |
| |
| /* SQL92 defines AVG of no values to be NULL */ |
| if (N.time == 0) |
| PG_RETURN_NULL(); |
| |
| return DirectFunctionCall2(interval_div, |
| IntervalPGetDatum(&sumX), |
| Float8GetDatum(N.time)); |
| } |
| |
| Datum |
| interval_decum(PG_FUNCTION_ARGS) |
| { |
| ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0); |
| Interval *newval = PG_GETARG_INTERVAL_P(1); |
| Datum *transdatums; |
| int ndatums; |
| Interval miX, |
| N; |
| Interval *newmi; |
| ArrayType *result; |
| |
| deconstruct_array(transarray, |
| INTERVALOID, sizeof(Interval), false, 'd', |
| &transdatums, NULL, &ndatums); |
| if (ndatums != 2) |
| elog(ERROR, "expected 2-element interval array"); |
| |
| /* |
| * XXX memcpy, instead of just extracting a pointer, to work around buggy |
| * array code: it won't ensure proper alignment of Interval objects on |
| * machines where double requires 8-byte alignment. That should be fixed, |
| * but in the meantime... |
| * |
| * Note: must use DatumGetPointer here, not DatumGetIntervalP, else some |
| * compilers optimize into double-aligned load/store anyway. |
| */ |
| memcpy((void *) &miX, DatumGetPointer(transdatums[0]), sizeof(Interval)); |
| memcpy((void *) &N, DatumGetPointer(transdatums[1]), sizeof(Interval)); |
| |
| newmi = DatumGetIntervalP(DirectFunctionCall2(interval_mi, |
| IntervalPGetDatum(&miX), |
| IntervalPGetDatum(newval))); |
| N.time -= 1; |
| |
| transdatums[0] = IntervalPGetDatum(newmi); |
| transdatums[1] = IntervalPGetDatum(&N); |
| |
| result = construct_array(transdatums, 2, |
| INTERVALOID, sizeof(Interval), false, 'd'); |
| |
| PG_RETURN_ARRAYTYPE_P(result); |
| } |
| |
| |
| |
| /* timestamp_age() |
| * Calculate time difference while retaining year/month fields. |
| * Note that this does not result in an accurate absolute time span |
| * since year and month are out of context once the arithmetic |
| * is done. |
| */ |
| Datum |
| timestamp_age(PG_FUNCTION_ARGS) |
| { |
| Timestamp dt1 = PG_GETARG_TIMESTAMP(0); |
| Timestamp dt2 = PG_GETARG_TIMESTAMP(1); |
| Interval *result; |
| fsec_t fsec, |
| fsec1 = 0, |
| fsec2 = 0; |
| struct pg_tm tt, |
| *tm = &tt; |
| struct pg_tm tt1, |
| *tm1 = &tt1; |
| struct pg_tm tt2, |
| *tm2 = &tt2; |
| |
| result = (Interval *) palloc(sizeof(Interval)); |
| |
| if (timestamp2tm(dt1, NULL, tm1, &fsec1, NULL, NULL) == 0 && |
| timestamp2tm(dt2, NULL, tm2, &fsec2, NULL, NULL) == 0) |
| { |
| /* form the symbolic difference */ |
| fsec = fsec1 - fsec2; |
| tm->tm_sec = tm1->tm_sec - tm2->tm_sec; |
| tm->tm_min = tm1->tm_min - tm2->tm_min; |
| tm->tm_hour = tm1->tm_hour - tm2->tm_hour; |
| tm->tm_mday = tm1->tm_mday - tm2->tm_mday; |
| tm->tm_mon = tm1->tm_mon - tm2->tm_mon; |
| tm->tm_year = tm1->tm_year - tm2->tm_year; |
| |
| /* flip sign if necessary... */ |
| if (dt1 < dt2) |
| { |
| fsec = -fsec; |
| tm->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 (fsec < 0) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| fsec += USECS_PER_SEC; |
| #else |
| fsec += 1.0; |
| #endif |
| 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) |
| { |
| fsec = -fsec; |
| 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 (tm2interval(tm, fsec, result) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("interval out of range"), |
| errOmitLocation(true))); |
| } |
| else |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| |
| /* timestamptz_age() |
| * Calculate time difference while retaining year/month fields. |
| * Note that this does not result in an accurate absolute time span |
| * since year and month are out of context once the arithmetic |
| * is done. |
| */ |
| Datum |
| timestamptz_age(PG_FUNCTION_ARGS) |
| { |
| TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0); |
| TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1); |
| Interval *result; |
| fsec_t fsec, |
| fsec1, |
| fsec2; |
| struct pg_tm tt, |
| *tm = &tt; |
| struct pg_tm tt1, |
| *tm1 = &tt1; |
| struct pg_tm tt2, |
| *tm2 = &tt2; |
| int tz1; |
| int tz2; |
| char *tzn; |
| |
| result = (Interval *) palloc(sizeof(Interval)); |
| |
| if (timestamp2tm(dt1, &tz1, tm1, &fsec1, &tzn, NULL) == 0 && |
| timestamp2tm(dt2, &tz2, tm2, &fsec2, &tzn, NULL) == 0) |
| { |
| /* form the symbolic difference */ |
| fsec = fsec1 - fsec2; |
| tm->tm_sec = tm1->tm_sec - tm2->tm_sec; |
| tm->tm_min = tm1->tm_min - tm2->tm_min; |
| tm->tm_hour = tm1->tm_hour - tm2->tm_hour; |
| tm->tm_mday = tm1->tm_mday - tm2->tm_mday; |
| tm->tm_mon = tm1->tm_mon - tm2->tm_mon; |
| tm->tm_year = tm1->tm_year - tm2->tm_year; |
| |
| /* flip sign if necessary... */ |
| if (dt1 < dt2) |
| { |
| fsec = -fsec; |
| tm->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 (fsec < 0) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| fsec += USECS_PER_SEC; |
| #else |
| fsec += 1.0; |
| #endif |
| 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) |
| { |
| fsec = -fsec; |
| 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 (tm2interval(tm, fsec, result) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("interval out of range"), |
| errOmitLocation(true))); |
| } |
| else |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| |
| /*---------------------------------------------------------- |
| * Conversion operators. |
| *---------------------------------------------------------*/ |
| |
| /* timestamp_text() |
| * Convert timestamp to text data type. |
| */ |
| Datum |
| timestamp_text(PG_FUNCTION_ARGS) |
| { |
| /* Input is a Timestamp, but may as well leave it in Datum form */ |
| Datum timestamp = PG_GETARG_DATUM(0); |
| text *result; |
| char *str; |
| int len; |
| |
| str = DatumGetCString(DirectFunctionCall1(timestamp_out, timestamp)); |
| |
| len = (strlen(str) + VARHDRSZ); |
| |
| result = palloc(len); |
| |
| SET_VARSIZE(result, len); |
| memcpy(VARDATA(result), str, (len - VARHDRSZ)); |
| |
| pfree(str); |
| |
| PG_RETURN_TEXT_P(result); |
| } |
| |
| |
| /* text_timestamp() |
| * Convert text string to timestamp. |
| * Text type is not null terminated, so use temporary string |
| * then call the standard input routine. |
| */ |
| Datum |
| text_timestamp(PG_FUNCTION_ARGS) |
| { |
| text *str = PG_GETARG_TEXT_P(0); |
| int i; |
| char *sp, |
| *dp, |
| dstr[MAXDATELEN + 1]; |
| |
| if (VARSIZE(str) - VARHDRSZ > MAXDATELEN) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_DATETIME_FORMAT), |
| errmsg("invalid input syntax for type timestamp: \"%s\"", |
| DatumGetCString(DirectFunctionCall1(textout, |
| PointerGetDatum(str)))), |
| errOmitLocation(true))); |
| |
| sp = VARDATA(str); |
| dp = dstr; |
| for (i = 0; i < VARSIZE(str) - VARHDRSZ; i++) |
| *dp++ = *sp++; |
| *dp = '\0'; |
| |
| return DirectFunctionCall3(timestamp_in, |
| CStringGetDatum(dstr), |
| ObjectIdGetDatum(InvalidOid), |
| Int32GetDatum(-1)); |
| } |
| |
| |
| /* timestamptz_text() |
| * Convert timestamp with time zone to text data type. |
| */ |
| Datum |
| timestamptz_text(PG_FUNCTION_ARGS) |
| { |
| /* Input is a Timestamp, but may as well leave it in Datum form */ |
| Datum timestamp = PG_GETARG_DATUM(0); |
| text *result; |
| char *str; |
| int len; |
| |
| str = DatumGetCString(DirectFunctionCall1(timestamptz_out, timestamp)); |
| |
| len = strlen(str) + VARHDRSZ; |
| |
| result = palloc(len); |
| |
| SET_VARSIZE(result, len); |
| memcpy(VARDATA(result), str, (len - VARHDRSZ)); |
| |
| pfree(str); |
| |
| PG_RETURN_TEXT_P(result); |
| } |
| |
| /* text_timestamptz() |
| * Convert text string to timestamp with time zone. |
| * Text type is not null terminated, so use temporary string |
| * then call the standard input routine. |
| */ |
| Datum |
| text_timestamptz(PG_FUNCTION_ARGS) |
| { |
| text *str = PG_GETARG_TEXT_P(0); |
| int i; |
| char *sp, |
| *dp, |
| dstr[MAXDATELEN + 1]; |
| |
| if (VARSIZE(str) - VARHDRSZ > MAXDATELEN) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_DATETIME_FORMAT), |
| errmsg("invalid input syntax for type timestamp with time zone: \"%s\"", |
| DatumGetCString(DirectFunctionCall1(textout, |
| PointerGetDatum(str)))), |
| errOmitLocation(true))); |
| |
| sp = VARDATA(str); |
| dp = dstr; |
| for (i = 0; i < VARSIZE(str) - VARHDRSZ; i++) |
| *dp++ = *sp++; |
| *dp = '\0'; |
| |
| return DirectFunctionCall3(timestamptz_in, |
| CStringGetDatum(dstr), |
| ObjectIdGetDatum(InvalidOid), |
| Int32GetDatum(-1)); |
| } |
| |
| |
| /* interval_text() |
| * Convert interval to text data type. |
| */ |
| Datum |
| interval_text(PG_FUNCTION_ARGS) |
| { |
| Interval *interval = PG_GETARG_INTERVAL_P(0); |
| text *result; |
| char *str; |
| int len; |
| |
| str = DatumGetCString(DirectFunctionCall1(interval_out, |
| IntervalPGetDatum(interval))); |
| |
| len = strlen(str) + VARHDRSZ; |
| |
| result = palloc(len); |
| |
| SET_VARSIZE(result, len); |
| memcpy(VARDATA(result), str, len - VARHDRSZ); |
| |
| pfree(str); |
| |
| PG_RETURN_TEXT_P(result); |
| } |
| |
| |
| /* text_interval() |
| * Convert text string to interval. |
| * Text type may not be null terminated, so copy to temporary string |
| * then call the standard input routine. |
| */ |
| Datum |
| text_interval(PG_FUNCTION_ARGS) |
| { |
| text *str = PG_GETARG_TEXT_P(0); |
| int i; |
| char *sp, |
| *dp, |
| dstr[MAXDATELEN + 1]; |
| |
| if (VARSIZE(str) - VARHDRSZ > MAXDATELEN) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_DATETIME_FORMAT), |
| errmsg("invalid input syntax for type interval: \"%s\"", |
| DatumGetCString(DirectFunctionCall1(textout, |
| PointerGetDatum(str)))), |
| errOmitLocation(true))); |
| |
| sp = VARDATA(str); |
| dp = dstr; |
| for (i = 0; i < (VARSIZE(str) - VARHDRSZ); i++) |
| *dp++ = *sp++; |
| *dp = '\0'; |
| |
| return DirectFunctionCall3(interval_in, |
| CStringGetDatum(dstr), |
| ObjectIdGetDatum(InvalidOid), |
| Int32GetDatum(-1)); |
| } |
| |
| |
| /* timestamp_trunc() |
| * Truncate timestamp to specified units. |
| */ |
| Datum |
| timestamp_trunc(PG_FUNCTION_ARGS) |
| { |
| text *units = PG_GETARG_TEXT_P(0); |
| Timestamp timestamp = PG_GETARG_TIMESTAMP(1); |
| Timestamp result; |
| int type, |
| val; |
| char *lowunits; |
| fsec_t fsec = 0; |
| struct pg_tm tt, |
| *tm = &tt; |
| |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| PG_RETURN_TIMESTAMP(timestamp); |
| |
| lowunits = downcase_truncate_identifier(VARDATA(units), |
| VARSIZE(units) - VARHDRSZ, |
| false); |
| |
| type = DecodeUnits(0, lowunits, &val); |
| |
| 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"), |
| errOmitLocation(true))); |
| |
| 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; |
| 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; |
| 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; |
| } |
| case DTK_YEAR: |
| tm->tm_mon = 1; |
| case DTK_QUARTER: |
| tm->tm_mon = (3 * ((tm->tm_mon - 1) / 3)) + 1; |
| case DTK_MONTH: |
| tm->tm_mday = 1; |
| case DTK_DAY: |
| tm->tm_hour = 0; |
| case DTK_HOUR: |
| tm->tm_min = 0; |
| case DTK_MINUTE: |
| tm->tm_sec = 0; |
| case DTK_SECOND: |
| fsec = 0; |
| break; |
| |
| case DTK_MILLISEC: |
| #ifdef HAVE_INT64_TIMESTAMP |
| fsec = (fsec / 1000) * 1000; |
| #else |
| fsec = rint(fsec * 1000) / 1000; |
| #endif |
| break; |
| |
| case DTK_MICROSEC: |
| #ifndef HAVE_INT64_TIMESTAMP |
| fsec = rint(fsec * 1000000) / 1000000; |
| #endif |
| break; |
| |
| default: |
| ereport(ERROR, |
| (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), |
| errmsg("timestamp units \"%s\" not supported", |
| lowunits), |
| errOmitLocation(true))); |
| result = 0; |
| } |
| |
| if (tm2timestamp(tm, fsec, NULL, &result) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| } |
| else |
| { |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("timestamp units \"%s\" not recognized", |
| lowunits), |
| errOmitLocation(true))); |
| result = 0; |
| } |
| |
| PG_RETURN_TIMESTAMP(result); |
| } |
| |
| /* timestamptz_trunc() |
| * Truncate timestamp to specified units. |
| */ |
| Datum |
| timestamptz_trunc(PG_FUNCTION_ARGS) |
| { |
| text *units = PG_GETARG_TEXT_P(0); |
| TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1); |
| TimestampTz result; |
| int tz = 0; |
| int type, |
| val; |
| bool redotz = false; |
| char *lowunits; |
| fsec_t fsec = 0; |
| char *tzn; |
| struct pg_tm tt, |
| *tm = &tt; |
| |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| PG_RETURN_TIMESTAMPTZ(timestamp); |
| |
| lowunits = downcase_truncate_identifier(VARDATA(units), |
| VARSIZE(units) - VARHDRSZ, |
| false); |
| |
| type = DecodeUnits(0, lowunits, &val); |
| |
| if (type == UNITS) |
| { |
| if (timestamp2tm(timestamp, &tz, tm, &fsec, &tzn, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| 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: |
| #ifdef HAVE_INT64_TIMESTAMP |
| fsec = (fsec / 1000) * 1000; |
| #else |
| fsec = rint(fsec * 1000) / 1000; |
| #endif |
| break; |
| case DTK_MICROSEC: |
| #ifndef HAVE_INT64_TIMESTAMP |
| fsec = rint(fsec * 1000000) / 1000000; |
| #endif |
| break; |
| |
| default: |
| ereport(ERROR, |
| (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), |
| errmsg("timestamp with time zone units \"%s\" not " |
| "supported", lowunits), |
| errOmitLocation(true))); |
| result = 0; |
| } |
| |
| if (redotz) |
| tz = DetermineTimeZoneOffset(tm, session_timezone); |
| |
| if (tm2timestamp(tm, fsec, &tz, &result) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| } |
| else |
| { |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("timestamp with time zone units \"%s\" not recognized", |
| lowunits), |
| errOmitLocation(true))); |
| result = 0; |
| } |
| |
| PG_RETURN_TIMESTAMPTZ(result); |
| } |
| |
| /* interval_trunc() |
| * Extract specified field from interval. |
| */ |
| Datum |
| interval_trunc(PG_FUNCTION_ARGS) |
| { |
| text *units = PG_GETARG_TEXT_P(0); |
| Interval *interval = PG_GETARG_INTERVAL_P(1); |
| Interval *result; |
| int type, |
| val; |
| char *lowunits; |
| fsec_t fsec; |
| struct pg_tm tt, |
| *tm = &tt; |
| |
| result = (Interval *) palloc(sizeof(Interval)); |
| |
| lowunits = downcase_truncate_identifier(VARDATA(units), |
| VARSIZE(units) - VARHDRSZ, |
| false); |
| |
| type = DecodeUnits(0, lowunits, &val); |
| |
| if (type == UNITS) |
| { |
| if (interval2tm(*interval, tm, &fsec) == 0) |
| { |
| switch (val) |
| { |
| /* fall through */ |
| case DTK_MILLENNIUM: |
| /* caution: C division may have negative remainder */ |
| tm->tm_year = (tm->tm_year / 1000) * 1000; |
| case DTK_CENTURY: |
| /* caution: C division may have negative remainder */ |
| tm->tm_year = (tm->tm_year / 100) * 100; |
| case DTK_DECADE: |
| /* caution: C division may have negative remainder */ |
| tm->tm_year = (tm->tm_year / 10) * 10; |
| case DTK_YEAR: |
| tm->tm_mon = 0; |
| case DTK_QUARTER: |
| tm->tm_mon = 3 * (tm->tm_mon / 3); |
| case DTK_MONTH: |
| tm->tm_mday = 0; |
| case DTK_DAY: |
| tm->tm_hour = 0; |
| case DTK_HOUR: |
| tm->tm_min = 0; |
| case DTK_MINUTE: |
| tm->tm_sec = 0; |
| case DTK_SECOND: |
| fsec = 0; |
| break; |
| |
| case DTK_MILLISEC: |
| #ifdef HAVE_INT64_TIMESTAMP |
| fsec = (fsec / 1000) * 1000; |
| #else |
| fsec = rint(fsec * 1000) / 1000; |
| #endif |
| break; |
| case DTK_MICROSEC: |
| #ifndef HAVE_INT64_TIMESTAMP |
| fsec = rint(fsec * 1000000) / 1000000; |
| #endif |
| break; |
| |
| default: |
| ereport(ERROR, |
| (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), |
| errmsg("interval units \"%s\" not supported", |
| lowunits), |
| errOmitLocation(true))); |
| } |
| |
| if (tm2interval(tm, fsec, result) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("interval out of range"), |
| errOmitLocation(true))); |
| } |
| else |
| elog(ERROR, "could not convert interval to tm"); |
| } |
| else |
| { |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("interval units \"%s\" not recognized", |
| lowunits), |
| errOmitLocation(true))); |
| } |
| |
| PG_RETURN_INTERVAL_P(result); |
| } |
| |
| /* isoweek2j() |
| * |
| * Return the Julian day which corresponds to the first day (Monday) of the given ISO 8601 year and week. |
| * Julian days are used to convert between ISO week dates and Gregorian dates. |
| */ |
| int |
| isoweek2j(int year, int week) |
| { |
| 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); |
| } |
| |
| /* isoweek2date() |
| * Convert ISO week of year number to date. |
| * The year field must be specified with the ISO year! |
| * karel 2000/08/07 |
| */ |
| void |
| isoweek2date(int woy, int *year, int *mon, int *mday) |
| { |
| j2date(isoweek2j(*year, woy), year, mon, mday); |
| } |
| |
| /* isoweekdate2date() |
| * |
| * Convert an ISO 8601 week date (ISO year, ISO week and day of week) into a Gregorian date. |
| * Populates year, mon, and mday with the correct Gregorian values. |
| * year must be passed in as the ISO year. |
| */ |
| void |
| isoweekdate2date(int isoweek, int isowday, int *year, int *mon, int *mday) |
| { |
| int jday; |
| |
| jday = isoweek2j(*year, isoweek); |
| jday += isowday - 1; |
| |
| j2date(jday, year, mon, mday); |
| } |
| |
| /* date2isoweek() |
| * |
| * Returns ISO week number of year. |
| */ |
| int |
| date2isoweek(int year, int mon, int mday) |
| { |
| 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; |
| } |
| |
| |
| /* date2isoyear() |
| * |
| * Returns ISO 8601 year number. |
| */ |
| int |
| date2isoyear(int year, int mon, int mday) |
| { |
| 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; |
| } |
| |
| |
| /* date2isoyearday() |
| * |
| * Returns the ISO 8601 day-of-year, given a Gregorian year, month and day. |
| * Possible return values are 1 through 371 (364 in non-leap years). |
| */ |
| int |
| date2isoyearday(int year, int mon, int mday) |
| { |
| return date2j(year, mon, mday) - isoweek2j(date2isoyear(year, mon, mday), 1) + 1; |
| } |
| |
| /* timestamp_part() |
| * Extract specified field from timestamp. |
| */ |
| Datum |
| timestamp_part(PG_FUNCTION_ARGS) |
| { |
| text *units = PG_GETARG_TEXT_P(0); |
| Timestamp timestamp = PG_GETARG_TIMESTAMP(1); |
| float8 result; |
| int type, |
| val; |
| char *lowunits; |
| fsec_t fsec = 0; |
| struct pg_tm tt, |
| *tm = &tt; |
| |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| { |
| result = 0; |
| PG_RETURN_FLOAT8(result); |
| } |
| |
| lowunits = downcase_truncate_identifier(VARDATA(units), |
| VARSIZE(units) - VARHDRSZ, |
| false); |
| |
| type = DecodeUnits(0, lowunits, &val); |
| if (type == UNKNOWN_FIELD) |
| type = DecodeSpecial(0, lowunits, &val); |
| |
| 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"), |
| errOmitLocation(true))); |
| |
| switch (val) |
| { |
| case DTK_MICROSEC: |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = tm->tm_sec * 1000000.0 + fsec; |
| #else |
| result = (tm->tm_sec + fsec) * 1000000; |
| #endif |
| break; |
| |
| case DTK_MILLISEC: |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = tm->tm_sec * 1000.0 + fsec / 1000.0; |
| #else |
| result = (tm->tm_sec + fsec) * 1000; |
| #endif |
| break; |
| |
| case DTK_SECOND: |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = tm->tm_sec + fsec / 1000000.0; |
| #else |
| result = tm->tm_sec + fsec; |
| #endif |
| break; |
| |
| case DTK_MINUTE: |
| result = tm->tm_min; |
| break; |
| |
| case DTK_HOUR: |
| result = tm->tm_hour; |
| break; |
| |
| case DTK_DAY: |
| result = tm->tm_mday; |
| break; |
| |
| case DTK_MONTH: |
| result = tm->tm_mon; |
| break; |
| |
| case DTK_QUARTER: |
| result = (tm->tm_mon - 1) / 3 + 1; |
| break; |
| |
| case DTK_WEEK: |
| result = (float8) date2isoweek(tm->tm_year, tm->tm_mon, tm->tm_mday); |
| break; |
| |
| case DTK_YEAR: |
| if (tm->tm_year > 0) |
| result = tm->tm_year; |
| else |
| /* there is no year 0, just 1 BC and 1 AD */ |
| result = 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) |
| result = tm->tm_year / 10; |
| else |
| result = -((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) |
| result = (tm->tm_year + 99) / 100; |
| else |
| /* caution: C division may have negative remainder */ |
| result = -((99 - (tm->tm_year - 1)) / 100); |
| break; |
| |
| case DTK_MILLENNIUM: |
| /* see comments above. */ |
| if (tm->tm_year > 0) |
| result = (tm->tm_year + 999) / 1000; |
| else |
| result = -((999 - (tm->tm_year - 1)) / 1000); |
| break; |
| |
| case DTK_JULIAN: |
| result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday); |
| #ifdef HAVE_INT64_TIMESTAMP |
| result += ((((tm->tm_hour * MINS_PER_HOUR) + tm->tm_min) * SECS_PER_MINUTE) + |
| tm->tm_sec + (fsec / 1000000.0)) / (double) SECS_PER_DAY; |
| #else |
| result += ((((tm->tm_hour * MINS_PER_HOUR) + tm->tm_min) * SECS_PER_MINUTE) + |
| tm->tm_sec + fsec) / (double) SECS_PER_DAY; |
| #endif |
| break; |
| |
| case DTK_ISOYEAR: |
| result = date2isoyear(tm->tm_year, tm->tm_mon, tm->tm_mday); |
| break; |
| |
| case DTK_TZ: |
| case DTK_TZ_MINUTE: |
| case DTK_TZ_HOUR: |
| default: |
| ereport(ERROR, |
| (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), |
| errmsg("timestamp units \"%s\" not supported", |
| lowunits))); |
| result = 0; |
| } |
| } |
| else if (type == RESERV) |
| { |
| switch (val) |
| { |
| case DTK_EPOCH: |
| { |
| int tz; |
| TimestampTz timestamptz; |
| |
| /* |
| * convert to timestamptz to produce consistent results |
| */ |
| if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| tz = DetermineTimeZoneOffset(tm, session_timezone); |
| |
| if (tm2timestamp(tm, fsec, &tz, ×tamptz) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = (timestamptz - SetEpochTimestamp()) / 1000000.0; |
| #else |
| result = timestamptz - SetEpochTimestamp(); |
| #endif |
| break; |
| } |
| case DTK_DOW: |
| case DTK_ISODOW: |
| if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| result = j2day(date2j(tm->tm_year, tm->tm_mon, tm->tm_mday)); |
| if (val == DTK_ISODOW && result == 0) |
| result = 7; |
| break; |
| |
| case DTK_DOY: |
| if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| result = (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("timestamp units \"%s\" not supported", |
| lowunits), |
| errOmitLocation(true))); |
| result = 0; |
| } |
| |
| } |
| else |
| { |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("timestamp units \"%s\" not recognized", lowunits), |
| errOmitLocation(true))); |
| result = 0; |
| } |
| |
| PG_RETURN_FLOAT8(result); |
| } |
| |
| /* timestamptz_part() |
| * Extract specified field from timestamp with time zone. |
| */ |
| Datum |
| timestamptz_part(PG_FUNCTION_ARGS) |
| { |
| text *units = PG_GETARG_TEXT_P(0); |
| TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1); |
| float8 result; |
| int tz = 0; |
| int type, |
| val; |
| char *lowunits; |
| double dummy; |
| fsec_t fsec = 0; |
| char *tzn; |
| struct pg_tm tt, |
| *tm = &tt; |
| |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| { |
| result = 0; |
| PG_RETURN_FLOAT8(result); |
| } |
| |
| lowunits = downcase_truncate_identifier(VARDATA(units), |
| VARSIZE(units) - VARHDRSZ, |
| false); |
| |
| type = DecodeUnits(0, lowunits, &val); |
| if (type == UNKNOWN_FIELD) |
| type = DecodeSpecial(0, lowunits, &val); |
| |
| if (type == UNITS) |
| { |
| if (timestamp2tm(timestamp, &tz, tm, &fsec, &tzn, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| switch (val) |
| { |
| case DTK_TZ: |
| result = -tz; |
| break; |
| |
| case DTK_TZ_MINUTE: |
| result = -tz; |
| result /= MINS_PER_HOUR; |
| FMODULO(result, dummy, (double) MINS_PER_HOUR); |
| break; |
| |
| case DTK_TZ_HOUR: |
| dummy = -tz; |
| FMODULO(dummy, result, (double) SECS_PER_HOUR); |
| break; |
| |
| case DTK_MICROSEC: |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = tm->tm_sec * 1000000.0 + fsec; |
| #else |
| result = (tm->tm_sec + fsec) * 1000000; |
| #endif |
| break; |
| |
| case DTK_MILLISEC: |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = tm->tm_sec * 1000.0 + fsec / 1000.0; |
| #else |
| result = (tm->tm_sec + fsec) * 1000; |
| #endif |
| break; |
| |
| case DTK_SECOND: |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = tm->tm_sec + fsec / 1000000.0; |
| #else |
| result = tm->tm_sec + fsec; |
| #endif |
| break; |
| |
| case DTK_MINUTE: |
| result = tm->tm_min; |
| break; |
| |
| case DTK_HOUR: |
| result = tm->tm_hour; |
| break; |
| |
| case DTK_DAY: |
| result = tm->tm_mday; |
| break; |
| |
| case DTK_MONTH: |
| result = tm->tm_mon; |
| break; |
| |
| case DTK_QUARTER: |
| result = (tm->tm_mon - 1) / 3 + 1; |
| break; |
| |
| case DTK_WEEK: |
| result = (float8) date2isoweek(tm->tm_year, tm->tm_mon, tm->tm_mday); |
| break; |
| |
| case DTK_YEAR: |
| if (tm->tm_year > 0) |
| result = tm->tm_year; |
| else |
| /* there is no year 0, just 1 BC and 1 AD */ |
| result = tm->tm_year - 1; |
| break; |
| |
| case DTK_DECADE: |
| /* see comments in timestamp_part */ |
| if (tm->tm_year > 0) |
| result = tm->tm_year / 10; |
| else |
| result = -((8 - (tm->tm_year - 1)) / 10); |
| break; |
| |
| case DTK_CENTURY: |
| /* see comments in timestamp_part */ |
| if (tm->tm_year > 0) |
| result = (tm->tm_year + 99) / 100; |
| else |
| result = -((99 - (tm->tm_year - 1)) / 100); |
| break; |
| |
| case DTK_MILLENNIUM: |
| /* see comments in timestamp_part */ |
| if (tm->tm_year > 0) |
| result = (tm->tm_year + 999) / 1000; |
| else |
| result = -((999 - (tm->tm_year - 1)) / 1000); |
| break; |
| |
| case DTK_JULIAN: |
| result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday); |
| #ifdef HAVE_INT64_TIMESTAMP |
| result += ((((tm->tm_hour * MINS_PER_HOUR) + tm->tm_min) * SECS_PER_MINUTE) + |
| tm->tm_sec + (fsec / 1000000.0)) / (double) SECS_PER_DAY; |
| #else |
| result += ((((tm->tm_hour * MINS_PER_HOUR) + tm->tm_min) * SECS_PER_MINUTE) + |
| tm->tm_sec + fsec) / (double) SECS_PER_DAY; |
| #endif |
| break; |
| |
| case DTK_ISOYEAR: |
| result = date2isoyear(tm->tm_year, tm->tm_mon, tm->tm_mday); |
| break; |
| |
| default: |
| ereport(ERROR, |
| (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), |
| errmsg("timestamp with time zone units \"%s\" not supported", |
| lowunits), |
| errOmitLocation(true))); |
| result = 0; |
| } |
| |
| } |
| else if (type == RESERV) |
| { |
| switch (val) |
| { |
| case DTK_EPOCH: |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = (timestamp - SetEpochTimestamp()) / 1000000.0; |
| #else |
| result = timestamp - SetEpochTimestamp(); |
| #endif |
| break; |
| |
| case DTK_DOW: |
| case DTK_ISODOW: |
| if (timestamp2tm(timestamp, &tz, tm, &fsec, &tzn, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| result = j2day(date2j(tm->tm_year, tm->tm_mon, tm->tm_mday)); |
| if (val == DTK_ISODOW && result == 0) |
| result = 7; |
| break; |
| |
| case DTK_DOY: |
| if (timestamp2tm(timestamp, &tz, tm, &fsec, &tzn, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| result = (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("timestamp with time zone units \"%s\" not supported", |
| lowunits), |
| errOmitLocation(true))); |
| result = 0; |
| } |
| } |
| else |
| { |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("timestamp with time zone units \"%s\" not recognized", |
| lowunits), |
| errOmitLocation(true))); |
| |
| result = 0; |
| } |
| |
| PG_RETURN_FLOAT8(result); |
| } |
| |
| |
| /* interval_part() |
| * Extract specified field from interval. |
| */ |
| Datum |
| interval_part(PG_FUNCTION_ARGS) |
| { |
| text *units = PG_GETARG_TEXT_P(0); |
| Interval *interval = PG_GETARG_INTERVAL_P(1); |
| float8 result; |
| int type, |
| val; |
| char *lowunits; |
| fsec_t fsec; |
| struct pg_tm tt, |
| *tm = &tt; |
| |
| lowunits = downcase_truncate_identifier(VARDATA(units), |
| VARSIZE(units) - VARHDRSZ, |
| false); |
| |
| type = DecodeUnits(0, lowunits, &val); |
| if (type == UNKNOWN_FIELD) |
| type = DecodeSpecial(0, lowunits, &val); |
| |
| if (type == UNITS) |
| { |
| if (interval2tm(*interval, tm, &fsec) == 0) |
| { |
| switch (val) |
| { |
| case DTK_MICROSEC: |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = tm->tm_sec * 1000000.0 + fsec; |
| #else |
| result = (tm->tm_sec + fsec) * 1000000; |
| #endif |
| break; |
| |
| case DTK_MILLISEC: |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = tm->tm_sec * 1000.0 + fsec / 1000.0; |
| #else |
| result = (tm->tm_sec + fsec) * 1000; |
| #endif |
| break; |
| |
| case DTK_SECOND: |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = tm->tm_sec + fsec / 1000000.0; |
| #else |
| result = tm->tm_sec + fsec; |
| #endif |
| break; |
| |
| case DTK_MINUTE: |
| result = tm->tm_min; |
| break; |
| |
| case DTK_HOUR: |
| result = tm->tm_hour; |
| break; |
| |
| case DTK_DAY: |
| result = tm->tm_mday; |
| break; |
| |
| case DTK_MONTH: |
| result = tm->tm_mon; |
| break; |
| |
| case DTK_QUARTER: |
| result = (tm->tm_mon / 3) + 1; |
| break; |
| |
| case DTK_YEAR: |
| result = tm->tm_year; |
| break; |
| |
| case DTK_DECADE: |
| /* caution: C division may have negative remainder */ |
| result = tm->tm_year / 10; |
| break; |
| |
| case DTK_CENTURY: |
| /* caution: C division may have negative remainder */ |
| result = tm->tm_year / 100; |
| break; |
| |
| case DTK_MILLENNIUM: |
| /* caution: C division may have negative remainder */ |
| result = tm->tm_year / 1000; |
| break; |
| |
| default: |
| ereport(ERROR, |
| (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), |
| errmsg("interval units \"%s\" not supported", |
| lowunits), |
| errOmitLocation(true))); |
| result = 0; |
| } |
| |
| } |
| else |
| { |
| elog(ERROR, "could not convert interval to tm"); |
| result = 0; |
| } |
| } |
| else if (type == RESERV && val == DTK_EPOCH) |
| { |
| #ifdef HAVE_INT64_TIMESTAMP |
| result = interval->time / 1000000.0; |
| #else |
| result = interval->time; |
| #endif |
| result += ((double) DAYS_PER_YEAR * SECS_PER_DAY) * (interval->month / MONTHS_PER_YEAR); |
| result += ((double) DAYS_PER_MONTH * SECS_PER_DAY) * (interval->month % MONTHS_PER_YEAR); |
| result += ((double) SECS_PER_DAY) * interval->day; |
| } |
| else |
| { |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("interval units \"%s\" not recognized", |
| lowunits), |
| errOmitLocation(true))); |
| result = 0; |
| } |
| |
| PG_RETURN_FLOAT8(result); |
| } |
| |
| |
| /* timestamp_zone() |
| * Encode timestamp type with specified time zone. |
| * This function is just timestamp2timestamptz() except instead of |
| * shifting to the global timezone, we shift to the specified timezone. |
| * This is different from the other AT TIME ZONE cases because instead |
| * of shifting to a _to_ a new time zone, it sets the time to _be_ the |
| * specified timezone. |
| */ |
| Datum |
| timestamp_zone(PG_FUNCTION_ARGS) |
| { |
| text *zone = PG_GETARG_TEXT_P(0); |
| Timestamp timestamp = PG_GETARG_TIMESTAMP(1); |
| TimestampTz result; |
| int tz; |
| char tzname[TZ_STRLEN_MAX + 1]; |
| char *lowzone; |
| int type, |
| val; |
| pg_tz *tzp; |
| |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| PG_RETURN_TIMESTAMPTZ(timestamp); |
| |
| /* |
| * Look up the requested timezone. First we look in the date token table |
| * (to handle cases like "EST"), and if that fails, we look in the |
| * timezone database (to handle cases like "America/New_York"). (This |
| * matches the order in which timestamp input checks the cases; it's |
| * important because the timezone database unwisely uses a few zone names |
| * that are identical to offset abbreviations.) |
| */ |
| text_to_cstring_buffer(zone, tzname, sizeof(tzname)); |
| lowzone = downcase_truncate_identifier(tzname, |
| strlen(tzname), |
| false); |
| |
| type = DecodeSpecial(0, lowzone, &val); |
| |
| if (type == TZ || type == DTZ) |
| { |
| tz = -(val * 60); |
| result = dt2local(timestamp, tz); |
| } |
| else |
| { |
| tzp = pg_tzset(tzname); |
| if (tzp) |
| { |
| /* Apply the timezone change */ |
| struct pg_tm tm; |
| fsec_t fsec = 0; |
| |
| if (timestamp2tm(timestamp, NULL, &tm, &fsec, NULL, tzp) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| tz = DetermineTimeZoneOffset(&tm, tzp); |
| if (tm2timestamp(&tm, fsec, &tz, &result) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("could not convert to time zone \"%s\"", |
| tzname), |
| errOmitLocation(true))); |
| } |
| else |
| { |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("time zone \"%s\" not recognized", tzname), |
| errOmitLocation(true))); |
| result = 0; /* keep compiler quiet */ |
| } |
| } |
| |
| PG_RETURN_TIMESTAMPTZ(result); |
| } |
| |
| /* timestamp_izone() |
| * Encode timestamp type with specified time interval as time zone. |
| */ |
| Datum |
| timestamp_izone(PG_FUNCTION_ARGS) |
| { |
| Interval *zone = PG_GETARG_INTERVAL_P(0); |
| Timestamp timestamp = PG_GETARG_TIMESTAMP(1); |
| TimestampTz result; |
| int tz; |
| |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| PG_RETURN_TIMESTAMPTZ(timestamp); |
| |
| if (zone->month != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("interval time zone \"%s\" must not specify month", |
| DatumGetCString(DirectFunctionCall1(interval_out, |
| PointerGetDatum(zone)))), |
| errOmitLocation(true))); |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| tz = zone->time / USECS_PER_SEC; |
| #else |
| tz = zone->time; |
| #endif |
| |
| result = dt2local(timestamp, tz); |
| |
| PG_RETURN_TIMESTAMPTZ(result); |
| } /* timestamp_izone() */ |
| |
| /* timestamp_timestamptz() |
| * Convert local timestamp to timestamp at GMT |
| */ |
| Datum |
| timestamp_timestamptz(PG_FUNCTION_ARGS) |
| { |
| Timestamp timestamp = PG_GETARG_TIMESTAMP(0); |
| |
| PG_RETURN_TIMESTAMPTZ(timestamp2timestamptz(timestamp)); |
| } |
| |
| static TimestampTz |
| timestamp2timestamptz(Timestamp timestamp) |
| { |
| TimestampTz result; |
| struct pg_tm tt, |
| *tm = &tt; |
| fsec_t fsec = 0; |
| int tz; |
| |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| result = timestamp; |
| else |
| { |
| if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| |
| tz = DetermineTimeZoneOffset(tm, session_timezone); |
| |
| if (tm2timestamp(tm, fsec, &tz, &result) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| } |
| |
| return result; |
| } |
| |
| /* timestamptz_timestamp() |
| * Convert timestamp at GMT to local timestamp |
| */ |
| Datum |
| timestamptz_timestamp(PG_FUNCTION_ARGS) |
| { |
| TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0); |
| Timestamp result; |
| struct pg_tm tt, |
| *tm = &tt; |
| fsec_t fsec = 0; |
| char *tzn; |
| int tz; |
| |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| result = timestamp; |
| else |
| { |
| if (timestamp2tm(timestamp, &tz, tm, &fsec, &tzn, NULL) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| if (tm2timestamp(tm, fsec, NULL, &result) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| } |
| PG_RETURN_TIMESTAMP(result); |
| } |
| |
| /* timestamptz_zone() |
| * Evaluate timestamp with time zone type at the specified time zone. |
| * Returns a timestamp without time zone. |
| */ |
| Datum |
| timestamptz_zone(PG_FUNCTION_ARGS) |
| { |
| text *zone = PG_GETARG_TEXT_P(0); |
| TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1); |
| Timestamp result; |
| int tz; |
| char tzname[TZ_STRLEN_MAX + 1]; |
| char *lowzone; |
| int type, |
| val; |
| pg_tz *tzp; |
| |
| if (TIMESTAMP_NOT_FINITE(timestamp)) |
| PG_RETURN_TIMESTAMP(timestamp); |
| |
| /* |
| * Look up the requested timezone. First we look in the date token table |
| * (to handle cases like "EST"), and if that fails, we look in the |
| * timezone database (to handle cases like "America/New_York"). (This |
| * matches the order in which timestamp input checks the cases; it's |
| * important because the timezone database unwisely uses a few zone names |
| * that are identical to offset abbreviations.) |
| */ |
| text_to_cstring_buffer(zone, tzname, sizeof(tzname)); |
| lowzone = downcase_truncate_identifier(tzname, |
| strlen(tzname), |
| false); |
| |
| type = DecodeSpecial(0, lowzone, &val); |
| |
| if (type == TZ || type == DTZ) |
| { |
| tz = val * 60; |
| result = dt2local(timestamp, tz); |
| } |
| else |
| { |
| tzp = pg_tzset(tzname); |
| if (tzp) |
| { |
| /* Apply the timezone change */ |
| struct pg_tm tm; |
| fsec_t fsec = 0; |
| |
| if (timestamp2tm(timestamp, &tz, &tm, &fsec, NULL, tzp) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), |
| errmsg("timestamp out of range"), |
| errOmitLocation(true))); |
| if (tm2timestamp(&tm, fsec, NULL, &result) != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("could not convert to time zone \"%s\"", |
| tzname))); |
| } |
| else |
| { |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("time zone \"%s\" not recognized", tzname), |
| errOmitLocation(true))); |
| result = 0; /* keep compiler quiet */ |
| } |
| } |
| |
| PG_RETURN_TIMESTAMP(result); |
| } |
| |
| /* timestamptz_izone() |
| * Encode timestamp with time zone type with specified time interval as time zone. |
| * Returns a timestamp without time zone. |
| */ |
| Datum |
| timestamptz_izone(PG_FUNCTION_ARGS) |
| { |
| 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 (zone->month != 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("interval time zone \"%s\" must not specify month", |
| DatumGetCString(DirectFunctionCall1(interval_out, |
| PointerGetDatum(zone)))), |
| errOmitLocation(true))); |
| |
| #ifdef HAVE_INT64_TIMESTAMP |
| tz = -(zone->time / USECS_PER_SEC); |
| #else |
| tz = -zone->time; |
| #endif |
| |
| result = dt2local(timestamp, tz); |
| |
| PG_RETURN_TIMESTAMP(result); |
| } |
| |
| /* generate_series_timestamp() |
| * Generate the set of timestamps from start to finish by step |
| */ |
| Datum |
| generate_series_timestamp(PG_FUNCTION_ARGS) |
| { |
| FuncCallContext *funcctx; |
| generate_series_timestamp_fctx *fctx; |
| Timestamp result; |
| |
| /* stuff done only on the first call of the function */ |
| if (SRF_IS_FIRSTCALL()) |
| { |
| Timestamp start = PG_GETARG_TIMESTAMP(0); |
| Timestamp finish = PG_GETARG_TIMESTAMP(1); |
| Interval *step = PG_GETARG_INTERVAL_P(2); |
| MemoryContext oldcontext; |
| Interval interval_zero; |
| |
| /* create a function context for cross-call persistence */ |
| funcctx = SRF_FIRSTCALL_INIT(); |
| |
| /* |
| * switch to memory context appropriate for multiple function calls |
| */ |
| oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); |
| |
| /* allocate memory for user context */ |
| fctx = (generate_series_timestamp_fctx *) |
| palloc(sizeof(generate_series_timestamp_fctx)); |
| |
| /* |
| * Use fctx to keep state from call to call. Seed current with the |
| * original start value |
| */ |
| fctx->current = start; |
| fctx->finish = finish; |
| fctx->step = *step; |
| |
| /* Determine sign of the interval */ |
| MemSet(&interval_zero, 0, sizeof(Interval)); |
| fctx->step_sign = interval_cmp_internal(&fctx->step, &interval_zero); |
| |
| if (fctx->step_sign == 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("step size cannot equal zero"), |
| errOmitLocation(true))); |
| |
| 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); |
| } |
| } |
| |
| /* generate_series_timestamptz() |
| * Generate the set of timestamps from start to finish by step |
| */ |
| Datum |
| generate_series_timestamptz(PG_FUNCTION_ARGS) |
| { |
| FuncCallContext *funcctx; |
| generate_series_timestamptz_fctx *fctx; |
| TimestampTz result; |
| |
| /* stuff done only on the first call of the function */ |
| if (SRF_IS_FIRSTCALL()) |
| { |
| TimestampTz start = PG_GETARG_TIMESTAMPTZ(0); |
| TimestampTz finish = PG_GETARG_TIMESTAMPTZ(1); |
| Interval *step = PG_GETARG_INTERVAL_P(2); |
| MemoryContext oldcontext; |
| Interval interval_zero; |
| |
| /* create a function context for cross-call persistence */ |
| funcctx = SRF_FIRSTCALL_INIT(); |
| |
| /* |
| * switch to memory context appropriate for multiple function calls |
| */ |
| oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); |
| |
| /* allocate memory for user context */ |
| fctx = (generate_series_timestamptz_fctx *) |
| palloc(sizeof(generate_series_timestamptz_fctx)); |
| |
| /* |
| * Use fctx to keep state from call to call. Seed current with the |
| * original start value |
| */ |
| fctx->current = start; |
| fctx->finish = finish; |
| fctx->step = *step; |
| |
| /* Determine sign of the interval */ |
| MemSet(&interval_zero, 0, sizeof(Interval)); |
| fctx->step_sign = interval_cmp_internal(&fctx->step, &interval_zero); |
| |
| if (fctx->step_sign == 0) |
| ereport(ERROR, |
| (errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| errmsg("step size cannot equal zero"), |
| errOmitLocation(true))); |
| |
| funcctx->user_fctx = fctx; |
| MemoryContextSwitchTo(oldcontext); |
| } |
| |
| /* stuff done on every call of the function */ |
| funcctx = SRF_PERCALL_SETUP(); |
| |
| /* |
| * get the saved state and use current as the result for this iteration |
| */ |
| fctx = funcctx->user_fctx; |
| result = fctx->current; |
| |
| if (fctx->step_sign > 0 ? |
| timestamp_cmp_internal(result, fctx->finish) <= 0 : |
| timestamp_cmp_internal(result, fctx->finish) >= 0) |
| { |
| /* increment current in preparation for next iteration */ |
| fctx->current = DatumGetTimestampTz( |
| DirectFunctionCall2(timestamptz_pl_interval, |
| TimestampTzGetDatum(fctx->current), |
| PointerGetDatum(&fctx->step))); |
| |
| /* do when there is more left to send */ |
| SRF_RETURN_NEXT(funcctx, TimestampTzGetDatum(result)); |
| } |
| else |
| { |
| /* do when there is no more left */ |
| SRF_RETURN_DONE(funcctx); |
| } |
| } |
| |
| /* ---------------------------------------------------------------------- |
| * |
| * Aggregate functions -- Greenplum Database Extensions |
| * |
| * Greenplum Database adds some builtin functions to amalgamate transition type |
| * instances for two-stage aggregation. |
| * |
| * ---------------------------------------------------------------------- |
| */ |
| |
| Datum |
| interval_amalg(PG_FUNCTION_ARGS) |
| { |
| ArrayType *aTransArray = PG_GETARG_ARRAYTYPE_P(0); |
| ArrayType *bTransArray = PG_GETARG_ARRAYTYPE_P(1); |
| |
| PG_RETURN_ARRAYTYPE_P(interval_amalg_demalg(aTransArray, bTransArray, |
| true)); |
| } |
| |
| Datum |
| interval_demalg(PG_FUNCTION_ARGS) |
| { |
| ArrayType *aTransArray = PG_GETARG_ARRAYTYPE_P(0); |
| ArrayType *bTransArray = PG_GETARG_ARRAYTYPE_P(1); |
| |
| PG_RETURN_ARRAYTYPE_P(interval_amalg_demalg(aTransArray, bTransArray, |
| false)); |
| } |
| |
| static ArrayType * |
| interval_amalg_demalg(ArrayType *aTransArray, |
| ArrayType *bTransArray, |
| bool is_amalg) |
| { |
| Datum *transdatums; |
| int ndatums; |
| Interval aSumMiX, bSumMiX, |
| aN, bN; |
| Interval *newsummi; |
| ArrayType *result; |
| |
| deconstruct_array(aTransArray, |
| INTERVALOID, sizeof(Interval), false, 'd', |
| &transdatums, NULL, &ndatums); |
| if (ndatums != 2) |
| elog(ERROR, "expected 2-element interval array"); |
| |
| /* |
| * XXX memcpy, instead of just extracting a pointer, to work around buggy |
| * array code: it won't ensure proper alignment of Interval objects on |
| * machines where double requires 8-byte alignment. That should be fixed, |
| * but in the meantime... |
| * |
| * Note: must use DatumGetPointer here, not DatumGetIntervalP, else some |
| * compilers optimize into double-aligned load/store anyway. |
| */ |
| memcpy((void *) &aSumMiX, DatumGetPointer(transdatums[0]), sizeof(Interval)); |
| memcpy((void *) &aN, DatumGetPointer(transdatums[1]), sizeof(Interval)); |
| |
| deconstruct_array(bTransArray, |
| INTERVALOID, sizeof(Interval), false, 'd', |
| &transdatums, NULL, &ndatums); |
| if (ndatums != 2) |
| elog(ERROR, "expected 2-element interval array"); |
| |
| memcpy((void *) &bSumMiX, DatumGetPointer(transdatums[0]), sizeof(Interval)); |
| memcpy((void *) &bN, DatumGetPointer(transdatums[1]), sizeof(Interval)); |
| |
| |
| if (is_amalg) |
| { |
| newsummi = DatumGetIntervalP(DirectFunctionCall2(interval_pl, |
| IntervalPGetDatum(&aSumMiX), |
| IntervalPGetDatum(&bSumMiX))); |
| aN.time += bN.time; |
| } |
| |
| else |
| { |
| newsummi = DatumGetIntervalP(DirectFunctionCall2(interval_mi, |
| IntervalPGetDatum(&aSumMiX), |
| IntervalPGetDatum(&bSumMiX))); |
| aN.time -= bN.time; |
| } |
| |
| transdatums[0] = IntervalPGetDatum(newsummi); |
| transdatums[1] = IntervalPGetDatum(&aN); |
| |
| result = construct_array(transdatums, 2, |
| INTERVALOID, sizeof(Interval), false, 'd'); |
| |
| return result; |
| } |
| |