开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
date.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：28k
源码类别：

数据库系统

开发平台：

Unix_Linux

date.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * date.c
  4.  *   Utilities for the built-in type "AbsoluteTime" (defined in nabstime).
  5.  *   Functions for the built-in type "RelativeTime".
  6.  *   Functions for the built-in type "TimeInterval".
  7.  *
  8.  * Copyright (c) 1994, Regents of the University of California
  9.  *
  10.  *
  11.  * IDENTIFICATION
  12.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.32.2.1 1999/08/02 05:24:51 scrappy Exp $
  13.  *
  14.  * NOTES
  15.  *  This code is actually (almost) unused.
  16.  *  It needs to be integrated with Time and struct trange.
  17.  *
  18.  * XXX This code needs to be rewritten to work with the "new" definitions
  19.  * XXX in h/tim.h.  Look for int32's, int, long, etc. in the code.  The
  20.  * XXX definitions in h/tim.h may need to be rethought also.
  21.  *
  22.  * XXX This code has been cleaned up some - avi 07/07/93
  23.  *
  24.  *-------------------------------------------------------------------------
  25.  */
  26. #include <ctype.h>
  27. #include <time.h>
  28. #include <sys/time.h>
  29. #include <sys/types.h>
  31. #include "postgres.h"
  32. #ifdef HAVE_FLOAT_H
  33. #include <float.h>
  34. #endif
  35. #ifdef HAVE_LIMITS_H
  36. #include <limits.h>
  37. #endif
  39. #include "access/xact.h"
  40. #include "miscadmin.h"
  41. #include "utils/builtins.h"
  42. #include "utils/dt.h"
  44. #define INVALID_RELTIME_STR "Undefined RelTime"
  45. #define INVALID_RELTIME_STR_LEN (sizeof(INVALID_RELTIME_STR)-1)
  46. #define RELTIME_LABEL '@'
  47. #define RELTIME_PAST "ago"
  48. #define DIRMAXLEN (sizeof(RELTIME_PAST)-1)
  50. /*
  51.  * Unix epoch is Jan  1 00:00:00 1970.  Postgres knows about times
  52.  * sixty-eight years on either side of that.
  53.  */
  55. #define IsSpace(C) ((C) == ' ')
  57. #define T_INTERVAL_INVAL   0 /* data represents no valid interval */
  58. #define T_INTERVAL_VALID   1 /* data represents a valid interval */
  59. /*
  60.  * ['Mon May 10 23:59:12 1943 PST' 'Sun Jan 14 03:14:21 1973 PST']
  61.  * 0 1   2 3   4 5   6
  62.  * 1234567890123456789012345678901234567890123456789012345678901234
  63.  *
  64.  * we allocate some extra -- timezones are usually 3 characters but
  65.  * this is not in the POSIX standard...
  66.  */
  67. #define T_INTERVAL_LEN 80
  68. #define INVALID_INTERVAL_STR "Undefined Range"
  69. #define INVALID_INTERVAL_STR_LEN (sizeof(INVALID_INTERVAL_STR)-1)
  71. #define ABSTIMEMIN(t1, t2) abstimele((t1),(t2)) ? (t1) : (t2)
  72. #define ABSTIMEMAX(t1, t2) abstimelt((t1),(t2)) ? (t2) : (t1)
  74. #ifdef NOT_USED
  75. static char *unit_tab[] = {
  76. "second", "seconds", "minute", "minutes",
  77. "hour", "hours", "day", "days", "week", "weeks",
  78. "month", "months", "year", "years"};
  80. #define UNITMAXLEN 7 /* max length of a unit name */
  81. #define NUNITS 14 /* number of different units */
  83. /* table of seconds per unit (month = 30 days, year = 365 days)  */
  84. static int sec_tab[] = {
  85. 1, 1, 60, 60,
  86. 3600, 3600, 86400, 86400, 604800, 604800,
  87. 2592000, 2592000, 31536000, 31536000};
  89. #endif
  91. /*
  92.  * Function prototypes -- internal to this file only
  93.  */
  95. static void reltime2tm(RelativeTime time, struct tm * tm);
  97. #ifdef NOT_USED
  98. static int correct_unit(char *unit, int *unptr);
  99. static int correct_dir(char *direction, int *signptr);
  101. #endif
  103. static int istinterval(char *i_string,
  104. AbsoluteTime *i_start,
  105. AbsoluteTime *i_end);
  107. /*****************************************************************************
  108.  *  USER I/O ROUTINES  *
  109.  *****************************************************************************/
  111. /*
  112.  * reltimein - converts a reltime string in an internal format
  113.  */
  114. RelativeTime
  115. reltimein(char *str)
  116. {
  117. RelativeTime result;
  119. struct tm tt,
  120.    *tm = &tt;
  121. double fsec;
  122. int dtype;
  123. char    *field[MAXDATEFIELDS];
  124. int nf,
  125. ftype[MAXDATEFIELDS];
  126. char lowstr[MAXDATELEN + 1];
  128. if (!PointerIsValid(str))
  129. elog(ERROR, "Bad (null) date external representation", NULL);
  131. if (strlen(str) > MAXDATELEN)
  132. elog(ERROR, "Bad (length) reltime external representation '%s'", str);
  134. if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
  135. || (DecodeDateDelta(field, ftype, nf, &dtype, tm, &fsec) != 0))
  136. elog(ERROR, "Bad reltime external representation '%s'", str);
  138. #ifdef DATEDEBUG
  139. printf("reltimein- %d fields are type %d (DTK_DATE=%d)n", nf, dtype, DTK_DATE);
  140. #endif
  142. switch (dtype)
  143. {
  144. case DTK_DELTA:
  145. result = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec);
  146. result += (((tm->tm_year * 365) + (tm->tm_mon * 30) + tm->tm_mday) * (24 * 60 * 60));
  147. return result;
  149. default:
  150. return INVALID_RELTIME;
  151. }
  153. elog(ERROR, "Bad reltime (internal coding error) '%s'", str);
  154. return INVALID_RELTIME;
  155. } /* reltimein() */
  158. /*
  159.  * reltimeout - converts the internal format to a reltime string
  160.  */
  161. char *
  162. reltimeout(RelativeTime time)
  163. {
  164. char    *result;
  165. struct tm tt,
  166.    *tm = &tt;
  167. char buf[MAXDATELEN + 1];
  169. if (time == INVALID_RELTIME)
  170. {
  171. strcpy(buf, INVALID_RELTIME_STR);
  173. }
  174. else
  175. {
  176. reltime2tm(time, tm);
  177. EncodeTimeSpan(tm, 0, DateStyle, buf);
  178. }
  180. result = palloc(strlen(buf) + 1);
  181. strcpy(result, buf);
  183. return result;
  184. } /* reltimeout() */
  187. #define TMODULO(t,q,u) 
  188. do { 
  189. q = (t / u); 
  190. if (q != 0) t -= (q * u); 
  191. } while(0)
  193. static void
  194. reltime2tm(RelativeTime time, struct tm * tm)
  195. {
  196. TMODULO(time, tm->tm_year, 31536000);
  197. TMODULO(time, tm->tm_mon, 2592000);
  198. TMODULO(time, tm->tm_mday, 86400);
  199. TMODULO(time, tm->tm_hour, 3600);
  200. TMODULO(time, tm->tm_min, 60);
  201. TMODULO(time, tm->tm_sec, 1);
  203. return;
  204. } /* reltime2tm() */
  206. #ifdef NOT_USED
  207. int
  208. dummyfunc()
  209. {
  210. char    *timestring;
  211. long quantity;
  212. int i;
  213. int unitnr;
  215. timestring = (char *) palloc(Max(strlen(INVALID_RELTIME_STR),
  216.  UNITMAXLEN) + 1);
  217. if (timevalue == INVALID_RELTIME)
  218. {
  219. strcpy(timestring, INVALID_RELTIME_STR);
  220. return timestring;
  221. }
  223. if (timevalue == 0)
  224. i = 1; /* unit = 'seconds' */
  225. else
  226. for (i = 12; i >= 0; i = i - 2)
  227. if ((timevalue % sec_tab[i]) == 0)
  228. break; /* appropriate unit found */
  229. unitnr = i;
  230. quantity = (timevalue / sec_tab[unitnr]);
  231. if (quantity > 1 || quantity < -1)
  232. unitnr++; /* adjust index for PLURAL of unit */
  233. if (quantity >= 0)
  234. sprintf(timestring, "%c %lu %s", RELTIME_LABEL,
  235. quantity, unit_tab[unitnr]);
  236. else
  237. sprintf(timestring, "%c %lu %s %s", RELTIME_LABEL,
  238. (quantity * -1), unit_tab[unitnr], RELTIME_PAST);
  239. return timestring;
  240. }
  242. #endif
  245. /*
  246.  * tintervalin - converts an interval string to an internal format
  247.  */
  248. TimeInterval
  249. tintervalin(char *intervalstr)
  250. {
  251. int error;
  252. AbsoluteTime i_start,
  253. i_end,
  254. t1,
  255. t2;
  256. TimeInterval interval;
  258. interval = (TimeInterval) palloc(sizeof(TimeIntervalData));
  259. error = istinterval(intervalstr, &t1, &t2);
  260. if (error == 0)
  261. interval->status = T_INTERVAL_INVAL;
  262. if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
  263. interval->status = T_INTERVAL_INVAL; /* undefined  */
  264. else
  265. {
  266. i_start = ABSTIMEMIN(t1, t2);
  267. i_end = ABSTIMEMAX(t1, t2);
  268. interval->data[0] = i_start;
  269. interval->data[1] = i_end;
  270. interval->status = T_INTERVAL_VALID;
  271. }
  272. return interval;
  273. }
  276. /*
  277.  * tintervalout - converts an internal interval format to a string
  278.  *
  279.  */
  280. char *
  281. tintervalout(TimeInterval interval)
  282. {
  283. char    *i_str,
  284.    *p;
  286. i_str = (char *) palloc(T_INTERVAL_LEN); /* ['...' '...'] */
  287. strcpy(i_str, "["");
  288. if (interval->status == T_INTERVAL_INVAL)
  289. strcat(i_str, INVALID_INTERVAL_STR);
  290. else
  291. {
  292. p = nabstimeout(interval->data[0]);
  293. strcat(i_str, p);
  294. pfree(p);
  295. strcat(i_str, "" "");
  296. p = nabstimeout(interval->data[1]);
  297. strcat(i_str, p);
  298. pfree(p);
  299. }
  300. strcat(i_str, ""]");
  301. return i_str;
  302. }
  305. /*****************************************************************************
  306.  *  PUBLIC ROUTINES  *
  307.  *****************************************************************************/
  309. RelativeTime
  310. timespan_reltime(TimeSpan *timespan)
  311. {
  312. RelativeTime time;
  313. int year,
  314. month;
  315. double span;
  317. if (!PointerIsValid(timespan))
  318. time = INVALID_RELTIME;
  320. if (TIMESPAN_IS_INVALID(*timespan))
  321. {
  322. time = INVALID_RELTIME;
  324. }
  325. else
  326. {
  327. if (timespan->month == 0)
  328. {
  329. year = 0;
  330. month = 0;
  332. }
  333. else if (abs(timespan->month) >= 12)
  334. {
  335. year = (timespan->month / 12);
  336. month = (timespan->month % 12);
  338. }
  339. else
  340. {
  341. year = 0;
  342. month = timespan->month;
  343. }
  345. span = (((((double) 365 * year) + ((double) 30 * month)) * 86400) + timespan->time);
  347. #ifdef DATEDEBUG
  348. printf("timespan_reltime- convert m%d s%f to %f [%d %d]n",
  349.    timespan->month, timespan->time, span, INT_MIN, INT_MAX);
  350. #endif
  352. time = (((span > INT_MIN) && (span < INT_MAX)) ? span : INVALID_RELTIME);
  353. }
  355. return time;
  356. } /* timespan_reltime() */
  359. TimeSpan   *
  360. reltime_timespan(RelativeTime reltime)
  361. {
  362. TimeSpan   *result;
  363. int year,
  364. month;
  366. if (!PointerIsValid(result = palloc(sizeof(TimeSpan))))
  367. elog(ERROR, "Memory allocation failed, can't convert reltime to timespan", NULL);
  369. switch (reltime)
  370. {
  371. case INVALID_RELTIME:
  372. TIMESPAN_INVALID(*result);
  373. break;
  375. default:
  376. TMODULO(reltime, year, 31536000);
  377. TMODULO(reltime, month, 2592000);
  379. result->time = reltime;
  380. result->month = ((12 * year) + month);
  381. }
  383. return result;
  384. } /* reltime_timespan() */
  387. /*
  388.  * mktinterval - creates a time interval with endpoints t1 and t2
  389.  */
  390. TimeInterval
  391. mktinterval(AbsoluteTime t1, AbsoluteTime t2)
  392. {
  393. AbsoluteTime tstart = ABSTIMEMIN(t1, t2),
  394. tend = ABSTIMEMAX(t1, t2);
  395. TimeInterval interval;
  397. interval = (TimeInterval) palloc(sizeof(TimeIntervalData));
  398. if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
  399. interval->status = T_INTERVAL_INVAL;
  400. else
  401. {
  402. interval->status = T_INTERVAL_VALID;
  403. interval->data[0] = tstart;
  404. interval->data[1] = tend;
  405. }
  407. return interval;
  408. }
  410. /*
  411.  * timepl, timemi and abstimemi use the formula
  412.  * abstime + reltime = abstime
  413.  * so abstime - reltime = abstime
  414.  * and abstime - abstime = reltime
  415.  */
  417. /*
  418.  * timepl - returns the value of (abstime t1 + relime t2)
  419.  */
  420. AbsoluteTime
  421. timepl(AbsoluteTime t1, RelativeTime t2)
  422. {
  423. if (t1 == CURRENT_ABSTIME)
  424. t1 = GetCurrentTransactionStartTime();
  426. if (AbsoluteTimeIsReal(t1) &&
  427. RelativeTimeIsValid(t2) &&
  428. ((t2 > 0) ? (t1 < NOEND_ABSTIME - t2)
  429.  : (t1 > NOSTART_ABSTIME - t2))) /* prevent overflow */
  430. return t1 + t2;
  432. return INVALID_ABSTIME;
  433. }
  436. /*
  437.  * timemi - returns the value of (abstime t1 - reltime t2)
  438.  */
  439. AbsoluteTime
  440. timemi(AbsoluteTime t1, RelativeTime t2)
  441. {
  442. if (t1 == CURRENT_ABSTIME)
  443. t1 = GetCurrentTransactionStartTime();
  445. if (AbsoluteTimeIsReal(t1) &&
  446. RelativeTimeIsValid(t2) &&
  447. ((t2 > 0) ? (t1 > NOSTART_ABSTIME + t2)
  448.  : (t1 < NOEND_ABSTIME + t2))) /* prevent overflow */
  449. return t1 - t2;
  451. return INVALID_ABSTIME;
  452. }
  455. /*
  456.  * abstimemi - returns the value of (abstime t1 - abstime t2)
  457.  */
  458. static RelativeTime
  459. abstimemi(AbsoluteTime t1, AbsoluteTime t2)
  460. {
  461. if (t1 == CURRENT_ABSTIME)
  462. t1 = GetCurrentTransactionStartTime();
  463. if (t2 == CURRENT_ABSTIME)
  464. t2 = GetCurrentTransactionStartTime();
  466. if (AbsoluteTimeIsReal(t1) &&
  467. AbsoluteTimeIsReal(t2))
  468. return t1 - t2;
  470. return INVALID_RELTIME;
  471. }
  474. /*
  475.  * ininterval - returns 1, iff absolute date is in the interval
  476.  */
  477. int
  478. ininterval(AbsoluteTime t, TimeInterval interval)
  479. {
  480. if (interval->status == T_INTERVAL_VALID && t != INVALID_ABSTIME)
  481. return (abstimege(t, interval->data[0]) &&
  482. abstimele(t, interval->data[1]));
  483. return 0;
  484. }
  486. /*
  487.  * intervalrel - returns  relative time corresponding to interval
  488.  */
  489. RelativeTime
  490. intervalrel(TimeInterval interval)
  491. {
  492. if (interval->status == T_INTERVAL_VALID)
  493. return abstimemi(interval->data[1], interval->data[0]);
  494. else
  495. return INVALID_RELTIME;
  496. }
  498. /*
  499.  * timenow - returns  time "now", internal format
  500.  *
  501.  * Now AbsoluteTime is time since Jan 1 1970 -mer 7 Feb 1992
  502.  */
  503. AbsoluteTime
  504. timenow()
  505. {
  506. time_t sec;
  508. if (time(&sec) < 0)
  509. return INVALID_ABSTIME;
  510. return (AbsoluteTime) sec;
  511. }
  513. /*
  514.  * reltimeeq - returns 1, iff arguments are equal
  515.  * reltimene - returns 1, iff arguments are not equal
  516.  * reltimelt - returns 1, iff t1 less than t2
  517.  * reltimegt - returns 1, iff t1 greater than t2
  518.  * reltimele - returns 1, iff t1 less than or equal to t2
  519.  * reltimege - returns 1, iff t1 greater than or equal to t2
  520.  */
  521. bool
  522. reltimeeq(RelativeTime t1, RelativeTime t2)
  523. {
  524. if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
  525. return 0;
  526. return t1 == t2;
  527. }
  529. bool
  530. reltimene(RelativeTime t1, RelativeTime t2)
  531. {
  532. if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
  533. return 0;
  534. return t1 != t2;
  535. }
  537. bool
  538. reltimelt(RelativeTime t1, RelativeTime t2)
  539. {
  540. if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
  541. return 0;
  542. return t1 < t2;
  543. }
  545. bool
  546. reltimegt(RelativeTime t1, RelativeTime t2)
  547. {
  548. if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
  549. return 0;
  550. return t1 > t2;
  551. }
  553. bool
  554. reltimele(RelativeTime t1, RelativeTime t2)
  555. {
  556. if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
  557. return 0;
  558. return t1 <= t2;
  559. }
  561. bool
  562. reltimege(RelativeTime t1, RelativeTime t2)
  563. {
  564. if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
  565. return 0;
  566. return t1 >= t2;
  567. }
  570. /*
  571.  * intervalsame - returns 1, iff interval i1 is same as interval i2
  572.  * Check begin and end time.
  573.  */
  574. bool
  575. intervalsame(TimeInterval i1, TimeInterval i2)
  576. {
  577. if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
  578. return FALSE; /* invalid interval */
  579. return (abstimeeq(i1->data[0], i2->data[0]) &&
  580. abstimeeq(i1->data[1], i2->data[1]));
  581. } /* intervalsame() */
  584. /*
  585.  * intervaleq - returns 1, iff interval i1 is equal to interval i2
  586.  * Check length of intervals.
  587.  */
  588. bool
  589. intervaleq(TimeInterval i1, TimeInterval i2)
  590. {
  591. AbsoluteTime t10,
  592. t11,
  593. t20,
  594. t21;
  596. if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
  597. return FALSE; /* invalid interval */
  599. t10 = i1->data[0];
  600. t11 = i1->data[1];
  601. t20 = i2->data[0];
  602. t21 = i2->data[1];
  604. if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
  605. || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
  606. return FALSE;
  608. if (t10 == CURRENT_ABSTIME)
  609. t10 = GetCurrentTransactionStartTime();
  610. if (t11 == CURRENT_ABSTIME)
  611. t11 = GetCurrentTransactionStartTime();
  612. if (t20 == CURRENT_ABSTIME)
  613. t20 = GetCurrentTransactionStartTime();
  614. if (t21 == CURRENT_ABSTIME)
  615. t21 = GetCurrentTransactionStartTime();
  617. return (t11 - t10) == (t21 - t20);
  618. } /* intervaleq() */
  620. /*
  621.  * intervalne - returns 1, iff interval i1 is not equal to interval i2
  622.  * Check length of intervals.
  623.  */
  624. bool
  625. intervalne(TimeInterval i1, TimeInterval i2)
  626. {
  627. AbsoluteTime t10,
  628. t11,
  629. t20,
  630. t21;
  632. if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
  633. return FALSE; /* invalid interval */
  635. t10 = i1->data[0];
  636. t11 = i1->data[1];
  637. t20 = i2->data[0];
  638. t21 = i2->data[1];
  640. if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
  641. || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
  642. return FALSE;
  644. if (t10 == CURRENT_ABSTIME)
  645. t10 = GetCurrentTransactionStartTime();
  646. if (t11 == CURRENT_ABSTIME)
  647. t11 = GetCurrentTransactionStartTime();
  648. if (t20 == CURRENT_ABSTIME)
  649. t20 = GetCurrentTransactionStartTime();
  650. if (t21 == CURRENT_ABSTIME)
  651. t21 = GetCurrentTransactionStartTime();
  653. return (t11 - t10) != (t21 - t20);
  654. } /* intervalne() */
  656. /*
  657.  * intervallt - returns TRUE, iff interval i1 is less than interval i2
  658.  * Check length of intervals.
  659.  */
  660. bool
  661. intervallt(TimeInterval i1, TimeInterval i2)
  662. {
  663. AbsoluteTime t10,
  664. t11,
  665. t20,
  666. t21;
  668. if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
  669. return FALSE; /* invalid interval */
  671. t10 = i1->data[0];
  672. t11 = i1->data[1];
  673. t20 = i2->data[0];
  674. t21 = i2->data[1];
  676. if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
  677. || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
  678. return FALSE;
  680. if (t10 == CURRENT_ABSTIME)
  681. t10 = GetCurrentTransactionStartTime();
  682. if (t11 == CURRENT_ABSTIME)
  683. t11 = GetCurrentTransactionStartTime();
  684. if (t20 == CURRENT_ABSTIME)
  685. t20 = GetCurrentTransactionStartTime();
  686. if (t21 == CURRENT_ABSTIME)
  687. t21 = GetCurrentTransactionStartTime();
  689. return (t11 - t10) < (t21 - t20);
  690. } /* intervallt() */
  692. /*
  693.  * intervalle - returns TRUE, iff interval i1 is less than or equal to interval i2
  694.  * Check length of intervals.
  695.  */
  696. bool
  697. intervalle(TimeInterval i1, TimeInterval i2)
  698. {
  699. AbsoluteTime t10,
  700. t11,
  701. t20,
  702. t21;
  704. if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
  705. return FALSE; /* invalid interval */
  707. t10 = i1->data[0];
  708. t11 = i1->data[1];
  709. t20 = i2->data[0];
  710. t21 = i2->data[1];
  712. if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
  713. || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
  714. return FALSE;
  716. if (t10 == CURRENT_ABSTIME)
  717. t10 = GetCurrentTransactionStartTime();
  718. if (t11 == CURRENT_ABSTIME)
  719. t11 = GetCurrentTransactionStartTime();
  720. if (t20 == CURRENT_ABSTIME)
  721. t20 = GetCurrentTransactionStartTime();
  722. if (t21 == CURRENT_ABSTIME)
  723. t21 = GetCurrentTransactionStartTime();
  725. return (t11 - t10) <= (t21 - t20);
  726. } /* intervalle() */
  728. /*
  729.  * intervalgt - returns TRUE, iff interval i1 is less than interval i2
  730.  * Check length of intervals.
  731.  */
  732. bool
  733. intervalgt(TimeInterval i1, TimeInterval i2)
  734. {
  735. AbsoluteTime t10,
  736. t11,
  737. t20,
  738. t21;
  740. if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
  741. return FALSE; /* invalid interval */
  743. t10 = i1->data[0];
  744. t11 = i1->data[1];
  745. t20 = i2->data[0];
  746. t21 = i2->data[1];
  748. if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
  749. || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
  750. return FALSE;
  752. if (t10 == CURRENT_ABSTIME)
  753. t10 = GetCurrentTransactionStartTime();
  754. if (t11 == CURRENT_ABSTIME)
  755. t11 = GetCurrentTransactionStartTime();
  756. if (t20 == CURRENT_ABSTIME)
  757. t20 = GetCurrentTransactionStartTime();
  758. if (t21 == CURRENT_ABSTIME)
  759. t21 = GetCurrentTransactionStartTime();
  761. return (t11 - t10) > (t21 - t20);
  762. } /* intervalgt() */
  764. /*
  765.  * intervalge - returns TRUE, iff interval i1 is less than or equal to interval i2
  766.  * Check length of intervals.
  767.  */
  768. bool
  769. intervalge(TimeInterval i1, TimeInterval i2)
  770. {
  771. AbsoluteTime t10,
  772. t11,
  773. t20,
  774. t21;
  776. if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
  777. return FALSE; /* invalid interval */
  779. t10 = i1->data[0];
  780. t11 = i1->data[1];
  781. t20 = i2->data[0];
  782. t21 = i2->data[1];
  784. if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
  785. || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
  786. return FALSE;
  788. if (t10 == CURRENT_ABSTIME)
  789. t10 = GetCurrentTransactionStartTime();
  790. if (t11 == CURRENT_ABSTIME)
  791. t11 = GetCurrentTransactionStartTime();
  792. if (t20 == CURRENT_ABSTIME)
  793. t20 = GetCurrentTransactionStartTime();
  794. if (t21 == CURRENT_ABSTIME)
  795. t21 = GetCurrentTransactionStartTime();
  797. return (t11 - t10) >= (t21 - t20);
  798. } /* intervalge() */
  801. /*
  802.  * intervalleneq - returns 1, iff length of interval i is equal to
  803.  * reltime t
  804.  */
  805. bool
  806. intervalleneq(TimeInterval i, RelativeTime t)
  807. {
  808. RelativeTime rt;
  810. if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
  811. return 0;
  812. rt = intervalrel(i);
  813. return rt != INVALID_RELTIME && rt == t;
  814. }
  816. /*
  817.  * intervallenne - returns 1, iff length of interval i is not equal
  818.  * to reltime t
  819.  */
  820. bool
  821. intervallenne(TimeInterval i, RelativeTime t)
  822. {
  823. RelativeTime rt;
  825. if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
  826. return 0;
  827. rt = intervalrel(i);
  828. return rt != INVALID_RELTIME && rt != t;
  829. }
  831. /*
  832.  * intervallenlt - returns 1, iff length of interval i is less than
  833.  * reltime t
  834.  */
  835. bool
  836. intervallenlt(TimeInterval i, RelativeTime t)
  837. {
  838. RelativeTime rt;
  840. if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
  841. return 0;
  842. rt = intervalrel(i);
  843. return rt != INVALID_RELTIME && rt < t;
  844. }
  846. /*
  847.  * intervallengt - returns 1, iff length of interval i is greater than
  848.  * reltime t
  849.  */
  850. bool
  851. intervallengt(TimeInterval i, RelativeTime t)
  852. {
  853. RelativeTime rt;
  855. if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
  856. return 0;
  857. rt = intervalrel(i);
  858. return rt != INVALID_RELTIME && rt > t;
  859. }
  861. /*
  862.  * intervallenle - returns 1, iff length of interval i is less or equal
  863.  * than reltime t
  864.  */
  865. bool
  866. intervallenle(TimeInterval i, RelativeTime t)
  867. {
  868. RelativeTime rt;
  870. if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
  871. return 0;
  872. rt = intervalrel(i);
  873. return rt != INVALID_RELTIME && rt <= t;
  874. }
  876. /*
  877.  * intervallenge - returns 1, iff length of interval i is greater or
  878.  * equal than reltime t
  879.  */
  880. bool
  881. intervallenge(TimeInterval i, RelativeTime t)
  882. {
  883. RelativeTime rt;
  885. if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
  886. return 0;
  887. rt = intervalrel(i);
  888. return rt != INVALID_RELTIME && rt >= t;
  889. }
  891. /*
  892.  * intervalct - returns 1, iff interval i1 contains interval i2
  893.  */
  894. bool
  895. intervalct(TimeInterval i1, TimeInterval i2)
  896. {
  897. if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
  898. return 0;
  899. return (abstimele(i1->data[0], i2->data[0]) &&
  900. abstimege(i1->data[1], i2->data[1]));
  901. }
  903. /*
  904.  * intervalov - returns 1, iff interval i1 (partially) overlaps i2
  905.  */
  906. bool
  907. intervalov(TimeInterval i1, TimeInterval i2)
  908. {
  909. if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
  910. return 0;
  911. return (!(abstimelt(i1->data[1], i2->data[0]) ||
  912.   abstimegt(i1->data[0], i2->data[1])));
  913. }
  915. /*
  916.  * intervalstart - returns  the start of interval i
  917.  */
  918. AbsoluteTime
  919. intervalstart(TimeInterval i)
  920. {
  921. if (i->status == T_INTERVAL_INVAL)
  922. return INVALID_ABSTIME;
  923. return i->data[0];
  924. }
  926. /*
  927.  * intervalend - returns  the end of interval i
  928.  */
  929. AbsoluteTime
  930. intervalend(TimeInterval i)
  931. {
  932. if (i->status == T_INTERVAL_INVAL)
  933. return INVALID_ABSTIME;
  934. return i->data[1];
  935. }
  938. /*****************************************************************************
  939.  *  PRIVATE ROUTINES  *
  940.  *****************************************************************************/
  942. #ifdef NOT_USED
  943. /*
  944.  * isreltime - returns 1, iff datestring is of type reltime
  945.  *   2, iff datestring is 'invalid time' identifier
  946.  *   0, iff datestring contains a syntax error
  947.  * VALID time less or equal +/-  `@ 68 years'
  948.  *
  949.  */
  950. int
  951. isreltime(char *str)
  952. {
  953. struct tm tt,
  954.    *tm = &tt;
  955. double fsec;
  956. int dtype;
  957. char    *field[MAXDATEFIELDS];
  958. int nf,
  959. ftype[MAXDATEFIELDS];
  960. char lowstr[MAXDATELEN + 1];
  962. if (!PointerIsValid(str))
  963. return 0;
  965. if (strlen(str) > MAXDATELEN)
  966. return 0;
  968. if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
  969. || (DecodeDateDelta(field, ftype, nf, &dtype, tm, &fsec) != 0))
  970. return 0;
  972. switch (dtype)
  973. {
  974. case (DTK_DELTA):
  975. return (abs(tm->tm_year) <= 68) ? 1 : 0;
  976. break;
  978. case (DTK_INVALID):
  979. return 2;
  980. break;
  982. default:
  983. return 0;
  984. break;
  985. }
  987. return 0;
  988. } /* isreltime() */
  990. #endif
  992. #ifdef NOT_USED
  993. int
  994. dummyfunc()
  995. {
  996. char    *p;
  997. char c;
  998. int i;
  999. char unit[UNITMAXLEN];
  1000. char direction[DIRMAXLEN];
  1001. int localSign;
  1002. int localUnitNumber;
  1003. long localQuantity;
  1005. if (!PointerIsValid(sign))
  1006. sign = &localSign;
  1008. if (!PointerIsValid(unitnr))
  1009. unitnr = &localUnitNumber;
  1011. if (!PointerIsValid(quantity))
  1012. quantity = &localQuantity;
  1014. unit[0] = '';
  1015. direction[0] = '';
  1016. p = timestring;
  1017. /* skip leading blanks */
  1018. while ((c = *p) != '')
  1019. {
  1020. if (c != ' ')
  1021. break;
  1022. p++;
  1023. }
  1025. /* Test whether 'invalid time' identifier or not */
  1026. if (!strncmp(INVALID_RELTIME_STR, p, strlen(INVALID_RELTIME_STR) + 1))
  1027. return 2; /* correct 'invalid time' identifier found */
  1029. /* handle label of relative time */
  1030. if (c != RELTIME_LABEL)
  1031. return 0; /* syntax error */
  1032. c = *++p;
  1033. if (c != ' ')
  1034. return 0; /* syntax error */
  1035. p++;
  1036. /* handle the quantity */
  1037. *quantity = 0;
  1038. for (;;)
  1039. {
  1040. c = *p;
  1041. if (isdigit(c))
  1042. {
  1043. *quantity = *quantity * 10 + (c - '0');
  1044. p++;
  1045. }
  1046. else
  1047. {
  1048. if (c == ' ')
  1049. break; /* correct quantity found */
  1050. else
  1051. return 0; /* syntax error */
  1052. }
  1053. }
  1055. /* handle unit */
  1056. p++;
  1057. i = 0;
  1058. for (;;)
  1059. {
  1060. c = *p;
  1061. if (c >= 'a' && c <= 'z' && i <= (UNITMAXLEN - 1))
  1062. {
  1063. unit[i] = c;
  1064. p++;
  1065. i++;
  1066. }
  1067. else
  1068. {
  1069. if ((c == ' ' || c == '')
  1070. && correct_unit(unit, unitnr))
  1071. break; /* correct unit found */
  1072. else
  1073. return 0; /* syntax error */
  1074. }
  1075. }
  1077. /* handle optional direction */
  1078. if (c == ' ')
  1079. p++;
  1080. i = 0;
  1081. *sign = 1;
  1082. for (;;)
  1083. {
  1084. c = *p;
  1085. if (c >= 'a' && c <= 'z' && i <= (DIRMAXLEN - 1))
  1086. {
  1087. direction[i] = c;
  1088. p++;
  1089. i++;
  1090. }
  1091. else
  1092. {
  1093. if ((c == ' ' || c == '') && i == 0)
  1094. {
  1095. *sign = 1;
  1096. break; /* no direction specified */
  1097. }
  1098. if ((c == ' ' || c == '') && i != 0)
  1099. {
  1100. direction[i] = '';
  1101. correct_dir(direction, sign);
  1102. break; /* correct direction found */
  1103. }
  1104. else
  1105. return 0; /* syntax error */
  1106. }
  1107. }
  1109. return 1;
  1110. }
  1112. /*
  1113.  * correct_unit - returns 1, iff unit is a correct unit description
  1114.  *
  1115.  * output parameter:
  1116.  * unptr: points to an integer which is the appropriate unit number
  1117.  *    (see function isreltime())
  1118.  */
  1119. static int
  1120. correct_unit(char *unit, int *unptr)
  1121. {
  1122. int j = 0;
  1124. while (j < NUNITS)
  1125. {
  1126. if (strncmp(unit, unit_tab[j], strlen(unit_tab[j])) == 0)
  1127. {
  1128. *unptr = j;
  1129. return 1;
  1130. }
  1131. j++;
  1132. }
  1133. return 0; /* invalid unit descriptor */
  1134. }
  1136. /*
  1137.  * correct_dir - returns 1, iff direction is a correct identifier
  1138.  *
  1139.  * output parameter:
  1140.  * signptr: points to -1 if dir corresponds to past tense
  1141.  *  else  to 1
  1142.  */
  1143. static int
  1144. correct_dir(char *direction, int *signptr)
  1145. {
  1146. *signptr = 1;
  1147. if (strncmp(RELTIME_PAST, direction, strlen(RELTIME_PAST) + 1) == 0)
  1148. {
  1149. *signptr = -1;
  1150. return 1;
  1151. }
  1152. else
  1153. return 0; /* invalid direction descriptor */
  1154. }
  1156. #endif
  1158. /*
  1159.  * istinterval - returns 1, iff i_string is a valid interval descr.
  1160.  *   0, iff i_string is NOT a valid interval desc.
  1161.  *   2, iff any time is INVALID_ABSTIME
  1162.  *
  1163.  * output parameter:
  1164.  * i_start, i_end: interval margins
  1165.  *
  1166.  * Time interval:
  1167.  * `[' {` '} `'' <AbsTime> `'' {` '} `'' <AbsTime> `'' {` '} `]'
  1168.  *
  1169.  * OR `Undefined Range' (see also INVALID_INTERVAL_STR)
  1170.  *
  1171.  * where <AbsTime> satisfies the syntax of absolute time.
  1172.  *
  1173.  * e.g.  [  '  Jan 18 1902'   'Jan 1 00:00:00 1970']
  1174.  */
  1175. static int
  1176. istinterval(char *i_string,
  1177. AbsoluteTime *i_start,
  1178. AbsoluteTime *i_end)
  1179. {
  1180. char    *p,
  1181.    *p1;
  1182. char c;
  1184. p = i_string;
  1185. /* skip leading blanks up to '[' */
  1186. while ((c = *p) != '')
  1187. {
  1188. if (IsSpace(c))
  1189. p++;
  1190. else if (c != '[')
  1191. return 0; /* syntax error */
  1192. else
  1193. break;
  1194. }
  1195. p++;
  1196. /* skip leading blanks up to "'" */
  1197. while ((c = *p) != '')
  1198. {
  1199. if (IsSpace(c))
  1200. p++;
  1201. else if (c != '"')
  1202. return 0; /* syntax error */
  1203. else
  1204. break;
  1205. }
  1206. p++;
  1207. if (strncmp(INVALID_INTERVAL_STR, p, strlen(INVALID_INTERVAL_STR)) == 0)
  1208. return 0; /* undefined range, handled like a syntax
  1209.  * err. */
  1210. /* search for the end of the first date and change it to a NULL */
  1211. p1 = p;
  1212. while ((c = *p1) != '')
  1213. {
  1214. if (c == '"')
  1215. {
  1216. *p1 = '';
  1217. break;
  1218. }
  1219. p1++;
  1220. }
  1221. /* get the first date */
  1222. *i_start = nabstimein(p); /* first absolute date */
  1223. /* rechange NULL at the end of the first date to a "'" */
  1224. *p1 = '"';
  1225. p = ++p1;
  1226. /* skip blanks up to "'", beginning of second date */
  1227. while ((c = *p) != '')
  1228. {
  1229. if (IsSpace(c))
  1230. p++;
  1231. else if (c != '"')
  1232. return 0; /* syntax error */
  1233. else
  1234. break;
  1235. }
  1236. p++;
  1237. /* search for the end of the second date and change it to a NULL */
  1238. p1 = p;
  1239. while ((c = *p1) != '')
  1240. {
  1241. if (c == '"')
  1242. {
  1243. *p1 = '';
  1244. break;
  1245. }
  1246. p1++;
  1247. }
  1248. /* get the second date */
  1249. *i_end = nabstimein(p); /* second absolute date */
  1250. /* rechange NULL at the end of the first date to a ''' */
  1251. *p1 = '"';
  1252. p = ++p1;
  1253. /* skip blanks up to ']' */
  1254. while ((c = *p) != '')
  1255. {
  1256. if (IsSpace(c))
  1257. p++;
  1258. else if (c != ']')
  1259. return 0; /* syntax error */
  1260. else
  1261. break;
  1262. }
  1263. p++;
  1264. c = *p;
  1265. if (c != '')
  1266. return 0; /* syntax error */
  1267. /* it seems to be a valid interval */
  1268. return 1;
  1269. }
  1272. /*****************************************************************************
  1273.  *
  1274.  *****************************************************************************/
  1276. /*
  1277.  * timeofday -
  1278.  *    returns the current time as a text. similar to timenow() but returns
  1279.  *    seconds with more precision (up to microsecs). (I need this to compare
  1280.  *    the Wisconsin benchmark with Illustra whose TimeNow() shows current
  1281.  *    time with precision up to microsecs.)   - ay 3/95
  1282.  */
  1283. text *
  1284. timeofday(void)
  1285. {
  1287. struct timeval tp;
  1288. struct timezone tpz;
  1289. char templ[500];
  1290. char buf[500];
  1291. text    *tm;
  1292. int len = 0;
  1294. gettimeofday(&tp, &tpz);
  1295. strftime(templ, sizeof(templ), "%a %b %d %H:%M:%S.%%d %Y %Z",
  1296.  localtime((time_t *) &tp.tv_sec));
  1297. sprintf(buf, templ, tp.tv_usec);
  1299. len = VARHDRSZ + strlen(buf);
  1300. tm = (text *) palloc(len);
  1301. VARSIZE(tm) = len;
  1302. strncpy(VARDATA(tm), buf, strlen(buf));
  1303. return tm;
  1304. }