Logo Search packages:      
Sourcecode: postgresql-8.4 version File versions  Download package

nabstime.c
/*-------------------------------------------------------------------------
 *
 * nabstime.c
 *      Utilities for the built-in type "AbsoluteTime".
 *      Functions for the built-in type "RelativeTime".
 *      Functions for the built-in type "TimeInterval".
 *
 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *      $PostgreSQL: pgsql/src/backend/utils/adt/nabstime.c,v 1.161 2009/06/11 14:49:03 momjian Exp $
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include <ctype.h>
#include <float.h>
#include <limits.h>
#include <time.h>
#include <sys/time.h>

#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "utils/builtins.h"
#include "utils/nabstime.h"

#define MIN_DAYNUM (-24856)         /* December 13, 1901 */
#define MAX_DAYNUM 24854            /* January 18, 2038 */

/*
 * Unix epoch is Jan  1 00:00:00 1970.
 * Postgres knows about times sixty-eight years on either side of that
 * for these 4-byte types.
 *
 * "tinterval" is two 4-byte fields.
 * Definitions for parsing tinterval.
 */

#define IsSpace(C)                        ((C) == ' ')

#define T_INTERVAL_INVAL   0  /* data represents no valid tinterval */
#define T_INTERVAL_VALID   1  /* data represents a valid tinterval */
/*
 * ['Mon May 10 23:59:12 1943 PST' 'Sun Jan 14 03:14:21 1973 PST']
 * 0        1             2               3             4               5             6
 * 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) \
      (DatumGetBool(DirectFunctionCall2(abstimele, \
                          AbsoluteTimeGetDatum(t1), \
                          AbsoluteTimeGetDatum(t2))) ? (t1) : (t2))
#define ABSTIMEMAX(t1, t2) \
      (DatumGetBool(DirectFunctionCall2(abstimelt, \
                          AbsoluteTimeGetDatum(t1), \
                          AbsoluteTimeGetDatum(t2))) ? (t2) : (t1))


/*
 * Function prototypes -- internal to this file only
 */

static AbsoluteTime tm2abstime(struct pg_tm * tm, int tz);
static void reltime2tm(RelativeTime time, struct pg_tm * tm);
static void parsetinterval(char *i_string,
                     AbsoluteTime *i_start,
                     AbsoluteTime *i_end);


/*
 * GetCurrentAbsoluteTime()
 *
 * Get the current system time (relative to Unix epoch).
 *
 * NB: this will overflow in 2038; it should be gone long before that.
 */
AbsoluteTime
GetCurrentAbsoluteTime(void)
{
      time_t            now;

      now = time(NULL);
      return (AbsoluteTime) now;
}


void
abstime2tm(AbsoluteTime _time, int *tzp, struct pg_tm * tm, char **tzn)
{
      pg_time_t   time = (pg_time_t) _time;
      struct pg_tm *tx;

      /*
       * If HasCTZSet is true then we have a brute force time zone specified. Go
       * ahead and rotate to the local time zone since we will later bypass any
       * calls which adjust the tm fields.
       */
      if (HasCTZSet && (tzp != NULL))
            time -= CTimeZone;

      if (!HasCTZSet && tzp != NULL)
            tx = pg_localtime(&time, session_timezone);
      else
            tx = pg_gmtime(&time);

      tm->tm_year = tx->tm_year + 1900;
      tm->tm_mon = tx->tm_mon + 1;
      tm->tm_mday = tx->tm_mday;
      tm->tm_hour = tx->tm_hour;
      tm->tm_min = tx->tm_min;
      tm->tm_sec = tx->tm_sec;
      tm->tm_isdst = tx->tm_isdst;

      tm->tm_gmtoff = tx->tm_gmtoff;
      tm->tm_zone = tx->tm_zone;

      if (tzp != NULL)
      {
            /*
             * We have a brute force time zone per SQL99? Then use it without
             * change since we have already rotated to the time zone.
             */
            if (HasCTZSet)
            {
                  *tzp = CTimeZone;
                  tm->tm_gmtoff = CTimeZone;
                  tm->tm_isdst = 0;
                  tm->tm_zone = NULL;
                  if (tzn != NULL)
                        *tzn = NULL;
            }
            else
            {
                  *tzp = -tm->tm_gmtoff;        /* tm_gmtoff is Sun/DEC-ism */

                  /*
                   * XXX FreeBSD man pages indicate that this should work - tgl
                   * 97/04/23
                   */
                  if (tzn != NULL)
                  {
                        /*
                         * Copy no more than MAXTZLEN bytes of timezone to tzn, in
                         * case it contains an error message, which doesn't fit in the
                         * buffer
                         */
                        StrNCpy(*tzn, tm->tm_zone, MAXTZLEN + 1);
                        if (strlen(tm->tm_zone) > MAXTZLEN)
                              ereport(WARNING,
                                          (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                           errmsg("invalid time zone name: \"%s\"",
                                                      tm->tm_zone)));
                  }
            }
      }
      else
            tm->tm_isdst = -1;
}


/* tm2abstime()
 * Convert a tm structure to abstime.
 * Note that tm has full year (not 1900-based) and 1-based month.
 */
static AbsoluteTime
tm2abstime(struct pg_tm * tm, int tz)
{
      int               day;
      AbsoluteTime sec;

      /* validate, before going out of range on some members */
      if (tm->tm_year < 1901 || tm->tm_year > 2038 ||
            tm->tm_mon < 1 || tm->tm_mon > 12 ||
            tm->tm_mday < 1 || tm->tm_mday > 31 ||
            tm->tm_hour < 0 ||
            tm->tm_hour > 24 ||           /* test for > 24:00:00 */
            (tm->tm_hour == 24 && (tm->tm_min > 0 || tm->tm_sec > 0)) ||
            tm->tm_min < 0 || tm->tm_min > 59 ||
            tm->tm_sec < 0 || tm->tm_sec > 60)
            return INVALID_ABSTIME;

      day = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - UNIX_EPOCH_JDATE;

      /* check for time out of range */
      if (day < MIN_DAYNUM || day > MAX_DAYNUM)
            return INVALID_ABSTIME;

      /* convert to seconds */
      sec = tm->tm_sec + tz + (tm->tm_min + (day * HOURS_PER_DAY + tm->tm_hour) * MINS_PER_HOUR) * SECS_PER_MINUTE;

      /*
       * check for overflow.  We need a little slop here because the H/M/S plus
       * TZ offset could add up to more than 1 day.
       */
      if ((day >= MAX_DAYNUM - 10 && sec < 0) ||
            (day <= MIN_DAYNUM + 10 && sec > 0))
            return INVALID_ABSTIME;

      /* check for reserved values (e.g. "current" on edge of usual range */
      if (!AbsoluteTimeIsReal(sec))
            return INVALID_ABSTIME;

      return sec;
}


/* abstimein()
 * Decode date/time string and return abstime.
 */
Datum
abstimein(PG_FUNCTION_ARGS)
{
      char     *str = PG_GETARG_CSTRING(0);
      AbsoluteTime result;
      fsec_t            fsec;
      int               tz = 0;
      struct pg_tm date,
                     *tm = &date;
      int               dterr;
      char     *field[MAXDATEFIELDS];
      char        workbuf[MAXDATELEN + 1];
      int               dtype;
      int               nf,
                        ftype[MAXDATEFIELDS];

      dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
                                      field, ftype, MAXDATEFIELDS, &nf);
      if (dterr == 0)
            dterr = DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tz);
      if (dterr != 0)
            DateTimeParseError(dterr, str, "abstime");

      switch (dtype)
      {
            case DTK_DATE:
                  result = tm2abstime(tm, tz);
                  break;

            case DTK_EPOCH:

                  /*
                   * Don't bother retaining this as a reserved value, but instead
                   * just set to the actual epoch time (1970-01-01)
                   */
                  result = 0;
                  break;

            case DTK_LATE:
                  result = NOEND_ABSTIME;
                  break;

            case DTK_EARLY:
                  result = NOSTART_ABSTIME;
                  break;

            case DTK_INVALID:
                  result = INVALID_ABSTIME;
                  break;

            default:
                  elog(ERROR, "unexpected dtype %d while parsing abstime \"%s\"",
                         dtype, str);
                  result = INVALID_ABSTIME;
                  break;
      };

      PG_RETURN_ABSOLUTETIME(result);
}


/* abstimeout()
 * Given an AbsoluteTime return the English text version of the date
 */
Datum
abstimeout(PG_FUNCTION_ARGS)
{
      AbsoluteTime time = PG_GETARG_ABSOLUTETIME(0);
      char     *result;
      int               tz;
      double            fsec = 0;
      struct pg_tm tt,
                     *tm = &tt;
      char        buf[MAXDATELEN + 1];
      char        zone[MAXDATELEN + 1],
                     *tzn = zone;

      switch (time)
      {
                  /*
                   * Note that timestamp no longer supports 'invalid'. Retain
                   * 'invalid' for abstime for now, but dump it someday.
                   */
            case INVALID_ABSTIME:
                  strcpy(buf, INVALID);
                  break;
            case NOEND_ABSTIME:
                  strcpy(buf, LATE);
                  break;
            case NOSTART_ABSTIME:
                  strcpy(buf, EARLY);
                  break;
            default:
                  abstime2tm(time, &tz, tm, &tzn);
                  EncodeDateTime(tm, fsec, &tz, &tzn, DateStyle, buf);
                  break;
      }

      result = pstrdup(buf);
      PG_RETURN_CSTRING(result);
}

/*
 *          abstimerecv             - converts external binary format to abstime
 */
Datum
abstimerecv(PG_FUNCTION_ARGS)
{
      StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);

      PG_RETURN_ABSOLUTETIME((AbsoluteTime) pq_getmsgint(buf, sizeof(AbsoluteTime)));
}

/*
 *          abstimesend             - converts abstime to binary format
 */
Datum
abstimesend(PG_FUNCTION_ARGS)
{
      AbsoluteTime time = PG_GETARG_ABSOLUTETIME(0);
      StringInfoData buf;

      pq_begintypsend(&buf);
      pq_sendint(&buf, time, sizeof(time));
      PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}


/* abstime_finite()
 */
Datum
abstime_finite(PG_FUNCTION_ARGS)
{
      AbsoluteTime abstime = PG_GETARG_ABSOLUTETIME(0);

      PG_RETURN_BOOL(abstime != INVALID_ABSTIME &&
                           abstime != NOSTART_ABSTIME &&
                           abstime != NOEND_ABSTIME);
}


/*
 * abstime comparison routines
 */
static int
abstime_cmp_internal(AbsoluteTime a, AbsoluteTime b)
{
      /*
       * We consider all INVALIDs to be equal and larger than any non-INVALID.
       * This is somewhat arbitrary; the important thing is to have a consistent
       * sort order.
       */
      if (a == INVALID_ABSTIME)
      {
            if (b == INVALID_ABSTIME)
                  return 0;               /* INVALID = INVALID */
            else
                  return 1;               /* INVALID > non-INVALID */
      }

      if (b == INVALID_ABSTIME)
            return -1;                    /* non-INVALID < INVALID */

      if (a > b)
            return 1;
      else if (a == b)
            return 0;
      else
            return -1;
}

Datum
abstimeeq(PG_FUNCTION_ARGS)
{
      AbsoluteTime t1 = PG_GETARG_ABSOLUTETIME(0);
      AbsoluteTime t2 = PG_GETARG_ABSOLUTETIME(1);

      PG_RETURN_BOOL(abstime_cmp_internal(t1, t2) == 0);
}

Datum
abstimene(PG_FUNCTION_ARGS)
{
      AbsoluteTime t1 = PG_GETARG_ABSOLUTETIME(0);
      AbsoluteTime t2 = PG_GETARG_ABSOLUTETIME(1);

      PG_RETURN_BOOL(abstime_cmp_internal(t1, t2) != 0);
}

Datum
abstimelt(PG_FUNCTION_ARGS)
{
      AbsoluteTime t1 = PG_GETARG_ABSOLUTETIME(0);
      AbsoluteTime t2 = PG_GETARG_ABSOLUTETIME(1);

      PG_RETURN_BOOL(abstime_cmp_internal(t1, t2) < 0);
}

Datum
abstimegt(PG_FUNCTION_ARGS)
{
      AbsoluteTime t1 = PG_GETARG_ABSOLUTETIME(0);
      AbsoluteTime t2 = PG_GETARG_ABSOLUTETIME(1);

      PG_RETURN_BOOL(abstime_cmp_internal(t1, t2) > 0);
}

Datum
abstimele(PG_FUNCTION_ARGS)
{
      AbsoluteTime t1 = PG_GETARG_ABSOLUTETIME(0);
      AbsoluteTime t2 = PG_GETARG_ABSOLUTETIME(1);

      PG_RETURN_BOOL(abstime_cmp_internal(t1, t2) <= 0);
}

Datum
abstimege(PG_FUNCTION_ARGS)
{
      AbsoluteTime t1 = PG_GETARG_ABSOLUTETIME(0);
      AbsoluteTime t2 = PG_GETARG_ABSOLUTETIME(1);

      PG_RETURN_BOOL(abstime_cmp_internal(t1, t2) >= 0);
}

Datum
btabstimecmp(PG_FUNCTION_ARGS)
{
      AbsoluteTime t1 = PG_GETARG_ABSOLUTETIME(0);
      AbsoluteTime t2 = PG_GETARG_ABSOLUTETIME(1);

      PG_RETURN_INT32(abstime_cmp_internal(t1, t2));
}


/* timestamp_abstime()
 * Convert timestamp to abstime.
 */
Datum
timestamp_abstime(PG_FUNCTION_ARGS)
{
      Timestamp   timestamp = PG_GETARG_TIMESTAMP(0);
      AbsoluteTime result;
      fsec_t            fsec;
      int               tz;
      struct pg_tm tt,
                     *tm = &tt;

      if (TIMESTAMP_IS_NOBEGIN(timestamp))
            result = NOSTART_ABSTIME;
      else if (TIMESTAMP_IS_NOEND(timestamp))
            result = NOEND_ABSTIME;
      else if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) == 0)
      {
            tz = DetermineTimeZoneOffset(tm, session_timezone);
            result = tm2abstime(tm, tz);
      }
      else
      {
            ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
            result = INVALID_ABSTIME;
      }

      PG_RETURN_ABSOLUTETIME(result);
}

/* abstime_timestamp()
 * Convert abstime to timestamp.
 */
Datum
abstime_timestamp(PG_FUNCTION_ARGS)
{
      AbsoluteTime abstime = PG_GETARG_ABSOLUTETIME(0);
      Timestamp   result;
      struct pg_tm tt,
                     *tm = &tt;
      int               tz;
      char        zone[MAXDATELEN + 1],
                     *tzn = zone;

      switch (abstime)
      {
            case INVALID_ABSTIME:
                  ereport(ERROR,
                              (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot convert abstime \"invalid\" to timestamp")));
                  TIMESTAMP_NOBEGIN(result);
                  break;

            case NOSTART_ABSTIME:
                  TIMESTAMP_NOBEGIN(result);
                  break;

            case NOEND_ABSTIME:
                  TIMESTAMP_NOEND(result);
                  break;

            default:
                  abstime2tm(abstime, &tz, tm, &tzn);
                  if (tm2timestamp(tm, 0, NULL, &result) != 0)
                        ereport(ERROR,
                                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                     errmsg("timestamp out of range")));
                  break;
      };

      PG_RETURN_TIMESTAMP(result);
}


/* timestamptz_abstime()
 * Convert timestamp with time zone to abstime.
 */
Datum
timestamptz_abstime(PG_FUNCTION_ARGS)
{
      TimestampTz timestamp = PG_GETARG_TIMESTAMP(0);
      AbsoluteTime result;
      fsec_t            fsec;
      struct pg_tm tt,
                     *tm = &tt;

      if (TIMESTAMP_IS_NOBEGIN(timestamp))
            result = NOSTART_ABSTIME;
      else if (TIMESTAMP_IS_NOEND(timestamp))
            result = NOEND_ABSTIME;
      else if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) == 0)
            result = tm2abstime(tm, 0);
      else
      {
            ereport(ERROR,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timestamp out of range")));
            result = INVALID_ABSTIME;
      }

      PG_RETURN_ABSOLUTETIME(result);
}

/* abstime_timestamptz()
 * Convert abstime to timestamp with time zone.
 */
Datum
abstime_timestamptz(PG_FUNCTION_ARGS)
{
      AbsoluteTime abstime = PG_GETARG_ABSOLUTETIME(0);
      TimestampTz result;
      struct pg_tm tt,
                     *tm = &tt;
      int               tz;
      char        zone[MAXDATELEN + 1],
                     *tzn = zone;

      switch (abstime)
      {
            case INVALID_ABSTIME:
                  ereport(ERROR,
                              (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot convert abstime \"invalid\" to timestamp")));
                  TIMESTAMP_NOBEGIN(result);
                  break;

            case NOSTART_ABSTIME:
                  TIMESTAMP_NOBEGIN(result);
                  break;

            case NOEND_ABSTIME:
                  TIMESTAMP_NOEND(result);
                  break;

            default:
                  abstime2tm(abstime, &tz, tm, &tzn);
                  if (tm2timestamp(tm, 0, &tz, &result) != 0)
                        ereport(ERROR,
                                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                     errmsg("timestamp out of range")));
                  break;
      };

      PG_RETURN_TIMESTAMP(result);
}


/*****************************************************************************
 *     USER I/O ROUTINES                                                                                     *
 *****************************************************************************/

/*
 *          reltimein         - converts a reltime string in an internal format
 */
Datum
reltimein(PG_FUNCTION_ARGS)
{
      char     *str = PG_GETARG_CSTRING(0);
      RelativeTime result;
      struct pg_tm tt,
                     *tm = &tt;
      fsec_t            fsec;
      int               dtype;
      int               dterr;
      char     *field[MAXDATEFIELDS];
      int               nf,
                        ftype[MAXDATEFIELDS];
      char        workbuf[MAXDATELEN + 1];

      dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
                                      field, ftype, MAXDATEFIELDS, &nf);
      if (dterr == 0)
            dterr = DecodeInterval(field, ftype, nf, INTERVAL_FULL_RANGE,
                                             &dtype, tm, &fsec);

      /* if those functions think it's a bad format, try ISO8601 style */
      if (dterr == DTERR_BAD_FORMAT)
            dterr = DecodeISO8601Interval(str,
                                                        &dtype, tm, &fsec);

      if (dterr != 0)
      {
            if (dterr == DTERR_FIELD_OVERFLOW)
                  dterr = DTERR_INTERVAL_OVERFLOW;
            DateTimeParseError(dterr, str, "reltime");
      }

      switch (dtype)
      {
            case DTK_DELTA:
                  result = ((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec;
                  result += tm->tm_year * SECS_PER_YEAR + ((tm->tm_mon * DAYS_PER_MONTH) + tm->tm_mday) * SECS_PER_DAY;
                  break;

            default:
                  elog(ERROR, "unexpected dtype %d while parsing reltime \"%s\"",
                         dtype, str);
                  result = INVALID_RELTIME;
                  break;
      }

      PG_RETURN_RELATIVETIME(result);
}

/*
 *          reltimeout        - converts the internal format to a reltime string
 */
Datum
reltimeout(PG_FUNCTION_ARGS)
{
      RelativeTime time = PG_GETARG_RELATIVETIME(0);
      char     *result;
      struct pg_tm tt,
                     *tm = &tt;
      char        buf[MAXDATELEN + 1];

      reltime2tm(time, tm);
      EncodeInterval(tm, 0, IntervalStyle, buf);

      result = pstrdup(buf);
      PG_RETURN_CSTRING(result);
}

/*
 *          reltimerecv             - converts external binary format to reltime
 */
Datum
reltimerecv(PG_FUNCTION_ARGS)
{
      StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);

      PG_RETURN_RELATIVETIME((RelativeTime) pq_getmsgint(buf, sizeof(RelativeTime)));
}

/*
 *          reltimesend             - converts reltime to binary format
 */
Datum
reltimesend(PG_FUNCTION_ARGS)
{
      RelativeTime time = PG_GETARG_RELATIVETIME(0);
      StringInfoData buf;

      pq_begintypsend(&buf);
      pq_sendint(&buf, time, sizeof(time));
      PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}


static void
reltime2tm(RelativeTime time, struct pg_tm * tm)
{
      double            dtime = time;

      FMODULO(dtime, tm->tm_year, 31557600);
      FMODULO(dtime, tm->tm_mon, 2592000);
      FMODULO(dtime, tm->tm_mday, SECS_PER_DAY);
      FMODULO(dtime, tm->tm_hour, SECS_PER_HOUR);
      FMODULO(dtime, tm->tm_min, SECS_PER_MINUTE);
      FMODULO(dtime, tm->tm_sec, 1);
}


/*
 *          tintervalin       - converts an tinterval string to internal format
 */
Datum
tintervalin(PG_FUNCTION_ARGS)
{
      char     *tintervalstr = PG_GETARG_CSTRING(0);
      TimeInterval tinterval;
      AbsoluteTime i_start,
                        i_end,
                        t1,
                        t2;

      parsetinterval(tintervalstr, &t1, &t2);

      tinterval = (TimeInterval) palloc(sizeof(TimeIntervalData));

      if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
            tinterval->status = T_INTERVAL_INVAL;     /* undefined  */
      else
            tinterval->status = T_INTERVAL_VALID;

      i_start = ABSTIMEMIN(t1, t2);
      i_end = ABSTIMEMAX(t1, t2);
      tinterval->data[0] = i_start;
      tinterval->data[1] = i_end;

      PG_RETURN_TIMEINTERVAL(tinterval);
}


/*
 *          tintervalout      - converts an internal tinterval format to a string
 */
Datum
tintervalout(PG_FUNCTION_ARGS)
{
      TimeInterval tinterval = PG_GETARG_TIMEINTERVAL(0);
      char     *i_str,
                     *p;

      i_str = (char *) palloc(T_INTERVAL_LEN);  /* ["..." "..."] */
      strcpy(i_str, "[\"");
      if (tinterval->status == T_INTERVAL_INVAL)
            strcat(i_str, INVALID_INTERVAL_STR);
      else
      {
            p = DatumGetCString(DirectFunctionCall1(abstimeout,
                                                  AbsoluteTimeGetDatum(tinterval->data[0])));
            strcat(i_str, p);
            pfree(p);
            strcat(i_str, "\" \"");
            p = DatumGetCString(DirectFunctionCall1(abstimeout,
                                                  AbsoluteTimeGetDatum(tinterval->data[1])));
            strcat(i_str, p);
            pfree(p);
      }
      strcat(i_str, "\"]");
      PG_RETURN_CSTRING(i_str);
}

/*
 *          tintervalrecv                 - converts external binary format to tinterval
 */
Datum
tintervalrecv(PG_FUNCTION_ARGS)
{
      StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
      TimeInterval tinterval;

      tinterval = (TimeInterval) palloc(sizeof(TimeIntervalData));

      tinterval->status = pq_getmsgint(buf, sizeof(tinterval->status));

      if (!(tinterval->status == T_INTERVAL_INVAL ||
              tinterval->status == T_INTERVAL_VALID))
            ereport(ERROR,
                        (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                         errmsg("invalid status in external \"tinterval\" value")));

      tinterval->data[0] = pq_getmsgint(buf, sizeof(tinterval->data[0]));
      tinterval->data[1] = pq_getmsgint(buf, sizeof(tinterval->data[1]));

      PG_RETURN_TIMEINTERVAL(tinterval);
}

/*
 *          tintervalsend                 - converts tinterval to binary format
 */
Datum
tintervalsend(PG_FUNCTION_ARGS)
{
      TimeInterval tinterval = PG_GETARG_TIMEINTERVAL(0);
      StringInfoData buf;

      pq_begintypsend(&buf);
      pq_sendint(&buf, tinterval->status, sizeof(tinterval->status));
      pq_sendint(&buf, tinterval->data[0], sizeof(tinterval->data[0]));
      pq_sendint(&buf, tinterval->data[1], sizeof(tinterval->data[1]));
      PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}


/*****************************************************************************
 *     PUBLIC ROUTINES                                                                                 *
 *****************************************************************************/

Datum
interval_reltime(PG_FUNCTION_ARGS)
{
      Interval   *interval = PG_GETARG_INTERVAL_P(0);
      RelativeTime time;
      int               year,
                        month,
                        day;
      TimeOffset  span;

      year = interval->month / MONTHS_PER_YEAR;
      month = interval->month % MONTHS_PER_YEAR;
      day = interval->day;

#ifdef HAVE_INT64_TIMESTAMP
      span = ((INT64CONST(365250000) * year + INT64CONST(30000000) * month +
                   INT64CONST(1000000) * day) * INT64CONST(86400)) +
            interval->time;
      span /= USECS_PER_SEC;
#else
      span = (DAYS_PER_YEAR * year + (double) DAYS_PER_MONTH * month + day) * SECS_PER_DAY + interval->time;
#endif

      if (span < INT_MIN || span > INT_MAX)
            time = INVALID_RELTIME;
      else
            time = span;

      PG_RETURN_RELATIVETIME(time);
}


Datum
reltime_interval(PG_FUNCTION_ARGS)
{
      RelativeTime reltime = PG_GETARG_RELATIVETIME(0);
      Interval   *result;
      int               year,
                        month,
                        day;

      result = (Interval *) palloc(sizeof(Interval));

      switch (reltime)
      {
            case INVALID_RELTIME:
                  ereport(ERROR,
                              (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("cannot convert reltime \"invalid\" to interval")));
                  result->time = 0;
                  result->day = 0;
                  result->month = 0;
                  break;

            default:
#ifdef HAVE_INT64_TIMESTAMP
                  year = reltime / SECS_PER_YEAR;
                  reltime -= year * SECS_PER_YEAR;
                  month = reltime / (DAYS_PER_MONTH * SECS_PER_DAY);
                  reltime -= month * (DAYS_PER_MONTH * SECS_PER_DAY);
                  day = reltime / SECS_PER_DAY;
                  reltime -= day * SECS_PER_DAY;

                  result->time = (reltime * USECS_PER_SEC);
#else
                  TMODULO(reltime, year, SECS_PER_YEAR);
                  TMODULO(reltime, month, DAYS_PER_MONTH * SECS_PER_DAY);
                  TMODULO(reltime, day, SECS_PER_DAY);

                  result->time = reltime;
#endif
                  result->month = MONTHS_PER_YEAR * year + month;
                  result->day = day;
                  break;
      }

      PG_RETURN_INTERVAL_P(result);
}


/*
 *          mktinterval       - creates a time interval with endpoints t1 and t2
 */
Datum
mktinterval(PG_FUNCTION_ARGS)
{
      AbsoluteTime t1 = PG_GETARG_ABSOLUTETIME(0);
      AbsoluteTime t2 = PG_GETARG_ABSOLUTETIME(1);
      AbsoluteTime tstart = ABSTIMEMIN(t1, t2);
      AbsoluteTime tend = ABSTIMEMAX(t1, t2);
      TimeInterval tinterval;

      tinterval = (TimeInterval) palloc(sizeof(TimeIntervalData));

      if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
            tinterval->status = T_INTERVAL_INVAL;

      else
      {
            tinterval->status = T_INTERVAL_VALID;
            tinterval->data[0] = tstart;
            tinterval->data[1] = tend;
      }

      PG_RETURN_TIMEINTERVAL(tinterval);
}

/*
 *          timepl, timemi and abstimemi use the formula
 *                      abstime + reltime = abstime
 *          so          abstime - reltime = abstime
 *          and         abstime - abstime = reltime
 */

/*
 *          timepl                  - returns the value of (abstime t1 + reltime t2)
 */
Datum
timepl(PG_FUNCTION_ARGS)
{
      AbsoluteTime t1 = PG_GETARG_ABSOLUTETIME(0);
      RelativeTime t2 = PG_GETARG_RELATIVETIME(1);

      if (AbsoluteTimeIsReal(t1) &&
            RelativeTimeIsValid(t2) &&
            ((t2 > 0 && t1 < NOEND_ABSTIME - t2) ||
             (t2 <= 0 && t1 > NOSTART_ABSTIME - t2)))       /* prevent overflow */
            PG_RETURN_ABSOLUTETIME(t1 + t2);

      PG_RETURN_ABSOLUTETIME(INVALID_ABSTIME);
}


/*
 *          timemi                  - returns the value of (abstime t1 - reltime t2)
 */
Datum
timemi(PG_FUNCTION_ARGS)
{
      AbsoluteTime t1 = PG_GETARG_ABSOLUTETIME(0);
      RelativeTime t2 = PG_GETARG_RELATIVETIME(1);

      if (AbsoluteTimeIsReal(t1) &&
            RelativeTimeIsValid(t2) &&
            ((t2 > 0 && t1 > NOSTART_ABSTIME + t2) ||
             (t2 <= 0 && t1 < NOEND_ABSTIME + t2))) /* prevent overflow */
            PG_RETURN_ABSOLUTETIME(t1 - t2);

      PG_RETURN_ABSOLUTETIME(INVALID_ABSTIME);
}


/*
 *          intinterval       - returns true iff absolute date is in the tinterval
 */
Datum
intinterval(PG_FUNCTION_ARGS)
{
      AbsoluteTime t = PG_GETARG_ABSOLUTETIME(0);
      TimeInterval tinterval = PG_GETARG_TIMEINTERVAL(1);

      if (tinterval->status == T_INTERVAL_VALID && t != INVALID_ABSTIME)
      {
            if (DatumGetBool(DirectFunctionCall2(abstimege,
                                                                   AbsoluteTimeGetDatum(t),
                                                AbsoluteTimeGetDatum(tinterval->data[0]))) &&
                  DatumGetBool(DirectFunctionCall2(abstimele,
                                                                   AbsoluteTimeGetDatum(t),
                                                  AbsoluteTimeGetDatum(tinterval->data[1]))))
                  PG_RETURN_BOOL(true);
      }
      PG_RETURN_BOOL(false);
}

/*
 *          tintervalrel            - returns  relative time corresponding to tinterval
 */
Datum
tintervalrel(PG_FUNCTION_ARGS)
{
      TimeInterval tinterval = PG_GETARG_TIMEINTERVAL(0);
      AbsoluteTime t1 = tinterval->data[0];
      AbsoluteTime t2 = tinterval->data[1];

      if (tinterval->status != T_INTERVAL_VALID)
            PG_RETURN_RELATIVETIME(INVALID_RELTIME);

      if (AbsoluteTimeIsReal(t1) &&
            AbsoluteTimeIsReal(t2))
            PG_RETURN_RELATIVETIME(t2 - t1);

      PG_RETURN_RELATIVETIME(INVALID_RELTIME);
}


/*
 *          timenow                 - returns  time "now", internal format
 *
 *          Now AbsoluteTime is time since Jan 1 1970 -mer 7 Feb 1992
 */
Datum
timenow(PG_FUNCTION_ARGS)
{
      PG_RETURN_ABSOLUTETIME(GetCurrentAbsoluteTime());
}

/*
 * reltime comparison routines
 */
static int
reltime_cmp_internal(RelativeTime a, RelativeTime b)
{
      /*
       * We consider all INVALIDs to be equal and larger than any non-INVALID.
       * This is somewhat arbitrary; the important thing is to have a consistent
       * sort order.
       */
      if (a == INVALID_RELTIME)
      {
            if (b == INVALID_RELTIME)
                  return 0;               /* INVALID = INVALID */
            else
                  return 1;               /* INVALID > non-INVALID */
      }

      if (b == INVALID_RELTIME)
            return -1;                    /* non-INVALID < INVALID */

      if (a > b)
            return 1;
      else if (a == b)
            return 0;
      else
            return -1;
}

Datum
reltimeeq(PG_FUNCTION_ARGS)
{
      RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
      RelativeTime t2 = PG_GETARG_RELATIVETIME(1);

      PG_RETURN_BOOL(reltime_cmp_internal(t1, t2) == 0);
}

Datum
reltimene(PG_FUNCTION_ARGS)
{
      RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
      RelativeTime t2 = PG_GETARG_RELATIVETIME(1);

      PG_RETURN_BOOL(reltime_cmp_internal(t1, t2) != 0);
}

Datum
reltimelt(PG_FUNCTION_ARGS)
{
      RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
      RelativeTime t2 = PG_GETARG_RELATIVETIME(1);

      PG_RETURN_BOOL(reltime_cmp_internal(t1, t2) < 0);
}

Datum
reltimegt(PG_FUNCTION_ARGS)
{
      RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
      RelativeTime t2 = PG_GETARG_RELATIVETIME(1);

      PG_RETURN_BOOL(reltime_cmp_internal(t1, t2) > 0);
}

Datum
reltimele(PG_FUNCTION_ARGS)
{
      RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
      RelativeTime t2 = PG_GETARG_RELATIVETIME(1);

      PG_RETURN_BOOL(reltime_cmp_internal(t1, t2) <= 0);
}

Datum
reltimege(PG_FUNCTION_ARGS)
{
      RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
      RelativeTime t2 = PG_GETARG_RELATIVETIME(1);

      PG_RETURN_BOOL(reltime_cmp_internal(t1, t2) >= 0);
}

Datum
btreltimecmp(PG_FUNCTION_ARGS)
{
      RelativeTime t1 = PG_GETARG_RELATIVETIME(0);
      RelativeTime t2 = PG_GETARG_RELATIVETIME(1);

      PG_RETURN_INT32(reltime_cmp_internal(t1, t2));
}


/*
 *          tintervalsame     - returns true iff tinterval i1 is same as tinterval i2
 *          Check begin and end time.
 */
Datum
tintervalsame(PG_FUNCTION_ARGS)
{
      TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
      TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);

      if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
            PG_RETURN_BOOL(false);

      if (DatumGetBool(DirectFunctionCall2(abstimeeq,
                                                             AbsoluteTimeGetDatum(i1->data[0]),
                                                         AbsoluteTimeGetDatum(i2->data[0]))) &&
            DatumGetBool(DirectFunctionCall2(abstimeeq,
                                                             AbsoluteTimeGetDatum(i1->data[1]),
                                                             AbsoluteTimeGetDatum(i2->data[1]))))
            PG_RETURN_BOOL(true);
      PG_RETURN_BOOL(false);
}

/*
 * tinterval comparison routines
 *
 * Note: comparison is based on the lengths of the tintervals, not on
 * endpoint value.      This is pretty bogus, but since it's only a legacy
 * datatype I'm not going to propose changing it.
 */
static int
tinterval_cmp_internal(TimeInterval a, TimeInterval b)
{
      bool        a_invalid;
      bool        b_invalid;
      AbsoluteTime a_len;
      AbsoluteTime b_len;

      /*
       * We consider all INVALIDs to be equal and larger than any non-INVALID.
       * This is somewhat arbitrary; the important thing is to have a consistent
       * sort order.
       */
      a_invalid = a->status == T_INTERVAL_INVAL ||
            a->data[0] == INVALID_ABSTIME ||
            a->data[1] == INVALID_ABSTIME;
      b_invalid = b->status == T_INTERVAL_INVAL ||
            b->data[0] == INVALID_ABSTIME ||
            b->data[1] == INVALID_ABSTIME;

      if (a_invalid)
      {
            if (b_invalid)
                  return 0;               /* INVALID = INVALID */
            else
                  return 1;               /* INVALID > non-INVALID */
      }

      if (b_invalid)
            return -1;                    /* non-INVALID < INVALID */

      a_len = a->data[1] - a->data[0];
      b_len = b->data[1] - b->data[0];

      if (a_len > b_len)
            return 1;
      else if (a_len == b_len)
            return 0;
      else
            return -1;
}

Datum
tintervaleq(PG_FUNCTION_ARGS)
{
      TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
      TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);

      PG_RETURN_BOOL(tinterval_cmp_internal(i1, i2) == 0);
}

Datum
tintervalne(PG_FUNCTION_ARGS)
{
      TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
      TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);

      PG_RETURN_BOOL(tinterval_cmp_internal(i1, i2) != 0);
}

Datum
tintervallt(PG_FUNCTION_ARGS)
{
      TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
      TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);

      PG_RETURN_BOOL(tinterval_cmp_internal(i1, i2) < 0);
}

Datum
tintervalle(PG_FUNCTION_ARGS)
{
      TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
      TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);

      PG_RETURN_BOOL(tinterval_cmp_internal(i1, i2) <= 0);
}

Datum
tintervalgt(PG_FUNCTION_ARGS)
{
      TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
      TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);

      PG_RETURN_BOOL(tinterval_cmp_internal(i1, i2) > 0);
}

Datum
tintervalge(PG_FUNCTION_ARGS)
{
      TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
      TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);

      PG_RETURN_BOOL(tinterval_cmp_internal(i1, i2) >= 0);
}

Datum
bttintervalcmp(PG_FUNCTION_ARGS)
{
      TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
      TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);

      PG_RETURN_INT32(tinterval_cmp_internal(i1, i2));
}


/*
 *          tintervalleneq    - returns true iff length of tinterval i is equal to
 *                                              reltime t
 *          tintervallenne    - returns true iff length of tinterval i is not equal
 *                                              to reltime t
 *          tintervallenlt    - returns true iff length of tinterval i is less than
 *                                              reltime t
 *          tintervallengt    - returns true iff length of tinterval i is greater
 *                                              than reltime t
 *          tintervallenle    - returns true iff length of tinterval i is less or
 *                                              equal than reltime t
 *          tintervallenge    - returns true iff length of tinterval i is greater or
 *                                              equal than reltime t
 */
Datum
tintervalleneq(PG_FUNCTION_ARGS)
{
      TimeInterval i = PG_GETARG_TIMEINTERVAL(0);
      RelativeTime t = PG_GETARG_RELATIVETIME(1);
      RelativeTime rt;

      if (i->status == T_INTERVAL_INVAL || t == INVALID_RELTIME)
            PG_RETURN_BOOL(false);
      rt = DatumGetRelativeTime(DirectFunctionCall1(tintervalrel,
                                                                          TimeIntervalGetDatum(i)));
      PG_RETURN_BOOL(rt != INVALID_RELTIME && rt == t);
}

Datum
tintervallenne(PG_FUNCTION_ARGS)
{
      TimeInterval i = PG_GETARG_TIMEINTERVAL(0);
      RelativeTime t = PG_GETARG_RELATIVETIME(1);
      RelativeTime rt;

      if (i->status == T_INTERVAL_INVAL || t == INVALID_RELTIME)
            PG_RETURN_BOOL(false);
      rt = DatumGetRelativeTime(DirectFunctionCall1(tintervalrel,
                                                                          TimeIntervalGetDatum(i)));
      PG_RETURN_BOOL(rt != INVALID_RELTIME && rt != t);
}

Datum
tintervallenlt(PG_FUNCTION_ARGS)
{
      TimeInterval i = PG_GETARG_TIMEINTERVAL(0);
      RelativeTime t = PG_GETARG_RELATIVETIME(1);
      RelativeTime rt;

      if (i->status == T_INTERVAL_INVAL || t == INVALID_RELTIME)
            PG_RETURN_BOOL(false);
      rt = DatumGetRelativeTime(DirectFunctionCall1(tintervalrel,
                                                                          TimeIntervalGetDatum(i)));
      PG_RETURN_BOOL(rt != INVALID_RELTIME && rt < t);
}

Datum
tintervallengt(PG_FUNCTION_ARGS)
{
      TimeInterval i = PG_GETARG_TIMEINTERVAL(0);
      RelativeTime t = PG_GETARG_RELATIVETIME(1);
      RelativeTime rt;

      if (i->status == T_INTERVAL_INVAL || t == INVALID_RELTIME)
            PG_RETURN_BOOL(false);
      rt = DatumGetRelativeTime(DirectFunctionCall1(tintervalrel,
                                                                          TimeIntervalGetDatum(i)));
      PG_RETURN_BOOL(rt != INVALID_RELTIME && rt > t);
}

Datum
tintervallenle(PG_FUNCTION_ARGS)
{
      TimeInterval i = PG_GETARG_TIMEINTERVAL(0);
      RelativeTime t = PG_GETARG_RELATIVETIME(1);
      RelativeTime rt;

      if (i->status == T_INTERVAL_INVAL || t == INVALID_RELTIME)
            PG_RETURN_BOOL(false);
      rt = DatumGetRelativeTime(DirectFunctionCall1(tintervalrel,
                                                                          TimeIntervalGetDatum(i)));
      PG_RETURN_BOOL(rt != INVALID_RELTIME && rt <= t);
}

Datum
tintervallenge(PG_FUNCTION_ARGS)
{
      TimeInterval i = PG_GETARG_TIMEINTERVAL(0);
      RelativeTime t = PG_GETARG_RELATIVETIME(1);
      RelativeTime rt;

      if (i->status == T_INTERVAL_INVAL || t == INVALID_RELTIME)
            PG_RETURN_BOOL(false);
      rt = DatumGetRelativeTime(DirectFunctionCall1(tintervalrel,
                                                                          TimeIntervalGetDatum(i)));
      PG_RETURN_BOOL(rt != INVALID_RELTIME && rt >= t);
}

/*
 *          tintervalct       - returns true iff tinterval i1 contains tinterval i2
 */
Datum
tintervalct(PG_FUNCTION_ARGS)
{
      TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
      TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);

      if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
            PG_RETURN_BOOL(false);
      if (DatumGetBool(DirectFunctionCall2(abstimele,
                                                             AbsoluteTimeGetDatum(i1->data[0]),
                                                         AbsoluteTimeGetDatum(i2->data[0]))) &&
            DatumGetBool(DirectFunctionCall2(abstimege,
                                                             AbsoluteTimeGetDatum(i1->data[1]),
                                                             AbsoluteTimeGetDatum(i2->data[1]))))
            PG_RETURN_BOOL(true);
      PG_RETURN_BOOL(false);
}

/*
 *          tintervalov       - returns true iff tinterval i1 (partially) overlaps i2
 */
Datum
tintervalov(PG_FUNCTION_ARGS)
{
      TimeInterval i1 = PG_GETARG_TIMEINTERVAL(0);
      TimeInterval i2 = PG_GETARG_TIMEINTERVAL(1);

      if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
            PG_RETURN_BOOL(false);
      if (DatumGetBool(DirectFunctionCall2(abstimelt,
                                                             AbsoluteTimeGetDatum(i1->data[1]),
                                                         AbsoluteTimeGetDatum(i2->data[0]))) ||
            DatumGetBool(DirectFunctionCall2(abstimegt,
                                                             AbsoluteTimeGetDatum(i1->data[0]),
                                                             AbsoluteTimeGetDatum(i2->data[1]))))
            PG_RETURN_BOOL(false);
      PG_RETURN_BOOL(true);
}

/*
 *          tintervalstart    - returns  the start of tinterval i
 */
Datum
tintervalstart(PG_FUNCTION_ARGS)
{
      TimeInterval i = PG_GETARG_TIMEINTERVAL(0);

      if (i->status == T_INTERVAL_INVAL)
            PG_RETURN_ABSOLUTETIME(INVALID_ABSTIME);
      PG_RETURN_ABSOLUTETIME(i->data[0]);
}

/*
 *          tintervalend            - returns  the end of tinterval i
 */
Datum
tintervalend(PG_FUNCTION_ARGS)
{
      TimeInterval i = PG_GETARG_TIMEINTERVAL(0);

      if (i->status == T_INTERVAL_INVAL)
            PG_RETURN_ABSOLUTETIME(INVALID_ABSTIME);
      PG_RETURN_ABSOLUTETIME(i->data[1]);
}


/*****************************************************************************
 *     PRIVATE ROUTINES                                                                                *
 *****************************************************************************/

/*
 *          parsetinterval -- parse a tinterval string
 *
 *          output parameters:
 *                      i_start, i_end: tinterval 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']
 */
static void
parsetinterval(char *i_string,
                     AbsoluteTime *i_start,
                     AbsoluteTime *i_end)
{
      char     *p,
                     *p1;
      char        c;

      p = i_string;
      /* skip leading blanks up to '[' */
      while ((c = *p) != '\0')
      {
            if (IsSpace(c))
                  p++;
            else if (c != '[')
                  goto bogus;             /* syntax error */
            else
                  break;
      }
      if (c == '\0')
            goto bogus;                   /* syntax error */
      p++;
      /* skip leading blanks up to '"' */
      while ((c = *p) != '\0')
      {
            if (IsSpace(c))
                  p++;
            else if (c != '"')
                  goto bogus;             /* syntax error */
            else
                  break;
      }
      if (c == '\0')
            goto bogus;                   /* syntax error */
      p++;
      if (strncmp(INVALID_INTERVAL_STR, p, strlen(INVALID_INTERVAL_STR)) == 0)
            goto bogus;                   /* undefined range, handled like a syntax err. */
      /* search for the end of the first date and change it to a \0 */
      p1 = p;
      while ((c = *p1) != '\0')
      {
            if (c == '"')
                  break;
            p1++;
      }
      if (c == '\0')
            goto bogus;                   /* syntax error */
      *p1 = '\0';
      /* get the first date */
      *i_start = DatumGetAbsoluteTime(DirectFunctionCall1(abstimein,
                                                                                    CStringGetDatum(p)));
      /* undo change to \0 */
      *p1 = c;
      p = ++p1;
      /* skip blanks up to '"', beginning of second date */
      while ((c = *p) != '\0')
      {
            if (IsSpace(c))
                  p++;
            else if (c != '"')
                  goto bogus;             /* syntax error */
            else
                  break;
      }
      if (c == '\0')
            goto bogus;                   /* syntax error */
      p++;
      /* search for the end of the second date and change it to a \0 */
      p1 = p;
      while ((c = *p1) != '\0')
      {
            if (c == '"')
                  break;
            p1++;
      }
      if (c == '\0')
            goto bogus;                   /* syntax error */
      *p1 = '\0';
      /* get the second date */
      *i_end = DatumGetAbsoluteTime(DirectFunctionCall1(abstimein,
                                                                                CStringGetDatum(p)));
      /* undo change to \0 */
      *p1 = c;
      p = ++p1;
      /* skip blanks up to ']' */
      while ((c = *p) != '\0')
      {
            if (IsSpace(c))
                  p++;
            else if (c != ']')
                  goto bogus;             /* syntax error */
            else
                  break;
      }
      if (c == '\0')
            goto bogus;                   /* syntax error */
      p++;
      c = *p;
      if (c != '\0')
            goto bogus;                   /* syntax error */

      /* it seems to be a valid tinterval */
      return;

bogus:
      ereport(ERROR,
                  (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                   errmsg("invalid input syntax for type tinterval: \"%s\"",
                              i_string)));
      *i_start = *i_end = INVALID_ABSTIME;            /* keep compiler quiet */
}


/*****************************************************************************
 *
 *****************************************************************************/

/*
 * timeofday -
 *       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
 */
Datum
timeofday(PG_FUNCTION_ARGS)
{
      struct timeval tp;
      char        templ[128];
      char        buf[128];
      pg_time_t   tt;

      gettimeofday(&tp, NULL);
      tt = (pg_time_t) tp.tv_sec;
      pg_strftime(templ, sizeof(templ), "%a %b %d %H:%M:%S.%%06d %Y %Z",
                        pg_localtime(&tt, session_timezone));
      snprintf(buf, sizeof(buf), templ, tp.tv_usec);

      PG_RETURN_TEXT_P(cstring_to_text(buf));
}

Generated by  Doxygen 1.6.0   Back to index