1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* date.c--
|
1997-09-07 07:04:48 +02:00
|
|
|
* Utilities for the built-in type "AbsoluteTime" (defined in nabstime).
|
|
|
|
* Functions for the built-in type "RelativeTime".
|
|
|
|
* Functions for the built-in type "TimeInterval".
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
1997-09-08 23:56:23 +02:00
|
|
|
* $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.18 1997/09/08 21:48:21 momjian Exp $
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* NOTES
|
1997-09-07 07:04:48 +02:00
|
|
|
* This code is actually (almost) unused.
|
|
|
|
* It needs to be integrated with Time and struct trange.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* XXX This code has been cleaned up some - avi 07/07/93
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "postgres.h"
|
|
|
|
#include "miscadmin.h"
|
1997-04-04 10:53:08 +02:00
|
|
|
#ifdef HAVE_FLOAT_H
|
1997-09-07 07:04:48 +02:00
|
|
|
#include <float.h>
|
1997-04-04 10:53:08 +02:00
|
|
|
#endif
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
#ifdef HAVE_LIMITS_H
|
1997-09-07 07:04:48 +02:00
|
|
|
#include <limits.h>
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
#endif
|
1996-07-09 08:22:35 +02:00
|
|
|
#include "access/xact.h"
|
1997-09-07 07:04:48 +02:00
|
|
|
#include "utils/builtins.h" /* where function declarations go */
|
1996-07-09 08:22:35 +02:00
|
|
|
#include "utils/palloc.h"
|
1997-03-15 00:21:12 +01:00
|
|
|
#include "utils/dt.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
#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)
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Unix epoch is Jan 1 00:00:00 1970. Postgres knows about times
|
|
|
|
* sixty-eight years on either side of that.
|
|
|
|
*/
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
#define IsSpace(C) ((C) == ' ')
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
#define T_INTERVAL_INVAL 0 /* data represents no valid interval */
|
|
|
|
#define T_INTERVAL_VALID 1 /* data represents a valid interval */
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
|
|
|
* ['Mon May 10 23:59:12 1943 PST' 'Sun Jan 14 03:14:21 1973 PST']
|
1997-09-07 07:04:48 +02:00
|
|
|
* 0 1 2 3 4 5 6
|
1996-07-09 08:22:35 +02:00
|
|
|
* 1234567890123456789012345678901234567890123456789012345678901234
|
|
|
|
*
|
|
|
|
* we allocate some extra -- timezones are usually 3 characters but
|
|
|
|
* this is not in the POSIX standard...
|
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
#define T_INTERVAL_LEN 80
|
|
|
|
#define INVALID_INTERVAL_STR "Undefined Range"
|
|
|
|
#define INVALID_INTERVAL_STR_LEN (sizeof(INVALID_INTERVAL_STR)-1)
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
#define ABSTIMEMIN(t1, t2) abstimele((t1),(t2)) ? (t1) : (t2)
|
|
|
|
#define ABSTIMEMAX(t1, t2) abstimelt((t1),(t2)) ? (t2) : (t1)
|
|
|
|
|
1997-07-29 17:54:49 +02:00
|
|
|
#if FALSE
|
1997-09-08 04:41:22 +02:00
|
|
|
static char *unit_tab[] = {
|
1996-07-09 08:22:35 +02:00
|
|
|
"second", "seconds", "minute", "minutes",
|
|
|
|
"hour", "hours", "day", "days", "week", "weeks",
|
1997-09-07 07:04:48 +02:00
|
|
|
"month", "months", "year", "years"};
|
|
|
|
|
|
|
|
#define UNITMAXLEN 7 /* max length of a unit name */
|
|
|
|
#define NUNITS 14 /* number of different units */
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/* table of seconds per unit (month = 30 days, year = 365 days) */
|
1997-09-08 04:41:22 +02:00
|
|
|
static int sec_tab[] = {
|
1997-09-07 07:04:48 +02:00
|
|
|
1, 1, 60, 60,
|
|
|
|
3600, 3600, 86400, 86400, 604800, 604800,
|
|
|
|
2592000, 2592000, 31536000, 31536000};
|
|
|
|
|
1997-07-29 17:54:49 +02:00
|
|
|
#endif
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Function prototypes -- internal to this file only
|
|
|
|
*/
|
1997-03-15 00:21:12 +01:00
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
static void reltime2tm(int32 time, struct tm * tm);
|
1997-07-29 17:54:49 +02:00
|
|
|
|
|
|
|
#if FALSE
|
1997-09-08 04:41:22 +02:00
|
|
|
static int correct_unit(char unit[], int *unptr);
|
|
|
|
static int correct_dir(char direction[], int *signptr);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1997-07-29 17:54:49 +02:00
|
|
|
#endif
|
1997-03-15 00:21:12 +01:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
static int
|
|
|
|
istinterval(char *i_string,
|
1997-09-08 22:59:27 +02:00
|
|
|
AbsoluteTime *i_start,
|
|
|
|
AbsoluteTime *i_end);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* USER I/O ROUTINES *
|
1996-07-09 08:22:35 +02:00
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* reltimein - converts a reltime string in an internal format
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-03-15 00:21:12 +01:00
|
|
|
RelativeTime
|
|
|
|
reltimein(char *str)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
RelativeTime result;
|
1997-03-15 00:21:12 +01:00
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
struct tm tt,
|
|
|
|
*tm = &tt;
|
|
|
|
double fsec;
|
|
|
|
int dtype;
|
|
|
|
char *field[MAXDATEFIELDS];
|
|
|
|
int nf,
|
|
|
|
ftype[MAXDATEFIELDS];
|
|
|
|
char lowstr[MAXDATELEN + 1];
|
1997-03-15 00:21:12 +01:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (!PointerIsValid(str))
|
|
|
|
elog(WARN, "Bad (null) date external representation", NULL);
|
1997-03-15 00:21:12 +01:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (strlen(str) > MAXDATELEN)
|
|
|
|
elog(WARN, "Bad (length) reltime external representation '%s'", str);
|
1997-03-15 00:21:12 +01:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
|
|
|
|
|| (DecodeDateDelta(field, ftype, nf, &dtype, tm, &fsec) != 0))
|
|
|
|
elog(WARN, "Bad reltime external representation '%s'", str);
|
1997-03-15 00:21:12 +01:00
|
|
|
|
|
|
|
#ifdef DATEDEBUG
|
1997-09-07 07:04:48 +02:00
|
|
|
printf("reltimein- %d fields are type %d (DTK_DATE=%d)\n", nf, dtype, DTK_DATE);
|
1997-03-15 00:21:12 +01:00
|
|
|
#endif
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
switch (dtype)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
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);
|
1997-03-15 00:21:12 +01:00
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
default:
|
|
|
|
return (INVALID_RELTIME);
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1997-03-15 00:21:12 +01:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
elog(WARN, "Bad reltime (internal coding error) '%s'", str);
|
|
|
|
return (INVALID_RELTIME);
|
|
|
|
} /* reltimein() */
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* reltimeout - converts the internal format to a reltime string
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
char *
|
1997-09-07 07:04:48 +02:00
|
|
|
reltimeout(int32 time)
|
1997-07-29 17:54:49 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
char *result;
|
|
|
|
struct tm tt,
|
|
|
|
*tm = &tt;
|
|
|
|
char buf[MAXDATELEN + 1];
|
1997-07-29 17:54:49 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (time == INVALID_RELTIME)
|
|
|
|
{
|
|
|
|
strcpy(buf, INVALID_RELTIME_STR);
|
1997-07-29 17:54:49 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
reltime2tm(time, tm);
|
|
|
|
EncodeTimeSpan(tm, 0, DateStyle, buf);
|
|
|
|
}
|
1997-07-29 17:54:49 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
result = PALLOC(strlen(buf) + 1);
|
|
|
|
strcpy(result, buf);
|
1997-07-29 17:54:49 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
return (result);
|
|
|
|
} /* reltimeout() */
|
1997-07-29 17:54:49 +02:00
|
|
|
|
|
|
|
|
|
|
|
#define TMODULO(t,q,u) {q = (t / u); \
|
1997-09-07 07:04:48 +02:00
|
|
|
if (q != 0) t -= (q * u);}
|
1997-07-29 17:54:49 +02:00
|
|
|
|
1997-08-19 23:40:56 +02:00
|
|
|
static void
|
1997-09-07 07:04:48 +02:00
|
|
|
reltime2tm(int32 time, struct tm * tm)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
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);
|
1997-07-29 17:54:49 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
return;
|
|
|
|
} /* reltime2tm() */
|
1997-07-29 17:54:49 +02:00
|
|
|
|
|
|
|
#if FALSE
|
1997-09-08 04:41:22 +02:00
|
|
|
char *timestring;
|
|
|
|
long quantity;
|
|
|
|
register int i;
|
|
|
|
int unitnr;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
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);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1997-07-29 17:54:49 +02:00
|
|
|
#endif
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* tintervalin - converts an interval string to an internal format
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
TimeInterval
|
|
|
|
tintervalin(char *intervalstr)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int error;
|
|
|
|
AbsoluteTime i_start,
|
|
|
|
i_end,
|
|
|
|
t1,
|
|
|
|
t2;
|
|
|
|
TimeInterval interval;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
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);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* tintervalout - converts an internal interval format to a string
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
char *
|
1997-09-07 07:04:48 +02:00
|
|
|
tintervalout(TimeInterval interval)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
char *i_str,
|
|
|
|
*p;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
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 *
|
1996-07-09 08:22:35 +02:00
|
|
|
*****************************************************************************/
|
|
|
|
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
RelativeTime
|
1997-09-08 23:56:23 +02:00
|
|
|
timespan_reltime(TimeSpan *timespan)
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
RelativeTime time;
|
|
|
|
int year,
|
|
|
|
month;
|
|
|
|
double span;
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (!PointerIsValid(timespan))
|
|
|
|
time = INVALID_RELTIME;
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (TIMESPAN_IS_INVALID(*timespan))
|
|
|
|
{
|
|
|
|
time = INVALID_RELTIME;
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (timespan->month == 0)
|
|
|
|
{
|
|
|
|
year = 0;
|
|
|
|
month = 0;
|
1997-07-29 17:54:49 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
else if (abs(timespan->month) >= 12)
|
|
|
|
{
|
|
|
|
year = (timespan->month / 12);
|
|
|
|
month = (timespan->month % 12);
|
1997-07-29 17:54:49 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
year = 0;
|
|
|
|
month = timespan->month;
|
|
|
|
}
|
1997-07-29 17:54:49 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
span = (((((double) 365 * year) + ((double) 30 * month)) * 86400) + timespan->time);
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
|
|
|
|
#ifdef DATEDEBUG
|
1997-09-07 07:04:48 +02:00
|
|
|
printf("timespan_reltime- convert m%d s%f to %f [%d %d]\n",
|
|
|
|
timespan->month, timespan->time, span, INT_MIN, INT_MAX);
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
#endif
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
time = (((span > INT_MIN) && (span < INT_MAX)) ? span : INVALID_RELTIME);
|
|
|
|
}
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
return (time);
|
|
|
|
} /* timespan_reltime() */
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
|
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
TimeSpan *
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
reltime_timespan(RelativeTime reltime)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
TimeSpan *result;
|
|
|
|
int year,
|
|
|
|
month;
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (!PointerIsValid(result = PALLOCTYPE(TimeSpan)))
|
|
|
|
elog(WARN, "Memory allocation failed, can't convert reltime to timespan", NULL);
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
switch (reltime)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
case INVALID_RELTIME:
|
|
|
|
TIMESPAN_INVALID(*result);
|
|
|
|
break;
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
default:
|
|
|
|
TMODULO(reltime, year, 31536000);
|
|
|
|
TMODULO(reltime, month, 2592000);
|
1997-07-29 17:54:49 +02:00
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
result->time = reltime;
|
|
|
|
result->month = ((12 * year) + month);
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
return (result);
|
|
|
|
} /* reltime_timespan() */
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* mktinterval - creates a time interval with endpoints t1 and t2
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
TimeInterval
|
|
|
|
mktinterval(AbsoluteTime t1, AbsoluteTime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
AbsoluteTime tstart = ABSTIMEMIN(t1, t2),
|
|
|
|
tend = ABSTIMEMAX(t1, t2);
|
|
|
|
TimeInterval interval;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
return interval;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* timepl, timemi and abstimemi use the formula
|
|
|
|
* abstime + reltime = abstime
|
|
|
|
* so abstime - reltime = abstime
|
|
|
|
* and abstime - abstime = reltime
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* timepl - returns the value of (abstime t1 + relime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
AbsoluteTime
|
|
|
|
timepl(AbsoluteTime t1, RelativeTime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
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 (INVALID_ABSTIME);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* timemi - returns the value of (abstime t1 - reltime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
AbsoluteTime
|
|
|
|
timemi(AbsoluteTime t1, RelativeTime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
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);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* abstimemi - returns the value of (abstime t1 - abstime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
static RelativeTime
|
|
|
|
abstimemi(AbsoluteTime t1, AbsoluteTime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (t1 == CURRENT_ABSTIME)
|
|
|
|
t1 = GetCurrentTransactionStartTime();
|
|
|
|
if (t2 == CURRENT_ABSTIME)
|
|
|
|
t2 = GetCurrentTransactionStartTime();
|
|
|
|
|
|
|
|
if (AbsoluteTimeIsReal(t1) &&
|
|
|
|
AbsoluteTimeIsReal(t2))
|
|
|
|
return (t1 - t2);
|
|
|
|
|
|
|
|
return (INVALID_RELTIME);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* ininterval - returns 1, iff absolute date is in the interval
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
int
|
|
|
|
ininterval(AbsoluteTime t, TimeInterval interval)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (interval->status == T_INTERVAL_VALID && t != INVALID_ABSTIME)
|
|
|
|
return (abstimege(t, interval->data[0]) &&
|
|
|
|
abstimele(t, interval->data[1]));
|
|
|
|
return (0);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* intervalrel - returns relative time corresponding to interval
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
RelativeTime
|
|
|
|
intervalrel(TimeInterval interval)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (interval->status == T_INTERVAL_VALID)
|
|
|
|
return (abstimemi(interval->data[1], interval->data[0]));
|
|
|
|
else
|
|
|
|
return (INVALID_RELTIME);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* timenow - returns time "now", internal format
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Now AbsoluteTime is time since Jan 1 1970 -mer 7 Feb 1992
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
AbsoluteTime
|
|
|
|
timenow()
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
time_t sec;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if (time(&sec) < 0)
|
|
|
|
return (INVALID_ABSTIME);
|
|
|
|
return ((AbsoluteTime) sec);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* 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
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
reltimeeq(RelativeTime t1, RelativeTime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
|
|
|
|
return 0;
|
|
|
|
return (t1 == t2);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
reltimene(RelativeTime t1, RelativeTime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
|
|
|
|
return 0;
|
|
|
|
return (t1 != t2);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
reltimelt(RelativeTime t1, RelativeTime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
|
|
|
|
return 0;
|
|
|
|
return (t1 < t2);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
reltimegt(RelativeTime t1, RelativeTime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
|
|
|
|
return 0;
|
|
|
|
return (t1 > t2);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
reltimele(RelativeTime t1, RelativeTime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
|
|
|
|
return 0;
|
|
|
|
return (t1 <= t2);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
reltimege(RelativeTime t1, RelativeTime t2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
|
|
|
|
return 0;
|
|
|
|
return (t1 >= t2);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* intervaleq - returns 1, iff interval i1 is equal to interval i2
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
intervaleq(TimeInterval i1, TimeInterval i2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
|
|
|
|
return (0); /* invalid interval */
|
|
|
|
return (abstimeeq(i1->data[0], i2->data[0]) &&
|
|
|
|
abstimeeq(i1->data[1], i2->data[1]));
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* intervalleneq - returns 1, iff length of interval i is equal to
|
|
|
|
* reltime t
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
intervalleneq(TimeInterval i, RelativeTime t)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
RelativeTime rt;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
|
|
|
|
return (0);
|
|
|
|
rt = intervalrel(i);
|
|
|
|
return (rt != INVALID_RELTIME && rt == t);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* intervallenne - returns 1, iff length of interval i is not equal
|
|
|
|
* to reltime t
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
intervallenne(TimeInterval i, RelativeTime t)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
RelativeTime rt;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
|
|
|
|
return (0);
|
|
|
|
rt = intervalrel(i);
|
|
|
|
return (rt != INVALID_RELTIME && rt != t);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* intervallenlt - returns 1, iff length of interval i is less than
|
|
|
|
* reltime t
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
intervallenlt(TimeInterval i, RelativeTime t)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
RelativeTime rt;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
|
|
|
|
return (0);
|
|
|
|
rt = intervalrel(i);
|
|
|
|
return (rt != INVALID_RELTIME && rt < t);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* intervallengt - returns 1, iff length of interval i is greater than
|
|
|
|
* reltime t
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
intervallengt(TimeInterval i, RelativeTime t)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
RelativeTime rt;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
|
|
|
|
return (0);
|
|
|
|
rt = intervalrel(i);
|
|
|
|
return (rt != INVALID_RELTIME && rt > t);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* intervallenle - returns 1, iff length of interval i is less or equal
|
|
|
|
* than reltime t
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
intervallenle(TimeInterval i, RelativeTime t)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
RelativeTime rt;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
|
|
|
|
return (0);
|
|
|
|
rt = intervalrel(i);
|
|
|
|
return (rt != INVALID_RELTIME && rt <= t);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* intervallenge - returns 1, iff length of interval i is greater or
|
|
|
|
* equal than reltime t
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
intervallenge(TimeInterval i, RelativeTime t)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
RelativeTime rt;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
|
|
|
|
return (0);
|
|
|
|
rt = intervalrel(i);
|
|
|
|
return (rt != INVALID_RELTIME && rt >= t);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* intervalct - returns 1, iff interval i1 contains interval i2
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
intervalct(TimeInterval i1, TimeInterval i2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
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]));
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* intervalov - returns 1, iff interval i1 (partially) overlaps i2
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
bool
|
|
|
|
intervalov(TimeInterval i1, TimeInterval i2)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
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])));
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* intervalstart - returns the start of interval i
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
AbsoluteTime
|
|
|
|
intervalstart(TimeInterval i)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (i->status == T_INTERVAL_INVAL)
|
|
|
|
return INVALID_ABSTIME;
|
|
|
|
return (i->data[0]);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* intervalend - returns the end of interval i
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
AbsoluteTime
|
|
|
|
intervalend(TimeInterval i)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (i->status == T_INTERVAL_INVAL)
|
|
|
|
return INVALID_ABSTIME;
|
|
|
|
return (i->data[1]);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* PRIVATE ROUTINES *
|
1996-07-09 08:22:35 +02:00
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* 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'
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
int
|
|
|
|
isreltime(char *str)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
struct tm tt,
|
|
|
|
*tm = &tt;
|
|
|
|
double fsec;
|
|
|
|
int dtype;
|
|
|
|
char *field[MAXDATEFIELDS];
|
|
|
|
int nf,
|
|
|
|
ftype[MAXDATEFIELDS];
|
|
|
|
char lowstr[MAXDATELEN + 1];
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if (!PointerIsValid(str))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (strlen(str) > MAXDATELEN)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
|
|
|
|
|| (DecodeDateDelta(field, ftype, nf, &dtype, tm, &fsec) != 0))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (dtype)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
case (DTK_DELTA):
|
|
|
|
return ((abs(tm->tm_year) <= 68) ? 1 : 0);
|
|
|
|
break;
|
1997-07-29 17:54:49 +02:00
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
case (DTK_INVALID):
|
|
|
|
return 2;
|
|
|
|
break;
|
1997-07-29 17:54:49 +02:00
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
break;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1997-07-29 17:54:49 +02:00
|
|
|
|
|
|
|
return 0;
|
1997-09-07 07:04:48 +02:00
|
|
|
} /* isreltime() */
|
1997-07-29 17:54:49 +02:00
|
|
|
|
|
|
|
#if FALSE
|
1997-09-08 04:41:22 +02:00
|
|
|
register char *p;
|
|
|
|
register char c;
|
|
|
|
int i;
|
|
|
|
char unit[UNITMAXLEN];
|
|
|
|
char direction[DIRMAXLEN];
|
|
|
|
int localSign;
|
|
|
|
int localUnitNumber;
|
|
|
|
long localQuantity;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if (!PointerIsValid(sign))
|
|
|
|
{
|
1996-07-09 08:22:35 +02:00
|
|
|
sign = &localSign;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!PointerIsValid(unitnr))
|
|
|
|
{
|
1996-07-09 08:22:35 +02:00
|
|
|
unitnr = &localUnitNumber;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!PointerIsValid(quantity))
|
|
|
|
{
|
1996-07-09 08:22:35 +02:00
|
|
|
quantity = &localQuantity;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
unit[0] = '\0';
|
|
|
|
direction[0] = '\0';
|
|
|
|
p = timestring;
|
|
|
|
/* skip leading blanks */
|
|
|
|
while ((c = *p) != '\0')
|
|
|
|
{
|
1996-07-09 08:22:35 +02:00
|
|
|
if (c != ' ')
|
1997-09-07 07:04:48 +02:00
|
|
|
break;
|
1996-07-09 08:22:35 +02:00
|
|
|
p++;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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 (;;)
|
|
|
|
{
|
1996-07-09 08:22:35 +02:00
|
|
|
c = *p;
|
1997-09-07 07:04:48 +02:00
|
|
|
if (isdigit(c))
|
|
|
|
{
|
|
|
|
*quantity = *quantity * 10 + (c - '0');
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (c == ' ')
|
|
|
|
break; /* correct quantity found */
|
|
|
|
else
|
|
|
|
return (0); /* syntax error */
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* handle unit */
|
|
|
|
p++;
|
|
|
|
i = 0;
|
|
|
|
for (;;)
|
|
|
|
{
|
1996-07-09 08:22:35 +02:00
|
|
|
c = *p;
|
1997-09-07 07:04:48 +02:00
|
|
|
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 */
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* handle optional direction */
|
|
|
|
if (c == ' ')
|
1996-07-09 08:22:35 +02:00
|
|
|
p++;
|
1997-09-07 07:04:48 +02:00
|
|
|
i = 0;
|
|
|
|
*sign = 1;
|
|
|
|
for (;;)
|
|
|
|
{
|
1996-07-09 08:22:35 +02:00
|
|
|
c = *p;
|
1997-09-07 07:04:48 +02:00
|
|
|
if (c >= 'a' && c <= 'z' && i <= (DIRMAXLEN - 1))
|
|
|
|
{
|
|
|
|
direction[i] = c;
|
|
|
|
p++;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((c == ' ' || c == '\0') && i == 0)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
*sign = 1;
|
|
|
|
break; /* no direction specified */
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
if ((c == ' ' || c == '\0') && i != 0)
|
|
|
|
{
|
|
|
|
direction[i] = '\0';
|
|
|
|
correct_dir(direction, sign);
|
|
|
|
break; /* correct direction found */
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return (0); /* syntax error */
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return (1);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* correct_unit - returns 1, iff unit is a correct unit description
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* output parameter:
|
|
|
|
* unptr: points to an integer which is the appropriate unit number
|
|
|
|
* (see function isreltime())
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
correct_unit(char unit[], int *unptr)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int j = 0;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
while (j < NUNITS)
|
|
|
|
{
|
|
|
|
if (strncmp(unit, unit_tab[j], strlen(unit_tab[j])) == 0)
|
|
|
|
{
|
|
|
|
*unptr = j;
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
j++;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
return (0); /* invalid unit descriptor */
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* correct_dir - returns 1, iff direction is a correct identifier
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* 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)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
*signptr = -1;
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return (0); /* invalid direction descriptor */
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1997-07-29 17:54:49 +02:00
|
|
|
#endif
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* 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
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* output parameter:
|
|
|
|
* i_start, i_end: interval margins
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Time interval:
|
|
|
|
* `[' {` '} `'' <AbsTime> `'' {` '} `'' <AbsTime> `'' {` '} `]'
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* OR `Undefined Range' (see also INVALID_INTERVAL_STR)
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* where <AbsTime> satisfies the syntax of absolute time.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* e.g. [ ' Jan 18 1902' 'Jan 1 00:00:00 1970']
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
istinterval(char *i_string,
|
1997-09-08 22:59:27 +02:00
|
|
|
AbsoluteTime *i_start,
|
|
|
|
AbsoluteTime *i_end)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
register char *p,
|
|
|
|
*p1;
|
|
|
|
register char c;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
p = i_string;
|
|
|
|
/* skip leading blanks up to '[' */
|
|
|
|
while ((c = *p) != '\0')
|
|
|
|
{
|
|
|
|
if (IsSpace(c))
|
|
|
|
p++;
|
|
|
|
else if (c != '[')
|
|
|
|
return (0); /* syntax error */
|
|
|
|
else
|
|
|
|
break;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
p++;
|
|
|
|
/* skip leading blanks up to "'" */
|
|
|
|
while ((c = *p) != '\0')
|
|
|
|
{
|
|
|
|
if (IsSpace(c))
|
|
|
|
p++;
|
|
|
|
else if (c != '"')
|
|
|
|
return (0); /* syntax error */
|
|
|
|
else
|
|
|
|
break;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
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')
|
|
|
|
{
|
|
|
|
if (IsSpace(c))
|
|
|
|
p++;
|
|
|
|
else if (c != ']')
|
|
|
|
return (0); /* syntax error */
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
c = *p;
|
|
|
|
if (c != '\0')
|
|
|
|
return (0); /* syntax error */
|
|
|
|
/* it seems to be a valid interval */
|
|
|
|
return (1);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* timeofday -
|
1997-09-07 07:04:48 +02:00
|
|
|
* 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
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
text *
|
1996-11-10 04:06:38 +01:00
|
|
|
timeofday(void)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
struct timeval tp;
|
1997-09-07 07:04:48 +02:00
|
|
|
struct timezone tpz;
|
1997-09-08 04:41:22 +02:00
|
|
|
char templ[500];
|
|
|
|
char buf[500];
|
|
|
|
text *tm;
|
|
|
|
int len = 0;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
gettimeofday(&tp, &tpz);
|
|
|
|
strftime(templ, sizeof(templ), "%a %b %d %H:%M:%S.%%d %Y %Z",
|
1997-09-08 23:56:23 +02:00
|
|
|
localtime((time_t *) &tp.tv_sec));
|
1997-09-07 07:04:48 +02:00
|
|
|
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;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|