/*-------------------------------------------------------------------------
*
* date.c
- * Utilities for the built-in type "AbsoluteTime" (defined in nabstime).
- * Functions for the built-in type "RelativeTime".
- * Functions for the built-in type "TimeInterval".
+ * implements DATE and TIME data types specified in SQL-92 standard
*
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
- * Portions Copyright (c) 1994, Regents of the University of California
+ * Portions Copyright (c) 1994-5, Regents of the University of California
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.41 2000/01/26 05:57:13 momjian Exp $
- *
- * NOTES
- * This code is actually (almost) unused.
- * It needs to be integrated with Time and struct trange.
- *
- * XXX This code needs to be rewritten to work with the "new" definitions
- * XXX in h/tim.h. Look for int32's, int, long, etc. in the code. The
- * XXX definitions in h/tim.h may need to be rethought also.
- *
- * XXX This code has been cleaned up some - avi 07/07/93
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.42 2000/02/16 18:17:02 thomas Exp $
*
*-------------------------------------------------------------------------
*/
-#include <ctype.h>
-#include <time.h>
-#include <sys/time.h>
-#include <sys/types.h>
+#include <limits.h>
#include "postgres.h"
#ifdef HAVE_FLOAT_H
#include <float.h>
#endif
-#ifdef HAVE_LIMITS_H
-#include <limits.h>
-#ifndef MAXINT
-#define MAXINT INT_MAX
-#endif
-#else
-#ifdef HAVE_VALUES_H
-#include <values.h>
-#endif
-#endif
-
-#include "access/xact.h"
#include "miscadmin.h"
#include "utils/builtins.h"
-#include "utils/dt.h"
-
-#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 */
-/*
- * ['Mon May 10 23:59:12 1943 PST' 'Sun Jan 14 03:14:21 1973 PST']
- * 0 1 2 3 4 5 6
- * 1234567890123456789012345678901234567890123456789012345678901234
- *
- * we allocate some extra -- timezones are usually 3 characters but
- * this is not in the POSIX standard...
- */
-#define T_INTERVAL_LEN 80
-#define INVALID_INTERVAL_STR "Undefined Range"
-#define INVALID_INTERVAL_STR_LEN (sizeof(INVALID_INTERVAL_STR)-1)
-
-#define ABSTIMEMIN(t1, t2) abstimele((t1),(t2)) ? (t1) : (t2)
-#define ABSTIMEMAX(t1, t2) abstimelt((t1),(t2)) ? (t2) : (t1)
-
-#ifdef NOT_USED
-static char *unit_tab[] = {
- "second", "seconds", "minute", "minutes",
- "hour", "hours", "day", "days", "week", "weeks",
-"month", "months", "year", "years"};
-
-#define UNITMAXLEN 7 /* max length of a unit name */
-#define NUNITS 14 /* number of different units */
-
-/* table of seconds per unit (month = 30 days, year = 365 days) */
-static int sec_tab[] = {
- 1, 1, 60, 60,
- 3600, 3600, 86400, 86400, 604800, 604800,
-2592000, 2592000, 31536000, 31536000};
-
-#endif
-
-/*
- * Function prototypes -- internal to this file only
- */
-static void reltime2tm(RelativeTime time, struct tm * tm);
-
-#ifdef NOT_USED
-static int correct_unit(char *unit, int *unptr);
-static int correct_dir(char *direction, int *signptr);
-
-#endif
+static int
+date2tm(DateADT dateVal, int *tzp, struct tm * tm, double *fsec, char **tzn);
-static int istinterval(char *i_string,
- AbsoluteTime *i_start,
- AbsoluteTime *i_end);
/*****************************************************************************
- * USER I/O ROUTINES *
+ * Date ADT
*****************************************************************************/
-/*
- * reltimein - converts a reltime string in an internal format
+
+/* date_in()
+ * Given date text string, convert to internal date format.
*/
-RelativeTime
-reltimein(char *str)
+DateADT
+date_in(char *str)
{
- RelativeTime result;
-
+ DateADT date;
+ double fsec;
struct tm tt,
*tm = &tt;
- double fsec;
+ int tzp;
int dtype;
+ int nf;
char *field[MAXDATEFIELDS];
- int nf,
- ftype[MAXDATEFIELDS];
+ int ftype[MAXDATEFIELDS];
char lowstr[MAXDATELEN + 1];
if (!PointerIsValid(str))
elog(ERROR, "Bad (null) date external representation");
- if (strlen(str) > MAXDATELEN)
- elog(ERROR, "Bad (length) reltime external representation '%s'", str);
-
if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
- || (DecodeDateDelta(field, ftype, nf, &dtype, tm, &fsec) != 0))
- elog(ERROR, "Bad reltime external representation '%s'", str);
+ || (DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tzp) != 0))
+ elog(ERROR, "Bad date external representation '%s'", str);
switch (dtype)
{
- case DTK_DELTA:
- result = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec);
- result += (((tm->tm_year * 365) + (tm->tm_mon * 30) + tm->tm_mday) * (24 * 60 * 60));
- return result;
+ case DTK_DATE:
+ break;
+
+ case DTK_CURRENT:
+ GetCurrentTime(tm);
+ break;
+
+ case DTK_EPOCH:
+ tm->tm_year = 1970;
+ tm->tm_mon = 1;
+ tm->tm_mday = 1;
+ break;
default:
- return INVALID_RELTIME;
+ elog(ERROR, "Unrecognized date external representation '%s'", str);
}
- elog(ERROR, "Bad reltime (internal coding error) '%s'", str);
- return INVALID_RELTIME;
-} /* reltimein() */
+ date = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1));
+ return date;
+} /* date_in() */
-/*
- * reltimeout - converts the internal format to a reltime string
+/* date_out()
+ * Given internal format date, convert to text string.
*/
char *
-reltimeout(RelativeTime time)
+date_out(DateADT date)
{
char *result;
struct tm tt,
*tm = &tt;
char buf[MAXDATELEN + 1];
- if (time == INVALID_RELTIME)
- {
- strcpy(buf, INVALID_RELTIME_STR);
+ j2date((date + date2j(2000, 1, 1)),
+ &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
- }
- else
- {
- reltime2tm(time, tm);
- EncodeTimeSpan(tm, 0, DateStyle, buf);
- }
+ EncodeDateOnly(tm, DateStyle, buf);
result = palloc(strlen(buf) + 1);
+
strcpy(result, buf);
return result;
-} /* reltimeout() */
-
-
-#define TMODULO(t,q,u) \
-do { \
- q = (t / u); \
- if (q != 0) t -= (q * u); \
-} while(0)
-
-static void
-reltime2tm(RelativeTime time, struct tm * tm)
-{
- TMODULO(time, tm->tm_year, 31536000);
- 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() */
+} /* date_out() */
-#ifdef NOT_USED
-int
-dummyfunc()
+bool
+date_eq(DateADT dateVal1, DateADT dateVal2)
{
- char *timestring;
- long quantity;
- int i;
- int unitnr;
-
- timestring = (char *) palloc(Max(strlen(INVALID_RELTIME_STR),
- UNITMAXLEN) + 1);
- if (timevalue == INVALID_RELTIME)
- {
- strcpy(timestring, INVALID_RELTIME_STR);
- return timestring;
- }
-
- if (timevalue == 0)
- i = 1; /* unit = 'seconds' */
- else
- for (i = 12; i >= 0; i = i - 2)
- if ((timevalue % sec_tab[i]) == 0)
- break; /* appropriate unit found */
- unitnr = i;
- quantity = (timevalue / sec_tab[unitnr]);
- if (quantity > 1 || quantity < -1)
- unitnr++; /* adjust index for PLURAL of unit */
- if (quantity >= 0)
- sprintf(timestring, "%c %lu %s", RELTIME_LABEL,
- quantity, unit_tab[unitnr]);
- else
- sprintf(timestring, "%c %lu %s %s", RELTIME_LABEL,
- (quantity * -1), unit_tab[unitnr], RELTIME_PAST);
- return timestring;
+ return dateVal1 == dateVal2;
}
-#endif
-
-
-/*
- * tintervalin - converts an interval string to an internal format
- */
-TimeInterval
-tintervalin(char *intervalstr)
+bool
+date_ne(DateADT dateVal1, DateADT dateVal2)
{
- int error;
- AbsoluteTime i_start,
- i_end,
- t1,
- t2;
- TimeInterval interval;
-
- interval = (TimeInterval) palloc(sizeof(TimeIntervalData));
- error = istinterval(intervalstr, &t1, &t2);
- if (error == 0)
- interval->status = T_INTERVAL_INVAL;
- if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
- interval->status = T_INTERVAL_INVAL; /* undefined */
- else
- {
- i_start = ABSTIMEMIN(t1, t2);
- i_end = ABSTIMEMAX(t1, t2);
- interval->data[0] = i_start;
- interval->data[1] = i_end;
- interval->status = T_INTERVAL_VALID;
- }
- return interval;
+ return dateVal1 != dateVal2;
}
-
-/*
- * tintervalout - converts an internal interval format to a string
- *
- */
-char *
-tintervalout(TimeInterval interval)
+bool
+date_lt(DateADT dateVal1, DateADT dateVal2)
{
- char *i_str,
- *p;
-
- i_str = (char *) palloc(T_INTERVAL_LEN); /* ['...' '...'] */
- strcpy(i_str, "[\"");
- if (interval->status == T_INTERVAL_INVAL)
- strcat(i_str, INVALID_INTERVAL_STR);
- else
- {
- p = nabstimeout(interval->data[0]);
- strcat(i_str, p);
- pfree(p);
- strcat(i_str, "\" \"");
- p = nabstimeout(interval->data[1]);
- strcat(i_str, p);
- pfree(p);
- }
- strcat(i_str, "\"]\0");
- return i_str;
-}
-
-
-/*****************************************************************************
- * PUBLIC ROUTINES *
- *****************************************************************************/
+ return dateVal1 < dateVal2;
+} /* date_lt() */
-RelativeTime
-timespan_reltime(TimeSpan *timespan)
+bool
+date_le(DateADT dateVal1, DateADT dateVal2)
{
- RelativeTime time;
- int year,
- month;
- double span;
-
- if (!PointerIsValid(timespan))
- time = INVALID_RELTIME;
-
- if (TIMESPAN_IS_INVALID(*timespan))
- {
- time = INVALID_RELTIME;
-
- }
- else
- {
- if (timespan->month == 0)
- {
- year = 0;
- month = 0;
-
- }
- else if (abs(timespan->month) >= 12)
- {
- year = (timespan->month / 12);
- month = (timespan->month % 12);
-
- }
- else
- {
- year = 0;
- month = timespan->month;
- }
-
- span = (((((double) 365 * year) + ((double) 30 * month)) * 86400) + timespan->time);
-
- time = (((span > INT_MIN) && (span < INT_MAX)) ? span : INVALID_RELTIME);
- }
+ return dateVal1 <= dateVal2;
+} /* date_le() */
- return time;
-} /* timespan_reltime() */
-
-
-TimeSpan *
-reltime_timespan(RelativeTime reltime)
+bool
+date_gt(DateADT dateVal1, DateADT dateVal2)
{
- TimeSpan *result;
- int year,
- month;
-
- if (!PointerIsValid(result = palloc(sizeof(TimeSpan))))
- elog(ERROR, "Memory allocation failed, can't convert reltime to timespan");
-
- switch (reltime)
- {
- case INVALID_RELTIME:
- TIMESPAN_INVALID(*result);
- break;
-
- default:
- TMODULO(reltime, year, 31536000);
- TMODULO(reltime, month, 2592000);
-
- result->time = reltime;
- result->month = ((12 * year) + month);
- }
-
- return result;
-} /* reltime_timespan() */
+ return dateVal1 > dateVal2;
+} /* date_gt() */
+bool
+date_ge(DateADT dateVal1, DateADT dateVal2)
+{
+ return dateVal1 >= dateVal2;
+} /* date_ge() */
-/*
- * mktinterval - creates a time interval with endpoints t1 and t2
- */
-TimeInterval
-mktinterval(AbsoluteTime t1, AbsoluteTime t2)
+int
+date_cmp(DateADT dateVal1, DateADT dateVal2)
{
- AbsoluteTime tstart = ABSTIMEMIN(t1, t2),
- tend = ABSTIMEMAX(t1, t2);
- TimeInterval interval;
+ if (dateVal1 < dateVal2)
+ return -1;
+ else if (dateVal1 > dateVal2)
+ return 1;
+ return 0;
+} /* date_cmp() */
- interval = (TimeInterval) palloc(sizeof(TimeIntervalData));
- if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
- interval->status = T_INTERVAL_INVAL;
- else
- {
- interval->status = T_INTERVAL_VALID;
- interval->data[0] = tstart;
- interval->data[1] = tend;
- }
+DateADT
+date_larger(DateADT dateVal1, DateADT dateVal2)
+{
+ return date_gt(dateVal1, dateVal2) ? dateVal1 : dateVal2;
+} /* date_larger() */
- return interval;
-}
+DateADT
+date_smaller(DateADT dateVal1, DateADT dateVal2)
+{
+ return date_lt(dateVal1, dateVal2) ? dateVal1 : dateVal2;
+} /* date_smaller() */
-/*
- * timepl, timemi and abstimemi use the formula
- * abstime + reltime = abstime
- * so abstime - reltime = abstime
- * and abstime - abstime = reltime
+/* Compute difference between two dates in days.
*/
+int4
+date_mi(DateADT dateVal1, DateADT dateVal2)
+{
+ return dateVal1 - dateVal2;
+} /* date_mi() */
-/*
- * timepl - returns the value of (abstime t1 + relime t2)
+/* Add a number of days to a date, giving a new date.
+ * Must handle both positive and negative numbers of days.
*/
-AbsoluteTime
-timepl(AbsoluteTime t1, RelativeTime t2)
+DateADT
+date_pli(DateADT dateVal, int4 days)
{
- if (t1 == CURRENT_ABSTIME)
- t1 = GetCurrentTransactionStartTime();
-
- if (AbsoluteTimeIsReal(t1) &&
- RelativeTimeIsValid(t2) &&
- ((t2 > 0) ? (t1 < NOEND_ABSTIME - t2)
- : (t1 > NOSTART_ABSTIME - t2))) /* prevent overflow */
- return t1 + t2;
+ return dateVal + days;
+} /* date_pli() */
- return INVALID_ABSTIME;
-}
-
-
-/*
- * timemi - returns the value of (abstime t1 - reltime t2)
+/* Subtract a number of days from a date, giving a new date.
*/
-AbsoluteTime
-timemi(AbsoluteTime t1, RelativeTime t2)
+DateADT
+date_mii(DateADT dateVal, int4 days)
{
- if (t1 == CURRENT_ABSTIME)
- t1 = GetCurrentTransactionStartTime();
-
- if (AbsoluteTimeIsReal(t1) &&
- RelativeTimeIsValid(t2) &&
- ((t2 > 0) ? (t1 > NOSTART_ABSTIME + t2)
- : (t1 < NOEND_ABSTIME + t2))) /* prevent overflow */
- return t1 - t2;
-
- return INVALID_ABSTIME;
-}
+ return date_pli(dateVal, -days);
+} /* date_mii() */
-/*
- * abstimemi - returns the value of (abstime t1 - abstime t2)
+/* date_timestamp()
+ * Convert date to timestamp data type.
*/
-static RelativeTime
-abstimemi(AbsoluteTime t1, AbsoluteTime t2)
+Timestamp *
+date_timestamp(DateADT dateVal)
{
- if (t1 == CURRENT_ABSTIME)
- t1 = GetCurrentTransactionStartTime();
- if (t2 == CURRENT_ABSTIME)
- t2 = GetCurrentTransactionStartTime();
+ Timestamp *result;
+ struct tm tt,
+ *tm = &tt;
+ int tz;
+ double fsec = 0;
+ char *tzn;
- if (AbsoluteTimeIsReal(t1) &&
- AbsoluteTimeIsReal(t2))
- return t1 - t2;
+ result = palloc(sizeof(Timestamp));
- return INVALID_RELTIME;
-}
+ if (date2tm(dateVal, &tz, tm, &fsec, &tzn) != 0)
+ elog(ERROR, "Unable to convert date to timestamp");
+ if (tm2timestamp(tm, fsec, &tz, result) != 0)
+ elog(ERROR, "Timestamp out of range");
-/*
- * ininterval - returns 1, iff absolute date is in the interval
- */
-int
-ininterval(AbsoluteTime t, TimeInterval interval)
-{
- if (interval->status == T_INTERVAL_VALID && t != INVALID_ABSTIME)
- return (abstimege(t, interval->data[0]) &&
- abstimele(t, interval->data[1]));
- return 0;
-}
+ return result;
+} /* date_timestamp() */
-/*
- * intervalrel - returns relative time corresponding to interval
- */
-RelativeTime
-intervalrel(TimeInterval interval)
-{
- if (interval->status == T_INTERVAL_VALID)
- return abstimemi(interval->data[1], interval->data[0]);
- else
- return INVALID_RELTIME;
-}
-/*
- * timenow - returns time "now", internal format
- *
- * Now AbsoluteTime is time since Jan 1 1970 -mer 7 Feb 1992
+/* timestamp_date()
+ * Convert timestamp to date data type.
*/
-AbsoluteTime
-timenow()
+DateADT
+timestamp_date(Timestamp *timestamp)
{
- time_t sec;
+ DateADT result;
+ struct tm tt,
+ *tm = &tt;
+ int tz;
+ double fsec;
+ char *tzn;
- if (time(&sec) < 0)
- return INVALID_ABSTIME;
- return (AbsoluteTime) sec;
-}
+ if (!PointerIsValid(timestamp))
+ elog(ERROR, "Unable to convert null timestamp to date");
-/*
- * reltimeeq - returns 1, iff arguments are equal
- * reltimene - returns 1, iff arguments are not equal
- * reltimelt - returns 1, iff t1 less than t2
- * reltimegt - returns 1, iff t1 greater than t2
- * reltimele - returns 1, iff t1 less than or equal to t2
- * reltimege - returns 1, iff t1 greater than or equal to t2
- */
-bool
-reltimeeq(RelativeTime t1, RelativeTime t2)
-{
- if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
- return 0;
- return t1 == t2;
-}
+ if (TIMESTAMP_NOT_FINITE(*timestamp))
+ elog(ERROR, "Unable to convert timestamp to date");
-bool
-reltimene(RelativeTime t1, RelativeTime t2)
-{
- if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
- return 0;
- return t1 != t2;
-}
+ if (TIMESTAMP_IS_EPOCH(*timestamp))
+ {
+ timestamp2tm(SetTimestamp(*timestamp), NULL, tm, &fsec, NULL);
-bool
-reltimelt(RelativeTime t1, RelativeTime t2)
-{
- if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
- return 0;
- return t1 < t2;
-}
+ }
+ else if (TIMESTAMP_IS_CURRENT(*timestamp))
+ {
+ timestamp2tm(SetTimestamp(*timestamp), &tz, tm, &fsec, &tzn);
-bool
-reltimegt(RelativeTime t1, RelativeTime t2)
-{
- if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
- return 0;
- return t1 > t2;
-}
+ }
+ else
+ {
+ if (timestamp2tm(*timestamp, &tz, tm, &fsec, &tzn) != 0)
+ elog(ERROR, "Unable to convert timestamp to date");
+ }
-bool
-reltimele(RelativeTime t1, RelativeTime t2)
-{
- if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
- return 0;
- return t1 <= t2;
-}
+ result = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1));
-bool
-reltimege(RelativeTime t1, RelativeTime t2)
-{
- if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
- return 0;
- return t1 >= t2;
-}
+ return result;
+} /* timestamp_date() */
-/*
- * intervalsame - returns 1, iff interval i1 is same as interval i2
- * Check begin and end time.
+/* abstime_date()
+ * Convert abstime to date data type.
*/
-bool
-intervalsame(TimeInterval i1, TimeInterval i2)
+DateADT
+abstime_date(AbsoluteTime abstime)
{
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- return FALSE; /* invalid interval */
- return (abstimeeq(i1->data[0], i2->data[0]) &&
- abstimeeq(i1->data[1], i2->data[1]));
-} /* intervalsame() */
+ DateADT result;
+ struct tm tt,
+ *tm = &tt;
+ int tz;
+ switch (abstime)
+ {
+ case INVALID_ABSTIME:
+ case NOSTART_ABSTIME:
+ case NOEND_ABSTIME:
+ elog(ERROR, "Unable to convert reserved abstime value to date");
+
+ /*
+ * pretend to drop through to make compiler think that result
+ * will be set
+ */
+
+ case EPOCH_ABSTIME:
+ result = date2j(1970, 1, 1) - date2j(2000, 1, 1);
+ break;
-/*
- * intervaleq - returns 1, iff interval i1 is equal to interval i2
- * Check length of intervals.
- */
-bool
-intervaleq(TimeInterval i1, TimeInterval i2)
-{
- AbsoluteTime t10,
- t11,
- t20,
- t21;
+ case CURRENT_ABSTIME:
+ GetCurrentTime(tm);
+ result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1);
+ break;
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- return FALSE; /* invalid interval */
+ default:
+ abstime2tm(abstime, &tz, tm, NULL);
+ result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1);
+ break;
+ }
- t10 = i1->data[0];
- t11 = i1->data[1];
- t20 = i2->data[0];
- t21 = i2->data[1];
+ return result;
+} /* abstime_date() */
- if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
- return FALSE;
- if (t10 == CURRENT_ABSTIME)
- t10 = GetCurrentTransactionStartTime();
- if (t11 == CURRENT_ABSTIME)
- t11 = GetCurrentTransactionStartTime();
- if (t20 == CURRENT_ABSTIME)
- t20 = GetCurrentTransactionStartTime();
- if (t21 == CURRENT_ABSTIME)
- t21 = GetCurrentTransactionStartTime();
-
- return (t11 - t10) == (t21 - t20);
-} /* intervaleq() */
-
-/*
- * intervalne - returns 1, iff interval i1 is not equal to interval i2
- * Check length of intervals.
+/* date2tm()
+ * Convert date to time structure.
+ * Note that date is an implicit local time, but the system calls assume
+ * that everything is GMT. So, convert to GMT, rotate to local time,
+ * and then convert again to try to get the time zones correct.
*/
-bool
-intervalne(TimeInterval i1, TimeInterval i2)
+static int
+date2tm(DateADT dateVal, int *tzp, struct tm * tm, double *fsec, char **tzn)
{
- AbsoluteTime t10,
- t11,
- t20,
- t21;
+ struct tm *tx;
+ time_t utime;
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- return FALSE; /* invalid interval */
+ *fsec = 0;
- t10 = i1->data[0];
- t11 = i1->data[1];
- t20 = i2->data[0];
- t21 = i2->data[1];
+ j2date((dateVal + date2j(2000, 1, 1)), &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
+ tm->tm_hour = 0;
+ tm->tm_min = 0;
+ tm->tm_sec = 0;
+ tm->tm_isdst = -1;
- if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
- return FALSE;
+ if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon, tm->tm_mday))
+ {
- if (t10 == CURRENT_ABSTIME)
- t10 = GetCurrentTransactionStartTime();
- if (t11 == CURRENT_ABSTIME)
- t11 = GetCurrentTransactionStartTime();
- if (t20 == CURRENT_ABSTIME)
- t20 = GetCurrentTransactionStartTime();
- if (t21 == CURRENT_ABSTIME)
- t21 = GetCurrentTransactionStartTime();
-
- return (t11 - t10) != (t21 - t20);
-} /* intervalne() */
-
-/*
- * intervallt - returns TRUE, iff interval i1 is less than interval i2
- * Check length of intervals.
- */
-bool
-intervallt(TimeInterval i1, TimeInterval i2)
-{
- AbsoluteTime t10,
- t11,
- t20,
- t21;
+ /* convert to system time */
+ utime = ((dateVal + (date2j(2000, 1, 1) - date2j(1970, 1, 1))) * 86400);
+ /* rotate to noon to get the right day in time zone */
+ utime += (12 * 60 * 60);
+
+#ifdef USE_POSIX_TIME
+ tx = localtime(&utime);
+
+ tm->tm_year = tx->tm_year + 1900;
+ tm->tm_mon = tx->tm_mon + 1;
+ tm->tm_mday = tx->tm_mday;
+ tm->tm_isdst = tx->tm_isdst;
+
+#if defined(HAVE_TM_ZONE)
+ tm->tm_gmtoff = tx->tm_gmtoff;
+ tm->tm_zone = tx->tm_zone;
+
+ /* tm_gmtoff is Sun/DEC-ism */
+ *tzp = -(tm->tm_gmtoff);
+ if (tzn != NULL)
+ *tzn = (char *) tm->tm_zone;
+#elif defined(HAVE_INT_TIMEZONE)
+#ifdef __CYGWIN__
+ *tzp = (tm->tm_isdst ? (_timezone - 3600) : _timezone);
+#else
+ *tzp = (tm->tm_isdst ? (timezone - 3600) : timezone);
+#endif
+ if (tzn != NULL)
+ *tzn = tzname[(tm->tm_isdst > 0)];
+#else
+#error USE_POSIX_TIME is defined but neither HAVE_TM_ZONE or HAVE_INT_TIMEZONE are defined
+#endif
+#else /* !USE_POSIX_TIME */
+ *tzp = CTimeZone; /* V7 conventions; don't know timezone? */
+ if (tzn != NULL)
+ *tzn = CTZName;
+#endif
+
+ /* otherwise, outside of timezone range so convert to GMT... */
+ }
+ else
+ {
+ *tzp = 0;
+ tm->tm_isdst = 0;
+ if (tzn != NULL)
+ *tzn = NULL;
+ }
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- return FALSE; /* invalid interval */
+ return 0;
+} /* date2tm() */
- t10 = i1->data[0];
- t11 = i1->data[1];
- t20 = i2->data[0];
- t21 = i2->data[1];
- if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
- return FALSE;
+/*****************************************************************************
+ * Time ADT
+ *****************************************************************************/
- if (t10 == CURRENT_ABSTIME)
- t10 = GetCurrentTransactionStartTime();
- if (t11 == CURRENT_ABSTIME)
- t11 = GetCurrentTransactionStartTime();
- if (t20 == CURRENT_ABSTIME)
- t20 = GetCurrentTransactionStartTime();
- if (t21 == CURRENT_ABSTIME)
- t21 = GetCurrentTransactionStartTime();
-
- return (t11 - t10) < (t21 - t20);
-} /* intervallt() */
-
-/*
- * intervalle - returns TRUE, iff interval i1 is less than or equal to interval i2
- * Check length of intervals.
- */
-bool
-intervalle(TimeInterval i1, TimeInterval i2)
+
+TimeADT *
+time_in(char *str)
{
- AbsoluteTime t10,
- t11,
- t20,
- t21;
+ TimeADT *time;
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- return FALSE; /* invalid interval */
+ double fsec;
+ struct tm tt,
+ *tm = &tt;
- t10 = i1->data[0];
- t11 = i1->data[1];
- t20 = i2->data[0];
- t21 = i2->data[1];
+ int nf;
+ char lowstr[MAXDATELEN + 1];
+ char *field[MAXDATEFIELDS];
+ int dtype;
+ int ftype[MAXDATEFIELDS];
- if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
- return FALSE;
+ if (!PointerIsValid(str))
+ elog(ERROR, "Bad (null) time external representation");
- if (t10 == CURRENT_ABSTIME)
- t10 = GetCurrentTransactionStartTime();
- if (t11 == CURRENT_ABSTIME)
- t11 = GetCurrentTransactionStartTime();
- if (t20 == CURRENT_ABSTIME)
- t20 = GetCurrentTransactionStartTime();
- if (t21 == CURRENT_ABSTIME)
- t21 = GetCurrentTransactionStartTime();
-
- return (t11 - t10) <= (t21 - t20);
-} /* intervalle() */
-
-/*
- * intervalgt - returns TRUE, iff interval i1 is less than interval i2
- * Check length of intervals.
- */
-bool
-intervalgt(TimeInterval i1, TimeInterval i2)
-{
- AbsoluteTime t10,
- t11,
- t20,
- t21;
+ if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
+ || (DecodeTimeOnly(field, ftype, nf, &dtype, tm, &fsec) != 0))
+ elog(ERROR, "Bad time external representation '%s'", str);
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- return FALSE; /* invalid interval */
+ time = palloc(sizeof(TimeADT));
- t10 = i1->data[0];
- t11 = i1->data[1];
- t20 = i2->data[0];
- t21 = i2->data[1];
+ *time = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec + fsec);
- if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
- return FALSE;
+ return time;
+} /* time_in() */
- if (t10 == CURRENT_ABSTIME)
- t10 = GetCurrentTransactionStartTime();
- if (t11 == CURRENT_ABSTIME)
- t11 = GetCurrentTransactionStartTime();
- if (t20 == CURRENT_ABSTIME)
- t20 = GetCurrentTransactionStartTime();
- if (t21 == CURRENT_ABSTIME)
- t21 = GetCurrentTransactionStartTime();
-
- return (t11 - t10) > (t21 - t20);
-} /* intervalgt() */
-
-/*
- * intervalge - returns TRUE, iff interval i1 is less than or equal to interval i2
- * Check length of intervals.
- */
-bool
-intervalge(TimeInterval i1, TimeInterval i2)
-{
- AbsoluteTime t10,
- t11,
- t20,
- t21;
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- return FALSE; /* invalid interval */
+char *
+time_out(TimeADT *time)
+{
+ char *result;
+ struct tm tt,
+ *tm = &tt;
- t10 = i1->data[0];
- t11 = i1->data[1];
- t20 = i2->data[0];
- t21 = i2->data[1];
+ double fsec;
+ char buf[MAXDATELEN + 1];
- if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
- return FALSE;
+ if (!PointerIsValid(time))
+ return NULL;
- if (t10 == CURRENT_ABSTIME)
- t10 = GetCurrentTransactionStartTime();
- if (t11 == CURRENT_ABSTIME)
- t11 = GetCurrentTransactionStartTime();
- if (t20 == CURRENT_ABSTIME)
- t20 = GetCurrentTransactionStartTime();
- if (t21 == CURRENT_ABSTIME)
- t21 = GetCurrentTransactionStartTime();
+ tm->tm_hour = (*time / (60 * 60));
+ tm->tm_min = (((int) (*time / 60)) % 60);
+ tm->tm_sec = (((int) *time) % 60);
- return (t11 - t10) >= (t21 - t20);
-} /* intervalge() */
+ fsec = 0;
+ EncodeTimeOnly(tm, fsec, DateStyle, buf);
-/*
- * intervalleneq - returns 1, iff length of interval i is equal to
- * reltime t
- */
-bool
-intervalleneq(TimeInterval i, RelativeTime t)
-{
- RelativeTime rt;
+ result = palloc(strlen(buf) + 1);
- if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
- return 0;
- rt = intervalrel(i);
- return rt != INVALID_RELTIME && rt == t;
-}
+ strcpy(result, buf);
-/*
- * intervallenne - returns 1, iff length of interval i is not equal
- * to reltime t
- */
-bool
-intervallenne(TimeInterval i, RelativeTime t)
-{
- RelativeTime rt;
+ return result;
+} /* time_out() */
- if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
- return 0;
- rt = intervalrel(i);
- return rt != INVALID_RELTIME && rt != t;
-}
-/*
- * intervallenlt - returns 1, iff length of interval i is less than
- * reltime t
- */
bool
-intervallenlt(TimeInterval i, RelativeTime t)
+time_eq(TimeADT *time1, TimeADT *time2)
{
- RelativeTime rt;
+ if (!PointerIsValid(time1) || !PointerIsValid(time2))
+ return FALSE;
- if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
- return 0;
- rt = intervalrel(i);
- return rt != INVALID_RELTIME && rt < t;
-}
+ return *time1 == *time2;
+} /* time_eq() */
-/*
- * intervallengt - returns 1, iff length of interval i is greater than
- * reltime t
- */
bool
-intervallengt(TimeInterval i, RelativeTime t)
+time_ne(TimeADT *time1, TimeADT *time2)
{
- RelativeTime rt;
+ if (!PointerIsValid(time1) || !PointerIsValid(time2))
+ return FALSE;
- if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
- return 0;
- rt = intervalrel(i);
- return rt != INVALID_RELTIME && rt > t;
-}
+ return *time1 != *time2;
+} /* time_eq() */
-/*
- * intervallenle - returns 1, iff length of interval i is less or equal
- * than reltime t
- */
bool
-intervallenle(TimeInterval i, RelativeTime t)
+time_lt(TimeADT *time1, TimeADT *time2)
{
- RelativeTime rt;
+ if (!PointerIsValid(time1) || !PointerIsValid(time2))
+ return FALSE;
- if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
- return 0;
- rt = intervalrel(i);
- return rt != INVALID_RELTIME && rt <= t;
-}
+ return *time1 < *time2;
+} /* time_eq() */
-/*
- * intervallenge - returns 1, iff length of interval i is greater or
- * equal than reltime t
- */
bool
-intervallenge(TimeInterval i, RelativeTime t)
+time_le(TimeADT *time1, TimeADT *time2)
{
- RelativeTime rt;
+ if (!PointerIsValid(time1) || !PointerIsValid(time2))
+ return FALSE;
- if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
- return 0;
- rt = intervalrel(i);
- return rt != INVALID_RELTIME && rt >= t;
-}
+ return *time1 <= *time2;
+} /* time_eq() */
-/*
- * intervalct - returns 1, iff interval i1 contains interval i2
- */
bool
-intervalct(TimeInterval i1, TimeInterval i2)
+time_gt(TimeADT *time1, TimeADT *time2)
{
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- return 0;
- return (abstimele(i1->data[0], i2->data[0]) &&
- abstimege(i1->data[1], i2->data[1]));
-}
+ if (!PointerIsValid(time1) || !PointerIsValid(time2))
+ return FALSE;
+
+ return *time1 > *time2;
+} /* time_eq() */
-/*
- * intervalov - returns 1, iff interval i1 (partially) overlaps i2
- */
bool
-intervalov(TimeInterval i1, TimeInterval i2)
+time_ge(TimeADT *time1, TimeADT *time2)
{
- if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
- return 0;
- return (!(abstimelt(i1->data[1], i2->data[0]) ||
- abstimegt(i1->data[0], i2->data[1])));
-}
+ if (!PointerIsValid(time1) || !PointerIsValid(time2))
+ return FALSE;
-/*
- * intervalstart - returns the start of interval i
- */
-AbsoluteTime
-intervalstart(TimeInterval i)
-{
- if (i->status == T_INTERVAL_INVAL)
- return INVALID_ABSTIME;
- return i->data[0];
-}
+ return *time1 >= *time2;
+} /* time_eq() */
-/*
- * intervalend - returns the end of interval i
- */
-AbsoluteTime
-intervalend(TimeInterval i)
+int
+time_cmp(TimeADT *time1, TimeADT *time2)
{
- if (i->status == T_INTERVAL_INVAL)
- return INVALID_ABSTIME;
- return i->data[1];
-}
+ return (*time1 < *time2) ? -1 : (((*time1 > *time2) ? 1 : 0));
+} /* time_cmp() */
-/*****************************************************************************
- * PRIVATE ROUTINES *
- *****************************************************************************/
-
-#ifdef NOT_USED
-/*
- * isreltime - returns 1, iff datestring is of type reltime
- * 2, iff datestring is 'invalid time' identifier
- * 0, iff datestring contains a syntax error
- * VALID time less or equal +/- `@ 68 years'
- *
+/* timestamp_time()
+ * Convert timestamp to time data type.
*/
-int
-isreltime(char *str)
+TimeADT *
+timestamp_time(Timestamp *timestamp)
{
+ TimeADT *result;
struct tm tt,
*tm = &tt;
+ int tz;
double fsec;
- int dtype;
- char *field[MAXDATEFIELDS];
- int nf,
- ftype[MAXDATEFIELDS];
- char lowstr[MAXDATELEN + 1];
+ char *tzn;
- if (!PointerIsValid(str))
- return 0;
-
- if (strlen(str) > MAXDATELEN)
- return 0;
+ if (!PointerIsValid(timestamp))
+ elog(ERROR, "Unable to convert null timestamp to date");
- if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
- || (DecodeDateDelta(field, ftype, nf, &dtype, tm, &fsec) != 0))
- return 0;
+ if (TIMESTAMP_NOT_FINITE(*timestamp))
+ elog(ERROR, "Unable to convert timestamp to date");
- switch (dtype)
+ if (TIMESTAMP_IS_EPOCH(*timestamp))
{
- case (DTK_DELTA):
- return (abs(tm->tm_year) <= 68) ? 1 : 0;
- break;
-
- case (DTK_INVALID):
- return 2;
- break;
-
- default:
- return 0;
- break;
- }
+ timestamp2tm(SetTimestamp(*timestamp), NULL, tm, &fsec, NULL);
- return 0;
-} /* isreltime() */
-
-#endif
-
-#ifdef NOT_USED
-int
-dummyfunc()
-{
- char *p;
- char c;
- int i;
- char unit[UNITMAXLEN];
- char direction[DIRMAXLEN];
- int localSign;
- int localUnitNumber;
- long localQuantity;
-
- if (!PointerIsValid(sign))
- sign = &localSign;
-
- if (!PointerIsValid(unitnr))
- unitnr = &localUnitNumber;
-
- if (!PointerIsValid(quantity))
- quantity = &localQuantity;
-
- unit[0] = '\0';
- direction[0] = '\0';
- p = timestring;
- /* skip leading blanks */
- while ((c = *p) != '\0')
- {
- if (c != ' ')
- break;
- p++;
}
-
- /* Test whether 'invalid time' identifier or not */
- if (!strncmp(INVALID_RELTIME_STR, p, strlen(INVALID_RELTIME_STR) + 1))
- return 2; /* correct 'invalid time' identifier found */
-
- /* handle label of relative time */
- if (c != RELTIME_LABEL)
- return 0; /* syntax error */
- c = *++p;
- if (c != ' ')
- return 0; /* syntax error */
- p++;
- /* handle the quantity */
- *quantity = 0;
- for (;;)
+ else if (TIMESTAMP_IS_CURRENT(*timestamp))
{
- c = *p;
- if (isdigit(c))
- {
- *quantity = *quantity * 10 + (c - '0');
- p++;
- }
- else
- {
- if (c == ' ')
- break; /* correct quantity found */
- else
- return 0; /* syntax error */
- }
- }
+ timestamp2tm(SetTimestamp(*timestamp), &tz, tm, &fsec, &tzn);
- /* handle unit */
- p++;
- i = 0;
- for (;;)
- {
- c = *p;
- if (c >= 'a' && c <= 'z' && i <= (UNITMAXLEN - 1))
- {
- unit[i] = c;
- p++;
- i++;
- }
- else
- {
- if ((c == ' ' || c == '\0')
- && correct_unit(unit, unitnr))
- break; /* correct unit found */
- else
- return 0; /* syntax error */
- }
}
-
- /* handle optional direction */
- if (c == ' ')
- p++;
- i = 0;
- *sign = 1;
- for (;;)
+ else
{
- c = *p;
- if (c >= 'a' && c <= 'z' && i <= (DIRMAXLEN - 1))
- {
- direction[i] = c;
- p++;
- i++;
- }
- else
- {
- if ((c == ' ' || c == '\0') && i == 0)
- {
- *sign = 1;
- break; /* no direction specified */
- }
- if ((c == ' ' || c == '\0') && i != 0)
- {
- direction[i] = '\0';
- correct_dir(direction, sign);
- break; /* correct direction found */
- }
- else
- return 0; /* syntax error */
- }
+ if (timestamp2tm(*timestamp, &tz, tm, &fsec, &tzn) != 0)
+ elog(ERROR, "Unable to convert timestamp to date");
}
- return 1;
-}
+ result = palloc(sizeof(TimeADT));
-/*
- * correct_unit - returns 1, iff unit is a correct unit description
- *
- * output parameter:
- * unptr: points to an integer which is the appropriate unit number
- * (see function isreltime())
- */
-static int
-correct_unit(char *unit, int *unptr)
-{
- int j = 0;
-
- while (j < NUNITS)
- {
- if (strncmp(unit, unit_tab[j], strlen(unit_tab[j])) == 0)
- {
- *unptr = j;
- return 1;
- }
- j++;
- }
- return 0; /* invalid unit descriptor */
-}
+ *result = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec + fsec);
-/*
- * correct_dir - returns 1, iff direction is a correct identifier
- *
- * output parameter:
- * signptr: points to -1 if dir corresponds to past tense
- * else to 1
- */
-static int
-correct_dir(char *direction, int *signptr)
-{
- *signptr = 1;
- if (strncmp(RELTIME_PAST, direction, strlen(RELTIME_PAST) + 1) == 0)
- {
- *signptr = -1;
- return 1;
- }
- else
- return 0; /* invalid direction descriptor */
-}
+ return result;
+} /* timestamp_time() */
-#endif
-/*
- * 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
- *
- * output parameter:
- * i_start, i_end: interval margins
- *
- * Time interval:
- * `[' {` '} `'' <AbsTime> `'' {` '} `'' <AbsTime> `'' {` '} `]'
- *
- * OR `Undefined Range' (see also INVALID_INTERVAL_STR)
- *
- * where <AbsTime> satisfies the syntax of absolute time.
- *
- * e.g. [ ' Jan 18 1902' 'Jan 1 00:00:00 1970']
+/* datetime_timestamp()
+ * Convert date and time to timestamp data type.
*/
-static int
-istinterval(char *i_string,
- AbsoluteTime *i_start,
- AbsoluteTime *i_end)
+Timestamp *
+datetime_timestamp(DateADT date, TimeADT *time)
{
- char *p,
- *p1;
- char c;
+ Timestamp *result;
- p = i_string;
- /* skip leading blanks up to '[' */
- while ((c = *p) != '\0')
+ if (!PointerIsValid(time))
{
- if (IsSpace(c))
- p++;
- else if (c != '[')
- return 0; /* syntax error */
- else
- break;
+ result = palloc(sizeof(Timestamp));
+ TIMESTAMP_INVALID(*result);
}
- p++;
- /* skip leading blanks up to "'" */
- while ((c = *p) != '\0')
- {
- if (IsSpace(c))
- p++;
- else if (c != '"')
- return 0; /* syntax error */
- else
- break;
- }
- 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 */
- p1 = p;
- while ((c = *p1) != '\0')
- {
- if (c == '"')
- {
- *p1 = '\0';
- break;
- }
- p1++;
- }
- /* get the first date */
- *i_start = nabstimein(p); /* first absolute date */
- /* rechange NULL at the end of the first date to a "'" */
- *p1 = '"';
- p = ++p1;
- /* skip blanks up to "'", beginning of second date */
- while ((c = *p) != '\0')
- {
- if (IsSpace(c))
- p++;
- else if (c != '"')
- return 0; /* syntax error */
- else
- break;
- }
- p++;
- /* search for the end of the second date and change it to a NULL */
- p1 = p;
- while ((c = *p1) != '\0')
- {
- if (c == '"')
- {
- *p1 = '\0';
- break;
- }
- p1++;
- }
- /* get the second date */
- *i_end = nabstimein(p); /* second absolute date */
- /* rechange NULL at the end of the first date to a ''' */
- *p1 = '"';
- p = ++p1;
- /* skip blanks up to ']' */
- while ((c = *p) != '\0')
+ else
{
- if (IsSpace(c))
- p++;
- else if (c != ']')
- return 0; /* syntax error */
- else
- break;
+ result = date_timestamp(date);
+ *result += *time;
}
- p++;
- c = *p;
- if (c != '\0')
- return 0; /* syntax error */
- /* it seems to be a valid interval */
- return 1;
-}
-
-/*****************************************************************************
- *
- *****************************************************************************/
-
-/*
- * timeofday -
- * returns the current time as a text. similar to timenow() but returns
- * seconds with more precision (up to microsecs). (I need this to compare
- * the Wisconsin benchmark with Illustra whose TimeNow() shows current
- * time with precision up to microsecs.) - ay 3/95
- */
-text *
-timeofday(void)
-{
-
- struct timeval tp;
- struct timezone tpz;
- char templ[500];
- char buf[500];
- text *tm;
- int len = 0;
-
- gettimeofday(&tp, &tpz);
- strftime(templ, sizeof(templ), "%a %b %d %H:%M:%S.%%d %Y %Z",
- localtime((time_t *) &tp.tv_sec));
- sprintf(buf, templ, tp.tv_usec);
-
- len = VARHDRSZ + strlen(buf);
- tm = (text *) palloc(len);
- VARSIZE(tm) = len;
- strncpy(VARDATA(tm), buf, strlen(buf));
- return tm;
-}
+ return result;
+} /* datetime_timestamp() */
/*-------------------------------------------------------------------------
*
* datetime.c
- * implements DATE and TIME data types specified in SQL-92 standard
+ * Support functions for date/time types.
*
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
- * Portions Copyright (c) 1994-5, Regents of the University of California
+ * Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.41 2000/01/26 05:57:13 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.42 2000/02/16 18:17:02 thomas Exp $
*
*-------------------------------------------------------------------------
*/
-#include <limits.h>
+#include <ctype.h>
+#include <math.h>
+#include <sys/types.h>
+#include <errno.h>
#include "postgres.h"
#ifdef HAVE_FLOAT_H
#include <float.h>
#endif
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+#ifndef USE_POSIX_TIME
+#include <sys/timeb.h>
+#endif
+
#include "miscadmin.h"
-#include "utils/builtins.h"
+#include "utils/datetime.h"
-static int date2tm(DateADT dateVal, int *tzp, struct tm * tm, double *fsec, char **tzn);
+#define USE_DATE_CACHE 1
+#define ROUND_ALL 0
-/*****************************************************************************
- * Date ADT
- *****************************************************************************/
-
+int day_tab[2][13] = {
+ {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0},
+{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0}};
-/* date_in()
- * Given date text string, convert to internal date format.
- */
-DateADT
-date_in(char *str)
-{
- DateADT date;
- double fsec;
- struct tm tt,
- *tm = &tt;
- int tzp;
- int dtype;
- int nf;
- char *field[MAXDATEFIELDS];
- int ftype[MAXDATEFIELDS];
- char lowstr[MAXDATELEN + 1];
- if (!PointerIsValid(str))
- elog(ERROR, "Bad (null) date external representation");
+char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+"Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL};
- if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
- || (DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tzp) != 0))
- elog(ERROR, "Bad date external representation '%s'", str);
+char *days[] = {"Sunday", "Monday", "Tuesday", "Wednesday",
+"Thursday", "Friday", "Saturday", NULL};
- switch (dtype)
- {
- case DTK_DATE:
- break;
- case DTK_CURRENT:
- GetCurrentTime(tm);
- break;
+#if 0
- case DTK_EPOCH:
- tm->tm_year = 1970;
- tm->tm_mon = 1;
- tm->tm_mday = 1;
- break;
- default:
- elog(ERROR, "Unrecognized date external representation '%s'", str);
- }
+static void GetEpochTime(struct tm * tm);
- date = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1));
- return date;
-} /* date_in() */
+#endif
-/* date_out()
- * Given internal format date, convert to text string.
- */
-char *
-date_out(DateADT date)
-{
- char *result;
- struct tm tt,
- *tm = &tt;
- char buf[MAXDATELEN + 1];
- j2date((date + date2j(2000, 1, 1)),
- &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
+#define UTIME_MINYEAR (1901)
+#define UTIME_MINMONTH (12)
+#define UTIME_MINDAY (14)
+#define UTIME_MAXYEAR (2038)
+#define UTIME_MAXMONTH (01)
+#define UTIME_MAXDAY (18)
- EncodeDateOnly(tm, DateStyle, buf);
+#define IS_VALID_UTIME(y,m,d) (((y > UTIME_MINYEAR) \
+ || ((y == UTIME_MINYEAR) && ((m > UTIME_MINMONTH) \
+ || ((m == UTIME_MINMONTH) && (d >= UTIME_MINDAY))))) \
+ && ((y < UTIME_MAXYEAR) \
+ || ((y == UTIME_MAXYEAR) && ((m < UTIME_MAXMONTH) \
+ || ((m == UTIME_MAXMONTH) && (d <= UTIME_MAXDAY))))))
- result = palloc(strlen(buf) + 1);
- strcpy(result, buf);
+/*****************************************************************************
+ * PRIVATE ROUTINES *
+ *****************************************************************************/
- return result;
-} /* date_out() */
+/* definitions for squeezing values into "value" */
+#define ABS_SIGNBIT (char) 0200
+#define VALMASK (char) 0177
+#define NEG(n) ((n)|ABS_SIGNBIT)
+#define SIGNEDCHAR(c) ((c)&ABS_SIGNBIT? -((c)&VALMASK): (c))
+#define FROMVAL(tp) (-SIGNEDCHAR((tp)->value) * 10) /* uncompress */
+#define TOVAL(tp, v) ((tp)->value = ((v) < 0? NEG((-(v))/10): (v)/10))
+
+/*
+ * to keep this table reasonably small, we divide the lexval for TZ and DTZ
+ * entries by 10 and truncate the text field at MAXTOKLEN characters.
+ * the text field is not guaranteed to be NULL-terminated.
+ */
+static datetkn datetktbl[] = {
+/* text token lexval */
+ {EARLY, RESERV, DTK_EARLY}, /* "-infinity" reserved for "early time" */
+ {"acsst", DTZ, 63}, /* Cent. Australia */
+ {"acst", TZ, 57}, /* Cent. Australia */
+ {DA_D, ADBC, AD}, /* "ad" for years >= 0 */
+ {"abstime", IGNORE, 0}, /* "abstime" for pre-v6.1 "Invalid
+ * Abstime" */
+ {"adt", DTZ, NEG(18)}, /* Atlantic Daylight Time */
+ {"aesst", DTZ, 66}, /* E. Australia */
+ {"aest", TZ, 60}, /* Australia Eastern Std Time */
+ {"ahst", TZ, NEG(60)}, /* Alaska-Hawaii Std Time */
+ {"allballs", RESERV, DTK_ZULU}, /* 00:00:00 */
+ {"am", AMPM, AM},
+ {"apr", MONTH, 4},
+ {"april", MONTH, 4},
+ {"ast", TZ, NEG(24)}, /* Atlantic Std Time (Canada) */
+ {"at", IGNORE, 0}, /* "at" (throwaway) */
+ {"aug", MONTH, 8},
+ {"august", MONTH, 8},
+ {"awsst", DTZ, 54}, /* W. Australia */
+ {"awst", TZ, 48}, /* W. Australia */
+ {DB_C, ADBC, BC}, /* "bc" for years < 0 */
+ {"bst", TZ, 6}, /* British Summer Time */
+ {"bt", TZ, 18}, /* Baghdad Time */
+ {"cadt", DTZ, 63}, /* Central Australian DST */
+ {"cast", TZ, 57}, /* Central Australian ST */
+ {"cat", TZ, NEG(60)}, /* Central Alaska Time */
+ {"cct", TZ, 48}, /* China Coast */
+ {"cdt", DTZ, NEG(30)}, /* Central Daylight Time */
+ {"cet", TZ, 6}, /* Central European Time */
+ {"cetdst", DTZ, 12}, /* Central European Dayl.Time */
+#if USE_AUSTRALIAN_RULES
+ {"cst", TZ, 63}, /* Australia Eastern Std Time */
+#else
+ {"cst", TZ, NEG(36)}, /* Central Standard Time */
+#endif
+ {DCURRENT, RESERV, DTK_CURRENT}, /* "current" is always now */
+ {"dec", MONTH, 12},
+ {"december", MONTH, 12},
+ {"dnt", TZ, 6}, /* Dansk Normal Tid */
+ {"dow", RESERV, DTK_DOW}, /* day of week */
+ {"doy", RESERV, DTK_DOY}, /* day of year */
+ {"dst", DTZMOD, 6},
+ {"east", TZ, 60}, /* East Australian Std Time */
+ {"edt", DTZ, NEG(24)}, /* Eastern Daylight Time */
+ {"eet", TZ, 12}, /* East. Europe, USSR Zone 1 */
+ {"eetdst", DTZ, 18}, /* Eastern Europe */
+ {EPOCH, RESERV, DTK_EPOCH}, /* "epoch" reserved for system epoch time */
+#if USE_AUSTRALIAN_RULES
+ {"est", TZ, 60}, /* Australia Eastern Std Time */
+#else
+ {"est", TZ, NEG(30)}, /* Eastern Standard Time */
+#endif
+ {"feb", MONTH, 2},
+ {"february", MONTH, 2},
+ {"fri", DOW, 5},
+ {"friday", DOW, 5},
+ {"fst", TZ, 6}, /* French Summer Time */
+ {"fwt", DTZ, 12}, /* French Winter Time */
+ {"gmt", TZ, 0}, /* Greenwish Mean Time */
+ {"gst", TZ, 60}, /* Guam Std Time, USSR Zone 9 */
+ {"hdt", DTZ, NEG(54)}, /* Hawaii/Alaska */
+ {"hmt", DTZ, 18}, /* Hellas ? ? */
+ {"hst", TZ, NEG(60)}, /* Hawaii Std Time */
+ {"idle", TZ, 72}, /* Intl. Date Line, East */
+ {"idlw", TZ, NEG(72)}, /* Intl. Date Line, West */
+ {LATE, RESERV, DTK_LATE}, /* "infinity" reserved for "late time" */
+ {INVALID, RESERV, DTK_INVALID},
+ /* "invalid" reserved for invalid time */
+ {"ist", TZ, 12}, /* Israel */
+ {"it", TZ, 21}, /* Iran Time */
+ {"jan", MONTH, 1},
+ {"january", MONTH, 1},
+ {"jst", TZ, 54}, /* Japan Std Time,USSR Zone 8 */
+ {"jt", TZ, 45}, /* Java Time */
+ {"jul", MONTH, 7},
+ {"july", MONTH, 7},
+ {"jun", MONTH, 6},
+ {"june", MONTH, 6},
+ {"kst", TZ, 54}, /* Korea Standard Time */
+ {"ligt", TZ, 60}, /* From Melbourne, Australia */
+ {"mar", MONTH, 3},
+ {"march", MONTH, 3},
+ {"may", MONTH, 5},
+ {"mdt", DTZ, NEG(36)}, /* Mountain Daylight Time */
+ {"mest", DTZ, 12}, /* Middle Europe Summer Time */
+ {"met", TZ, 6}, /* Middle Europe Time */
+ {"metdst", DTZ, 12}, /* Middle Europe Daylight Time */
+ {"mewt", TZ, 6}, /* Middle Europe Winter Time */
+ {"mez", TZ, 6}, /* Middle Europe Zone */
+ {"mon", DOW, 1},
+ {"monday", DOW, 1},
+ {"mst", TZ, NEG(42)}, /* Mountain Standard Time */
+ {"mt", TZ, 51}, /* Moluccas Time */
+ {"ndt", DTZ, NEG(15)}, /* Nfld. Daylight Time */
+ {"nft", TZ, NEG(21)}, /* Newfoundland Standard Time */
+ {"nor", TZ, 6}, /* Norway Standard Time */
+ {"nov", MONTH, 11},
+ {"november", MONTH, 11},
+ {NOW, RESERV, DTK_NOW}, /* current transaction time */
+ {"nst", TZ, NEG(21)}, /* Nfld. Standard Time */
+ {"nt", TZ, NEG(66)}, /* Nome Time */
+ {"nzdt", DTZ, 78}, /* New Zealand Daylight Time */
+ {"nzst", TZ, 72}, /* New Zealand Standard Time */
+ {"nzt", TZ, 72}, /* New Zealand Time */
+ {"oct", MONTH, 10},
+ {"october", MONTH, 10},
+ {"on", IGNORE, 0}, /* "on" (throwaway) */
+ {"pdt", DTZ, NEG(42)}, /* Pacific Daylight Time */
+ {"pm", AMPM, PM},
+ {"pst", TZ, NEG(48)}, /* Pacific Standard Time */
+ {"sadt", DTZ, 63}, /* S. Australian Dayl. Time */
+ {"sast", TZ, 57}, /* South Australian Std Time */
+ {"sat", DOW, 6},
+ {"saturday", DOW, 6},
+ {"sep", MONTH, 9},
+ {"sept", MONTH, 9},
+ {"september", MONTH, 9},
+ {"set", TZ, NEG(6)}, /* Seychelles Time ?? */
+ {"sst", DTZ, 12}, /* Swedish Summer Time */
+ {"sun", DOW, 0},
+ {"sunday", DOW, 0},
+ {"swt", TZ, 6}, /* Swedish Winter Time */
+ {"thu", DOW, 4},
+ {"thur", DOW, 4},
+ {"thurs", DOW, 4},
+ {"thursday", DOW, 4},
+ {TODAY, RESERV, DTK_TODAY}, /* midnight */
+ {TOMORROW, RESERV, DTK_TOMORROW}, /* tomorrow midnight */
+ {"tue", DOW, 2},
+ {"tues", DOW, 2},
+ {"tuesday", DOW, 2},
+ {"undefined", RESERV, DTK_INVALID}, /* "undefined" pre-v6.1 invalid
+ * time */
+ {"ut", TZ, 0},
+ {"utc", TZ, 0},
+ {"wadt", DTZ, 48}, /* West Australian DST */
+ {"wast", TZ, 42}, /* West Australian Std Time */
+ {"wat", TZ, NEG(6)}, /* West Africa Time */
+ {"wdt", DTZ, 54}, /* West Australian DST */
+ {"wed", DOW, 3},
+ {"wednesday", DOW, 3},
+ {"weds", DOW, 3},
+ {"wet", TZ, 0}, /* Western Europe */
+ {"wetdst", DTZ, 6}, /* Western Europe */
+ {"wst", TZ, 48}, /* West Australian Std Time */
+ {"ydt", DTZ, NEG(48)}, /* Yukon Daylight Time */
+ {YESTERDAY, RESERV, DTK_YESTERDAY}, /* yesterday midnight */
+ {"yst", TZ, NEG(54)}, /* Yukon Standard Time */
+ {"zp4", TZ, NEG(24)}, /* GMT +4 hours. */
+ {"zp5", TZ, NEG(30)}, /* GMT +5 hours. */
+ {"zp6", TZ, NEG(36)}, /* GMT +6 hours. */
+ {"z", RESERV, DTK_ZULU}, /* 00:00:00 */
+ {ZULU, RESERV, DTK_ZULU}, /* 00:00:00 */
+};
+
+static unsigned int szdatetktbl = sizeof datetktbl / sizeof datetktbl[0];
+
+static datetkn deltatktbl[] = {
+/* text token lexval */
+ {"@", IGNORE, 0}, /* postgres relative time prefix */
+ {DAGO, AGO, 0}, /* "ago" indicates negative time offset */
+ {"c", UNITS, DTK_CENTURY}, /* "century" relative time units */
+ {"cent", UNITS, DTK_CENTURY}, /* "century" relative time units */
+ {"centuries", UNITS, DTK_CENTURY}, /* "centuries" relative time units */
+ {DCENTURY, UNITS, DTK_CENTURY}, /* "century" relative time units */
+ {"d", UNITS, DTK_DAY}, /* "day" relative time units */
+ {DDAY, UNITS, DTK_DAY}, /* "day" relative time units */
+ {"days", UNITS, DTK_DAY}, /* "days" relative time units */
+ {"dec", UNITS, DTK_DECADE}, /* "decade" relative time units */
+ {"decs", UNITS, DTK_DECADE},/* "decades" relative time units */
+ {DDECADE, UNITS, DTK_DECADE}, /* "decade" relative time units */
+ {"decades", UNITS, DTK_DECADE}, /* "decades" relative time units */
+ {"h", UNITS, DTK_HOUR}, /* "hour" relative time units */
+ {DHOUR, UNITS, DTK_HOUR}, /* "hour" relative time units */
+ {"hours", UNITS, DTK_HOUR}, /* "hours" relative time units */
+ {"hr", UNITS, DTK_HOUR}, /* "hour" relative time units */
+ {"hrs", UNITS, DTK_HOUR}, /* "hours" relative time units */
+ {INVALID, RESERV, DTK_INVALID}, /* "invalid" reserved for invalid
+ * time */
+ {"m", UNITS, DTK_MINUTE}, /* "minute" relative time units */
+ {"microsecon", UNITS, DTK_MICROSEC}, /* "microsecond" relative
+ * time units */
+ {"mil", UNITS, DTK_MILLENIUM}, /* "millenium" relative time units */
+ {"mils", UNITS, DTK_MILLENIUM}, /* "millenia" relative time units */
+ {"millenia", UNITS, DTK_MILLENIUM}, /* "millenia" relative time units */
+ {DMILLENIUM, UNITS, DTK_MILLENIUM}, /* "millenium" relative time units */
+ {"millisecon", UNITS, DTK_MILLISEC}, /* relative time units */
+ {"min", UNITS, DTK_MINUTE}, /* "minute" relative time units */
+ {"mins", UNITS, DTK_MINUTE},/* "minutes" relative time units */
+ {"mins", UNITS, DTK_MINUTE},/* "minutes" relative time units */
+ {DMINUTE, UNITS, DTK_MINUTE}, /* "minute" relative time units */
+ {"minutes", UNITS, DTK_MINUTE}, /* "minutes" relative time units */
+ {"mon", UNITS, DTK_MONTH}, /* "months" relative time units */
+ {"mons", UNITS, DTK_MONTH}, /* "months" relative time units */
+ {DMONTH, UNITS, DTK_MONTH}, /* "month" relative time units */
+ {"months", UNITS, DTK_MONTH},
+ {"ms", UNITS, DTK_MILLISEC},
+ {"msec", UNITS, DTK_MILLISEC},
+ {DMILLISEC, UNITS, DTK_MILLISEC},
+ {"mseconds", UNITS, DTK_MILLISEC},
+ {"msecs", UNITS, DTK_MILLISEC},
+ {"qtr", UNITS, DTK_QUARTER},/* "quarter" relative time */
+ {DQUARTER, UNITS, DTK_QUARTER}, /* "quarter" relative time */
+ {"reltime", IGNORE, 0}, /* for pre-v6.1 "Undefined Reltime" */
+ {"s", UNITS, DTK_SECOND},
+ {"sec", UNITS, DTK_SECOND},
+ {DSECOND, UNITS, DTK_SECOND},
+ {"seconds", UNITS, DTK_SECOND},
+ {"secs", UNITS, DTK_SECOND},
+ {DTIMEZONE, UNITS, DTK_TZ}, /* "timezone" time offset */
+ {"tz", UNITS, DTK_TZ}, /* "timezone" time offset */
+ {"tz_hour", UNITS, DTK_TZ_HOUR}, /* timezone hour units */
+ {"tz_minute", UNITS, DTK_TZ_MINUTE}, /* timezone minutes units */
+ {"undefined", RESERV, DTK_INVALID}, /* pre-v6.1 invalid time */
+ {"us", UNITS, DTK_MICROSEC},/* "microsecond" relative time units */
+ {"usec", UNITS, DTK_MICROSEC}, /* "microsecond" relative time
+ * units */
+ {DMICROSEC, UNITS, DTK_MICROSEC}, /* "microsecond" relative time
+ * units */
+ {"useconds", UNITS, DTK_MICROSEC}, /* "microseconds" relative time
+ * units */
+ {"usecs", UNITS, DTK_MICROSEC}, /* "microseconds" relative time
+ * units */
+ {"w", UNITS, DTK_WEEK}, /* "week" relative time units */
+ {DWEEK, UNITS, DTK_WEEK}, /* "week" relative time units */
+ {"weeks", UNITS, DTK_WEEK}, /* "weeks" relative time units */
+ {"y", UNITS, DTK_YEAR}, /* "year" relative time units */
+ {DYEAR, UNITS, DTK_YEAR}, /* "year" relative time units */
+ {"years", UNITS, DTK_YEAR}, /* "years" relative time units */
+ {"yr", UNITS, DTK_YEAR}, /* "year" relative time units */
+ {"yrs", UNITS, DTK_YEAR}, /* "years" relative time units */
+};
+
+static unsigned int szdeltatktbl = sizeof deltatktbl / sizeof deltatktbl[0];
+
+#if USE_DATE_CACHE
+datetkn *datecache[MAXDATEFIELDS] = {NULL};
+
+datetkn *deltacache[MAXDATEFIELDS] = {NULL};
-bool
-date_eq(DateADT dateVal1, DateADT dateVal2)
-{
- return dateVal1 == dateVal2;
-}
+#endif
-bool
-date_ne(DateADT dateVal1, DateADT dateVal2)
-{
- return dateVal1 != dateVal2;
-}
-bool
-date_lt(DateADT dateVal1, DateADT dateVal2)
-{
- return dateVal1 < dateVal2;
-} /* date_lt() */
+/*
+ * Calendar time to Julian date conversions.
+ * Julian date is commonly used in astronomical applications,
+ * since it is numerically accurate and computationally simple.
+ * The algorithms here will accurately convert between Julian day
+ * and calendar date for all non-negative Julian days
+ * (i.e. from Nov 23, -4713 on).
+ *
+ * Ref: Explanatory Supplement to the Astronomical Almanac, 1992.
+ * University Science Books, 20 Edgehill Rd. Mill Valley CA 94941.
+ *
+ * Use the algorithm by Henry Fliegel, a former NASA/JPL colleague
+ * now at Aerospace Corp. (hi, Henry!)
+ *
+ * These routines will be used by other date/time packages - tgl 97/02/25
+ */
-bool
-date_le(DateADT dateVal1, DateADT dateVal2)
+int
+date2j(int y, int m, int d)
{
- return dateVal1 <= dateVal2;
-} /* date_le() */
+ int m12 = (m - 14) / 12;
-bool
-date_gt(DateADT dateVal1, DateADT dateVal2)
-{
- return dateVal1 > dateVal2;
-} /* date_gt() */
+ return ((1461 * (y + 4800 + m12)) / 4 + (367 * (m - 2 - 12 * (m12))) / 12
+ - (3 * ((y + 4900 + m12) / 100)) / 4 + d - 32075);
+} /* date2j() */
-bool
-date_ge(DateADT dateVal1, DateADT dateVal2)
+void
+j2date(int jd, int *year, int *month, int *day)
{
- return dateVal1 >= dateVal2;
-} /* date_ge() */
+ int j,
+ y,
+ m,
+ d;
+
+ int i,
+ l,
+ n;
+
+ l = jd + 68569;
+ n = (4 * l) / 146097;
+ l -= (146097 * n + 3) / 4;
+ i = (4000 * (l + 1)) / 1461001;
+ l += 31 - (1461 * i) / 4;
+ j = (80 * l) / 2447;
+ d = l - (2447 * j) / 80;
+ l = j / 11;
+ m = (j + 2) - (12 * l);
+ y = 100 * (n - 49) + i + l;
+
+ *year = y;
+ *month = m;
+ *day = d;
+ return;
+} /* j2date() */
int
-date_cmp(DateADT dateVal1, DateADT dateVal2)
+j2day(int date)
{
- if (dateVal1 < dateVal2)
- return -1;
- else if (dateVal1 > dateVal2)
- return 1;
- return 0;
-} /* date_cmp() */
+ int day;
+
+ day = (date + 1) % 7;
-DateADT
-date_larger(DateADT dateVal1, DateADT dateVal2)
+ return day;
+} /* j2day() */
+
+
+#if 0
+
+
+static double
+time2t(const int hour, const int min, const double sec)
{
- return date_gt(dateVal1, dateVal2) ? dateVal1 : dateVal2;
-} /* date_larger() */
+ return (((hour * 60) + min) * 60) + sec;
+} /* time2t() */
-DateADT
-date_smaller(DateADT dateVal1, DateADT dateVal2)
+static void
+dt2time(Timestamp jd, int *hour, int *min, double *sec)
{
- return date_lt(dateVal1, dateVal2) ? dateVal1 : dateVal2;
-} /* date_smaller() */
+ double time;
+
+ time = jd;
+
+ *hour = (time / 3600);
+ time -= ((*hour) * 3600);
+ *min = (time / 60);
+ time -= ((*min) * 60);
+ *sec = JROUND(time);
+
+ return;
+} /* dt2time() */
+
+
+#endif
+
-/* Compute difference between two dates in days.
+/*
+ * parse and convert date in timestr (the normal interface)
+ *
+ * Returns the number of seconds since epoch (J2000)
*/
-int4
-date_mi(DateADT dateVal1, DateADT dateVal2)
-{
- return dateVal1 - dateVal2;
-} /* date_mi() */
-/* Add a number of days to a date, giving a new date.
- * Must handle both positive and negative numbers of days.
+/* ParseDateTime()
+ * Break string into tokens based on a date/time context.
*/
-DateADT
-date_pli(DateADT dateVal, int4 days)
+int
+ParseDateTime(char *timestr, char *lowstr,
+ char **field, int *ftype, int maxfields, int *numfields)
{
- return dateVal + days;
-} /* date_pli() */
+ int nf = 0;
+ char *cp = timestr;
+ char *lp = lowstr;
+
+ /* outer loop through fields */
+ while (*cp != '\0')
+ {
+ field[nf] = lp;
+
+ /* leading digit? then date or time */
+ if (isdigit(*cp) || (*cp == '.'))
+ {
+ *lp++ = *cp++;
+ while (isdigit(*cp))
+ *lp++ = *cp++;
+ /* time field? */
+ if (*cp == ':')
+ {
+ ftype[nf] = DTK_TIME;
+ while (isdigit(*cp) || (*cp == ':') || (*cp == '.'))
+ *lp++ = *cp++;
+
+ }
+ /* date field? allow embedded text month */
+ else if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
+ {
+ ftype[nf] = DTK_DATE;
+ while (isalnum(*cp) || (*cp == '-') || (*cp == '/') || (*cp == '.'))
+ *lp++ = tolower(*cp++);
+
+ }
+
+ /*
+ * otherwise, number only and will determine year, month, or
+ * day later
+ */
+ else
+ ftype[nf] = DTK_NUMBER;
+
+ }
+
+ /*
+ * text? then date string, month, day of week, special, or
+ * timezone
+ */
+ else if (isalpha(*cp))
+ {
+ ftype[nf] = DTK_STRING;
+ *lp++ = tolower(*cp++);
+ while (isalpha(*cp))
+ *lp++ = tolower(*cp++);
+
+ /* full date string with leading text month? */
+ if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
+ {
+ /*
+ * special case of Posix timezone "GMT-0800"
+ * Note that other sign (e.g. "GMT+0800"
+ * is recognized as two separate fields and handled later.
+ * XXX There is no room for a delimiter between
+ * the "GMT" and the "-0800", so we are going to just swallow the "GMT".
+ * But this leads to other troubles with the definition of signs,
+ * so we have to flip
+ * - thomas 2000-02-06
+ */
+ if ((*cp == '-') && isdigit(*(cp+1))
+ && (strncmp(field[nf], "gmt", 3) == 0))
+ {
+ *cp = '+';
+ continue;
+ }
+
+ ftype[nf] = DTK_DATE;
+ while (isdigit(*cp) || (*cp == '-') || (*cp == '/') || (*cp == '.'))
+ *lp++ = tolower(*cp++);
+ }
+
+ /* skip leading spaces */
+ }
+ else if (isspace(*cp))
+ {
+ cp++;
+ continue;
+
+ /* sign? then special or numeric timezone */
+ }
+ else if ((*cp == '+') || (*cp == '-'))
+ {
+ *lp++ = *cp++;
+ /* soak up leading whitespace */
+ while (isspace(*cp))
+ cp++;
+ /* numeric timezone? */
+ if (isdigit(*cp))
+ {
+ ftype[nf] = DTK_TZ;
+ *lp++ = *cp++;
+ while (isdigit(*cp) || (*cp == ':'))
+ *lp++ = *cp++;
+
+ /* special? */
+ }
+ else if (isalpha(*cp))
+ {
+ ftype[nf] = DTK_SPECIAL;
+ *lp++ = tolower(*cp++);
+ while (isalpha(*cp))
+ *lp++ = tolower(*cp++);
+
+ /* otherwise something wrong... */
+ }
+ else
+ return -1;
+
+ /* ignore punctuation but use as delimiter */
+ }
+ else if (ispunct(*cp))
+ {
+ cp++;
+ continue;
+
+ }
+ else
+ return -1;
+
+ /* force in a delimiter */
+ *lp++ = '\0';
+ nf++;
+ if (nf > MAXDATEFIELDS)
+ return -1;
+ }
+
+ *numfields = nf;
-/* Subtract a number of days from a date, giving a new date.
+ return 0;
+} /* ParseDateTime() */
+
+
+/* DecodeDateTime()
+ * Interpret previously parsed fields for general date and time.
+ * Return 0 if full date, 1 if only time, and -1 if problems.
+ * External format(s):
+ * "<weekday> <month>-<day>-<year> <hour>:<minute>:<second>"
+ * "Fri Feb-7-1997 15:23:27"
+ * "Feb-7-1997 15:23:27"
+ * "2-7-1997 15:23:27"
+ * "1997-2-7 15:23:27"
+ * "1997.038 15:23:27" (day of year 1-366)
+ * Also supports input in compact time:
+ * "970207 152327"
+ * "97038 152327"
+ *
+ * Use the system-provided functions to get the current time zone
+ * if not specified in the input string.
+ * If the date is outside the time_t system-supported time range,
+ * then assume GMT time zone. - tgl 97/05/27
*/
-DateADT
-date_mii(DateADT dateVal, int4 days)
+int
+DecodeDateTime(char **field, int *ftype, int nf,
+ int *dtype, struct tm * tm, double *fsec, int *tzp)
{
- return date_pli(dateVal, -days);
-} /* date_mii() */
+ int fmask = 0,
+ tmask,
+ type;
+ int i;
+ int flen,
+ val;
+ int mer = HR24;
+ int haveTextMonth = FALSE;
+ int is2digits = FALSE;
+ int bc = FALSE;
+
+ *dtype = DTK_DATE;
+ tm->tm_hour = 0;
+ tm->tm_min = 0;
+ tm->tm_sec = 0;
+ *fsec = 0;
+ tm->tm_isdst = -1; /* don't know daylight savings time status
+ * apriori */
+ if (tzp != NULL)
+ *tzp = 0;
+
+ for (i = 0; i < nf; i++)
+ {
+ switch (ftype[i])
+ {
+ case DTK_DATE:
+ if (DecodeDate(field[i], fmask, &tmask, tm) != 0)
+ return -1;
+ break;
+
+ case DTK_TIME:
+ if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
+ return -1;
+
+ /*
+ * check upper limit on hours; other limits checked in
+ * DecodeTime()
+ */
+ if (tm->tm_hour > 23)
+ return -1;
+ break;
+
+ case DTK_TZ:
+ if (tzp == NULL)
+ return -1;
+ if (DecodeTimezone(field[i], tzp) != 0)
+ return -1;
+ tmask = DTK_M(TZ);
+ break;
+
+ case DTK_NUMBER:
+ flen = strlen(field[i]);
+
+ /*
+ * long numeric string and either no date or no time read
+ * yet? then interpret as a concatenated date or time...
+ */
+ if ((flen > 4) && !((fmask & DTK_DATE_M) && (fmask & DTK_TIME_M)))
+ {
+ if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec, &is2digits) != 0)
+ return -1;
+
+ }
+ /* otherwise it is a single date/time field... */
+ else
+ {
+ if (DecodeNumber(flen, field[i], fmask, &tmask, tm, fsec, &is2digits) != 0)
+ return -1;
+ }
+ break;
+
+ case DTK_STRING:
+ case DTK_SPECIAL:
+ type = DecodeSpecial(i, field[i], &val);
+ if (type == IGNORE)
+ continue;
+
+ tmask = DTK_M(type);
+ switch (type)
+ {
+ case RESERV:
+ switch (val)
+ {
+ case DTK_NOW:
+ tmask = (DTK_DATE_M | DTK_TIME_M | DTK_M(TZ));
+ *dtype = DTK_DATE;
+ GetCurrentTime(tm);
+ if (tzp != NULL)
+ *tzp = CTimeZone;
+ break;
+
+ case DTK_YESTERDAY:
+ tmask = DTK_DATE_M;
+ *dtype = DTK_DATE;
+ GetCurrentTime(tm);
+ j2date((date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - 1),
+ &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
+ tm->tm_hour = 0;
+ tm->tm_min = 0;
+ tm->tm_sec = 0;
+ break;
+
+ case DTK_TODAY:
+ tmask = DTK_DATE_M;
+ *dtype = DTK_DATE;
+ GetCurrentTime(tm);
+ tm->tm_hour = 0;
+ tm->tm_min = 0;
+ tm->tm_sec = 0;
+ break;
+
+ case DTK_TOMORROW:
+ tmask = DTK_DATE_M;
+ *dtype = DTK_DATE;
+ GetCurrentTime(tm);
+ j2date((date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) + 1),
+ &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
+ tm->tm_hour = 0;
+ tm->tm_min = 0;
+ tm->tm_sec = 0;
+ break;
+
+ case DTK_ZULU:
+ tmask = (DTK_TIME_M | DTK_M(TZ));
+ *dtype = DTK_DATE;
+ tm->tm_hour = 0;
+ tm->tm_min = 0;
+ tm->tm_sec = 0;
+ if (tzp != NULL)
+ *tzp = 0;
+ break;
+
+ default:
+ *dtype = val;
+ }
+
+ break;
+
+ case MONTH:
+ /*
+ * already have a (numeric) month? then see if we
+ * can substitute...
+ */
+ if ((fmask & DTK_M(MONTH)) && (!haveTextMonth)
+ && (!(fmask & DTK_M(DAY)))
+ && ((tm->tm_mon >= 1) && (tm->tm_mon <= 31)))
+ {
+ tm->tm_mday = tm->tm_mon;
+ tmask = DTK_M(DAY);
+ }
+ haveTextMonth = TRUE;
+ tm->tm_mon = val;
+ break;
+
+ case DTZMOD:
+
+ /*
+ * daylight savings time modifier (solves "MET
+ * DST" syntax)
+ */
+ tmask |= DTK_M(DTZ);
+ tm->tm_isdst = 1;
+ if (tzp == NULL)
+ return -1;
+ *tzp += val * 60;
+ break;
+
+ case DTZ:
+
+ /*
+ * set mask for TZ here _or_ check for DTZ later
+ * when getting default timezone
+ */
+ tmask |= DTK_M(TZ);
+ tm->tm_isdst = 1;
+ if (tzp == NULL)
+ return -1;
+ *tzp = val * 60;
+ break;
+
+ case TZ:
+ tm->tm_isdst = 0;
+ if (tzp == NULL)
+ return -1;
+ *tzp = val * 60;
+
+ /* Swallow an immediately succeeding timezone if this is GMT
+ * This handles the odd case in FreeBSD of "GMT+0800"
+ * but note that we need to flip the sign on this too.
+ * Claims to be some sort of POSIX standard format :(
+ * - thomas 2000-01-20
+ */
+ if ((i < (nf-1)) && (ftype[i+1] == DTK_TZ)
+ && (strcmp(field[i], "gmt") == 0))
+ {
+ i++;
+ if (DecodeTimezone(field[i], tzp) != 0)
+ return -1;
+
+ /* flip the sign per POSIX standard */
+ *tzp = -(*tzp);
+ }
+
+
+ break;
+
+ case IGNORE:
+ break;
+
+ case AMPM:
+ mer = val;
+ break;
+
+ case ADBC:
+ bc = (val == BC);
+ break;
+
+ case DOW:
+ tm->tm_wday = val;
+ break;
+
+ default:
+ return -1;
+ }
+ break;
+
+ default:
+ return -1;
+ }
+
+ if (tmask & fmask)
+ return -1;
+ fmask |= tmask;
+ }
+
+ /* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */
+ if (bc)
+ {
+ if (tm->tm_year > 0)
+ tm->tm_year = -(tm->tm_year - 1);
+ else
+ elog(ERROR, "Inconsistant use of year %04d and 'BC'", tm->tm_year);
+ }
+ else if (is2digits)
+ {
+ if (tm->tm_year < 70)
+ tm->tm_year += 2000;
+ else if (tm->tm_year < 100)
+ tm->tm_year += 1900;
+ }
+
+ if ((mer != HR24) && (tm->tm_hour > 12))
+ return -1;
+ if ((mer == AM) && (tm->tm_hour == 12))
+ tm->tm_hour = 0;
+ else if ((mer == PM) && (tm->tm_hour != 12))
+ tm->tm_hour += 12;
+
+ /* do additional checking for full date specs... */
+ if (*dtype == DTK_DATE)
+ {
+ if ((fmask & DTK_DATE_M) != DTK_DATE_M)
+ return ((fmask & DTK_TIME_M) == DTK_TIME_M) ? 1 : -1;
+
+ /*
+ * check for valid day of month, now that we know for sure the
+ * month and year...
+ */
+ if ((tm->tm_mday < 1)
+ || (tm->tm_mday > day_tab[isleap(tm->tm_year)][tm->tm_mon - 1]))
+ return -1;
+
+ /* timezone not specified? then find local timezone if possible */
+ if (((fmask & DTK_DATE_M) == DTK_DATE_M)
+ && (tzp != NULL) && (!(fmask & DTK_M(TZ))))
+ {
+
+ /*
+ * daylight savings time modifier but no standard timezone?
+ * then error
+ */
+ if (fmask & DTK_M(DTZMOD))
+ return -1;
+
+ if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon, tm->tm_mday))
+ {
+#ifdef USE_POSIX_TIME
+ tm->tm_year -= 1900;
+ tm->tm_mon -= 1;
+ tm->tm_isdst = -1;
+ mktime(tm);
+ tm->tm_year += 1900;
+ tm->tm_mon += 1;
+
+#if defined(HAVE_TM_ZONE)
+ *tzp = -(tm->tm_gmtoff); /* tm_gmtoff is
+ * Sun/DEC-ism */
+#elif defined(HAVE_INT_TIMEZONE)
+#ifdef __CYGWIN__
+ *tzp = ((tm->tm_isdst > 0) ? (_timezone - 3600) : _timezone);
+#else
+ *tzp = ((tm->tm_isdst > 0) ? (timezone - 3600) : timezone);
+#endif
+#else
+#error USE_POSIX_TIME is defined but neither HAVE_TM_ZONE or HAVE_INT_TIMEZONE are defined
+#endif
+#else /* !USE_POSIX_TIME */
+ *tzp = CTimeZone;
+#endif
+ }
+ else
+ {
+ tm->tm_isdst = 0;
+ *tzp = 0;
+ }
+ }
+ }
-/* date_datetime()
- * Convert date to datetime data type.
+ return 0;
+} /* DecodeDateTime() */
+
+
+/* DecodeTimeOnly()
+ * Interpret parsed string as time fields only.
*/
-DateTime *
-date_datetime(DateADT dateVal)
+int
+DecodeTimeOnly(char **field, int *ftype, int nf, int *dtype, struct tm * tm, double *fsec)
{
- DateTime *result;
- struct tm tt,
- *tm = &tt;
- int tz;
- double fsec = 0;
- char *tzn;
+ int fmask,
+ tmask,
+ type;
+ int i;
+ int flen,
+ val;
+ int is2digits = FALSE;
+ int mer = HR24;
+
+ *dtype = DTK_TIME;
+ tm->tm_hour = 0;
+ tm->tm_min = 0;
+ tm->tm_sec = 0;
+ tm->tm_isdst = -1; /* don't know daylight savings time status
+ * apriori */
+ *fsec = 0;
- result = palloc(sizeof(DateTime));
+ fmask = DTK_DATE_M;
- if (date2tm(dateVal, &tz, tm, &fsec, &tzn) != 0)
- elog(ERROR, "Unable to convert date to datetime");
+ for (i = 0; i < nf; i++)
+ {
+ switch (ftype[i])
+ {
+ case DTK_TIME:
+ if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
+ return -1;
+ break;
+
+ case DTK_NUMBER:
+ flen = strlen(field[i]);
+
+ if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec, &is2digits) != 0)
+ return -1;
+ break;
+
+ case DTK_STRING:
+ case DTK_SPECIAL:
+ type = DecodeSpecial(i, field[i], &val);
+ if (type == IGNORE)
+ continue;
+
+ tmask = DTK_M(type);
+ switch (type)
+ {
+ case RESERV:
+ switch (val)
+ {
+ case DTK_NOW:
+ tmask = DTK_TIME_M;
+ *dtype = DTK_TIME;
+ GetCurrentTime(tm);
+ break;
+
+ case DTK_ZULU:
+ tmask = (DTK_TIME_M | DTK_M(TZ));
+ *dtype = DTK_TIME;
+ tm->tm_hour = 0;
+ tm->tm_min = 0;
+ tm->tm_sec = 0;
+ tm->tm_isdst = 0;
+ break;
+
+ default:
+ return -1;
+ }
+
+ break;
+
+ case IGNORE:
+ break;
+
+ case AMPM:
+ mer = val;
+ break;
+
+ default:
+ return -1;
+ }
+ break;
+
+ default:
+ return -1;
+ }
+
+ if (tmask & fmask)
+ return -1;
+ fmask |= tmask;
+ }
- if (tm2datetime(tm, fsec, &tz, result) != 0)
- elog(ERROR, "Datetime out of range");
+ if ((mer != HR24) && (tm->tm_hour > 12))
+ return -1;
+ if ((mer == AM) && (tm->tm_hour == 12))
+ tm->tm_hour = 0;
+ else if ((mer == PM) && (tm->tm_hour != 12))
+ tm->tm_hour += 12;
+
+ if (((tm->tm_hour < 0) || (tm->tm_hour > 23))
+ || ((tm->tm_min < 0) || (tm->tm_min > 59))
+ || ((tm->tm_sec < 0) || ((tm->tm_sec + *fsec) >= 60)))
+ return -1;
- return result;
-} /* date_datetime() */
+ if ((fmask & DTK_TIME_M) != DTK_TIME_M)
+ return -1;
+ return 0;
+} /* DecodeTimeOnly() */
-/* datetime_date()
- * Convert datetime to date data type.
+
+/* DecodeDate()
+ * Decode date string which includes delimiters.
+ * Insist on a complete set of fields.
*/
-DateADT
-datetime_date(DateTime *datetime)
+int
+DecodeDate(char *str, int fmask, int *tmask, struct tm * tm)
{
- DateADT result;
- struct tm tt,
- *tm = &tt;
- int tz;
double fsec;
- char *tzn;
- if (!PointerIsValid(datetime))
- elog(ERROR, "Unable to convert null datetime to date");
+ int nf = 0;
+ int i,
+ len;
+ int bc = FALSE;
+ int is2digits = FALSE;
+ int type,
+ val,
+ dmask = 0;
+ char *field[MAXDATEFIELDS];
+
+ /* parse this string... */
+ while ((*str != '\0') && (nf < MAXDATEFIELDS))
+ {
+ /* skip field separators */
+ while (!isalnum(*str))
+ str++;
+
+ field[nf] = str;
+ if (isdigit(*str))
+ {
+ while (isdigit(*str))
+ str++;
+ }
+ else if (isalpha(*str))
+ {
+ while (isalpha(*str))
+ str++;
+ }
+
+ if (*str != '\0')
+ *str++ = '\0';
+ nf++;
+ }
+
+#if 0
+ /* don't allow too many fields */
+ if (nf > 3)
+ return -1;
+#endif
- if (DATETIME_NOT_FINITE(*datetime))
- elog(ERROR, "Unable to convert datetime to date");
+ *tmask = 0;
- if (DATETIME_IS_EPOCH(*datetime))
+ /* look first for text fields, since that will be unambiguous month */
+ for (i = 0; i < nf; i++)
{
- datetime2tm(SetDateTime(*datetime), NULL, tm, &fsec, NULL);
+ if (isalpha(*field[i]))
+ {
+ type = DecodeSpecial(i, field[i], &val);
+ if (type == IGNORE)
+ continue;
+
+ dmask = DTK_M(type);
+ switch (type)
+ {
+ case MONTH:
+ tm->tm_mon = val;
+ break;
+
+ case ADBC:
+ bc = (val == BC);
+ break;
+
+ default:
+ return -1;
+ }
+ if (fmask & dmask)
+ return -1;
+
+ fmask |= dmask;
+ *tmask |= dmask;
+
+ /* mark this field as being completed */
+ field[i] = NULL;
+ }
+ }
+
+ /* now pick up remaining numeric fields */
+ for (i = 0; i < nf; i++)
+ {
+ if (field[i] == NULL)
+ continue;
+
+ if ((len = strlen(field[i])) <= 0)
+ return -1;
+
+ if (DecodeNumber(len, field[i], fmask, &dmask, tm, &fsec, &is2digits) != 0)
+ return -1;
+
+ if (fmask & dmask)
+ return -1;
+
+ fmask |= dmask;
+ *tmask |= dmask;
+ }
+
+ if ((fmask & ~(DTK_M(DOY) | DTK_M(TZ))) != DTK_DATE_M)
+ return -1;
+
+ /* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */
+ if (bc)
+ {
+ if (tm->tm_year > 0)
+ tm->tm_year = -(tm->tm_year - 1);
+ else
+ elog(ERROR, "Inconsistant use of year %04d and 'BC'", tm->tm_year);
+ }
+ else if (is2digits)
+ {
+ if (tm->tm_year < 70)
+ tm->tm_year += 2000;
+ else if (tm->tm_year < 100)
+ tm->tm_year += 1900;
+ }
+
+ return 0;
+} /* DecodeDate() */
+
+
+/* DecodeTime()
+ * Decode time string which includes delimiters.
+ * Only check the lower limit on hours, since this same code
+ * can be used to represent time spans.
+ */
+int
+DecodeTime(char *str, int fmask, int *tmask, struct tm * tm, double *fsec)
+{
+ char *cp;
+
+ *tmask = DTK_TIME_M;
+
+ tm->tm_hour = strtol(str, &cp, 10);
+ if (*cp != ':')
+ return -1;
+ str = cp + 1;
+ tm->tm_min = strtol(str, &cp, 10);
+ if (*cp == '\0')
+ {
+ tm->tm_sec = 0;
+ *fsec = 0;
}
- else if (DATETIME_IS_CURRENT(*datetime))
+ else if (*cp != ':')
{
- datetime2tm(SetDateTime(*datetime), &tz, tm, &fsec, &tzn);
+ return -1;
}
else
{
- if (datetime2tm(*datetime, &tz, tm, &fsec, &tzn) != 0)
- elog(ERROR, "Unable to convert datetime to date");
+ str = cp + 1;
+ tm->tm_sec = strtol(str, &cp, 10);
+ if (*cp == '\0')
+ *fsec = 0;
+ else if (*cp == '.')
+ {
+ str = cp;
+ *fsec = strtod(str, &cp);
+ if (cp == str)
+ return -1;
+ }
+ else
+ return -1;
}
- result = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1));
+ /* do a sanity check */
+ if ((tm->tm_hour < 0)
+ || (tm->tm_min < 0) || (tm->tm_min > 59)
+ || (tm->tm_sec < 0) || (tm->tm_sec > 59))
+ return -1;
- return result;
-} /* datetime_date() */
+ return 0;
+} /* DecodeTime() */
-/* abstime_date()
- * Convert abstime to date data type.
+/* DecodeNumber()
+ * Interpret numeric field as a date value in context.
*/
-DateADT
-abstime_date(AbsoluteTime abstime)
+int
+DecodeNumber(int flen, char *str, int fmask,
+ int *tmask, struct tm * tm, double *fsec, int *is2digits)
{
- DateADT result;
- struct tm tt,
- *tm = &tt;
- int tz;
+ int val;
+ char *cp;
+
+ *tmask = 0;
- switch (abstime)
+ val = strtol(str, &cp, 10);
+ if (cp == str)
+ return -1;
+ if (*cp == '.')
{
- case INVALID_ABSTIME:
- case NOSTART_ABSTIME:
- case NOEND_ABSTIME:
- elog(ERROR, "Unable to convert reserved abstime value to date");
+ *fsec = strtod(cp, &cp);
+ if (*cp != '\0')
+ return -1;
+ }
- /*
- * pretend to drop through to make compiler think that result
- * will be set
- */
+ /* Special case day of year? */
+ if ((flen == 3) && (fmask & DTK_M(YEAR))
+ && ((val >= 1) && (val <= 366)))
+ {
+ *tmask = (DTK_M(DOY) | DTK_M(MONTH) | DTK_M(DAY));
+ tm->tm_yday = val;
+ j2date((date2j(tm->tm_year, 1, 1) + tm->tm_yday - 1),
+ &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
- case EPOCH_ABSTIME:
- result = date2j(1970, 1, 1) - date2j(2000, 1, 1);
- break;
+ }
- case CURRENT_ABSTIME:
- GetCurrentTime(tm);
- result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1);
- break;
+ /*
+ * Enough digits to be unequivocal year? Used to test for 4 digits or
+ * more, but we now test first for a three-digit doy so anything
+ * bigger than two digits had better be an explicit year. - thomas
+ * 1999-01-09
+ */
+ else if (flen > 2)
+ {
+ *tmask = DTK_M(YEAR);
- default:
- abstime2tm(abstime, &tz, tm, NULL);
- result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1);
- break;
+ /* already have a year? then see if we can substitute... */
+ if ((fmask & DTK_M(YEAR)) && (!(fmask & DTK_M(DAY)))
+ && ((tm->tm_year >= 1) && (tm->tm_year <= 31)))
+ {
+ tm->tm_mday = tm->tm_year;
+ *tmask = DTK_M(DAY);
+ }
+
+ tm->tm_year = val;
}
+ /* already have year? then could be month */
+ else if ((fmask & DTK_M(YEAR)) && (!(fmask & DTK_M(MONTH)))
+ && ((val >= 1) && (val <= 12)))
+ {
+ *tmask = DTK_M(MONTH);
+ tm->tm_mon = val;
+ /* no year and EuroDates enabled? then could be day */
+ }
+ else if ((EuroDates || (fmask & DTK_M(MONTH)))
+ && (!(fmask & DTK_M(YEAR)) && !(fmask & DTK_M(DAY)))
+ && ((val >= 1) && (val <= 31)))
+ {
+ *tmask = DTK_M(DAY);
+ tm->tm_mday = val;
+ }
+ else if ((!(fmask & DTK_M(MONTH)))
+ && ((val >= 1) && (val <= 12)))
+ {
+ *tmask = DTK_M(MONTH);
+ tm->tm_mon = val;
+ }
+ else if ((!(fmask & DTK_M(DAY)))
+ && ((val >= 1) && (val <= 31)))
+ {
+ *tmask = DTK_M(DAY);
+ tm->tm_mday = val;
+ }
+ else if (!(fmask & DTK_M(YEAR)))
+ {
+ *tmask = DTK_M(YEAR);
+ tm->tm_year = val;
+
+ /* adjust ONLY if exactly two digits... */
+ *is2digits = (flen == 2);
+ }
+ else
+ return -1;
- return result;
-} /* abstime_date() */
+ return 0;
+} /* DecodeNumber() */
-/* date2tm()
- * Convert date to time structure.
- * Note that date is an implicit local time, but the system calls assume
- * that everything is GMT. So, convert to GMT, rotate to local time,
- * and then convert again to try to get the time zones correct.
+/* DecodeNumberField()
+ * Interpret numeric string as a concatenated date field.
*/
-static int
-date2tm(DateADT dateVal, int *tzp, struct tm * tm, double *fsec, char **tzn)
+int
+DecodeNumberField(int len, char *str, int fmask,
+ int *tmask, struct tm * tm, double *fsec, int *is2digits)
{
- struct tm *tx;
- time_t utime;
+ char *cp;
- *fsec = 0;
+ /* yyyymmdd? */
+ if (len == 8)
+ {
+ *tmask = DTK_DATE_M;
+
+ tm->tm_mday = atoi(str + 6);
+ *(str + 6) = '\0';
+ tm->tm_mon = atoi(str + 4);
+ *(str + 4) = '\0';
+ tm->tm_year = atoi(str + 0);
+ /* yymmdd or hhmmss? */
+ }
+ else if (len == 6)
+ {
+ if (fmask & DTK_DATE_M)
+ {
+ *tmask = DTK_TIME_M;
+ tm->tm_sec = atoi(str + 4);
+ *(str + 4) = '\0';
+ tm->tm_min = atoi(str + 2);
+ *(str + 2) = '\0';
+ tm->tm_hour = atoi(str + 0);
+ }
+ else
+ {
+ *tmask = DTK_DATE_M;
+ tm->tm_mday = atoi(str + 4);
+ *(str + 4) = '\0';
+ tm->tm_mon = atoi(str + 2);
+ *(str + 2) = '\0';
+ tm->tm_year = atoi(str + 0);
+ *is2digits = TRUE;
+ }
+
+ }
+ else if ((len == 5) && !(fmask & DTK_DATE_M))
+ {
+ *tmask = DTK_DATE_M;
+ tm->tm_mday = atoi(str + 2);
+ *(str + 2) = '\0';
+ tm->tm_mon = 1;
+ tm->tm_year = atoi(str + 0);
+ *is2digits = TRUE;
+ }
+ else if (strchr(str, '.') != NULL)
+ {
+ *tmask = DTK_TIME_M;
+ tm->tm_sec = strtod((str + 4), &cp);
+ if (cp == (str + 4))
+ return -1;
+ if (*cp == '.')
+ *fsec = strtod(cp, NULL);
+ *(str + 4) = '\0';
+ tm->tm_min = strtod((str + 2), &cp);
+ *(str + 2) = '\0';
+ tm->tm_hour = strtod((str + 0), &cp);
+
+ }
+ else
+ return -1;
+
+ return 0;
+} /* DecodeNumberField() */
- j2date((dateVal + date2j(2000, 1, 1)), &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
- tm->tm_hour = 0;
- tm->tm_min = 0;
- tm->tm_sec = 0;
- tm->tm_isdst = -1;
- if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon, tm->tm_mday))
+/* DecodeTimezone()
+ * Interpret string as a numeric timezone.
+ */
+int
+DecodeTimezone(char *str, int *tzp)
+{
+ int tz;
+ int hr,
+ min;
+ char *cp;
+ int len;
+
+ /* assume leading character is "+" or "-" */
+ hr = strtol((str + 1), &cp, 10);
+
+ /* explicit delimiter? */
+ if (*cp == ':')
{
+ min = strtol((cp + 1), &cp, 10);
- /* convert to system time */
- utime = ((dateVal + (date2j(2000, 1, 1) - date2j(1970, 1, 1))) * 86400);
- /* rotate to noon to get the right day in time zone */
- utime += (12 * 60 * 60);
+ /* otherwise, might have run things together... */
+ }
+ else if ((*cp == '\0') && ((len = strlen(str)) > 3))
+ {
+ min = strtol((str + len - 2), &cp, 10);
+ *(str + len - 2) = '\0';
+ hr = strtol((str + 1), &cp, 10);
-#ifdef USE_POSIX_TIME
- tx = localtime(&utime);
+ }
+ else
+ min = 0;
- tm->tm_year = tx->tm_year + 1900;
- tm->tm_mon = tx->tm_mon + 1;
- tm->tm_mday = tx->tm_mday;
- tm->tm_isdst = tx->tm_isdst;
+ tz = (hr * 60 + min) * 60;
+ if (*str == '-')
+ tz = -tz;
-#if defined(HAVE_TM_ZONE)
- tm->tm_gmtoff = tx->tm_gmtoff;
- tm->tm_zone = tx->tm_zone;
+ *tzp = -tz;
+ return *cp != '\0';
+} /* DecodeTimezone() */
- /* tm_gmtoff is Sun/DEC-ism */
- *tzp = -(tm->tm_gmtoff);
- if (tzn != NULL)
- *tzn = (char *) tm->tm_zone;
-#elif defined(HAVE_INT_TIMEZONE)
-#ifdef __CYGWIN__
- *tzp = (tm->tm_isdst ? (_timezone - 3600) : _timezone);
-#else
- *tzp = (tm->tm_isdst ? (timezone - 3600) : timezone);
-#endif
- if (tzn != NULL)
- *tzn = tzname[(tm->tm_isdst > 0)];
-#else
-#error USE_POSIX_TIME is defined but neither HAVE_TM_ZONE or HAVE_INT_TIMEZONE are defined
+
+/* DecodeSpecial()
+ * Decode text string using lookup table.
+ * Implement a cache lookup since it is likely that dates
+ * will be related in format.
+ */
+int
+DecodeSpecial(int field, char *lowtoken, int *val)
+{
+ int type;
+ datetkn *tp;
+
+#if USE_DATE_CACHE
+ if ((datecache[field] != NULL)
+ && (strncmp(lowtoken, datecache[field]->token, TOKMAXLEN) == 0))
+ tp = datecache[field];
+ else
+ {
#endif
-#else /* !USE_POSIX_TIME */
- *tzp = CTimeZone; /* V7 conventions; don't know timezone? */
- if (tzn != NULL)
- *tzn = CTZName;
+ tp = datebsearch(lowtoken, datetktbl, szdatetktbl);
+#if USE_DATE_CACHE
+ }
+ datecache[field] = tp;
#endif
-
- /* otherwise, outside of timezone range so convert to GMT... */
+ if (tp == NULL)
+ {
+ type = IGNORE;
+ *val = 0;
}
else
{
- *tzp = 0;
- tm->tm_isdst = 0;
- if (tzn != NULL)
- *tzn = NULL;
+ type = tp->type;
+ switch (type)
+ {
+ case TZ:
+ case DTZ:
+ case DTZMOD:
+ *val = FROMVAL(tp);
+ break;
+
+ default:
+ *val = tp->value;
+ break;
+ }
}
- return 0;
-} /* date2tm() */
-
-
-/*****************************************************************************
- * Time ADT
- *****************************************************************************/
+ return type;
+} /* DecodeSpecial() */
-TimeADT *
-time_in(char *str)
+/* DecodeDateDelta()
+ * Interpret previously parsed fields for general time interval.
+ * Return 0 if decoded and -1 if problems.
+ *
+ * Allow "date" field DTK_DATE since this could be just
+ * an unsigned floating point number. - thomas 1997-11-16
+ *
+ * Allow ISO-style time span, with implicit units on number of days
+ * preceeding an hh:mm:ss field. - thomas 1998-04-30
+ */
+int
+DecodeDateDelta(char **field, int *ftype, int nf, int *dtype, struct tm * tm, double *fsec)
{
- TimeADT *time;
+ int is_before = FALSE;
+
+ char *cp;
+ int fmask = 0,
+ tmask,
+ type;
+ int i;
+ int flen,
+ val;
+ double fval;
+ double sec;
+
+ *dtype = DTK_DELTA;
+
+ type = DTK_SECOND;
+ 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;
- double fsec;
- struct tm tt,
- *tm = &tt;
+ /* read through list backwards to pick up units before values */
+ for (i = nf - 1; i >= 0; i--)
+ {
+ switch (ftype[i])
+ {
+ case DTK_TIME:
+ if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
+ return -1;
+ type = DTK_DAY;
+ break;
+
+ case DTK_TZ:
+
+ /*
+ * Timezone is a token with a leading sign character and
+ * otherwise the same as a non-signed numeric field
+ */
+ case DTK_DATE:
+ case DTK_NUMBER:
+ val = strtol(field[i], &cp, 10);
+ if (*cp == '.')
+ {
+ fval = strtod(cp, &cp);
+ if (*cp != '\0')
+ return -1;
+
+ if (val < 0)
+ fval = -(fval);
+ }
+ else if (*cp == '\0')
+ fval = 0;
+ else
+ return -1;
+
+ flen = strlen(field[i]);
+ tmask = 0; /* DTK_M(type); */
+
+ switch (type)
+ {
+ case DTK_MICROSEC:
+ *fsec += ((val + fval) * 1e-6);
+ break;
+
+ case DTK_MILLISEC:
+ *fsec += ((val + fval) * 1e-3);
+ break;
+
+ case DTK_SECOND:
+ tm->tm_sec += val;
+ *fsec += fval;
+ tmask = DTK_M(SECOND);
+ break;
+
+ case DTK_MINUTE:
+ tm->tm_min += val;
+ if (fval != 0)
+ tm->tm_sec += (fval * 60);
+ tmask = DTK_M(MINUTE);
+ break;
+
+ case DTK_HOUR:
+ tm->tm_hour += val;
+ if (fval != 0)
+ tm->tm_sec += (fval * 3600);
+ tmask = DTK_M(HOUR);
+ break;
+
+ case DTK_DAY:
+ tm->tm_mday += val;
+ if (fval != 0)
+ tm->tm_sec += (fval * 86400);
+ tmask = ((fmask & DTK_M(DAY)) ? 0 : DTK_M(DAY));
+ break;
+
+ case DTK_WEEK:
+ tm->tm_mday += val * 7;
+ if (fval != 0)
+ tm->tm_sec += (fval * (7 * 86400));
+ tmask = ((fmask & DTK_M(DAY)) ? 0 : DTK_M(DAY));
+ break;
+
+ case DTK_MONTH:
+ tm->tm_mon += val;
+ if (fval != 0)
+ tm->tm_sec += (fval * (30 * 86400));
+ tmask = DTK_M(MONTH);
+ break;
+
+ case DTK_YEAR:
+ tm->tm_year += val;
+ if (fval != 0)
+ tm->tm_mon += (fval * 12);
+ tmask = ((fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR));
+ break;
+
+ case DTK_DECADE:
+ tm->tm_year += val * 10;
+ if (fval != 0)
+ tm->tm_mon += (fval * 120);
+ tmask = ((fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR));
+ break;
+
+ case DTK_CENTURY:
+ tm->tm_year += val * 100;
+ if (fval != 0)
+ tm->tm_mon += (fval * 1200);
+ tmask = ((fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR));
+ break;
+
+ case DTK_MILLENIUM:
+ tm->tm_year += val * 1000;
+ if (fval != 0)
+ tm->tm_mon += (fval * 12000);
+ tmask = ((fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR));
+ break;
+
+ default:
+ return -1;
+ }
+ break;
+
+ case DTK_STRING:
+ case DTK_SPECIAL:
+ type = DecodeUnits(i, field[i], &val);
+ if (type == IGNORE)
+ continue;
+
+ tmask = 0; /* DTK_M(type); */
+ switch (type)
+ {
+ case UNITS:
+ type = val;
+ break;
+
+ case AGO:
+ is_before = TRUE;
+ type = val;
+ break;
+
+ case RESERV:
+ tmask = (DTK_DATE_M || DTK_TIME_M);
+ *dtype = val;
+ break;
+
+ default:
+ return -1;
+ }
+ break;
+
+ default:
+ return -1;
+ }
+
+ if (tmask & fmask)
+ return -1;
+ fmask |= tmask;
+ }
- int nf;
- char lowstr[MAXDATELEN + 1];
- char *field[MAXDATEFIELDS];
- int dtype;
- int ftype[MAXDATEFIELDS];
+ if (*fsec != 0)
+ {
+ TMODULO(*fsec, sec, 1e0);
+ tm->tm_sec += sec;
+ }
- if (!PointerIsValid(str))
- elog(ERROR, "Bad (null) time external representation");
+ if (is_before)
+ {
+ *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 ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
- || (DecodeTimeOnly(field, ftype, nf, &dtype, tm, &fsec) != 0))
- elog(ERROR, "Bad time external representation '%s'", str);
+ /* ensure that at least one time field has been found */
+ return (fmask != 0) ? 0 : -1;
+} /* DecodeDateDelta() */
- time = palloc(sizeof(TimeADT));
- *time = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec + fsec);
+/* DecodeUnits()
+ * Decode text string using lookup table.
+ * This routine supports time interval decoding.
+ */
+int
+DecodeUnits(int field, char *lowtoken, int *val)
+{
+ int type;
+ datetkn *tp;
- return time;
-} /* time_in() */
+#if USE_DATE_CACHE
+ if ((deltacache[field] != NULL)
+ && (strncmp(lowtoken, deltacache[field]->token, TOKMAXLEN) == 0))
+ tp = deltacache[field];
+ else
+ {
+#endif
+ tp = datebsearch(lowtoken, deltatktbl, szdeltatktbl);
+#if USE_DATE_CACHE
+ }
+ deltacache[field] = tp;
+#endif
+ if (tp == NULL)
+ {
+ type = IGNORE;
+ *val = 0;
+ }
+ else
+ {
+ type = tp->type;
+ if ((type == TZ) || (type == DTZ))
+ *val = FROMVAL(tp);
+ else
+ *val = tp->value;
+ }
+
+ return type;
+} /* DecodeUnits() */
-char *
-time_out(TimeADT *time)
+/* datebsearch()
+ * Binary search -- from Knuth (6.2.1) Algorithm B. Special case like this
+ * is WAY faster than the generic bsearch().
+ */
+datetkn *
+datebsearch(char *key, datetkn *base, unsigned int nel)
{
- char *result;
- struct tm tt,
- *tm = &tt;
+ datetkn *last = base + nel - 1,
+ *position;
+ int result;
- double fsec;
- char buf[MAXDATELEN + 1];
+ while (last >= base)
+ {
+ position = base + ((last - base) >> 1);
+ result = key[0] - position->token[0];
+ if (result == 0)
+ {
+ result = strncmp(key, position->token, TOKMAXLEN);
+ if (result == 0)
+ return position;
+ }
+ if (result < 0)
+ last = position - 1;
+ else
+ base = position + 1;
+ }
+ return NULL;
+}
- if (!PointerIsValid(time))
- return NULL;
- tm->tm_hour = (*time / (60 * 60));
- tm->tm_min = (((int) (*time / 60)) % 60);
- tm->tm_sec = (((int) *time) % 60);
+/* EncodeDateOnly()
+ * Encode date as local time.
+ */
+int
+EncodeDateOnly(struct tm * tm, int style, char *str)
+{
+ if ((tm->tm_mon < 1) || (tm->tm_mon > 12))
+ return -1;
- fsec = 0;
+ switch (style)
+ {
+ /* compatible with ISO date formats */
+ case USE_ISO_DATES:
+ if (tm->tm_year > 0)
+ sprintf(str, "%04d-%02d-%02d",
+ tm->tm_year, tm->tm_mon, tm->tm_mday);
+ else
+ sprintf(str, "%04d-%02d-%02d %s",
+ -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, "BC");
+ break;
- EncodeTimeOnly(tm, fsec, DateStyle, buf);
+ /* compatible with Oracle/Ingres date formats */
+ case USE_SQL_DATES:
+ if (EuroDates)
+ sprintf(str, "%02d/%02d", tm->tm_mday, tm->tm_mon);
+ else
+ sprintf(str, "%02d/%02d", tm->tm_mon, tm->tm_mday);
+ if (tm->tm_year > 0)
+ sprintf((str + 5), "/%04d", tm->tm_year);
+ else
+ sprintf((str + 5), "/%04d %s", -(tm->tm_year - 1), "BC");
+ break;
- result = palloc(strlen(buf) + 1);
+ /* German-style date format */
+ case USE_GERMAN_DATES:
+ sprintf(str, "%02d.%02d", tm->tm_mday, tm->tm_mon);
+ if (tm->tm_year > 0)
+ sprintf((str + 5), ".%04d", tm->tm_year);
+ else
+ sprintf((str + 5), ".%04d %s", -(tm->tm_year - 1), "BC");
+ break;
- strcpy(result, buf);
+ /* traditional date-only style for Postgres */
+ case USE_POSTGRES_DATES:
+ default:
+ if (EuroDates)
+ sprintf(str, "%02d-%02d", tm->tm_mday, tm->tm_mon);
+ else
+ sprintf(str, "%02d-%02d", tm->tm_mon, tm->tm_mday);
+ if (tm->tm_year > 0)
+ sprintf((str + 5), "-%04d", tm->tm_year);
+ else
+ sprintf((str + 5), "-%04d %s", -(tm->tm_year - 1), "BC");
+ break;
+ }
- return result;
-} /* time_out() */
+ return TRUE;
+} /* EncodeDateOnly() */
-bool
-time_eq(TimeADT *time1, TimeADT *time2)
+/* EncodeTimeOnly()
+ * Encode time fields only.
+ */
+int
+EncodeTimeOnly(struct tm * tm, double fsec, int style, char *str)
{
- if (!PointerIsValid(time1) || !PointerIsValid(time2))
- return FALSE;
+ double sec;
- return *time1 == *time2;
-} /* time_eq() */
+ if ((tm->tm_hour < 0) || (tm->tm_hour > 24))
+ return -1;
-bool
-time_ne(TimeADT *time1, TimeADT *time2)
-{
- if (!PointerIsValid(time1) || !PointerIsValid(time2))
- return FALSE;
+ sec = (tm->tm_sec + fsec);
- return *time1 != *time2;
-} /* time_eq() */
+ sprintf(str, "%02d:%02d:", tm->tm_hour, tm->tm_min);
+ sprintf((str + 6), ((fsec != 0) ? "%05.2f" : "%02.0f"), sec);
-bool
-time_lt(TimeADT *time1, TimeADT *time2)
-{
- if (!PointerIsValid(time1) || !PointerIsValid(time2))
- return FALSE;
+ return TRUE;
+} /* EncodeTimeOnly() */
- return *time1 < *time2;
-} /* time_eq() */
-bool
-time_le(TimeADT *time1, TimeADT *time2)
+/* EncodeDateTime()
+ * Encode date and time interpreted as local time.
+ * Support several date styles:
+ * Postgres - day mon hh:mm:ss yyyy tz
+ * SQL - mm/dd/yyyy hh:mm:ss.ss tz
+ * ISO - yyyy-mm-dd hh:mm:ss+/-tz
+ * German - dd.mm/yyyy hh:mm:ss tz
+ * Variants (affects order of month and day for Postgres and SQL styles):
+ * US - mm/dd/yyyy
+ * European - dd/mm/yyyy
+ */
+int
+EncodeDateTime(struct tm * tm, double fsec, int *tzp, char **tzn, int style, char *str)
{
- if (!PointerIsValid(time1) || !PointerIsValid(time2))
- return FALSE;
+ int day,
+ hour,
+ min;
+ double sec;
- return *time1 <= *time2;
-} /* time_eq() */
+ if ((tm->tm_mon < 1) || (tm->tm_mon > 12))
+ return -1;
-bool
-time_gt(TimeADT *time1, TimeADT *time2)
-{
- if (!PointerIsValid(time1) || !PointerIsValid(time2))
- return FALSE;
+ sec = (tm->tm_sec + fsec);
- return *time1 > *time2;
-} /* time_eq() */
+ switch (style)
+ {
+ /* compatible with ISO date formats */
+
+ case USE_ISO_DATES:
+ if (tm->tm_year > 0)
+ {
+ sprintf(str, "%04d-%02d-%02d %02d:%02d:",
+ tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min);
+ sprintf((str + 17), ((fsec != 0) ? "%05.2f" : "%02.0f"), sec);
+
+ if ((*tzn != NULL) && (tm->tm_isdst >= 0))
+ {
+ if (tzp != NULL)
+ {
+ hour = -(*tzp / 3600);
+ min = ((abs(*tzp) / 60) % 60);
+ }
+ else
+ {
+ hour = 0;
+ min = 0;
+ }
+ sprintf((str + strlen(str)), ((min != 0) ? "%+03d:%02d" : "%+03d"), hour, min);
+ }
+
+ }
+ else
+ {
+ if (tm->tm_hour || tm->tm_min)
+ sprintf(str, "%04d-%02d-%02d %02d:%02d %s",
+ -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, "BC");
+ else
+ sprintf(str, "%04d-%02d-%02d %s",
+ -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, "BC");
+ }
+ break;
-bool
-time_ge(TimeADT *time1, TimeADT *time2)
-{
- if (!PointerIsValid(time1) || !PointerIsValid(time2))
- return FALSE;
+ /* compatible with Oracle/Ingres date formats */
+ case USE_SQL_DATES:
+ if (EuroDates)
+ sprintf(str, "%02d/%02d", tm->tm_mday, tm->tm_mon);
+ else
+ sprintf(str, "%02d/%02d", tm->tm_mon, tm->tm_mday);
+
+ if (tm->tm_year > 0)
+ {
+ sprintf((str + 5), "/%04d %02d:%02d:%05.2f",
+ tm->tm_year, tm->tm_hour, tm->tm_min, sec);
+
+ if ((*tzn != NULL) && (tm->tm_isdst >= 0))
+ {
+ strcpy((str + 22), " ");
+ strcpy((str + 23), *tzn);
+ }
+
+ }
+ else
+ sprintf((str + 5), "/%04d %02d:%02d %s",
+ -(tm->tm_year - 1), tm->tm_hour, tm->tm_min, "BC");
+ break;
- return *time1 >= *time2;
-} /* time_eq() */
+ /* German variant on European style */
+ case USE_GERMAN_DATES:
+ sprintf(str, "%02d.%02d", tm->tm_mday, tm->tm_mon);
+ if (tm->tm_year > 0)
+ {
+ sprintf((str + 5), ".%04d %02d:%02d:%05.2f",
+ tm->tm_year, tm->tm_hour, tm->tm_min, sec);
+
+ if ((*tzn != NULL) && (tm->tm_isdst >= 0))
+ {
+ strcpy((str + 22), " ");
+ strcpy((str + 23), *tzn);
+ }
+
+ }
+ else
+ sprintf((str + 5), ".%04d %02d:%02d %s",
+ -(tm->tm_year - 1), tm->tm_hour, tm->tm_min, "BC");
+ break;
-int
-time_cmp(TimeADT *time1, TimeADT *time2)
-{
- return (*time1 < *time2) ? -1 : (((*time1 > *time2) ? 1 : 0));
-} /* time_cmp() */
+ /* backward-compatible with traditional Postgres abstime dates */
+ case USE_POSTGRES_DATES:
+ default:
+ day = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday);
+ tm->tm_wday = j2day(day);
+
+ strncpy(str, days[tm->tm_wday], 3);
+ strcpy((str + 3), " ");
+
+ if (EuroDates)
+ sprintf((str + 4), "%02d %3s", tm->tm_mday, months[tm->tm_mon - 1]);
+ else
+ sprintf((str + 4), "%3s %02d", months[tm->tm_mon - 1], tm->tm_mday);
+
+ if (tm->tm_year > 0)
+ {
+ sprintf((str + 10), " %02d:%02d", tm->tm_hour, tm->tm_min);
+ if (fsec != 0)
+ {
+ sprintf((str + 16), ":%05.2f %04d", sec, tm->tm_year);
+ if ((*tzn != NULL) && (tm->tm_isdst >= 0))
+ {
+ strcpy((str + 27), " ");
+ strncpy((str + 28), *tzn, MAXTZLEN);
+ }
+ }
+ else
+ {
+ sprintf((str + 16), ":%02.0f %04d", sec, tm->tm_year);
+ if ((*tzn != NULL) && (tm->tm_isdst >= 0))
+ {
+ strcpy((str + 24), " ");
+ strncpy((str + 25), *tzn, MAXTZLEN);
+ }
+ }
+
+ }
+ else
+ {
+ sprintf((str + 10), " %02d:%02d %04d %s",
+ tm->tm_hour, tm->tm_min, -(tm->tm_year - 1), "BC");
+ }
+ break;
+ }
+ return TRUE;
+} /* EncodeDateTime() */
-/* datetime_time()
- * Convert datetime to time data type.
+
+/* EncodeTimeSpan()
+ * Interpret time structure as a delta time and convert to string.
+ *
+ * Support "traditional Postgres" and ISO-8601 styles.
+ * Actually, afaik ISO does not address time interval formatting,
+ * but this looks similar to the spec for absolute date/time.
+ * - thomas 1998-04-30
*/
-TimeADT *
-datetime_time(DateTime *datetime)
+int
+EncodeTimeSpan(struct tm * tm, double fsec, int style, char *str)
{
- TimeADT *result;
- struct tm tt,
- *tm = &tt;
- int tz;
- double fsec;
- char *tzn;
+ int is_before = FALSE;
+ int is_nonzero = FALSE;
+ char *cp = str;
- if (!PointerIsValid(datetime))
- elog(ERROR, "Unable to convert null datetime to date");
+ switch (style)
+ {
+ /* compatible with ISO date formats */
+ case USE_ISO_DATES:
+ break;
- if (DATETIME_NOT_FINITE(*datetime))
- elog(ERROR, "Unable to convert datetime to date");
+ default:
+ strcpy(cp, "@ ");
+ cp += strlen(cp);
+ break;
+ }
- if (DATETIME_IS_EPOCH(*datetime))
+ if (tm->tm_year != 0)
{
- datetime2tm(SetDateTime(*datetime), NULL, tm, &fsec, NULL);
+ is_before |= (tm->tm_year < 0);
+ sprintf(cp, "%d year%s",
+ abs(tm->tm_year), ((abs(tm->tm_year) != 1) ? "s" : ""));
+ cp += strlen(cp);
+ is_nonzero = TRUE;
+ }
+ if (tm->tm_mon != 0)
+ {
+ is_before |= (tm->tm_mon < 0);
+ sprintf(cp, "%s%d mon%s", (is_nonzero ? " " : ""),
+ abs(tm->tm_mon), ((abs(tm->tm_mon) != 1) ? "s" : ""));
+ cp += strlen(cp);
+ is_nonzero = TRUE;
}
- else if (DATETIME_IS_CURRENT(*datetime))
+
+ switch (style)
{
- datetime2tm(SetDateTime(*datetime), &tz, tm, &fsec, &tzn);
+ /* compatible with ISO date formats */
+ case USE_ISO_DATES:
+ if (tm->tm_mday != 0)
+ {
+ is_before |= (tm->tm_mday < 0);
+ sprintf(cp, "%s%d", (is_nonzero ? " " : ""), abs(tm->tm_mday));
+ cp += strlen(cp);
+ is_nonzero = TRUE;
+ }
+ is_before |= ((tm->tm_hour < 0) || (tm->tm_min < 0));
+ sprintf(cp, "%s%02d:%02d", (is_nonzero ? " " : ""),
+ abs(tm->tm_hour), abs(tm->tm_min));
+ cp += strlen(cp);
+ if ((tm->tm_hour != 0) || (tm->tm_min != 0))
+ is_nonzero = TRUE;
+
+ /* fractional seconds? */
+ if (fsec != 0)
+ {
+ fsec += tm->tm_sec;
+ is_before |= (fsec < 0);
+ sprintf(cp, ":%05.2f", fabs(fsec));
+ cp += strlen(cp);
+ is_nonzero = TRUE;
+
+ /* otherwise, integer seconds only? */
+ }
+ else if (tm->tm_sec != 0)
+ {
+ is_before |= (tm->tm_sec < 0);
+ sprintf(cp, ":%02d", abs(tm->tm_sec));
+ cp += strlen(cp);
+ is_nonzero = TRUE;
+ }
+ break;
+ case USE_POSTGRES_DATES:
+ default:
+ if (tm->tm_mday != 0)
+ {
+ is_before |= (tm->tm_mday < 0);
+ sprintf(cp, "%s%d day%s", (is_nonzero ? " " : ""),
+ abs(tm->tm_mday), ((abs(tm->tm_mday) != 1) ? "s" : ""));
+ cp += strlen(cp);
+ is_nonzero = TRUE;
+ }
+ if (tm->tm_hour != 0)
+ {
+ is_before |= (tm->tm_hour < 0);
+ sprintf(cp, "%s%d hour%s", (is_nonzero ? " " : ""),
+ abs(tm->tm_hour), ((abs(tm->tm_hour) != 1) ? "s" : ""));
+ cp += strlen(cp);
+ is_nonzero = TRUE;
+ }
+
+ if (tm->tm_min != 0)
+ {
+ is_before |= (tm->tm_min < 0);
+ sprintf(cp, "%s%d min%s", (is_nonzero ? " " : ""),
+ abs(tm->tm_min), ((abs(tm->tm_min) != 1) ? "s" : ""));
+ cp += strlen(cp);
+ is_nonzero = TRUE;
+ }
+
+ /* fractional seconds? */
+ if (fsec != 0)
+ {
+ fsec += tm->tm_sec;
+ is_before |= (fsec < 0);
+ sprintf(cp, "%s%.2f secs", (is_nonzero ? " " : ""), fabs(fsec));
+ cp += strlen(cp);
+ is_nonzero = TRUE;
+
+ /* otherwise, integer seconds only? */
+ }
+ else if (tm->tm_sec != 0)
+ {
+ is_before |= (tm->tm_sec < 0);
+ sprintf(cp, "%s%d sec%s", (is_nonzero ? " " : ""),
+ abs(tm->tm_sec), ((abs(tm->tm_sec) != 1) ? "s" : ""));
+ cp += strlen(cp);
+ is_nonzero = TRUE;
+ }
+ break;
}
- else
+
+ /* identically zero? then put in a unitless zero... */
+ if (!is_nonzero)
{
- if (datetime2tm(*datetime, &tz, tm, &fsec, &tzn) != 0)
- elog(ERROR, "Unable to convert datetime to date");
+ strcat(cp, "0");
+ cp += strlen(cp);
}
- result = palloc(sizeof(TimeADT));
+ if (is_before)
+ {
+ strcat(cp, " ago");
+ cp += strlen(cp);
+ }
- *result = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec + fsec);
+ return 0;
+} /* EncodeTimeSpan() */
- return result;
-} /* datetime_time() */
+#if defined(linux) && defined(__powerpc__)
-/* datetime_datetime()
- * Convert date and time to datetime data type.
- */
-DateTime *
-datetime_datetime(DateADT date, TimeADT *time)
+int
+timestamp_is_epoch(double j)
{
- DateTime *result;
-
- if (!PointerIsValid(time))
+ static union
{
- result = palloc(sizeof(DateTime));
- DATETIME_INVALID(*result);
- }
- else
- {
- result = date_datetime(date);
- *result += *time;
- }
-
- return result;
-} /* datetime_datetime() */
+ double epoch;
+ unsigned char c[8];
+ } u;
+ u.c[0] = 0x80; /* sign bit */
+ u.c[1] = 0x10; /* DBL_MIN */
-int32 /* RelativeTime */
-int4reltime(int32 timevalue)
+ return j == u.epoch;
+}
+int
+timestamp_is_current(double j)
{
- return timevalue;
+ static union
+ {
+ double current;
+ unsigned char c[8];
+ } u;
+
+ u.c[1] = 0x10; /* DBL_MIN */
+
+ return j == u.current;
}
+
+#endif
projects / postgresql / commitdiff