/*-------------------------------------------------------------------------
+ *
* nabstime.c
* Utilities for the built-in type "AbsoluteTime".
* Functions for the built-in type "RelativeTime".
* Functions for the built-in type "TimeInterval".
*
- * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/nabstime.c,v 1.99 2002/09/04 20:31:28 momjian Exp $
- *
- * NOTES
+ * src/backend/utils/adt/nabstime.c
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include <ctype.h>
-#include <time.h>
-#include <sys/time.h>
#include <float.h>
#include <limits.h>
+#include <time.h>
+#include <sys/time.h>
-#if !(defined(HAVE_TM_ZONE) || defined(HAVE_INT_TIMEZONE))
-#include <sys/timeb.h>
-#endif
-
-#include "access/xact.h"
+#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "utils/builtins.h"
+#include "utils/datetime.h"
+#include "utils/nabstime.h"
-
-#define MIN_DAYNUM -24856 /* December 13, 1901 */
+#define MIN_DAYNUM (-24856) /* December 13, 1901 */
#define MAX_DAYNUM 24854 /* January 18, 2038 */
-#define INVALID_RELTIME_STR "Undefined RelTime"
-#define INVALID_RELTIME_STR_LEN (sizeof(INVALID_RELTIME_STR)-1)
-#define RELTIME_LABEL '@'
-#define RELTIME_PAST "ago"
-#define DIRMAXLEN (sizeof(RELTIME_PAST)-1)
-
/*
* Unix epoch is Jan 1 00:00:00 1970.
* Postgres knows about times sixty-eight years on either side of that
#define IsSpace(C) ((C) == ' ')
-#define T_INTERVAL_INVAL 0 /* data represents no valid interval */
-#define T_INTERVAL_VALID 1 /* data represents a valid interval */
+#define T_INTERVAL_INVAL 0 /* data represents no valid tinterval */
+#define T_INTERVAL_VALID 1 /* data represents a valid tinterval */
/*
* ['Mon May 10 23:59:12 1943 PST' 'Sun Jan 14 03:14:21 1973 PST']
* 0 1 2 3 4 5 6
* Function prototypes -- internal to this file only
*/
-static AbsoluteTime tm2abstime(struct tm * tm, int tz);
-static void reltime2tm(RelativeTime time, struct tm * tm);
-static int istinterval(char *i_string,
- AbsoluteTime *i_start,
- AbsoluteTime *i_end);
+static AbsoluteTime tm2abstime(struct pg_tm * tm, int tz);
+static void reltime2tm(RelativeTime time, struct pg_tm * tm);
+static void parsetinterval(char *i_string,
+ AbsoluteTime *i_start,
+ AbsoluteTime *i_end);
-/* GetCurrentAbsoluteTime()
- * Get the current system time. Set timezone parameters if not specified elsewhere.
- * Define HasCTZSet to allow clients to specify the default timezone.
+/*
+ * GetCurrentAbsoluteTime()
+ *
+ * Get the current system time (relative to Unix epoch).
*
- * Returns the number of seconds since epoch (January 1 1970 GMT)
+ * NB: this will overflow in 2038; it should be gone long before that.
*/
AbsoluteTime
GetCurrentAbsoluteTime(void)
{
time_t now;
-#if defined(HAVE_TM_ZONE) || defined(HAVE_INT_TIMEZONE)
- struct tm *tm;
-
now = time(NULL);
-#else
- struct timeb tb; /* the old V7-ism */
-
- ftime(&tb);
- now = tb.time;
-#endif
-
- if (!HasCTZSet)
- {
-#if defined(HAVE_TM_ZONE)
- tm = localtime(&now);
-
- CTimeZone = -tm->tm_gmtoff; /* tm_gmtoff is Sun/DEC-ism */
- CDayLight = (tm->tm_isdst > 0);
-
-#ifdef NOT_USED
-
- /*
- * XXX is there a better way to get local timezone string w/o
- * tzname? - tgl 97/03/18
- */
- strftime(CTZName, MAXTZLEN, "%Z", tm);
-#endif
-
- /*
- * XXX FreeBSD man pages indicate that this should work - thomas
- * 1998-12-12
- */
- strcpy(CTZName, tm->tm_zone);
-
-#elif defined(HAVE_INT_TIMEZONE)
- tm = localtime(&now);
-
- CDayLight = tm->tm_isdst;
- CTimeZone = ((tm->tm_isdst > 0) ? (TIMEZONE_GLOBAL - 3600) : TIMEZONE_GLOBAL);
- strcpy(CTZName, tzname[tm->tm_isdst]);
-#else /* neither HAVE_TM_ZONE nor
- * HAVE_INT_TIMEZONE */
- CTimeZone = tb.timezone * 60;
- CDayLight = (tb.dstflag != 0);
-
- /*
- * XXX does this work to get the local timezone string in V7? -
- * tgl 97/03/18
- */
- strftime(CTZName, MAXTZLEN, "%Z", localtime(&now));
-#endif
- }
-
return (AbsoluteTime) now;
-} /* GetCurrentAbsoluteTime() */
-
-
-/* GetCurrentAbsoluteTimeUsec()
- * Get the current system time. Set timezone parameters if not specified elsewhere.
- * Define HasCTZSet to allow clients to specify the default timezone.
- *
- * Returns the number of seconds since epoch (January 1 1970 GMT)
- */
-AbsoluteTime
-GetCurrentAbsoluteTimeUsec(int *usec)
-{
- time_t now;
- struct timeval tp;
-
-#ifdef NOT_USED
- struct timezone tpz;
-#endif
-#if defined(HAVE_TM_ZONE) || defined(HAVE_INT_TIMEZONE)
- struct tm *tm;
-
-#else
- struct timeb tb; /* the old V7-ism */
-#endif
-
- gettimeofday(&tp, NULL);
-
- now = tp.tv_sec;
- *usec = tp.tv_usec;
-
-#ifdef NOT_USED
-#if defined(HAVE_TM_ZONE) || defined(HAVE_INT_TIMEZONE)
- now = time(NULL);
-#else
- ftime(&tb);
- now = tb.time;
-#endif
-#endif
-
- if (!HasCTZSet)
- {
-#if defined(HAVE_TM_ZONE)
- tm = localtime(&now);
-
- CTimeZone = -tm->tm_gmtoff; /* tm_gmtoff is Sun/DEC-ism */
- CDayLight = (tm->tm_isdst > 0);
-
-#ifdef NOT_USED
-
- /*
- * XXX is there a better way to get local timezone string w/o
- * tzname? - tgl 97/03/18
- */
- strftime(CTZName, MAXTZLEN, "%Z", tm);
-#endif
-
- /*
- * XXX FreeBSD man pages indicate that this should work - thomas
- * 1998-12-12
- */
- strcpy(CTZName, tm->tm_zone);
-
-#elif defined(HAVE_INT_TIMEZONE)
- tm = localtime(&now);
-
- CDayLight = tm->tm_isdst;
- CTimeZone = ((tm->tm_isdst > 0) ? (TIMEZONE_GLOBAL - 3600) : TIMEZONE_GLOBAL);
- strcpy(CTZName, tzname[tm->tm_isdst]);
-#else /* neither HAVE_TM_ZONE nor
- * HAVE_INT_TIMEZONE */
- CTimeZone = tb.timezone * 60;
- CDayLight = (tb.dstflag != 0);
-
- /*
- * XXX does this work to get the local timezone string in V7? -
- * tgl 97/03/18
- */
- strftime(CTZName, MAXTZLEN, "%Z", localtime(&now));
-#endif
- };
-
- return (AbsoluteTime) now;
-} /* GetCurrentAbsoluteTimeUsec() */
-
-
-void
-GetCurrentDateTime(struct tm * tm)
-{
- int tz;
-
- abstime2tm(GetCurrentTransactionStartTime(), &tz, tm, NULL);
-
- return;
-} /* GetCurrentDateTime() */
-
-
-void
-GetCurrentTimeUsec(struct tm * tm, fsec_t *fsec)
-{
- int tz;
- int usec;
-
- abstime2tm(GetCurrentTransactionStartTimeUsec(&usec), &tz, tm, NULL);
-#ifdef HAVE_INT64_TIMESTAMP
- *fsec = usec;
-#else
- *fsec = usec * 1.0e-6;
-#endif
-
- return;
-} /* GetCurrentTimeUsec() */
+}
void
-abstime2tm(AbsoluteTime _time, int *tzp, struct tm * tm, char **tzn)
+abstime2tm(AbsoluteTime _time, int *tzp, struct pg_tm * tm, char **tzn)
{
- time_t time = (time_t) _time;
-
-#if defined(HAVE_TM_ZONE) || defined(HAVE_INT_TIMEZONE)
- struct tm *tx;
+ pg_time_t time = (pg_time_t) _time;
+ struct pg_tm *tx;
-#else
- struct timeb tb; /* the old V7-ism */
-
- ftime(&tb);
-#endif
-
- /*
- * 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 (HasCTZSet && (tzp != NULL))
- time -= CTimeZone;
-
-#if defined(HAVE_TM_ZONE) || defined(HAVE_INT_TIMEZONE)
- if ((!HasCTZSet) && (tzp != NULL))
- {
- tx = localtime((time_t *) &time);
-#ifdef NO_MKTIME_BEFORE_1970
- if (tx->tm_year < 70 && tx->tm_isdst == 1)
- {
- time -= 3600;
- tx = localtime((time_t *) &time);
- tx->tm_isdst = 0;
- }
-#endif
- }
+ if (tzp != NULL)
+ tx = pg_localtime(&time, session_timezone);
else
- {
- tx = gmtime((time_t *) &time);
- };
+ tx = pg_gmtime(&time);
tm->tm_year = tx->tm_year + 1900;
tm->tm_mon = tx->tm_mon + 1;
tm->tm_sec = tx->tm_sec;
tm->tm_isdst = tx->tm_isdst;
-#if defined(HAVE_TM_ZONE)
tm->tm_gmtoff = tx->tm_gmtoff;
tm->tm_zone = tx->tm_zone;
if (tzp != NULL)
{
- /*
- * We have a brute force time zone per SQL99? Then use it without
- * change since we have already rotated to the time zone.
- */
- if (HasCTZSet)
- {
- *tzp = CTimeZone;
- tm->tm_gmtoff = CTimeZone;
- tm->tm_isdst = 0;
- tm->tm_zone = NULL;
- if (tzn != NULL)
- *tzn = NULL;
- }
- else
- {
*tzp = -tm->tm_gmtoff; /* tm_gmtoff is Sun/DEC-ism */
/*
{
/*
* Copy no more than MAXTZLEN bytes of timezone to tzn, in
- * case it contains an error message, which doesn't fit in
- * the buffer
+ * case it contains an error message, which doesn't fit in the
+ * buffer
*/
StrNCpy(*tzn, tm->tm_zone, MAXTZLEN + 1);
if (strlen(tm->tm_zone) > MAXTZLEN)
- elog(WARNING, "Invalid timezone \'%s\'", tm->tm_zone);
- }
- }
- }
- else
- tm->tm_isdst = -1;
-#elif defined(HAVE_INT_TIMEZONE)
- if (tzp != NULL)
- {
- /*
- * We have a brute force time zone per SQL99? Then use it without
- * change since we have already rotated to the time zone.
- */
- if (HasCTZSet)
- {
- *tzp = CTimeZone;
- tm->tm_isdst = 0;
- if (tzn != NULL)
- *tzn = NULL;
- }
- else
- {
- *tzp = ((tm->tm_isdst > 0) ? (TIMEZONE_GLOBAL - 3600) : TIMEZONE_GLOBAL);
-
- if (tzn != NULL)
- {
- /*
- * Copy no more than MAXTZLEN bytes of timezone to tzn, in
- * case it contains an error message, which doesn't fit in
- * the buffer
- */
- StrNCpy(*tzn, tzname[tm->tm_isdst], MAXTZLEN + 1);
- if (strlen(tzname[tm->tm_isdst]) > MAXTZLEN)
- elog(WARNING, "Invalid timezone \'%s\'", tzname[tm->tm_isdst]);
- }
- }
- }
- else
- tm->tm_isdst = -1;
-#endif
-#else /* not (HAVE_TM_ZONE || HAVE_INT_TIMEZONE) */
- if (tzp != NULL)
- {
- /*
- * We have a brute force time zone per SQL99? Then use it without
- * change since we have already rotated to the time zone.
- */
- if (HasCTZSet)
- {
- *tzp = CTimeZone;
- if (tzn != NULL)
- *tzn = NULL;
- }
- else
- {
- *tzp = tb.timezone * 60;
-
- /*
- * XXX does this work to get the local timezone string in V7?
- * - tgl 97/03/18
- */
- if (tzn != NULL)
- {
- strftime(*tzn, MAXTZLEN, "%Z", localtime(&now));
- tzn[MAXTZLEN] = '\0'; /* let's just be sure it's
- * null-terminated */
+ ereport(WARNING,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("invalid time zone name: \"%s\"",
+ tm->tm_zone)));
}
- }
}
else
tm->tm_isdst = -1;
-#endif
-
- return;
-} /* abstime2tm() */
+}
/* tm2abstime()
* Note that tm has full year (not 1900-based) and 1-based month.
*/
static AbsoluteTime
-tm2abstime(struct tm * tm, int tz)
+tm2abstime(struct pg_tm * tm, int tz)
{
int day;
AbsoluteTime sec;
/* validate, before going out of range on some members */
- if (tm->tm_year < 1901 || tm->tm_year > 2038
- || tm->tm_mon < 1 || tm->tm_mon > 12
- || tm->tm_mday < 1 || tm->tm_mday > 31
- || tm->tm_hour < 0 || tm->tm_hour >= 24
- || tm->tm_min < 0 || tm->tm_min > 59
- || tm->tm_sec < 0 || tm->tm_sec > 59)
+ if (tm->tm_year < 1901 || tm->tm_year > 2038 ||
+ tm->tm_mon < 1 || tm->tm_mon > MONTHS_PER_YEAR ||
+ tm->tm_mday < 1 || tm->tm_mday > 31 ||
+ tm->tm_hour < 0 ||
+ tm->tm_hour > HOURS_PER_DAY || /* test for > 24:00:00 */
+ (tm->tm_hour == HOURS_PER_DAY && (tm->tm_min > 0 || tm->tm_sec > 0)) ||
+ tm->tm_min < 0 || tm->tm_min > MINS_PER_HOUR - 1 ||
+ tm->tm_sec < 0 || tm->tm_sec > SECS_PER_MINUTE)
return INVALID_ABSTIME;
- day = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(1970, 1, 1));
+ day = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - UNIX_EPOCH_JDATE;
/* check for time out of range */
- if ((day < MIN_DAYNUM) || (day > MAX_DAYNUM))
+ if (day < MIN_DAYNUM || day > MAX_DAYNUM)
return INVALID_ABSTIME;
/* convert to seconds */
- sec = tm->tm_sec + tz + (tm->tm_min + (day * 24 + tm->tm_hour) * 60) * 60;
+ sec = tm->tm_sec + tz + (tm->tm_min + (day * HOURS_PER_DAY + tm->tm_hour) * MINS_PER_HOUR) * SECS_PER_MINUTE;
- /* check for overflow */
- if ((day == MAX_DAYNUM && sec < 0) ||
- (day == MIN_DAYNUM && sec > 0))
+ /*
+ * check for overflow. We need a little slop here because the H/M/S plus
+ * TZ offset could add up to more than 1 day.
+ */
+ if ((day >= MAX_DAYNUM - 10 && sec < 0) ||
+ (day <= MIN_DAYNUM + 10 && sec > 0))
return INVALID_ABSTIME;
/* check for reserved values (e.g. "current" on edge of usual range */
return INVALID_ABSTIME;
return sec;
-} /* tm2abstime() */
+}
-/* nabstimein()
+/* abstimein()
* Decode date/time string and return abstime.
*/
Datum
-nabstimein(PG_FUNCTION_ARGS)
+abstimein(PG_FUNCTION_ARGS)
{
char *str = PG_GETARG_CSTRING(0);
AbsoluteTime result;
fsec_t fsec;
int tz = 0;
- struct tm date,
+ struct pg_tm date,
*tm = &date;
+ int dterr;
char *field[MAXDATEFIELDS];
- char lowstr[MAXDATELEN + 1];
+ char workbuf[MAXDATELEN + 1];
int dtype;
int nf,
ftype[MAXDATEFIELDS];
- if (strlen(str) >= sizeof(lowstr))
- elog(ERROR, "Bad abstime external representation (too long) '%s'", str);
-
- if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
- || (DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tz) != 0))
- elog(ERROR, "Bad abstime external representation '%s'", str);
+ 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, "abstime");
switch (dtype)
{
case DTK_EPOCH:
/*
- * Don't bother retaining this as a reserved value, but
- * instead just set to the actual epoch time (1970-01-01)
+ * Don't bother retaining this as a reserved value, but instead
+ * just set to the actual epoch time (1970-01-01)
*/
result = 0;
break;
break;
default:
- elog(ERROR, "Bad abstime (internal coding error) '%s'", str);
+ elog(ERROR, "unexpected dtype %d while parsing abstime \"%s\"",
+ dtype, str);
result = INVALID_ABSTIME;
break;
};
}
-/* nabstimeout()
+/* abstimeout()
* Given an AbsoluteTime return the English text version of the date
*/
Datum
-nabstimeout(PG_FUNCTION_ARGS)
+abstimeout(PG_FUNCTION_ARGS)
{
AbsoluteTime time = PG_GETARG_ABSOLUTETIME(0);
char *result;
int tz;
double fsec = 0;
- struct tm tt,
+ struct pg_tm tt,
*tm = &tt;
char buf[MAXDATELEN + 1];
char zone[MAXDATELEN + 1],
break;
default:
abstime2tm(time, &tz, tm, &tzn);
- EncodeDateTime(tm, fsec, &tz, &tzn, DateStyle, buf);
+ EncodeDateTime(tm, fsec, true, tz, tzn, DateStyle, buf);
break;
}
PG_RETURN_CSTRING(result);
}
+/*
+ * abstimerecv - converts external binary format to abstime
+ */
+Datum
+abstimerecv(PG_FUNCTION_ARGS)
+{
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
+
+ PG_RETURN_ABSOLUTETIME((AbsoluteTime) pq_getmsgint(buf, sizeof(AbsoluteTime)));
+}
+
+/*
+ * abstimesend - converts abstime to binary format
+ */
+Datum
+abstimesend(PG_FUNCTION_ARGS)
+{
+ AbsoluteTime time = PG_GETARG_ABSOLUTETIME(0);
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendint(&buf, time, sizeof(time));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+}
+
/* abstime_finite()
*/
{
AbsoluteTime abstime = PG_GETARG_ABSOLUTETIME(0);
- PG_RETURN_BOOL((abstime != INVALID_ABSTIME) &&
- (abstime != NOSTART_ABSTIME) &&
- (abstime != NOEND_ABSTIME));
+ PG_RETURN_BOOL(abstime != INVALID_ABSTIME &&
+ abstime != NOSTART_ABSTIME &&
+ abstime != NOEND_ABSTIME);
}
static int
abstime_cmp_internal(AbsoluteTime a, AbsoluteTime b)
{
-/*
- * We consider all INVALIDs to be equal and larger than any non-INVALID.
- * This is somewhat arbitrary; the important thing is to have a
- * consistent sort order.
- */
+ /*
+ * We consider all INVALIDs to be equal and larger than any non-INVALID.
+ * This is somewhat arbitrary; the important thing is to have a consistent
+ * sort order.
+ */
if (a == INVALID_ABSTIME)
{
if (b == INVALID_ABSTIME)
if (b == INVALID_ABSTIME)
return -1; /* non-INVALID < INVALID */
-#if 0
-/* CURRENT is no longer stored internally... */
- /* XXX this is broken, should go away: */
- if (a == CURRENT_ABSTIME)
- a = GetCurrentTransactionStartTime();
- if (b == CURRENT_ABSTIME)
- b = GetCurrentTransactionStartTime();
-#endif
-
if (a > b)
return 1;
else if (a == b)
AbsoluteTime result;
fsec_t fsec;
int tz;
- struct tm tt,
+ struct pg_tm tt,
*tm = &tt;
if (TIMESTAMP_IS_NOBEGIN(timestamp))
result = NOSTART_ABSTIME;
else if (TIMESTAMP_IS_NOEND(timestamp))
result = NOEND_ABSTIME;
- else if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL) == 0)
+ else if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) == 0)
{
- tz = DetermineLocalTimeZone(tm);
+ tz = DetermineTimeZoneOffset(tm, session_timezone);
result = tm2abstime(tm, tz);
}
else
{
- elog(ERROR, "Unable to convert timestamp to abstime");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
+ errmsg("timestamp out of range")));
result = INVALID_ABSTIME;
}
{
AbsoluteTime abstime = PG_GETARG_ABSOLUTETIME(0);
Timestamp result;
- struct tm tt,
+ struct pg_tm tt,
*tm = &tt;
int tz;
char zone[MAXDATELEN + 1],
switch (abstime)
{
case INVALID_ABSTIME:
- elog(ERROR, "Unable to convert abstime 'invalid' to timestamp");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("cannot convert abstime \"invalid\" to timestamp")));
TIMESTAMP_NOBEGIN(result);
break;
default:
abstime2tm(abstime, &tz, tm, &tzn);
if (tm2timestamp(tm, 0, NULL, &result) != 0)
- elog(ERROR, "Unable convert ABSTIME to TIMESTAMP"
- "\n\tabstime_timestamp() internal error");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
+ errmsg("timestamp out of range")));
break;
};
TimestampTz timestamp = PG_GETARG_TIMESTAMP(0);
AbsoluteTime result;
fsec_t fsec;
- struct tm tt,
+ struct pg_tm tt,
*tm = &tt;
if (TIMESTAMP_IS_NOBEGIN(timestamp))
result = NOSTART_ABSTIME;
else if (TIMESTAMP_IS_NOEND(timestamp))
result = NOEND_ABSTIME;
- else if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL) == 0)
+ else if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) == 0)
result = tm2abstime(tm, 0);
else
{
- elog(ERROR, "Unable to convert timestamp to abstime");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
+ errmsg("timestamp out of range")));
result = INVALID_ABSTIME;
}
}
/* abstime_timestamptz()
- * Convert abstime to timestamp.
+ * Convert abstime to timestamp with time zone.
*/
Datum
abstime_timestamptz(PG_FUNCTION_ARGS)
{
AbsoluteTime abstime = PG_GETARG_ABSOLUTETIME(0);
TimestampTz result;
- struct tm tt,
+ struct pg_tm tt,
*tm = &tt;
int tz;
char zone[MAXDATELEN + 1],
switch (abstime)
{
case INVALID_ABSTIME:
- elog(ERROR, "Unable to convert abstime 'invalid' to timestamptz");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("cannot convert abstime \"invalid\" to timestamp")));
TIMESTAMP_NOBEGIN(result);
break;
default:
abstime2tm(abstime, &tz, tm, &tzn);
if (tm2timestamp(tm, 0, &tz, &result) != 0)
- elog(ERROR, "Unable convert ABSTIME to TIMESTAMP WITH TIME ZONE"
- "\n\tabstime_timestamp() internal error");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
+ errmsg("timestamp out of range")));
break;
};
{
char *str = PG_GETARG_CSTRING(0);
RelativeTime result;
- struct tm tt,
+ struct pg_tm tt,
*tm = &tt;
fsec_t fsec;
int dtype;
+ int dterr;
char *field[MAXDATEFIELDS];
int nf,
ftype[MAXDATEFIELDS];
- char lowstr[MAXDATELEN + 1];
+ char workbuf[MAXDATELEN + 1];
- if (strlen(str) >= sizeof(lowstr))
- elog(ERROR, "Bad reltime external representation (too long) '%s'", str);
+ dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
+ field, ftype, MAXDATEFIELDS, &nf);
+ if (dterr == 0)
+ dterr = DecodeInterval(field, ftype, nf, INTERVAL_FULL_RANGE,
+ &dtype, tm, &fsec);
- if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
- || (DecodeInterval(field, ftype, nf, &dtype, tm, &fsec) != 0))
- elog(ERROR, "Bad reltime external representation '%s'", str);
+ /* 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, "reltime");
+ }
switch (dtype)
{
case DTK_DELTA:
- result = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec);
- result += ((tm->tm_year * 36525 * 864) + (((tm->tm_mon * 30) + tm->tm_mday) * 86400));
+ result = ((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec;
+ result += tm->tm_year * SECS_PER_YEAR + ((tm->tm_mon * DAYS_PER_MONTH) + tm->tm_mday) * SECS_PER_DAY;
break;
default:
- elog(ERROR, "Bad reltime (internal coding error) '%s'", str);
+ elog(ERROR, "unexpected dtype %d while parsing reltime \"%s\"",
+ dtype, str);
result = INVALID_RELTIME;
break;
}
PG_RETURN_RELATIVETIME(result);
}
-
/*
* reltimeout - converts the internal format to a reltime string
*/
{
RelativeTime time = PG_GETARG_RELATIVETIME(0);
char *result;
- struct tm tt,
+ struct pg_tm tt,
*tm = &tt;
char buf[MAXDATELEN + 1];
reltime2tm(time, tm);
- EncodeInterval(tm, 0, DateStyle, buf);
+ EncodeInterval(tm, 0, IntervalStyle, buf);
result = pstrdup(buf);
PG_RETURN_CSTRING(result);
}
+/*
+ * reltimerecv - converts external binary format to reltime
+ */
+Datum
+reltimerecv(PG_FUNCTION_ARGS)
+{
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
+
+ PG_RETURN_RELATIVETIME((RelativeTime) pq_getmsgint(buf, sizeof(RelativeTime)));
+}
+
+/*
+ * reltimesend - converts reltime to binary format
+ */
+Datum
+reltimesend(PG_FUNCTION_ARGS)
+{
+ RelativeTime time = PG_GETARG_RELATIVETIME(0);
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendint(&buf, time, sizeof(time));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+}
+
static void
-reltime2tm(RelativeTime time, struct tm * tm)
+reltime2tm(RelativeTime time, struct pg_tm * tm)
{
- TMODULO(time, tm->tm_year, 31557600);
- TMODULO(time, tm->tm_mon, 2592000);
- TMODULO(time, tm->tm_mday, 86400);
- TMODULO(time, tm->tm_hour, 3600);
- TMODULO(time, tm->tm_min, 60);
- TMODULO(time, tm->tm_sec, 1);
-
- return;
-} /* reltime2tm() */
+ double dtime = time;
+
+ FMODULO(dtime, tm->tm_year, 31557600);
+ FMODULO(dtime, tm->tm_mon, 2592000);
+ FMODULO(dtime, tm->tm_mday, SECS_PER_DAY);
+ FMODULO(dtime, tm->tm_hour, SECS_PER_HOUR);
+ FMODULO(dtime, tm->tm_min, SECS_PER_MINUTE);
+ FMODULO(dtime, tm->tm_sec, 1);
+}
/*
- * tintervalin - converts an interval string to internal format
+ * tintervalin - converts an tinterval string to internal format
*/
Datum
tintervalin(PG_FUNCTION_ARGS)
{
- char *intervalstr = PG_GETARG_CSTRING(0);
- TimeInterval interval;
+ char *tintervalstr = PG_GETARG_CSTRING(0);
+ TimeInterval tinterval;
AbsoluteTime i_start,
i_end,
t1,
t2;
- interval = (TimeInterval) palloc(sizeof(TimeIntervalData));
- if (istinterval(intervalstr, &t1, &t2) == 0)
- elog(ERROR, "Unable to decode tinterval '%s'", intervalstr);
+ parsetinterval(tintervalstr, &t1, &t2);
+
+ tinterval = (TimeInterval) palloc(sizeof(TimeIntervalData));
if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
- interval->status = T_INTERVAL_INVAL; /* undefined */
+ tinterval->status = T_INTERVAL_INVAL; /* undefined */
else
- interval->status = T_INTERVAL_VALID;
+ tinterval->status = T_INTERVAL_VALID;
i_start = ABSTIMEMIN(t1, t2);
i_end = ABSTIMEMAX(t1, t2);
- interval->data[0] = i_start;
- interval->data[1] = i_end;
+ tinterval->data[0] = i_start;
+ tinterval->data[1] = i_end;
- PG_RETURN_TIMEINTERVAL(interval);
+ PG_RETURN_TIMEINTERVAL(tinterval);
}
/*
- * tintervalout - converts an internal interval format to a string
- *
+ * tintervalout - converts an internal tinterval format to a string
*/
Datum
tintervalout(PG_FUNCTION_ARGS)
{
- TimeInterval interval = PG_GETARG_TIMEINTERVAL(0);
+ TimeInterval tinterval = PG_GETARG_TIMEINTERVAL(0);
char *i_str,
*p;
- i_str = (char *) palloc(T_INTERVAL_LEN); /* ['...' '...'] */
+ i_str = (char *) palloc(T_INTERVAL_LEN); /* ["..." "..."] */
strcpy(i_str, "[\"");
- if (interval->status == T_INTERVAL_INVAL)
+ if (tinterval->status == T_INTERVAL_INVAL)
strcat(i_str, INVALID_INTERVAL_STR);
else
{
- p = DatumGetCString(DirectFunctionCall1(nabstimeout,
- AbsoluteTimeGetDatum(interval->data[0])));
+ p = DatumGetCString(DirectFunctionCall1(abstimeout,
+ AbsoluteTimeGetDatum(tinterval->data[0])));
strcat(i_str, p);
pfree(p);
strcat(i_str, "\" \"");
- p = DatumGetCString(DirectFunctionCall1(nabstimeout,
- AbsoluteTimeGetDatum(interval->data[1])));
+ p = DatumGetCString(DirectFunctionCall1(abstimeout,
+ AbsoluteTimeGetDatum(tinterval->data[1])));
strcat(i_str, p);
pfree(p);
}
- strcat(i_str, "\"]\0");
+ strcat(i_str, "\"]");
PG_RETURN_CSTRING(i_str);
}
+/*
+ * tintervalrecv - converts external binary format to tinterval
+ */
+Datum
+tintervalrecv(PG_FUNCTION_ARGS)
+{
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
+ TimeInterval tinterval;
+ int32 status;
+
+ tinterval = (TimeInterval) palloc(sizeof(TimeIntervalData));
+
+ tinterval->status = pq_getmsgint(buf, sizeof(tinterval->status));
+ tinterval->data[0] = pq_getmsgint(buf, sizeof(tinterval->data[0]));
+ tinterval->data[1] = pq_getmsgint(buf, sizeof(tinterval->data[1]));
+
+ if (tinterval->data[0] == INVALID_ABSTIME ||
+ tinterval->data[1] == INVALID_ABSTIME)
+ status = T_INTERVAL_INVAL; /* undefined */
+ else
+ status = T_INTERVAL_VALID;
+
+ if (status != tinterval->status)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
+ errmsg("invalid status in external \"tinterval\" value")));
+
+ PG_RETURN_TIMEINTERVAL(tinterval);
+}
+
+/*
+ * tintervalsend - converts tinterval to binary format
+ */
+Datum
+tintervalsend(PG_FUNCTION_ARGS)
+{
+ TimeInterval tinterval = PG_GETARG_TIMEINTERVAL(0);
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendint(&buf, tinterval->status, sizeof(tinterval->status));
+ pq_sendint(&buf, tinterval->data[0], sizeof(tinterval->data[0]));
+ pq_sendint(&buf, tinterval->data[1], sizeof(tinterval->data[1]));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+}
+
/*****************************************************************************
* PUBLIC ROUTINES *
Interval *interval = PG_GETARG_INTERVAL_P(0);
RelativeTime time;
int year,
- month;
+ month,
+ day;
+ TimeOffset span;
-#ifdef HAVE_INT64_TIMESTAMP
- int64 span;
-
-#else
- double span;
-#endif
-
- if (interval->month == 0)
- {
- year = 0;
- month = 0;
- }
- else if (abs(interval->month) >= 12)
- {
- year = (interval->month / 12);
- month = (interval->month % 12);
- }
- else
- {
- year = 0;
- month = interval->month;
- }
+ year = interval->month / MONTHS_PER_YEAR;
+ month = interval->month % MONTHS_PER_YEAR;
+ day = interval->day;
#ifdef HAVE_INT64_TIMESTAMP
- span = ((((INT64CONST(365250000) * year) + (INT64CONST(30000000) * month))
- * INT64CONST(86400)) + interval->time);
- span /= INT64CONST(1000000);
+ span = ((INT64CONST(365250000) * year + INT64CONST(30000000) * month +
+ INT64CONST(1000000) * day) * INT64CONST(86400)) +
+ interval->time;
+ span /= USECS_PER_SEC;
#else
- span = (((((double) 365.25 * year) + ((double) 30 * month)) * 86400) + interval->time);
+ span = (DAYS_PER_YEAR * year + (double) DAYS_PER_MONTH * month + day) * SECS_PER_DAY + interval->time;
#endif
- if ((span < INT_MIN) || (span > INT_MAX))
+ if (span < INT_MIN || span > INT_MAX)
time = INVALID_RELTIME;
else
time = span;
RelativeTime reltime = PG_GETARG_RELATIVETIME(0);
Interval *result;
int year,
- month;
+ month,
+ day;
result = (Interval *) palloc(sizeof(Interval));
switch (reltime)
{
case INVALID_RELTIME:
- elog(ERROR, "Unable to convert reltime 'invalid' to interval");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("cannot convert reltime \"invalid\" to interval")));
result->time = 0;
+ result->day = 0;
result->month = 0;
break;
default:
#ifdef HAVE_INT64_TIMESTAMP
- year = (reltime / (36525 * 864));
- reltime -= (year * (36525 * 864));
- month = (reltime / (30 * 86400));
- reltime -= (month * (30 * 86400));
-
- result->time = (reltime * INT64CONST(1000000));
+ year = reltime / SECS_PER_YEAR;
+ reltime -= year * SECS_PER_YEAR;
+ month = reltime / (DAYS_PER_MONTH * SECS_PER_DAY);
+ reltime -= month * (DAYS_PER_MONTH * SECS_PER_DAY);
+ day = reltime / SECS_PER_DAY;
+ reltime -= day * SECS_PER_DAY;
+
+ result->time = (reltime * USECS_PER_SEC);
#else
- TMODULO(reltime, year, (36525 * 864));
- TMODULO(reltime, month, (30 * 86400));
+ TMODULO(reltime, year, SECS_PER_YEAR);
+ TMODULO(reltime, month, DAYS_PER_MONTH * SECS_PER_DAY);
+ TMODULO(reltime, day, SECS_PER_DAY);
result->time = reltime;
#endif
- result->month = ((12 * year) + month);
+ result->month = MONTHS_PER_YEAR * year + month;
+ result->day = day;
break;
}
AbsoluteTime t2 = PG_GETARG_ABSOLUTETIME(1);
AbsoluteTime tstart = ABSTIMEMIN(t1, t2);
AbsoluteTime tend = ABSTIMEMAX(t1, t2);
- TimeInterval interval;
+ TimeInterval tinterval;
- interval = (TimeInterval) palloc(sizeof(TimeIntervalData));
+ tinterval = (TimeInterval) palloc(sizeof(TimeIntervalData));
if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
- interval->status = T_INTERVAL_INVAL;
+ tinterval->status = T_INTERVAL_INVAL;
+
else
{
- interval->status = T_INTERVAL_VALID;
- interval->data[0] = tstart;
- interval->data[1] = tend;
+ tinterval->status = T_INTERVAL_VALID;
+ tinterval->data[0] = tstart;
+ tinterval->data[1] = tend;
}
- PG_RETURN_TIMEINTERVAL(interval);
+ PG_RETURN_TIMEINTERVAL(tinterval);
}
/*
if (AbsoluteTimeIsReal(t1) &&
RelativeTimeIsValid(t2) &&
- ((t2 > 0) ? (t1 < NOEND_ABSTIME - t2)
- : (t1 > NOSTART_ABSTIME - t2))) /* prevent overflow */
+ ((t2 > 0 && t1 < NOEND_ABSTIME - t2) ||
+ (t2 <= 0 && t1 > NOSTART_ABSTIME - t2))) /* prevent overflow */
PG_RETURN_ABSOLUTETIME(t1 + t2);
PG_RETURN_ABSOLUTETIME(INVALID_ABSTIME);
if (AbsoluteTimeIsReal(t1) &&
RelativeTimeIsValid(t2) &&
- ((t2 > 0) ? (t1 > NOSTART_ABSTIME + t2)
- : (t1 < NOEND_ABSTIME + t2))) /* prevent overflow */
+ ((t2 > 0 && t1 > NOSTART_ABSTIME + t2) ||
+ (t2 <= 0 && t1 < NOEND_ABSTIME + t2))) /* prevent overflow */
PG_RETURN_ABSOLUTETIME(t1 - t2);
PG_RETURN_ABSOLUTETIME(INVALID_ABSTIME);
/*
- * intinterval - returns true iff absolute date is in the interval
+ * intinterval - returns true iff absolute date is in the tinterval
*/
Datum
intinterval(PG_FUNCTION_ARGS)
{
AbsoluteTime t = PG_GETARG_ABSOLUTETIME(0);
- TimeInterval interval = PG_GETARG_TIMEINTERVAL(1);
+ TimeInterval tinterval = PG_GETARG_TIMEINTERVAL(1);
- if (interval->status == T_INTERVAL_VALID && t != INVALID_ABSTIME)
+ if (tinterval->status == T_INTERVAL_VALID && t != INVALID_ABSTIME)
{
if (DatumGetBool(DirectFunctionCall2(abstimege,
AbsoluteTimeGetDatum(t),
- AbsoluteTimeGetDatum(interval->data[0]))) &&
+ AbsoluteTimeGetDatum(tinterval->data[0]))) &&
DatumGetBool(DirectFunctionCall2(abstimele,
AbsoluteTimeGetDatum(t),
- AbsoluteTimeGetDatum(interval->data[1]))))
+ AbsoluteTimeGetDatum(tinterval->data[1]))))
PG_RETURN_BOOL(true);
}
PG_RETURN_BOOL(false);
}
/*
- * tintervalrel - returns relative time corresponding to interval
+ * tintervalrel - returns relative time corresponding to tinterval
*/
Datum
tintervalrel(PG_FUNCTION_ARGS)
{
- TimeInterval interval = PG_GETARG_TIMEINTERVAL(0);
- AbsoluteTime t1 = interval->data[0];
- AbsoluteTime t2 = interval->data[1];
+ TimeInterval tinterval = PG_GETARG_TIMEINTERVAL(0);
+ AbsoluteTime t1 = tinterval->data[0];
+ AbsoluteTime t2 = tinterval->data[1];
- if (interval->status != T_INTERVAL_VALID)
+ if (tinterval->status != T_INTERVAL_VALID)
PG_RETURN_RELATIVETIME(INVALID_RELTIME);
if (AbsoluteTimeIsReal(t1) &&
Datum
timenow(PG_FUNCTION_ARGS)
{
- time_t sec;
-
- if (time(&sec) < 0)
- PG_RETURN_ABSOLUTETIME(INVALID_ABSTIME);
-
- PG_RETURN_ABSOLUTETIME((AbsoluteTime) sec);
+ PG_RETURN_ABSOLUTETIME(GetCurrentAbsoluteTime());
}
/*
- * reltimeeq - returns true iff arguments are equal
- * reltimene - returns true iff arguments are not equal
- * reltimelt - returns true iff t1 less than t2
- * reltimegt - returns true iff t1 greater than t2
- * reltimele - returns true iff t1 less than or equal to t2
- * reltimege - returns true iff t1 greater than or equal to t2
+ * reltime comparison routines
*/
+static int
+reltime_cmp_internal(RelativeTime a, RelativeTime b)
+{
+ /*
+ * We consider all INVALIDs to be equal and larger than any non-INVALID.
+ * This is somewhat arbitrary; the important thing is to have a consistent
+ * sort order.
+ */
+ if (a == INVALID_RELTIME)
+ {
+ if (b == INVALID_RELTIME)
+ return 0; /* INVALID = INVALID */
+ else
+ return 1; /* INVALID > non-INVALID */
+ }
+
+ if (b == INVALID_RELTIME)
+ return -1; /* non-INVALID < INVALID */
+
+ if (a > b)
+ return 1;
+ else if (a == b)
+ return 0;
+ else
+ return -1;
+}
+
Datum
reltimeeq(PG_FUNCTION_ARGS)
{
RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
RelativeTime t2 = PG_GETARG_RELATIVETIME(1);
- if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
- PG_RETURN_BOOL(false);
- PG_RETURN_BOOL(t1 == t2);
+ PG_RETURN_BOOL(reltime_cmp_internal(t1, t2) == 0);
}
Datum
RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
RelativeTime t2 = PG_GETARG_RELATIVETIME(1);
- if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
- PG_RETURN_BOOL(false);
- PG_RETURN_BOOL(t1 != t2);
+ PG_RETURN_BOOL(reltime_cmp_internal(t1, t2) != 0);
}
Datum
RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
RelativeTime t2 = PG_GETARG_RELATIVETIME(1);
- if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
- PG_RETURN_BOOL(false);
- PG_RETURN_BOOL(t1 < t2);
+ PG_RETURN_BOOL(reltime_cmp_internal(t1, t2) < 0);
}
Datum
RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
RelativeTime t2 = PG_GETARG_RELATIVETIME(1);
- if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
- PG_RETURN_BOOL(false);
- PG_RETURN_BOOL(t1 > t2);
+ PG_RETURN_BOOL(reltime_cmp_internal(t1, t2) > 0);
}
Datum
RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
RelativeTime t2 = PG_GETARG_RELATIVETIME(1);
- if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
- PG_RETURN_BOOL(false);
- PG_RETURN_BOOL(t1 <= t2);
+ PG_RETURN_BOOL(reltime_cmp_internal(t1, t2) <= 0);
}
Datum
RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
RelativeTime t2 = PG_GETARG_RELATIVETIME(1);
- if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
- PG_RETURN_BOOL(false);
- PG_RETURN_BOOL(t1 >= t2);
+ PG_RETURN_BOOL(reltime_cmp_internal(t1, t2) >= 0);
+}
+
+Datum
+btreltimecmp(PG_FUNCTION_ARGS)
+{
+ RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
+ RelativeTime t2 = PG_GETARG_RELATIVETIME(1);
+
+ PG_RETURN_INT32(reltime_cmp_internal(t1, t2));
}
/*
- * tintervalsame - returns true iff interval i1 is same as interval i2
+ * tintervalsame - returns true iff tinterval i1 is same as tinterval i2
* Check begin and end time.
*/
Datum
PG_RETURN_BOOL(false);
if (DatumGetBool(DirectFunctionCall2(abstimeeq,
- AbsoluteTimeGetDatum(i1->data[0]),
- AbsoluteTimeGetDatum(i2->data[0]))) &&
+ AbsoluteTimeGetDatum(i1->data[0]),
+ AbsoluteTimeGetDatum(i2->data[0]))) &&
DatumGetBool(DirectFunctionCall2(abstimeeq,
- AbsoluteTimeGetDatum(i1->data[1]),
- AbsoluteTimeGetDatum(i2->data[1]))))
+ AbsoluteTimeGetDatum(i1->data[1]),
+ AbsoluteTimeGetDatum(i2->data[1]))))
PG_RETURN_BOOL(true);
PG_RETURN_BOOL(false);
}
-
/*
- * tintervaleq - returns true iff interval i1 is equal to interval i2
- * Check length of intervals.
+ * tinterval comparison routines
+ *
+ * Note: comparison is based only on the lengths of the tintervals, not on
+ * endpoint values (as long as they're not INVALID). This is pretty bogus,
+ * but since it's only a legacy datatype, we're not going to change it.
+ *
+ * Some other bogus things that won't be changed for compatibility reasons:
+ * 1. The interval length computations overflow at 2^31 seconds, causing
+ * intervals longer than that to sort oddly compared to those shorter.
+ * 2. infinity and minus infinity (NOEND_ABSTIME and NOSTART_ABSTIME) are
+ * just ordinary integers. Since this code doesn't handle them specially,
+ * it's possible for [a b] to be considered longer than [c infinity] for
+ * finite abstimes a, b, c. In combination with the previous point, the
+ * interval [-infinity infinity] is treated as being shorter than many finite
+ * intervals :-(
+ *
+ * If tinterval is ever reimplemented atop timestamp, it'd be good to give
+ * some consideration to avoiding these problems.
*/
-Datum
-tintervaleq(PG_FUNCTION_ARGS)
+static int
+tinterval_cmp_internal(TimeInterval a, TimeInterval b)
{
- TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
- TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);
- AbsoluteTime t10,
- t11,
- t20,
- t21;
+ bool a_invalid;
+ bool b_invalid;
+ AbsoluteTime a_len;
+ AbsoluteTime b_len;
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- PG_RETURN_BOOL(false);
+ /*
+ * We consider all INVALIDs to be equal and larger than any non-INVALID.
+ * This is somewhat arbitrary; the important thing is to have a consistent
+ * sort order.
+ */
+ a_invalid = a->status == T_INTERVAL_INVAL ||
+ a->data[0] == INVALID_ABSTIME ||
+ a->data[1] == INVALID_ABSTIME;
+ b_invalid = b->status == T_INTERVAL_INVAL ||
+ b->data[0] == INVALID_ABSTIME ||
+ b->data[1] == INVALID_ABSTIME;
+
+ if (a_invalid)
+ {
+ if (b_invalid)
+ return 0; /* INVALID = INVALID */
+ else
+ return 1; /* INVALID > non-INVALID */
+ }
- t10 = i1->data[0];
- t11 = i1->data[1];
- t20 = i2->data[0];
- t21 = i2->data[1];
+ if (b_invalid)
+ return -1; /* non-INVALID < INVALID */
- if ((t10 == INVALID_ABSTIME) || (t11 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
- PG_RETURN_BOOL(false);
+ a_len = a->data[1] - a->data[0];
+ b_len = b->data[1] - b->data[0];
- PG_RETURN_BOOL((t11 - t10) == (t21 - t20));
+ if (a_len > b_len)
+ return 1;
+ else if (a_len == b_len)
+ return 0;
+ else
+ return -1;
}
Datum
-tintervalne(PG_FUNCTION_ARGS)
+tintervaleq(PG_FUNCTION_ARGS)
{
TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);
- AbsoluteTime t10,
- t11,
- t20,
- t21;
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- PG_RETURN_BOOL(false);
-
- t10 = i1->data[0];
- t11 = i1->data[1];
- t20 = i2->data[0];
- t21 = i2->data[1];
+ PG_RETURN_BOOL(tinterval_cmp_internal(i1, i2) == 0);
+}
- if ((t10 == INVALID_ABSTIME) || (t11 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
- PG_RETURN_BOOL(false);
+Datum
+tintervalne(PG_FUNCTION_ARGS)
+{
+ TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
+ TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);
- PG_RETURN_BOOL((t11 - t10) != (t21 - t20));
+ PG_RETURN_BOOL(tinterval_cmp_internal(i1, i2) != 0);
}
Datum
{
TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);
- AbsoluteTime t10,
- t11,
- t20,
- t21;
-
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- PG_RETURN_BOOL(false);
-
- t10 = i1->data[0];
- t11 = i1->data[1];
- t20 = i2->data[0];
- t21 = i2->data[1];
-
- if ((t10 == INVALID_ABSTIME) || (t11 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
- PG_RETURN_BOOL(false);
- PG_RETURN_BOOL((t11 - t10) < (t21 - t20));
+ PG_RETURN_BOOL(tinterval_cmp_internal(i1, i2) < 0);
}
Datum
{
TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);
- AbsoluteTime t10,
- t11,
- t20,
- t21;
-
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- PG_RETURN_BOOL(false);
-
- t10 = i1->data[0];
- t11 = i1->data[1];
- t20 = i2->data[0];
- t21 = i2->data[1];
- if ((t10 == INVALID_ABSTIME) || (t11 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
- PG_RETURN_BOOL(false);
-
- PG_RETURN_BOOL((t11 - t10) <= (t21 - t20));
+ PG_RETURN_BOOL(tinterval_cmp_internal(i1, i2) <= 0);
}
Datum
{
TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);
- AbsoluteTime t10,
- t11,
- t20,
- t21;
-
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- PG_RETURN_BOOL(false);
- t10 = i1->data[0];
- t11 = i1->data[1];
- t20 = i2->data[0];
- t21 = i2->data[1];
-
- if ((t10 == INVALID_ABSTIME) || (t11 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
- PG_RETURN_BOOL(false);
-
- PG_RETURN_BOOL((t11 - t10) > (t21 - t20));
+ PG_RETURN_BOOL(tinterval_cmp_internal(i1, i2) > 0);
}
Datum
{
TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);
- AbsoluteTime t10,
- t11,
- t20,
- t21;
-
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- PG_RETURN_BOOL(false);
- t10 = i1->data[0];
- t11 = i1->data[1];
- t20 = i2->data[0];
- t21 = i2->data[1];
+ PG_RETURN_BOOL(tinterval_cmp_internal(i1, i2) >= 0);
+}
- if ((t10 == INVALID_ABSTIME) || (t11 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
- PG_RETURN_BOOL(false);
+Datum
+bttintervalcmp(PG_FUNCTION_ARGS)
+{
+ TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
+ TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);
- PG_RETURN_BOOL((t11 - t10) >= (t21 - t20));
+ PG_RETURN_INT32(tinterval_cmp_internal(i1, i2));
}
/*
- * tintervalleneq - returns true iff length of interval i is equal to
+ * tintervalleneq - returns true iff length of tinterval i is equal to
* reltime t
- * tintervallenne - returns true iff length of interval i is not equal
+ * tintervallenne - returns true iff length of tinterval i is not equal
* to reltime t
- * tintervallenlt - returns true iff length of interval i is less than
+ * tintervallenlt - returns true iff length of tinterval i is less than
* reltime t
- * tintervallengt - returns true iff length of interval i is greater
+ * tintervallengt - returns true iff length of tinterval i is greater
* than reltime t
- * tintervallenle - returns true iff length of interval i is less or
+ * tintervallenle - returns true iff length of tinterval i is less or
* equal than reltime t
- * tintervallenge - returns true iff length of interval i is greater or
+ * tintervallenge - returns true iff length of tinterval i is greater or
* equal than reltime t
*/
Datum
if (i->status == T_INTERVAL_INVAL || t == INVALID_RELTIME)
PG_RETURN_BOOL(false);
rt = DatumGetRelativeTime(DirectFunctionCall1(tintervalrel,
- TimeIntervalGetDatum(i)));
- PG_RETURN_BOOL((rt != INVALID_RELTIME) && (rt == t));
+ TimeIntervalGetDatum(i)));
+ PG_RETURN_BOOL(rt != INVALID_RELTIME && rt == t);
}
Datum
if (i->status == T_INTERVAL_INVAL || t == INVALID_RELTIME)
PG_RETURN_BOOL(false);
rt = DatumGetRelativeTime(DirectFunctionCall1(tintervalrel,
- TimeIntervalGetDatum(i)));
- PG_RETURN_BOOL((rt != INVALID_RELTIME) && (rt != t));
+ TimeIntervalGetDatum(i)));
+ PG_RETURN_BOOL(rt != INVALID_RELTIME && rt != t);
}
Datum
if (i->status == T_INTERVAL_INVAL || t == INVALID_RELTIME)
PG_RETURN_BOOL(false);
rt = DatumGetRelativeTime(DirectFunctionCall1(tintervalrel,
- TimeIntervalGetDatum(i)));
- PG_RETURN_BOOL((rt != INVALID_RELTIME) && (rt < t));
+ TimeIntervalGetDatum(i)));
+ PG_RETURN_BOOL(rt != INVALID_RELTIME && rt < t);
}
Datum
if (i->status == T_INTERVAL_INVAL || t == INVALID_RELTIME)
PG_RETURN_BOOL(false);
rt = DatumGetRelativeTime(DirectFunctionCall1(tintervalrel,
- TimeIntervalGetDatum(i)));
- PG_RETURN_BOOL((rt != INVALID_RELTIME) && (rt > t));
+ TimeIntervalGetDatum(i)));
+ PG_RETURN_BOOL(rt != INVALID_RELTIME && rt > t);
}
Datum
if (i->status == T_INTERVAL_INVAL || t == INVALID_RELTIME)
PG_RETURN_BOOL(false);
rt = DatumGetRelativeTime(DirectFunctionCall1(tintervalrel,
- TimeIntervalGetDatum(i)));
- PG_RETURN_BOOL((rt != INVALID_RELTIME) && (rt <= t));
+ TimeIntervalGetDatum(i)));
+ PG_RETURN_BOOL(rt != INVALID_RELTIME && rt <= t);
}
Datum
if (i->status == T_INTERVAL_INVAL || t == INVALID_RELTIME)
PG_RETURN_BOOL(false);
rt = DatumGetRelativeTime(DirectFunctionCall1(tintervalrel,
- TimeIntervalGetDatum(i)));
- PG_RETURN_BOOL((rt != INVALID_RELTIME) && (rt >= t));
+ TimeIntervalGetDatum(i)));
+ PG_RETURN_BOOL(rt != INVALID_RELTIME && rt >= t);
}
/*
- * tintervalct - returns true iff interval i1 contains interval i2
+ * tintervalct - returns true iff tinterval i1 contains tinterval i2
*/
Datum
tintervalct(PG_FUNCTION_ARGS)
if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
PG_RETURN_BOOL(false);
if (DatumGetBool(DirectFunctionCall2(abstimele,
- AbsoluteTimeGetDatum(i1->data[0]),
- AbsoluteTimeGetDatum(i2->data[0]))) &&
+ AbsoluteTimeGetDatum(i1->data[0]),
+ AbsoluteTimeGetDatum(i2->data[0]))) &&
DatumGetBool(DirectFunctionCall2(abstimege,
- AbsoluteTimeGetDatum(i1->data[1]),
- AbsoluteTimeGetDatum(i2->data[1]))))
+ AbsoluteTimeGetDatum(i1->data[1]),
+ AbsoluteTimeGetDatum(i2->data[1]))))
PG_RETURN_BOOL(true);
PG_RETURN_BOOL(false);
}
/*
- * tintervalov - returns true iff interval i1 (partially) overlaps i2
+ * tintervalov - returns true iff tinterval i1 (partially) overlaps i2
*/
Datum
tintervalov(PG_FUNCTION_ARGS)
if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
PG_RETURN_BOOL(false);
if (DatumGetBool(DirectFunctionCall2(abstimelt,
- AbsoluteTimeGetDatum(i1->data[1]),
- AbsoluteTimeGetDatum(i2->data[0]))) ||
+ AbsoluteTimeGetDatum(i1->data[1]),
+ AbsoluteTimeGetDatum(i2->data[0]))) ||
DatumGetBool(DirectFunctionCall2(abstimegt,
- AbsoluteTimeGetDatum(i1->data[0]),
- AbsoluteTimeGetDatum(i2->data[1]))))
+ AbsoluteTimeGetDatum(i1->data[0]),
+ AbsoluteTimeGetDatum(i2->data[1]))))
PG_RETURN_BOOL(false);
PG_RETURN_BOOL(true);
}
/*
- * tintervalstart - returns the start of interval i
+ * tintervalstart - returns the start of tinterval i
*/
Datum
tintervalstart(PG_FUNCTION_ARGS)
}
/*
- * tintervalend - returns the end of interval i
+ * tintervalend - returns the end of tinterval i
*/
Datum
tintervalend(PG_FUNCTION_ARGS)
*****************************************************************************/
/*
- * istinterval - returns 1, iff i_string is a valid interval descr.
- * 0, iff i_string is NOT a valid interval desc.
- * 2, iff any time is INVALID_ABSTIME
+ * parsetinterval -- parse a tinterval string
*
- * output parameter:
- * i_start, i_end: interval margins
+ * output parameters:
+ * i_start, i_end: tinterval margins
*
* Time interval:
* `[' {` '} `'' <AbsTime> `'' {` '} `'' <AbsTime> `'' {` '} `]'
*
* e.g. [ ' Jan 18 1902' 'Jan 1 00:00:00 1970']
*/
-static int
-istinterval(char *i_string,
- AbsoluteTime *i_start,
- AbsoluteTime *i_end)
+static void
+parsetinterval(char *i_string,
+ AbsoluteTime *i_start,
+ AbsoluteTime *i_end)
{
char *p,
*p1;
if (IsSpace(c))
p++;
else if (c != '[')
- return 0; /* syntax error */
+ goto bogus; /* syntax error */
else
break;
}
+ if (c == '\0')
+ goto bogus; /* syntax error */
p++;
- /* skip leading blanks up to "'" */
+ /* skip leading blanks up to '"' */
while ((c = *p) != '\0')
{
if (IsSpace(c))
p++;
else if (c != '"')
- return 0; /* syntax error */
+ goto bogus; /* syntax error */
else
break;
}
+ if (c == '\0')
+ goto bogus; /* syntax error */
p++;
if (strncmp(INVALID_INTERVAL_STR, p, strlen(INVALID_INTERVAL_STR)) == 0)
- return 0; /* undefined range, handled like a syntax
- * err. */
- /* search for the end of the first date and change it to a NULL */
+ goto bogus; /* undefined range, handled like a syntax err. */
+ /* search for the end of the first date and change it to a \0 */
p1 = p;
while ((c = *p1) != '\0')
{
if (c == '"')
- {
- *p1 = '\0';
break;
- }
p1++;
}
+ if (c == '\0')
+ goto bogus; /* syntax error */
+ *p1 = '\0';
/* get the first date */
- *i_start = DatumGetAbsoluteTime(DirectFunctionCall1(nabstimein,
- CStringGetDatum(p)));
- /* rechange NULL at the end of the first date to a "'" */
- *p1 = '"';
+ *i_start = DatumGetAbsoluteTime(DirectFunctionCall1(abstimein,
+ CStringGetDatum(p)));
+ /* undo change to \0 */
+ *p1 = c;
p = ++p1;
- /* skip blanks up to "'", beginning of second date */
+ /* skip blanks up to '"', beginning of second date */
while ((c = *p) != '\0')
{
if (IsSpace(c))
p++;
else if (c != '"')
- return 0; /* syntax error */
+ goto bogus; /* syntax error */
else
break;
}
+ if (c == '\0')
+ goto bogus; /* syntax error */
p++;
- /* search for the end of the second date and change it to a NULL */
+ /* search for the end of the second date and change it to a \0 */
p1 = p;
while ((c = *p1) != '\0')
{
if (c == '"')
- {
- *p1 = '\0';
break;
- }
p1++;
}
+ if (c == '\0')
+ goto bogus; /* syntax error */
+ *p1 = '\0';
/* get the second date */
- *i_end = DatumGetAbsoluteTime(DirectFunctionCall1(nabstimein,
- CStringGetDatum(p)));
- /* rechange NULL at the end of the first date to a ''' */
- *p1 = '"';
+ *i_end = DatumGetAbsoluteTime(DirectFunctionCall1(abstimein,
+ CStringGetDatum(p)));
+ /* undo change to \0 */
+ *p1 = c;
p = ++p1;
/* skip blanks up to ']' */
while ((c = *p) != '\0')
if (IsSpace(c))
p++;
else if (c != ']')
- return 0; /* syntax error */
+ goto bogus; /* syntax error */
else
break;
}
+ if (c == '\0')
+ goto bogus; /* syntax error */
p++;
c = *p;
if (c != '\0')
- return 0; /* syntax error */
- /* it seems to be a valid interval */
- return 1;
+ goto bogus; /* syntax error */
+
+ /* it seems to be a valid tinterval */
+ return;
+
+bogus:
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
+ errmsg("invalid input syntax for type tinterval: \"%s\"",
+ i_string)));
+ *i_start = *i_end = INVALID_ABSTIME; /* keep compiler quiet */
}
timeofday(PG_FUNCTION_ARGS)
{
struct timeval tp;
- struct timezone tpz;
- char templ[100];
- char buf[100];
- text *result;
- int len;
-
- gettimeofday(&tp, &tpz);
- strftime(templ, sizeof(templ), "%a %b %d %H:%M:%S.%%06d %Y %Z",
- localtime((time_t *) &tp.tv_sec));
+ char templ[128];
+ char buf[128];
+ pg_time_t tt;
+
+ gettimeofday(&tp, NULL);
+ tt = (pg_time_t) tp.tv_sec;
+ pg_strftime(templ, sizeof(templ), "%a %b %d %H:%M:%S.%%06d %Y %Z",
+ pg_localtime(&tt, session_timezone));
snprintf(buf, sizeof(buf), templ, tp.tv_usec);
- len = VARHDRSZ + strlen(buf);
- result = (text *) palloc(len);
- VARATT_SIZEP(result) = len;
- memcpy(VARDATA(result), buf, strlen(buf));
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(buf));
}
projects / postgresql / blobdiff