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

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

数据库系统

开发平台：

Unix_Linux

dt.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * dt.c
  4.  *   Functions for the built-in type "dt".
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/utils/adt/dt.c,v 1.72.2.1 1999/08/02 05:24:51 scrappy Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. #include <ctype.h>
  15. #include <math.h>
  16. #include <sys/types.h>
  17. #include <errno.h>
  19. #include "postgres.h"
  20. #ifdef HAVE_FLOAT_H
  21. #include <float.h>
  22. #endif
  23. #ifdef HAVE_LIMITS_H
  24. #include <limits.h>
  25. #endif
  26. #ifndef USE_POSIX_TIME
  27. #include <sys/timeb.h>
  28. #endif
  30. #include "miscadmin.h"
  31. #include "utils/builtins.h"
  33. static int DecodeDate(char *str, int fmask, int *tmask, struct tm * tm);
  34. static int DecodeNumber(int flen, char *field,
  35. int fmask, int *tmask, struct tm * tm, double *fsec, int *is2digits);
  36. static int DecodeNumberField(int len, char *str,
  37. int fmask, int *tmask, struct tm * tm, double *fsec, int *is2digits);
  38. static int DecodeSpecial(int field, char *lowtoken, int *val);
  39. static int DecodeTime(char *str, int fmask, int *tmask,
  40.    struct tm * tm, double *fsec);
  41. static int DecodeTimezone(char *str, int *tzp);
  42. static int DecodeUnits(int field, char *lowtoken, int *val);
  43. static int EncodeSpecialDateTime(DateTime dt, char *str);
  44. static datetkn *datebsearch(char *key, datetkn *base, unsigned int nel);
  45. static DateTime dt2local(DateTime dt, int timezone);
  46. static void dt2time(DateTime dt, int *hour, int *min, double *sec);
  47. static int j2day(int jd);
  48. static double time2t(const int hour, const int min, const double sec);
  49. static int timespan2tm(TimeSpan span, struct tm * tm, float8 *fsec);
  50. static int tm2timespan(struct tm * tm, double fsec, TimeSpan *span);
  53. #define USE_DATE_CACHE 1
  54. #define ROUND_ALL 0
  56. int day_tab[2][13] = {
  57. {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0},
  58. {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0}};
  61. char    *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  62. "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL};
  64. char    *days[] = {"Sunday", "Monday", "Tuesday", "Wednesday",
  65. "Thursday", "Friday", "Saturday", NULL};
  67. /* TMODULO()
  68.  * Macro to replace modf(), which is broken on some platforms.
  69.  */
  70. #define TMODULO(t,q,u) 
  71. do { 
  72. q = ((t < 0)? ceil(t / u): floor(t / u)); 
  73. if (q != 0) 
  74. t -= rint(q * u); 
  75. } while(0)
  77. static void GetEpochTime(struct tm * tm);
  79. #define UTIME_MINYEAR (1901)
  80. #define UTIME_MINMONTH (12)
  81. #define UTIME_MINDAY (14)
  82. #define UTIME_MAXYEAR (2038)
  83. #define UTIME_MAXMONTH (01)
  84. #define UTIME_MAXDAY (18)
  86. #define IS_VALID_UTIME(y,m,d) (((y > UTIME_MINYEAR) 
  87.  || ((y == UTIME_MINYEAR) && ((m > UTIME_MINMONTH) 
  88.   || ((m == UTIME_MINMONTH) && (d >= UTIME_MINDAY))))) 
  89.  && ((y < UTIME_MAXYEAR) 
  90.  || ((y == UTIME_MAXYEAR) && ((m < UTIME_MAXMONTH) 
  91.   || ((m == UTIME_MAXMONTH) && (d <= UTIME_MAXDAY))))))
  94. /*****************************************************************************
  95.  *  USER I/O ROUTINES  *
  96.  *****************************************************************************/
  98. /* datetime_in()
  99.  * Convert a string to internal form.
  100.  */
  101. DateTime   *
  102. datetime_in(char *str)
  103. {
  104. DateTime   *result;
  106. double fsec;
  107. struct tm tt,
  108.    *tm = &tt;
  109. int tz;
  110. int dtype;
  111. int nf;
  112. char    *field[MAXDATEFIELDS];
  113. int ftype[MAXDATEFIELDS];
  114. char lowstr[MAXDATELEN + 1];
  116. if (!PointerIsValid(str))
  117. elog(ERROR, "Bad (null) datetime external representation", NULL);
  119. if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
  120.   || (DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tz) != 0))
  121. elog(ERROR, "Bad datetime external representation '%s'", str);
  123. result = palloc(sizeof(DateTime));
  125. switch (dtype)
  126. {
  127. case DTK_DATE:
  128. if (tm2datetime(tm, fsec, &tz, result) != 0)
  129. elog(ERROR, "Datetime out of range '%s'", str);
  131. #ifdef DATEDEBUG
  132. printf("datetime_in- date is %fn", *result);
  133. #endif
  135. break;
  137. case DTK_EPOCH:
  138. DATETIME_EPOCH(*result);
  139. break;
  141. case DTK_CURRENT:
  142. DATETIME_CURRENT(*result);
  143. break;
  145. case DTK_LATE:
  146. DATETIME_NOEND(*result);
  147. break;
  149. case DTK_EARLY:
  150. DATETIME_NOBEGIN(*result);
  151. break;
  153. case DTK_INVALID:
  154. DATETIME_INVALID(*result);
  155. break;
  157. default:
  158. elog(ERROR, "Internal coding error, can't input datetime '%s'", str);
  159. }
  161. return result;
  162. } /* datetime_in() */
  164. /* datetime_out()
  165.  * Convert a datetime to external form.
  166.  */
  167. char *
  168. datetime_out(DateTime *dt)
  169. {
  170. char    *result;
  171. int tz;
  172. struct tm tt,
  173.    *tm = &tt;
  174. double fsec;
  175. char    *tzn;
  176. char buf[MAXDATELEN + 1];
  178. if (!PointerIsValid(dt))
  179. return NULL;
  181. if (DATETIME_IS_RESERVED(*dt))
  182. {
  183. EncodeSpecialDateTime(*dt, buf);
  185. }
  186. else if (datetime2tm(*dt, &tz, tm, &fsec, &tzn) == 0)
  187. {
  188. EncodeDateTime(tm, fsec, &tz, &tzn, DateStyle, buf);
  190. }
  191. else
  192. EncodeSpecialDateTime(DT_INVALID, buf);
  194. result = palloc(strlen(buf) + 1);
  196. strcpy(result, buf);
  198. return result;
  199. } /* datetime_out() */
  202. /* timespan_in()
  203.  * Convert a string to internal form.
  204.  *
  205.  * External format(s):
  206.  * Uses the generic date/time parsing and decoding routines.
  207.  */
  208. TimeSpan   *
  209. timespan_in(char *str)
  210. {
  211. TimeSpan   *span;
  213. double fsec;
  214. struct tm tt,
  215.    *tm = &tt;
  216. int dtype;
  217. int nf;
  218. char    *field[MAXDATEFIELDS];
  219. int ftype[MAXDATEFIELDS];
  220. char lowstr[MAXDATELEN + 1];
  222. tm->tm_year = 0;
  223. tm->tm_mon = 0;
  224. tm->tm_mday = 0;
  225. tm->tm_hour = 0;
  226. tm->tm_min = 0;
  227. tm->tm_sec = 0;
  228. fsec = 0;
  230. if (!PointerIsValid(str))
  231. elog(ERROR, "Bad (null) timespan external representation", NULL);
  233. if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
  234. || (DecodeDateDelta(field, ftype, nf, &dtype, tm, &fsec) != 0))
  235. elog(ERROR, "Bad timespan external representation '%s'", str);
  237. span = palloc(sizeof(TimeSpan));
  239. switch (dtype)
  240. {
  241. case DTK_DELTA:
  242. if (tm2timespan(tm, fsec, span) != 0)
  243. {
  244. #if NOT_USED
  245. TIMESPAN_INVALID(span);
  246. #endif
  247. elog(ERROR, "Bad timespan external representation '%s'", str);
  248. }
  249. break;
  251. default:
  252. elog(ERROR, "Internal coding error, can't input timespan '%s'", str);
  253. }
  255. return span;
  256. } /* timespan_in() */
  258. /* timespan_out()
  259.  * Convert a time span to external form.
  260.  */
  261. char *
  262. timespan_out(TimeSpan *span)
  263. {
  264. char    *result;
  266. struct tm tt,
  267.    *tm = &tt;
  268. double fsec;
  269. char buf[MAXDATELEN + 1];
  271. if (!PointerIsValid(span))
  272. return NULL;
  274. if (timespan2tm(*span, tm, &fsec) != 0)
  275. return NULL;
  277. if (EncodeTimeSpan(tm, fsec, DateStyle, buf) != 0)
  278. elog(ERROR, "Unable to format timespan", NULL);
  280. result = palloc(strlen(buf) + 1);
  282. strcpy(result, buf);
  283. return result;
  284. } /* timespan_out() */
  287. /*****************************************************************************
  288.  *  PUBLIC ROUTINES  *
  289.  *****************************************************************************/
  292. bool
  293. datetime_finite(DateTime *datetime)
  294. {
  295. if (!PointerIsValid(datetime))
  296. return FALSE;
  298. return !DATETIME_NOT_FINITE(*datetime);
  299. } /* datetime_finite() */
  301. bool
  302. timespan_finite(TimeSpan *timespan)
  303. {
  304. if (!PointerIsValid(timespan))
  305. return FALSE;
  307. return !TIMESPAN_NOT_FINITE(*timespan);
  308. } /* timespan_finite() */
  311. /*----------------------------------------------------------
  312.  * Relational operators for datetime.
  313.  *---------------------------------------------------------*/
  315. static void
  316. GetEpochTime(struct tm * tm)
  317. {
  318. struct tm  *t0;
  319. time_t epoch = 0;
  321. t0 = gmtime(&epoch);
  323. tm->tm_year = t0->tm_year;
  324. tm->tm_mon = t0->tm_mon;
  325. tm->tm_mday = t0->tm_mday;
  326. tm->tm_hour = t0->tm_hour;
  327. tm->tm_min = t0->tm_min;
  328. tm->tm_sec = t0->tm_sec;
  330. if (tm->tm_year < 1900)
  331. tm->tm_year += 1900;
  332. tm->tm_mon++;
  334. #ifdef DATEDEBUG
  335. printf("GetEpochTime- %04d-%02d-%02d %02d:%02d:%02dn",
  336.    tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
  337. #endif
  339. return;
  340. } /* GetEpochTime() */
  342. DateTime
  343. SetDateTime(DateTime dt)
  344. {
  345. struct tm tt;
  347. if (DATETIME_IS_CURRENT(dt))
  348. {
  349. GetCurrentTime(&tt);
  350. tm2datetime(&tt, 0, NULL, &dt);
  351. dt = dt2local(dt, -CTimeZone);
  353. #ifdef DATEDEBUG
  354. printf("SetDateTime- current time is %fn", dt);
  355. #endif
  356. }
  357. else
  358. { /* if (DATETIME_IS_EPOCH(dt1)) */
  359. GetEpochTime(&tt);
  360. tm2datetime(&tt, 0, NULL, &dt);
  361. #ifdef DATEDEBUG
  362. printf("SetDateTime- epoch time is %fn", dt);
  363. #endif
  364. }
  366. return dt;
  367. } /* SetDateTime() */
  369. /* datetime_relop - is datetime1 relop datetime2
  370.  */
  371. bool
  372. datetime_eq(DateTime *datetime1, DateTime *datetime2)
  373. {
  374. DateTime dt1,
  375. dt2;
  377. if (!PointerIsValid(datetime1) || !PointerIsValid(datetime2))
  378. return FALSE;
  380. dt1 = *datetime1;
  381. dt2 = *datetime2;
  383. if (DATETIME_IS_INVALID(dt1) || DATETIME_IS_INVALID(dt2))
  384. return FALSE;
  386. if (DATETIME_IS_RELATIVE(dt1))
  387. dt1 = SetDateTime(dt1);
  388. if (DATETIME_IS_RELATIVE(dt2))
  389. dt2 = SetDateTime(dt2);
  391. return dt1 == dt2;
  392. } /* datetime_eq() */
  394. bool
  395. datetime_ne(DateTime *datetime1, DateTime *datetime2)
  396. {
  397. DateTime dt1,
  398. dt2;
  400. if (!PointerIsValid(datetime1) || !PointerIsValid(datetime2))
  401. return FALSE;
  403. dt1 = *datetime1;
  404. dt2 = *datetime2;
  406. if (DATETIME_IS_INVALID(dt1) || DATETIME_IS_INVALID(dt2))
  407. return FALSE;
  409. if (DATETIME_IS_RELATIVE(dt1))
  410. dt1 = SetDateTime(dt1);
  411. if (DATETIME_IS_RELATIVE(dt2))
  412. dt2 = SetDateTime(dt2);
  414. return dt1 != dt2;
  415. } /* datetime_ne() */
  417. bool
  418. datetime_lt(DateTime *datetime1, DateTime *datetime2)
  419. {
  420. DateTime dt1,
  421. dt2;
  423. if (!PointerIsValid(datetime1) || !PointerIsValid(datetime2))
  424. return FALSE;
  426. dt1 = *datetime1;
  427. dt2 = *datetime2;
  429. if (DATETIME_IS_INVALID(dt1) || DATETIME_IS_INVALID(dt2))
  430. return FALSE;
  432. if (DATETIME_IS_RELATIVE(dt1))
  433. dt1 = SetDateTime(dt1);
  434. if (DATETIME_IS_RELATIVE(dt2))
  435. dt2 = SetDateTime(dt2);
  437. return dt1 < dt2;
  438. } /* datetime_lt() */
  440. bool
  441. datetime_gt(DateTime *datetime1, DateTime *datetime2)
  442. {
  443. DateTime dt1,
  444. dt2;
  446. if (!PointerIsValid(datetime1) || !PointerIsValid(datetime2))
  447. return FALSE;
  449. dt1 = *datetime1;
  450. dt2 = *datetime2;
  452. if (DATETIME_IS_INVALID(dt1) || DATETIME_IS_INVALID(dt2))
  453. return FALSE;
  455. if (DATETIME_IS_RELATIVE(dt1))
  456. dt1 = SetDateTime(dt1);
  457. if (DATETIME_IS_RELATIVE(dt2))
  458. dt2 = SetDateTime(dt2);
  460. #ifdef DATEDEBUG
  461. printf("datetime_gt- %f %s greater than %fn", dt1, ((dt1 > dt2) ? "is" : "is not"), dt2);
  462. #endif
  463. return dt1 > dt2;
  464. } /* datetime_gt() */
  466. bool
  467. datetime_le(DateTime *datetime1, DateTime *datetime2)
  468. {
  469. DateTime dt1,
  470. dt2;
  472. if (!PointerIsValid(datetime1) || !PointerIsValid(datetime2))
  473. return FALSE;
  475. dt1 = *datetime1;
  476. dt2 = *datetime2;
  478. if (DATETIME_IS_INVALID(dt1) || DATETIME_IS_INVALID(dt2))
  479. return FALSE;
  481. if (DATETIME_IS_RELATIVE(dt1))
  482. dt1 = SetDateTime(dt1);
  483. if (DATETIME_IS_RELATIVE(dt2))
  484. dt2 = SetDateTime(dt2);
  486. return dt1 <= dt2;
  487. } /* datetime_le() */
  489. bool
  490. datetime_ge(DateTime *datetime1, DateTime *datetime2)
  491. {
  492. DateTime dt1,
  493. dt2;
  495. if (!PointerIsValid(datetime1) || !PointerIsValid(datetime2))
  496. return FALSE;
  498. dt1 = *datetime1;
  499. dt2 = *datetime2;
  501. if (DATETIME_IS_INVALID(dt1) || DATETIME_IS_INVALID(dt2))
  502. return FALSE;
  504. if (DATETIME_IS_RELATIVE(dt1))
  505. dt1 = SetDateTime(dt1);
  506. if (DATETIME_IS_RELATIVE(dt2))
  507. dt2 = SetDateTime(dt2);
  509. return dt1 >= dt2;
  510. } /* datetime_ge() */
  513. /* datetime_cmp - 3-state comparison for datetime
  514.  * collate invalid datetime at the end
  515.  */
  516. int
  517. datetime_cmp(DateTime *datetime1, DateTime *datetime2)
  518. {
  519. DateTime dt1,
  520. dt2;
  522. if (!PointerIsValid(datetime1) || !PointerIsValid(datetime2))
  523. return 0;
  525. dt1 = *datetime1;
  526. dt2 = *datetime2;
  528. if (DATETIME_IS_INVALID(dt1))
  529. {
  530. return (DATETIME_IS_INVALID(dt2) ? 0 : 1);
  532. }
  533. else if (DATETIME_IS_INVALID(dt2))
  534. {
  535. return -1;
  537. }
  538. else
  539. {
  540. if (DATETIME_IS_RELATIVE(dt1))
  541. dt1 = SetDateTime(dt1);
  542. if (DATETIME_IS_RELATIVE(dt2))
  543. dt2 = SetDateTime(dt2);
  544. }
  546. return ((dt1 < dt2) ? -1 : ((dt1 > dt2) ? 1 : 0));
  547. } /* datetime_cmp() */
  550. /* timespan_relop - is timespan1 relop timespan2
  551.  */
  552. bool
  553. timespan_eq(TimeSpan *timespan1, TimeSpan *timespan2)
  554. {
  555. if (!PointerIsValid(timespan1) || !PointerIsValid(timespan2))
  556. return FALSE;
  558. if (TIMESPAN_IS_INVALID(*timespan1) || TIMESPAN_IS_INVALID(*timespan2))
  559. return FALSE;
  561. return ((timespan1->time == timespan2->time)
  562. && (timespan1->month == timespan2->month));
  563. } /* timespan_eq() */
  565. bool
  566. timespan_ne(TimeSpan *timespan1, TimeSpan *timespan2)
  567. {
  568. if (!PointerIsValid(timespan1) || !PointerIsValid(timespan2))
  569. return FALSE;
  571. if (TIMESPAN_IS_INVALID(*timespan1) || TIMESPAN_IS_INVALID(*timespan2))
  572. return FALSE;
  574. return ((timespan1->time != timespan2->time)
  575. || (timespan1->month != timespan2->month));
  576. } /* timespan_ne() */
  578. bool
  579. timespan_lt(TimeSpan *timespan1, TimeSpan *timespan2)
  580. {
  581. double span1,
  582. span2;
  584. if (!PointerIsValid(timespan1) || !PointerIsValid(timespan2))
  585. return FALSE;
  587. if (TIMESPAN_IS_INVALID(*timespan1) || TIMESPAN_IS_INVALID(*timespan2))
  588. return FALSE;
  590. span1 = timespan1->time;
  591. if (timespan1->month != 0)
  592. span1 += (timespan1->month * (30.0 * 86400));
  593. span2 = timespan2->time;
  594. if (timespan2->month != 0)
  595. span2 += (timespan2->month * (30.0 * 86400));
  597. return span1 < span2;
  598. } /* timespan_lt() */
  600. bool
  601. timespan_gt(TimeSpan *timespan1, TimeSpan *timespan2)
  602. {
  603. double span1,
  604. span2;
  606. if (!PointerIsValid(timespan1) || !PointerIsValid(timespan2))
  607. return FALSE;
  609. if (TIMESPAN_IS_INVALID(*timespan1) || TIMESPAN_IS_INVALID(*timespan2))
  610. return FALSE;
  612. span1 = timespan1->time;
  613. if (timespan1->month != 0)
  614. span1 += (timespan1->month * (30.0 * 86400));
  615. span2 = timespan2->time;
  616. if (timespan2->month != 0)
  617. span2 += (timespan2->month * (30.0 * 86400));
  619. return span1 > span2;
  620. } /* timespan_gt() */
  622. bool
  623. timespan_le(TimeSpan *timespan1, TimeSpan *timespan2)
  624. {
  625. double span1,
  626. span2;
  628. if (!PointerIsValid(timespan1) || !PointerIsValid(timespan2))
  629. return FALSE;
  631. if (TIMESPAN_IS_INVALID(*timespan1) || TIMESPAN_IS_INVALID(*timespan2))
  632. return FALSE;
  634. span1 = timespan1->time;
  635. if (timespan1->month != 0)
  636. span1 += (timespan1->month * (30.0 * 86400));
  637. span2 = timespan2->time;
  638. if (timespan2->month != 0)
  639. span2 += (timespan2->month * (30.0 * 86400));
  641. return span1 <= span2;
  642. } /* timespan_le() */
  644. bool
  645. timespan_ge(TimeSpan *timespan1, TimeSpan *timespan2)
  646. {
  647. double span1,
  648. span2;
  650. if (!PointerIsValid(timespan1) || !PointerIsValid(timespan2))
  651. return FALSE;
  653. if (TIMESPAN_IS_INVALID(*timespan1) || TIMESPAN_IS_INVALID(*timespan2))
  654. return FALSE;
  656. span1 = timespan1->time;
  657. if (timespan1->month != 0)
  658. span1 += (timespan1->month * (30.0 * 86400));
  659. span2 = timespan2->time;
  660. if (timespan2->month != 0)
  661. span2 += (timespan2->month * (30.0 * 86400));
  663. return span1 >= span2;
  664. } /* timespan_ge() */
  667. /* timespan_cmp - 3-state comparison for timespan
  668.  */
  669. int
  670. timespan_cmp(TimeSpan *timespan1, TimeSpan *timespan2)
  671. {
  672. double span1,
  673. span2;
  675. if (!PointerIsValid(timespan1) || !PointerIsValid(timespan2))
  676. return 0;
  678. if (TIMESPAN_IS_INVALID(*timespan1))
  679. {
  680. return TIMESPAN_IS_INVALID(*timespan2) ? 0 : 1;
  682. }
  683. else if (TIMESPAN_IS_INVALID(*timespan2))
  684. return -1;
  686. span1 = timespan1->time;
  687. if (timespan1->month != 0)
  688. span1 += (timespan1->month * (30.0 * 86400));
  689. span2 = timespan2->time;
  690. if (timespan2->month != 0)
  691. span2 += (timespan2->month * (30.0 * 86400));
  693. return (span1 < span2) ? -1 : (span1 > span2) ? 1 : 0;
  694. } /* timespan_cmp() */
  697. /*----------------------------------------------------------
  698.  * "Arithmetic" operators on date/times.
  699.  * datetime_foo returns foo as an object (pointer) that
  700.  * can be passed between languages.
  701.  * datetime_xx is an internal routine which returns the
  702.  * actual value.
  703.  *---------------------------------------------------------*/
  705. DateTime   *
  706. datetime_smaller(DateTime *datetime1, DateTime *datetime2)
  707. {
  708. DateTime   *result;
  710. DateTime dt1,
  711. dt2;
  713. if (!PointerIsValid(datetime1) || !PointerIsValid(datetime2))
  714. return NULL;
  716. dt1 = *datetime1;
  717. dt2 = *datetime2;
  719. result = palloc(sizeof(DateTime));
  721. if (DATETIME_IS_RELATIVE(dt1))
  722. dt1 = SetDateTime(dt1);
  723. if (DATETIME_IS_RELATIVE(dt2))
  724. dt2 = SetDateTime(dt2);
  726. if (DATETIME_IS_INVALID(dt1))
  727. *result = dt2;
  728. else if (DATETIME_IS_INVALID(dt2))
  729. *result = dt1;
  730. else
  731. *result = ((dt2 < dt1) ? dt2 : dt1);
  733. return result;
  734. } /* datetime_smaller() */
  736. DateTime   *
  737. datetime_larger(DateTime *datetime1, DateTime *datetime2)
  738. {
  739. DateTime   *result;
  741. DateTime dt1,
  742. dt2;
  744. if (!PointerIsValid(datetime1) || !PointerIsValid(datetime2))
  745. return NULL;
  747. dt1 = *datetime1;
  748. dt2 = *datetime2;
  750. result = palloc(sizeof(DateTime));
  752. if (DATETIME_IS_RELATIVE(dt1))
  753. dt1 = SetDateTime(dt1);
  754. if (DATETIME_IS_RELATIVE(dt2))
  755. dt2 = SetDateTime(dt2);
  757. if (DATETIME_IS_INVALID(dt1))
  758. *result = dt2;
  759. else if (DATETIME_IS_INVALID(dt2))
  760. *result = dt1;
  761. else
  762. *result = ((dt2 > dt1) ? dt2 : dt1);
  764. return result;
  765. } /* datetime_larger() */
  768. TimeSpan   *
  769. datetime_mi(DateTime *datetime1, DateTime *datetime2)
  770. {
  771. TimeSpan   *result;
  773. DateTime dt1,
  774. dt2;
  776. if (!PointerIsValid(datetime1) || !PointerIsValid(datetime2))
  777. return NULL;
  779. dt1 = *datetime1;
  780. dt2 = *datetime2;
  782. result = palloc(sizeof(TimeSpan));
  784. if (DATETIME_IS_RELATIVE(dt1))
  785. dt1 = SetDateTime(dt1);
  786. if (DATETIME_IS_RELATIVE(dt2))
  787. dt2 = SetDateTime(dt2);
  789. #ifdef DATEDEBUG
  790. printf("datetime_mi- evaluate %f - %fn", dt1, dt2);
  791. #endif
  793. if (DATETIME_IS_INVALID(dt1)
  794. || DATETIME_IS_INVALID(dt2))
  795. {
  796. DATETIME_INVALID(result->time);
  798. }
  799. else
  800. result->time = JROUND(dt1 - dt2);
  801. result->month = 0;
  803. return result;
  804. } /* datetime_mi() */
  807. /* datetime_pl_span()
  808.  * Add a timespan to a datetime data type.
  809.  * Note that timespan has provisions for qualitative year/month
  810.  * units, so try to do the right thing with them.
  811.  * To add a month, increment the month, and use the same day of month.
  812.  * Then, if the next month has fewer days, set the day of month
  813.  * to the last day of month.
  814.  */
  815. DateTime   *
  816. datetime_pl_span(DateTime *datetime, TimeSpan *span)
  817. {
  818. DateTime   *result;
  819. DateTime dt;
  820. int tz;
  821. char    *tzn;
  823. if ((!PointerIsValid(datetime)) || (!PointerIsValid(span)))
  824. return NULL;
  826. result = palloc(sizeof(DateTime));
  828. #ifdef DATEDEBUG
  829. printf("datetime_pl_span- add %f to %d %fn", *datetime, span->month, span->time);
  830. #endif
  832. if (DATETIME_NOT_FINITE(*datetime))
  833. {
  834. *result = *datetime;
  836. }
  837. else if (TIMESPAN_IS_INVALID(*span))
  838. {
  839. DATETIME_INVALID(*result);
  841. }
  842. else
  843. {
  844. dt = (DATETIME_IS_RELATIVE(*datetime) ? SetDateTime(*datetime) : *datetime);
  846. #ifdef ROUND_ALL
  847. dt = JROUND(dt + span->time);
  848. #else
  849. dt += span->time;
  850. #endif
  852. if (span->month != 0)
  853. {
  854. struct tm tt,
  855.    *tm = &tt;
  856. double fsec;
  858. if (datetime2tm(dt, &tz, tm, &fsec, &tzn) == 0)
  859. {
  860. #ifdef DATEDEBUG
  861. printf("datetime_pl_span- date was %04d-%02d-%02d %02d:%02d:%02dn",
  862.    tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
  863. #endif
  864. tm->tm_mon += span->month;
  865. if (tm->tm_mon > 12)
  866. {
  867. tm->tm_year += ((tm->tm_mon - 1) / 12);
  868. tm->tm_mon = (((tm->tm_mon - 1) % 12) + 1);
  869. }
  870. else if (tm->tm_mon < 1)
  871. {
  872. tm->tm_year += ((tm->tm_mon / 12) - 1);
  873. tm->tm_mon = ((tm->tm_mon % 12) + 12);
  874. }
  876. /* adjust for end of month boundary problems... */
  877. if (tm->tm_mday > day_tab[isleap(tm->tm_year)][tm->tm_mon - 1])
  878. tm->tm_mday = (day_tab[isleap(tm->tm_year)][tm->tm_mon - 1]);
  880. #ifdef DATEDEBUG
  881. printf("datetime_pl_span- date becomes %04d-%02d-%02d %02d:%02d:%02dn",
  882.    tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
  883. #endif
  884. if (tm2datetime(tm, fsec, &tz, &dt) != 0)
  885. elog(ERROR, "Unable to add datetime and timespan", NULL);
  887. }
  888. else
  889. DATETIME_INVALID(dt);
  890. }
  892. *result = dt;
  893. }
  895. return result;
  896. } /* datetime_pl_span() */
  898. DateTime   *
  899. datetime_mi_span(DateTime *datetime, TimeSpan *span)
  900. {
  901. DateTime   *result;
  902. TimeSpan tspan;
  904. if (!PointerIsValid(datetime) || !PointerIsValid(span))
  905. return NULL;
  907. tspan.month = -span->month;
  908. tspan.time = -span->time;
  910. result = datetime_pl_span(datetime, &tspan);
  912. return result;
  913. } /* datetime_mi_span() */
  916. TimeSpan   *
  917. timespan_um(TimeSpan *timespan)
  918. {
  919. TimeSpan   *result;
  921. if (!PointerIsValid(timespan))
  922. return NULL;
  924. result = palloc(sizeof(TimeSpan));
  926. result->time = -(timespan->time);
  927. result->month = -(timespan->month);
  929. return result;
  930. } /* timespan_um() */
  933. TimeSpan   *
  934. timespan_smaller(TimeSpan *timespan1, TimeSpan *timespan2)
  935. {
  936. TimeSpan   *result;
  938. double span1,
  939. span2;
  941. if (!PointerIsValid(timespan1) || !PointerIsValid(timespan2))
  942. return NULL;
  944. result = palloc(sizeof(TimeSpan));
  946. if (TIMESPAN_IS_INVALID(*timespan1))
  947. {
  948. result->time = timespan2->time;
  949. result->month = timespan2->month;
  951. }
  952. else if (TIMESPAN_IS_INVALID(*timespan2))
  953. {
  954. result->time = timespan1->time;
  955. result->month = timespan1->month;
  957. }
  958. else
  959. {
  960. span1 = timespan1->time;
  961. if (timespan1->month != 0)
  962. span1 += (timespan1->month * (30.0 * 86400));
  963. span2 = timespan2->time;
  964. if (timespan2->month != 0)
  965. span2 += (timespan2->month * (30.0 * 86400));
  967. #ifdef DATEDEBUG
  968. printf("timespan_smaller- months %d %d times %f %f spans %f %fn",
  969.    timespan1->month, timespan2->month, timespan1->time, timespan2->time, span1, span2);
  970. #endif
  972. if (span2 < span1)
  973. {
  974. result->time = timespan2->time;
  975. result->month = timespan2->month;
  977. }
  978. else
  979. {
  980. result->time = timespan1->time;
  981. result->month = timespan1->month;
  982. }
  983. }
  985. return result;
  986. } /* timespan_smaller() */
  988. TimeSpan   *
  989. timespan_larger(TimeSpan *timespan1, TimeSpan *timespan2)
  990. {
  991. TimeSpan   *result;
  993. double span1,
  994. span2;
  996. if (!PointerIsValid(timespan1) || !PointerIsValid(timespan2))
  997. return NULL;
  999. result = palloc(sizeof(TimeSpan));
  1001. if (TIMESPAN_IS_INVALID(*timespan1))
  1002. {
  1003. result->time = timespan2->time;
  1004. result->month = timespan2->month;
  1006. }
  1007. else if (TIMESPAN_IS_INVALID(*timespan2))
  1008. {
  1009. result->time = timespan1->time;
  1010. result->month = timespan1->month;
  1012. }
  1013. else
  1014. {
  1015. span1 = timespan1->time;
  1016. if (timespan1->month != 0)
  1017. span1 += (timespan1->month * (30.0 * 86400));
  1018. span2 = timespan2->time;
  1019. if (timespan2->month != 0)
  1020. span2 += (timespan2->month * (30.0 * 86400));
  1022. #ifdef DATEDEBUG
  1023. printf("timespan_larger- months %d %d times %f %f spans %f %fn",
  1024.    timespan1->month, timespan2->month, timespan1->time, timespan2->time, span1, span2);
  1025. #endif
  1027. if (span2 > span1)
  1028. {
  1029. result->time = timespan2->time;
  1030. result->month = timespan2->month;
  1032. }
  1033. else
  1034. {
  1035. result->time = timespan1->time;
  1036. result->month = timespan1->month;
  1037. }
  1038. }
  1040. return result;
  1041. } /* timespan_larger() */
  1044. TimeSpan   *
  1045. timespan_pl(TimeSpan *span1, TimeSpan *span2)
  1046. {
  1047. TimeSpan   *result;
  1049. if ((!PointerIsValid(span1)) || (!PointerIsValid(span2)))
  1050. return NULL;
  1052. result = palloc(sizeof(TimeSpan));
  1054. result->month = (span1->month + span2->month);
  1055. result->time = JROUND(span1->time + span2->time);
  1057. return result;
  1058. } /* timespan_pl() */
  1060. TimeSpan   *
  1061. timespan_mi(TimeSpan *span1, TimeSpan *span2)
  1062. {
  1063. TimeSpan   *result;
  1065. if ((!PointerIsValid(span1)) || (!PointerIsValid(span2)))
  1066. return NULL;
  1068. result = palloc(sizeof(TimeSpan));
  1070. result->month = (span1->month - span2->month);
  1071. result->time = JROUND(span1->time - span2->time);
  1073. return result;
  1074. } /* timespan_mi() */
  1076. TimeSpan   *
  1077. timespan_div(TimeSpan *span1, float8 *arg2)
  1078. {
  1079. TimeSpan   *result;
  1081. if ((!PointerIsValid(span1)) || (!PointerIsValid(arg2)))
  1082. return NULL;
  1084. if (!PointerIsValid(result = palloc(sizeof(TimeSpan))))
  1085. elog(ERROR, "Memory allocation failed, can't divide timespans", NULL);
  1087. if (*arg2 == 0.0)
  1088. elog(ERROR, "timespan_div:  divide by 0.0 error");
  1090. result->month = rint(span1->month / *arg2);
  1091. result->time = JROUND(span1->time / *arg2);
  1093. return result;
  1094. } /* timespan_div() */
  1096. /* datetime_age()
  1097.  * Calculate time difference while retaining year/month fields.
  1098.  * Note that this does not result in an accurate absolute time span
  1099.  * since year and month are out of context once the arithmetic
  1100.  * is done.
  1101.  */
  1102. TimeSpan   *
  1103. datetime_age(DateTime *datetime1, DateTime *datetime2)
  1104. {
  1105. TimeSpan   *result;
  1107. DateTime dt1,
  1108. dt2;
  1109. double fsec,
  1110. fsec1,
  1111. fsec2;
  1112. struct tm tt,
  1113.    *tm = &tt;
  1114. struct tm tt1,
  1115.    *tm1 = &tt1;
  1116. struct tm tt2,
  1117.    *tm2 = &tt2;
  1119. if (!PointerIsValid(datetime1) || !PointerIsValid(datetime2))
  1120. return NULL;
  1122. result = palloc(sizeof(TimeSpan));
  1124. dt1 = *datetime1;
  1125. dt2 = *datetime2;
  1127. if (DATETIME_IS_RELATIVE(dt1))
  1128. dt1 = SetDateTime(dt1);
  1129. if (DATETIME_IS_RELATIVE(dt2))
  1130. dt2 = SetDateTime(dt2);
  1132. if (DATETIME_IS_INVALID(dt1)
  1133. || DATETIME_IS_INVALID(dt2))
  1134. {
  1135. DATETIME_INVALID(result->time);
  1137. }
  1138. else if ((datetime2tm(dt1, NULL, tm1, &fsec1, NULL) == 0)
  1139.  && (datetime2tm(dt2, NULL, tm2, &fsec2, NULL) == 0))
  1140. {
  1141. fsec = (fsec1 - fsec2);
  1142. tm->tm_sec = (tm1->tm_sec - tm2->tm_sec);
  1143. tm->tm_min = (tm1->tm_min - tm2->tm_min);
  1144. tm->tm_hour = (tm1->tm_hour - tm2->tm_hour);
  1145. tm->tm_mday = (tm1->tm_mday - tm2->tm_mday);
  1146. tm->tm_mon = (tm1->tm_mon - tm2->tm_mon);
  1147. tm->tm_year = (tm1->tm_year - tm2->tm_year);
  1149. /* flip sign if necessary... */
  1150. if (dt1 < dt2)
  1151. {
  1152. fsec = -fsec;
  1153. tm->tm_sec = -tm->tm_sec;
  1154. tm->tm_min = -tm->tm_min;
  1155. tm->tm_hour = -tm->tm_hour;
  1156. tm->tm_mday = -tm->tm_mday;
  1157. tm->tm_mon = -tm->tm_mon;
  1158. tm->tm_year = -tm->tm_year;
  1159. }
  1161. if (tm->tm_sec < 0)
  1162. {
  1163. tm->tm_sec += 60;
  1164. tm->tm_min--;
  1165. }
  1167. if (tm->tm_min < 0)
  1168. {
  1169. tm->tm_min += 60;
  1170. tm->tm_hour--;
  1171. }
  1173. if (tm->tm_hour < 0)
  1174. {
  1175. tm->tm_hour += 24;
  1176. tm->tm_mday--;
  1177. }
  1179. if (tm->tm_mday < 0)
  1180. {
  1181. if (dt1 < dt2)
  1182. {
  1183. tm->tm_mday += day_tab[isleap(tm1->tm_year)][tm1->tm_mon - 1];
  1184. tm->tm_mon--;
  1185. }
  1186. else
  1187. {
  1188. tm->tm_mday += day_tab[isleap(tm2->tm_year)][tm2->tm_mon - 1];
  1189. tm->tm_mon--;
  1190. }
  1191. }
  1193. if (tm->tm_mon < 0)
  1194. {
  1195. tm->tm_mon += 12;
  1196. tm->tm_year--;
  1197. }
  1199. /* recover sign if necessary... */
  1200. if (dt1 < dt2)
  1201. {
  1202. fsec = -fsec;
  1203. tm->tm_sec = -tm->tm_sec;
  1204. tm->tm_min = -tm->tm_min;
  1205. tm->tm_hour = -tm->tm_hour;
  1206. tm->tm_mday = -tm->tm_mday;
  1207. tm->tm_mon = -tm->tm_mon;
  1208. tm->tm_year = -tm->tm_year;
  1209. }
  1211. if (tm2timespan(tm, fsec, result) != 0)
  1212. elog(ERROR, "Unable to decode datetime", NULL);
  1214. }
  1215. else
  1216. elog(ERROR, "Unable to decode datetime", NULL);
  1218. return result;
  1219. } /* datetime_age() */
  1222. /*----------------------------------------------------------
  1223.  * Conversion operators.
  1224.  *---------------------------------------------------------*/
  1227. /* datetime_text()
  1228.  * Convert datetime to text data type.
  1229.  */
  1230. text *
  1231. datetime_text(DateTime *datetime)
  1232. {
  1233. text    *result;
  1234. char    *str;
  1235. int len;
  1237. if (!PointerIsValid(datetime))
  1238. return NULL;
  1240. str = datetime_out(datetime);
  1242. if (!PointerIsValid(str))
  1243. return NULL;
  1245. len = (strlen(str) + VARHDRSZ);
  1247. result = palloc(len);
  1249. VARSIZE(result) = len;
  1250. memmove(VARDATA(result), str, (len - VARHDRSZ));
  1252. pfree(str);
  1254. return result;
  1255. } /* datetime_text() */
  1258. /* text_datetime()
  1259.  * Convert text string to datetime.
  1260.  * Text type is not null terminated, so use temporary string
  1261.  * then call the standard input routine.
  1262.  */
  1263. DateTime   *
  1264. text_datetime(text *str)
  1265. {
  1266. DateTime   *result;
  1267. int i;
  1268. char    *sp,
  1269.    *dp,
  1270. dstr[MAXDATELEN + 1];
  1272. if (!PointerIsValid(str))
  1273. return NULL;
  1275. sp = VARDATA(str);
  1276. dp = dstr;
  1277. for (i = 0; i < (VARSIZE(str) - VARHDRSZ); i++)
  1278. *dp++ = *sp++;
  1279. *dp = '';
  1281. result = datetime_in(dstr);
  1283. return result;
  1284. } /* text_datetime() */
  1287. /* timespan_text()
  1288.  * Convert timespan to text data type.
  1289.  */
  1290. text *
  1291. timespan_text(TimeSpan *timespan)
  1292. {
  1293. text    *result;
  1294. char    *str;
  1295. int len;
  1297. if (!PointerIsValid(timespan))
  1298. return NULL;
  1300. str = timespan_out(timespan);
  1302. if (!PointerIsValid(str))
  1303. return NULL;
  1305. len = (strlen(str) + VARHDRSZ);
  1307. result = palloc(len);
  1309. VARSIZE(result) = len;
  1310. memmove(VARDATA(result), str, (len - VARHDRSZ));
  1312. pfree(str);
  1314. return result;
  1315. } /* timespan_text() */
  1318. /* text_timespan()
  1319.  * Convert text string to timespan.
  1320.  * Text type may not be null terminated, so copy to temporary string
  1321.  * then call the standard input routine.
  1322.  */
  1323. TimeSpan   *
  1324. text_timespan(text *str)
  1325. {
  1326. TimeSpan   *result;
  1327. int i;
  1328. char    *sp,
  1329.    *dp,
  1330. dstr[MAXDATELEN + 1];
  1332. if (!PointerIsValid(str))
  1333. return NULL;
  1335. sp = VARDATA(str);
  1336. dp = dstr;
  1337. for (i = 0; i < (VARSIZE(str) - VARHDRSZ); i++)
  1338. *dp++ = *sp++;
  1339. *dp = '';
  1341. result = timespan_in(dstr);
  1343. return result;
  1344. } /* text_timespan() */
  1346. /* datetime_trunc()
  1347.  * Extract specified field from datetime.
  1348.  */
  1349. DateTime   *
  1350. datetime_trunc(text *units, DateTime *datetime)
  1351. {
  1352. DateTime   *result;
  1354. DateTime dt;
  1355. int tz;
  1356. int type,
  1357. val;
  1358. int i;
  1359. char    *up,
  1360.    *lp,
  1361. lowunits[MAXDATELEN + 1];
  1362. double fsec;
  1363. char    *tzn;
  1364. struct tm tt,
  1365.    *tm = &tt;
  1367. if ((!PointerIsValid(units)) || (!PointerIsValid(datetime)))
  1368. return NULL;
  1370. result = palloc(sizeof(DateTime));
  1372. up = VARDATA(units);
  1373. lp = lowunits;
  1374. for (i = 0; i < (VARSIZE(units) - VARHDRSZ); i++)
  1375. *lp++ = tolower(*up++);
  1376. *lp = '';
  1378. type = DecodeUnits(0, lowunits, &val);
  1380. #ifdef DATEDEBUG
  1381. if (type == IGNORE)
  1382. strcpy(lowunits, "(unknown)");
  1383. printf("datetime_trunc- units %s type=%d value=%dn", lowunits, type, val);
  1384. #endif
  1386. if (DATETIME_NOT_FINITE(*datetime))
  1387. {
  1388. #if NOT_USED
  1389. /* should return null but Postgres doesn't like that currently. - tgl 97/06/12 */
  1390. elog(ERROR, "Datetime is not finite", NULL);
  1391. #endif
  1392. *result = 0;
  1394. }
  1395. else
  1396. {
  1397. dt = (DATETIME_IS_RELATIVE(*datetime) ? SetDateTime(*datetime) : *datetime);
  1399. if ((type == UNITS) && (datetime2tm(dt, &tz, tm, &fsec, &tzn) == 0))
  1400. {
  1401. switch (val)
  1402. {
  1403. case DTK_MILLENIUM:
  1404. tm->tm_year = (tm->tm_year / 1000) * 1000;
  1405. case DTK_CENTURY:
  1406. tm->tm_year = (tm->tm_year / 100) * 100;
  1407. case DTK_DECADE:
  1408. tm->tm_year = (tm->tm_year / 10) * 10;
  1409. case DTK_YEAR:
  1410. tm->tm_mon = 1;
  1411. case DTK_QUARTER:
  1412. tm->tm_mon = (3 * (tm->tm_mon / 4)) + 1;
  1413. case DTK_MONTH:
  1414. tm->tm_mday = 1;
  1415. case DTK_DAY:
  1416. tm->tm_hour = 0;
  1417. case DTK_HOUR:
  1418. tm->tm_min = 0;
  1419. case DTK_MINUTE:
  1420. tm->tm_sec = 0;
  1421. case DTK_SECOND:
  1422. fsec = 0;
  1423. break;
  1425. case DTK_MILLISEC:
  1426. fsec = rint(fsec * 1000) / 1000;
  1427. break;
  1429. case DTK_MICROSEC:
  1430. fsec = rint(fsec * 1000000) / 1000000;
  1431. break;
  1433. default:
  1434. elog(ERROR, "Datetime units '%s' not supported", lowunits);
  1435. result = NULL;
  1436. }
  1438. if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon, tm->tm_mday))
  1439. {
  1440. #ifdef USE_POSIX_TIME
  1441. tm->tm_isdst = -1;
  1442. tm->tm_year -= 1900;
  1443. tm->tm_mon -= 1;
  1444. tm->tm_isdst = -1;
  1445. mktime(tm);
  1446. tm->tm_year += 1900;
  1447. tm->tm_mon += 1;
  1449. #if defined(HAVE_TM_ZONE)
  1450. tz = -(tm->tm_gmtoff); /* tm_gmtoff is Sun/DEC-ism */
  1451. #elif defined(HAVE_INT_TIMEZONE)
  1453. #ifdef __CYGWIN__
  1454. tz = (tm->tm_isdst ? (_timezone - 3600) : _timezone);
  1455. #else
  1456. tz = (tm->tm_isdst ? (timezone - 3600) : timezone);
  1457. #endif
  1459. #else
  1460. #error USE_POSIX_TIME is defined but neither HAVE_TM_ZONE or HAVE_INT_TIMEZONE are defined
  1461. #endif
  1463. #else /* !USE_POSIX_TIME */
  1464. tz = CTimeZone;
  1465. #endif
  1466. }
  1467. else
  1468. {
  1469. tm->tm_isdst = 0;
  1470. tz = 0;
  1471. }
  1473. if (tm2datetime(tm, fsec, &tz, result) != 0)
  1474. elog(ERROR, "Unable to truncate datetime to '%s'", lowunits);
  1476. #if NOT_USED
  1477. }
  1478. else if ((type == RESERV) && (val == DTK_EPOCH))
  1479. {
  1480. DATETIME_EPOCH(*result);
  1481. *result = dt - SetDateTime(*result);
  1482. #endif
  1484. }
  1485. else
  1486. {
  1487. elog(ERROR, "Datetime units '%s' not recognized", lowunits);
  1488. result = NULL;
  1489. }
  1490. }
  1492. return result;
  1493. } /* datetime_trunc() */
  1495. /* timespan_trunc()
  1496.  * Extract specified field from timespan.
  1497.  */
  1498. TimeSpan   *
  1499. timespan_trunc(text *units, TimeSpan *timespan)
  1500. {
  1501. TimeSpan   *result;
  1503. int type,
  1504. val;
  1505. int i;
  1506. char    *up,
  1507.    *lp,
  1508. lowunits[MAXDATELEN + 1];
  1509. double fsec;
  1510. struct tm tt,
  1511.    *tm = &tt;
  1513. if ((!PointerIsValid(units)) || (!PointerIsValid(timespan)))
  1514. return NULL;
  1516. result = palloc(sizeof(TimeSpan));
  1518. up = VARDATA(units);
  1519. lp = lowunits;
  1520. for (i = 0; i < (VARSIZE(units) - VARHDRSZ); i++)
  1521. *lp++ = tolower(*up++);
  1522. *lp = '';
  1524. type = DecodeUnits(0, lowunits, &val);
  1526. #ifdef DATEDEBUG
  1527. if (type == IGNORE)
  1528. strcpy(lowunits, "(unknown)");
  1529. printf("timespan_trunc- units %s type=%d value=%dn", lowunits, type, val);
  1530. #endif
  1532. if (TIMESPAN_IS_INVALID(*timespan))
  1533. {
  1534. #if NOT_USED
  1535. elog(ERROR, "Timespan is not finite", NULL);
  1536. #endif
  1537. result = NULL;
  1539. }
  1540. else if (type == UNITS)
  1541. {
  1543. if (timespan2tm(*timespan, tm, &fsec) == 0)
  1544. {
  1545. switch (val)
  1546. {
  1547. case DTK_MILLENIUM:
  1548. tm->tm_year = (tm->tm_year / 1000) * 1000;
  1549. case DTK_CENTURY:
  1550. tm->tm_year = (tm->tm_year / 100) * 100;
  1551. case DTK_DECADE:
  1552. tm->tm_year = (tm->tm_year / 10) * 10;
  1553. case DTK_YEAR:
  1554. tm->tm_mon = 0;
  1555. case DTK_QUARTER:
  1556. tm->tm_mon = (3 * (tm->tm_mon / 4));
  1557. case DTK_MONTH:
  1558. tm->tm_mday = 0;
  1559. case DTK_DAY:
  1560. tm->tm_hour = 0;
  1561. case DTK_HOUR:
  1562. tm->tm_min = 0;
  1563. case DTK_MINUTE:
  1564. tm->tm_sec = 0;
  1565. case DTK_SECOND:
  1566. fsec = 0;
  1567. break;
  1569. case DTK_MILLISEC:
  1570. fsec = rint(fsec * 1000) / 1000;
  1571. break;
  1573. case DTK_MICROSEC:
  1574. fsec = rint(fsec * 1000000) / 1000000;
  1575. break;
  1577. default:
  1578. elog(ERROR, "Timespan units '%s' not supported", lowunits);
  1579. result = NULL;
  1580. }
  1582. if (tm2timespan(tm, fsec, result) != 0)
  1583. elog(ERROR, "Unable to truncate timespan to '%s'", lowunits);
  1585. }
  1586. else
  1587. {
  1588. elog(NOTICE, "Timespan out of range", NULL);
  1589. result = NULL;
  1590. }
  1592. #if NOT_USED
  1593. }
  1594. else if ((type == RESERV) && (val == DTK_EPOCH))
  1595. {
  1596. *result = timespan->time;
  1597. if (timespan->month != 0)
  1598. {
  1599. *result += ((365.25 * 86400) * (timespan->month / 12));
  1600. *result += ((30 * 86400) * (timespan->month % 12));
  1601. }
  1602. #endif
  1604. }
  1605. else
  1606. {
  1607. elog(ERROR, "Timespan units '%s' not recognized", units);
  1608. result = NULL;
  1609. }
  1611. return result;
  1612. } /* timespan_trunc() */
  1615. /* datetime_part()
  1616.  * Extract specified field from datetime.
  1617.  */
  1618. float64
  1619. datetime_part(text *units, DateTime *datetime)
  1620. {
  1621. float64 result;
  1623. DateTime dt;
  1624. int tz;
  1625. int type,
  1626. val;
  1627. int i;
  1628. char    *up,
  1629.    *lp,
  1630. lowunits[MAXDATELEN + 1];
  1631. double dummy;
  1632. double fsec;
  1633. char    *tzn;
  1634. struct tm tt,
  1635.    *tm = &tt;
  1637. if ((!PointerIsValid(units)) || (!PointerIsValid(datetime)))
  1638. return NULL;
  1640. result = palloc(sizeof(float64data));
  1642. up = VARDATA(units);
  1643. lp = lowunits;
  1644. for (i = 0; i < (VARSIZE(units) - VARHDRSZ); i++)
  1645. *lp++ = tolower(*up++);
  1646. *lp = '';
  1648. type = DecodeUnits(0, lowunits, &val);
  1649. if (type == IGNORE)
  1650. type = DecodeSpecial(0, lowunits, &val);
  1652. #ifdef DATEDEBUG
  1653. if (type == IGNORE)
  1654. strcpy(lowunits, "(unknown)");
  1655. printf("datetime_part- units %s type=%d value=%dn", lowunits, type, val);
  1656. #endif
  1658. if (DATETIME_NOT_FINITE(*datetime))
  1659. {
  1660. #if NOT_USED
  1661. /* should return null but Postgres doesn't like that currently. - tgl 97/06/12 */
  1662. elog(ERROR, "Datetime is not finite", NULL);
  1663. #endif
  1664. *result = 0;
  1666. }
  1667. else
  1668. {
  1669. dt = (DATETIME_IS_RELATIVE(*datetime) ? SetDateTime(*datetime) : *datetime);
  1671. if ((type == UNITS) && (datetime2tm(dt, &tz, tm, &fsec, &tzn) == 0))
  1672. {
  1673. switch (val)
  1674. {
  1675. case DTK_TZ:
  1676. *result = tz;
  1677. break;
  1679. case DTK_TZ_MINUTE:
  1680. *result = tz / 60;
  1681. TMODULO(*result, dummy, 60e0);
  1682. break;
  1684. case DTK_TZ_HOUR:
  1685. dummy = tz;
  1686. TMODULO(dummy, *result, 3600e0);
  1687. break;
  1689. case DTK_MICROSEC:
  1690. *result = (fsec * 1000000);
  1691. break;
  1693. case DTK_MILLISEC:
  1694. *result = (fsec * 1000);
  1695. break;
  1697. case DTK_SECOND:
  1698. *result = (tm->tm_sec + fsec);
  1699. break;
  1701. case DTK_MINUTE:
  1702. *result = tm->tm_min;
  1703. break;
  1705. case DTK_HOUR:
  1706. *result = tm->tm_hour;
  1707. break;
  1709. case DTK_DAY:
  1710. *result = tm->tm_mday;
  1711. break;
  1713. case DTK_MONTH:
  1714. *result = tm->tm_mon;
  1715. break;
  1717. case DTK_QUARTER:
  1718. *result = (tm->tm_mon / 4) + 1;
  1719. break;
  1721. case DTK_YEAR:
  1722. *result = tm->tm_year;
  1723. break;
  1725. case DTK_DECADE:
  1726. *result = (tm->tm_year / 10);
  1727. break;
  1729. case DTK_CENTURY:
  1730. *result = (tm->tm_year / 100);
  1731. break;
  1733. case DTK_MILLENIUM:
  1734. *result = (tm->tm_year / 1000);
  1735. break;
  1737. default:
  1738. elog(ERROR, "Datetime units '%s' not supported", lowunits);
  1739. *result = 0;
  1740. }
  1742. }
  1743. else if (type == RESERV)
  1744. {
  1745. switch (val)
  1746. {
  1747. case DTK_EPOCH:
  1748. DATETIME_EPOCH(*result);
  1749. *result = dt - SetDateTime(*result);
  1750. break;
  1752. case DTK_DOW:
  1753. if (datetime2tm(dt, &tz, tm, &fsec, &tzn) != 0)
  1754. elog(ERROR, "Unable to encode datetime", NULL);
  1756. *result = j2day(date2j(tm->tm_year, tm->tm_mon, tm->tm_mday));
  1757. break;
  1759. case DTK_DOY:
  1760. if (datetime2tm(dt, &tz, tm, &fsec, &tzn) != 0)
  1761. elog(ERROR, "Unable to encode datetime", NULL);
  1763. *result = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday)
  1764.    - date2j(tm->tm_year, 1, 1) + 1);
  1765. break;
  1767. default:
  1768. elog(ERROR, "Datetime units '%s' not supported", lowunits);
  1769. *result = 0;
  1770. }
  1772. }
  1773. else
  1774. {
  1775. elog(ERROR, "Datetime units '%s' not recognized", lowunits);
  1776. *result = 0;
  1777. }
  1778. }
  1780. return result;
  1781. } /* datetime_part() */
  1784. /* timespan_part()
  1785.  * Extract specified field from timespan.
  1786.  */
  1787. float64
  1788. timespan_part(text *units, TimeSpan *timespan)
  1789. {
  1790. float64 result;
  1792. int type,
  1793. val;
  1794. int i;
  1795. char    *up,
  1796.    *lp,
  1797. lowunits[MAXDATELEN + 1];
  1798. double fsec;
  1799. struct tm tt,
  1800.    *tm = &tt;
  1802. if ((!PointerIsValid(units)) || (!PointerIsValid(timespan)))
  1803. return NULL;
  1805. result = palloc(sizeof(float64data));
  1807. up = VARDATA(units);
  1808. lp = lowunits;
  1809. for (i = 0; i < (VARSIZE(units) - VARHDRSZ); i++)
  1810. *lp++ = tolower(*up++);
  1811. *lp = '';
  1813. type = DecodeUnits(0, lowunits, &val);
  1814. if (type == IGNORE)
  1815. type = DecodeSpecial(0, lowunits, &val);
  1817. #ifdef DATEDEBUG
  1818. if (type == IGNORE)
  1819. strcpy(lowunits, "(unknown)");
  1820. printf("timespan_part- units %s type=%d value=%dn", lowunits, type, val);
  1821. #endif
  1823. if (TIMESPAN_IS_INVALID(*timespan))
  1824. {
  1825. #if NOT_USED
  1826. elog(ERROR, "Timespan is not finite", NULL);
  1827. #endif
  1828. *result = 0;
  1830. }
  1831. else if (type == UNITS)
  1832. {
  1834. if (timespan2tm(*timespan, tm, &fsec) == 0)
  1835. {
  1836. switch (val)
  1837. {
  1838. case DTK_MICROSEC:
  1839. *result = (fsec * 1000000);
  1840. break;
  1842. case DTK_MILLISEC:
  1843. *result = (fsec * 1000);
  1844. break;
  1846. case DTK_SECOND:
  1847. *result = (tm->tm_sec + fsec);
  1848. break;
  1850. case DTK_MINUTE:
  1851. *result = tm->tm_min;
  1852. break;
  1854. case DTK_HOUR:
  1855. *result = tm->tm_hour;
  1856. break;
  1858. case DTK_DAY:
  1859. *result = tm->tm_mday;
  1860. break;
  1862. case DTK_MONTH:
  1863. *result = tm->tm_mon;
  1864. break;
  1866. case DTK_QUARTER:
  1867. *result = (tm->tm_mon / 4) + 1;
  1868. break;
  1870. case DTK_YEAR:
  1871. *result = tm->tm_year;
  1872. break;
  1874. case DTK_DECADE:
  1875. *result = (tm->tm_year / 10);
  1876. break;
  1878. case DTK_CENTURY:
  1879. *result = (tm->tm_year / 100);
  1880. break;
  1882. case DTK_MILLENIUM:
  1883. *result = (tm->tm_year / 1000);
  1884. break;
  1886. default:
  1887. elog(ERROR, "Timespan units '%s' not yet supported", units);
  1888. result = NULL;
  1889. }
  1891. }
  1892. else
  1893. {
  1894. elog(NOTICE, "Timespan out of range", NULL);
  1895. *result = 0;
  1896. }
  1898. }
  1899. else if ((type == RESERV) && (val == DTK_EPOCH))
  1900. {
  1901. *result = timespan->time;
  1902. if (timespan->month != 0)
  1903. {
  1904. *result += ((365.25 * 86400) * (timespan->month / 12));
  1905. *result += ((30 * 86400) * (timespan->month % 12));
  1906. }
  1908. }
  1909. else
  1910. {
  1911. elog(ERROR, "Timespan units '%s' not recognized", units);
  1912. *result = 0;
  1913. }
  1915. return result;
  1916. } /* timespan_part() */
  1919. /* datetime_zone()
  1920.  * Encode datetime type with specified time zone.
  1921.  */
  1922. text *
  1923. datetime_zone(text *zone, DateTime *datetime)
  1924. {
  1925. text    *result;
  1927. DateTime dt;
  1928. int tz;
  1929. int type,
  1930. val;
  1931. int i;
  1932. char    *up,
  1933.    *lp,
  1934. lowzone[MAXDATELEN + 1];
  1935. char    *tzn,
  1936. upzone[MAXDATELEN + 1];
  1937. double fsec;
  1938. struct tm tt,
  1939.    *tm = &tt;
  1940. char buf[MAXDATELEN + 1];
  1941. int len;
  1943. if ((!PointerIsValid(zone)) || (!PointerIsValid(datetime)))
  1944. return NULL;
  1946. up = VARDATA(zone);
  1947. lp = lowzone;
  1948. for (i = 0; i < (VARSIZE(zone) - VARHDRSZ); i++)
  1949. *lp++ = tolower(*up++);
  1950. *lp = '';
  1952. type = DecodeSpecial(0, lowzone, &val);
  1954. #ifdef DATEDEBUG
  1955. if (type == IGNORE)
  1956. strcpy(lowzone, "(unknown)");
  1957. printf("datetime_zone- zone %s type=%d value=%dn", lowzone, type, val);
  1958. #endif
  1960. if (DATETIME_NOT_FINITE(*datetime))
  1961. {
  1963. /*
  1964.  * could return null but Postgres doesn't like that currently. -
  1965.  * tgl 97/06/12
  1966.  */
  1967. elog(ERROR, "Datetime is not finite", NULL);
  1968. result = NULL;
  1970. }
  1971. else if ((type == TZ) || (type == DTZ))
  1972. {
  1973. tm->tm_isdst = ((type == DTZ) ? 1 : 0);
  1974. tz = val * 60;
  1976. dt = (DATETIME_IS_RELATIVE(*datetime) ? SetDateTime(*datetime) : *datetime);
  1977. dt = dt2local(dt, tz);
  1979. if (datetime2tm(dt, NULL, tm, &fsec, NULL) != 0)
  1980. elog(ERROR, "Datetime not legal", NULL);
  1982. up = upzone;
  1983. lp = lowzone;
  1984. for (i = 0; *lp != ''; i++)
  1985. *up++ = toupper(*lp++);
  1986. *up = '';
  1988. tzn = upzone;
  1989. EncodeDateTime(tm, fsec, &tz, &tzn, DateStyle, buf);
  1991. len = (strlen(buf) + VARHDRSZ);
  1993. result = palloc(len);
  1995. VARSIZE(result) = len;
  1996. memmove(VARDATA(result), buf, (len - VARHDRSZ));
  1998. }
  1999. else
  2000. {
  2001. elog(ERROR, "Time zone '%s' not recognized", lowzone);
  2002. result = NULL;
  2003. }
  2005. return result;
  2006. } /* datetime_zone() */
  2009. /*****************************************************************************
  2010.  *  PRIVATE ROUTINES  *
  2011.  *****************************************************************************/
  2013. /* definitions for squeezing values into "value" */
  2014. #define ABS_SIGNBIT (char) 0200
  2015. #define VALMASK (char) 0177
  2016. #define NEG(n) ((n)|ABS_SIGNBIT)
  2017. #define SIGNEDCHAR(c) ((c)&ABS_SIGNBIT? -((c)&VALMASK): (c))
  2018. #define FROMVAL(tp) (-SIGNEDCHAR((tp)->value) * 10) /* uncompress */
  2019. #define TOVAL(tp, v) ((tp)->value = ((v) < 0? NEG((-(v))/10): (v)/10))
  2021. /*
  2022.  * to keep this table reasonably small, we divide the lexval for TZ and DTZ
  2023.  * entries by 10 and truncate the text field at MAXTOKLEN characters.
  2024.  * the text field is not guaranteed to be NULL-terminated.
  2025.  */
  2026. static datetkn datetktbl[] = {
  2027. /* text token lexval */
  2028. {EARLY, RESERV, DTK_EARLY}, /* "-infinity" reserved for "early time" */
  2029. {"acsst", DTZ, 63}, /* Cent. Australia */
  2030. {"acst", TZ, 57}, /* Cent. Australia */
  2031. {DA_D, ADBC, AD}, /* "ad" for years >= 0 */
  2032. {"abstime", IGNORE, 0}, /* "abstime" for pre-v6.1 "Invalid
  2033.  * Abstime" */
  2034. {"adt", DTZ, NEG(18)}, /* Atlantic Daylight Time */
  2035. {"aesst", DTZ, 66}, /* E. Australia */
  2036. {"aest", TZ, 60}, /* Australia Eastern Std Time */
  2037. {"ahst", TZ, NEG(60)}, /* Alaska-Hawaii Std Time */
  2038. {"allballs", RESERV, DTK_ZULU}, /* 00:00:00 */
  2039. {"am", AMPM, AM},
  2040. {"apr", MONTH, 4},
  2041. {"april", MONTH, 4},
  2042. {"ast", TZ, NEG(24)}, /* Atlantic Std Time (Canada) */
  2043. {"at", IGNORE, 0}, /* "at" (throwaway) */
  2044. {"aug", MONTH, 8},
  2045. {"august", MONTH, 8},
  2046. {"awsst", DTZ, 54}, /* W. Australia */
  2047. {"awst", TZ, 48}, /* W. Australia */
  2048. {DB_C, ADBC, BC}, /* "bc" for years < 0 */
  2049. {"bst", TZ, 6}, /* British Summer Time */
  2050. {"bt", TZ, 18}, /* Baghdad Time */
  2051. {"cadt", DTZ, 63}, /* Central Australian DST */
  2052. {"cast", TZ, 57}, /* Central Australian ST */
  2053. {"cat", TZ, NEG(60)}, /* Central Alaska Time */
  2054. {"cct", TZ, 48}, /* China Coast */
  2055. {"cdt", DTZ, NEG(30)}, /* Central Daylight Time */
  2056. {"cet", TZ, 6}, /* Central European Time */
  2057. {"cetdst", DTZ, 12}, /* Central European Dayl.Time */
  2058. {"cst", TZ, NEG(36)}, /* Central Standard Time */
  2059. {DCURRENT, RESERV, DTK_CURRENT}, /* "current" is always now */
  2060. {"dec", MONTH, 12},
  2061. {"december", MONTH, 12},
  2062. {"dnt", TZ, 6}, /* Dansk Normal Tid */
  2063. {"dow", RESERV, DTK_DOW}, /* day of week */
  2064. {"doy", RESERV, DTK_DOY}, /* day of year */
  2065. {"dst", DTZMOD, 6},
  2066. {"east", TZ, NEG(60)}, /* East Australian Std Time */
  2067. {"edt", DTZ, NEG(24)}, /* Eastern Daylight Time */
  2068. {"eet", TZ, 12}, /* East. Europe, USSR Zone 1 */
  2069. {"eetdst", DTZ, 18}, /* Eastern Europe */
  2070. {EPOCH, RESERV, DTK_EPOCH}, /* "epoch" reserved for system epoch time */
  2071. #if USE_AUSTRALIAN_RULES
  2072. {"est", TZ, 60}, /* Australia Eastern Std Time */
  2073. #else
  2074. {"est", TZ, NEG(30)}, /* Eastern Standard Time */
  2075. #endif
  2076. {"feb", MONTH, 2},
  2077. {"february", MONTH, 2},
  2078. {"fri", DOW, 5},
  2079. {"friday", DOW, 5},
  2080. {"fst", TZ, 6}, /* French Summer Time */
  2081. {"fwt", DTZ, 12}, /* French Winter Time  */
  2082. {"gmt", TZ, 0}, /* Greenwish Mean Time */
  2083. {"gst", TZ, 60}, /* Guam Std Time, USSR Zone 9 */
  2084. {"hdt", DTZ, NEG(54)}, /* Hawaii/Alaska */
  2085. {"hmt", DTZ, 18}, /* Hellas ? ? */
  2086. {"hst", TZ, NEG(60)}, /* Hawaii Std Time */
  2087. {"idle", TZ, 72}, /* Intl. Date Line, East */
  2088. {"idlw", TZ, NEG(72)}, /* Intl. Date Line, West */
  2089. {LATE, RESERV, DTK_LATE}, /* "infinity" reserved for "late time" */
  2090. {INVALID, RESERV, DTK_INVALID},
  2091. /* "invalid" reserved for invalid time */
  2092. {"ist", TZ, 12}, /* Israel */
  2093. {"it", TZ, 21}, /* Iran Time */
  2094. {"jan", MONTH, 1},
  2095. {"january", MONTH, 1},
  2096. {"jst", TZ, 54}, /* Japan Std Time,USSR Zone 8 */
  2097. {"jt", TZ, 45}, /* Java Time */
  2098. {"jul", MONTH, 7},
  2099. {"july", MONTH, 7},
  2100. {"jun", MONTH, 6},
  2101. {"june", MONTH, 6},
  2102. {"kst", TZ, 54}, /* Korea Standard Time */
  2103. {"ligt", TZ, 60}, /* From Melbourne, Australia */
  2104. {"mar", MONTH, 3},
  2105. {"march", MONTH, 3},
  2106. {"may", MONTH, 5},
  2107. {"mdt", DTZ, NEG(36)}, /* Mountain Daylight Time */
  2108. {"mest", DTZ, 12}, /* Middle Europe Summer Time */
  2109. {"met", TZ, 6}, /* Middle Europe Time */
  2110. {"metdst", DTZ, 12}, /* Middle Europe Daylight Time */
  2111. {"mewt", TZ, 6}, /* Middle Europe Winter Time */
  2112. {"mez", TZ, 6}, /* Middle Europe Zone */
  2113. {"mon", DOW, 1},
  2114. {"monday", DOW, 1},
  2115. {"mst", TZ, NEG(42)}, /* Mountain Standard Time */
  2116. {"mt", TZ, 51}, /* Moluccas Time */
  2117. {"ndt", DTZ, NEG(15)}, /* Nfld. Daylight Time */
  2118. {"nft", TZ, NEG(21)}, /* Newfoundland Standard Time */
  2119. {"nor", TZ, 6}, /* Norway Standard Time */
  2120. {"nov", MONTH, 11},
  2121. {"november", MONTH, 11},
  2122. {NOW, RESERV, DTK_NOW}, /* current transaction time */
  2123. {"nst", TZ, NEG(21)}, /* Nfld. Standard Time */
  2124. {"nt", TZ, NEG(66)}, /* Nome Time */
  2125. {"nzdt", DTZ, 78}, /* New Zealand Daylight Time */
  2126. {"nzst", TZ, 72}, /* New Zealand Standard Time */
  2127. {"nzt", TZ, 72}, /* New Zealand Time */
  2128. {"oct", MONTH, 10},
  2129. {"october", MONTH, 10},
  2130. {"on", IGNORE, 0}, /* "on" (throwaway) */
  2131. {"pdt", DTZ, NEG(42)}, /* Pacific Daylight Time */
  2132. {"pm", AMPM, PM},
  2133. {"pst", TZ, NEG(48)}, /* Pacific Standard Time */
  2134. {"sadt", DTZ, 63}, /* S. Australian Dayl. Time */
  2135. {"sast", TZ, 57}, /* South Australian Std Time */
  2136. {"sat", DOW, 6},
  2137. {"saturday", DOW, 6},
  2138. {"sep", MONTH, 9},
  2139. {"sept", MONTH, 9},
  2140. {"september", MONTH, 9},
  2141. {"set", TZ, NEG(6)}, /* Seychelles Time ?? */
  2142. {"sst", DTZ, 12}, /* Swedish Summer Time */
  2143. {"sun", DOW, 0},
  2144. {"sunday", DOW, 0},
  2145. {"swt", TZ, 6}, /* Swedish Winter Time */
  2146. {"thu", DOW, 4},
  2147. {"thur", DOW, 4},
  2148. {"thurs", DOW, 4},
  2149. {"thursday", DOW, 4},
  2150. {TODAY, RESERV, DTK_TODAY}, /* midnight */
  2151. {TOMORROW, RESERV, DTK_TOMORROW}, /* tomorrow midnight */
  2152. {"tue", DOW, 2},
  2153. {"tues", DOW, 2},
  2154. {"tuesday", DOW, 2},
  2155. {"undefined", RESERV, DTK_INVALID}, /* "undefined" pre-v6.1 invalid
  2156.  * time */
  2157. {"ut", TZ, 0},
  2158. {"utc", TZ, 0},
  2159. {"wadt", DTZ, 48}, /* West Australian DST */
  2160. {"wast", TZ, 42}, /* West Australian Std Time */
  2161. {"wat", TZ, NEG(6)}, /* West Africa Time */
  2162. {"wdt", DTZ, 54}, /* West Australian DST */
  2163. {"wed", DOW, 3},
  2164. {"wednesday", DOW, 3},
  2165. {"weds", DOW, 3},
  2166. {"wet", TZ, 0}, /* Western Europe */
  2167. {"wetdst", DTZ, 6}, /* Western Europe */
  2168. {"wst", TZ, 48}, /* West Australian Std Time */
  2169. {"ydt", DTZ, NEG(48)}, /* Yukon Daylight Time */
  2170. {YESTERDAY, RESERV, DTK_YESTERDAY}, /* yesterday midnight */
  2171. {"yst", TZ, NEG(54)}, /* Yukon Standard Time */
  2172. {"zp4", TZ, NEG(24)}, /* GMT +4  hours. */
  2173. {"zp5", TZ, NEG(30)}, /* GMT +5  hours. */
  2174. {"zp6", TZ, NEG(36)}, /* GMT +6  hours. */
  2175. {"z", RESERV, DTK_ZULU}, /* 00:00:00 */
  2176. {ZULU, RESERV, DTK_ZULU}, /* 00:00:00 */
  2177. };
  2179. static unsigned int szdatetktbl = sizeof datetktbl / sizeof datetktbl[0];
  2181. static datetkn deltatktbl[] = {
  2182. /* text token lexval */
  2183. {"@", IGNORE, 0}, /* postgres relative time prefix */
  2184. {DAGO, AGO, 0}, /* "ago" indicates negative time offset */
  2185. {"c", UNITS, DTK_CENTURY}, /* "century" relative time units */
  2186. {"cent", UNITS, DTK_CENTURY}, /* "century" relative time units */
  2187. {"centuries", UNITS, DTK_CENTURY}, /* "centuries" relative time units */
  2188. {DCENTURY, UNITS, DTK_CENTURY}, /* "century" relative time units */
  2189. {"d", UNITS, DTK_DAY}, /* "day" relative time units */
  2190. {DDAY, UNITS, DTK_DAY}, /* "day" relative time units */
  2191. {"days", UNITS, DTK_DAY}, /* "days" relative time units */
  2192. {"dec", UNITS, DTK_DECADE}, /* "decade" relative time units */
  2193. {"decs", UNITS, DTK_DECADE},/* "decades" relative time units */
  2194. {DDECADE, UNITS, DTK_DECADE}, /* "decade" relative time units */
  2195. {"decades", UNITS, DTK_DECADE}, /* "decades" relative time units */
  2196. {"h", UNITS, DTK_HOUR}, /* "hour" relative time units */
  2197. {DHOUR, UNITS, DTK_HOUR}, /* "hour" relative time units */
  2198. {"hours", UNITS, DTK_HOUR}, /* "hours" relative time units */
  2199. {"hr", UNITS, DTK_HOUR}, /* "hour" relative time units */
  2200. {"hrs", UNITS, DTK_HOUR}, /* "hours" relative time units */
  2201. {INVALID, RESERV, DTK_INVALID}, /* "invalid" reserved for invalid
  2202.  * time */
  2203. {"m", UNITS, DTK_MINUTE}, /* "minute" relative time units */
  2204. {"microsecon", UNITS, DTK_MICROSEC}, /* "microsecond" relative
  2205.  * time units */
  2206. {"mil", UNITS, DTK_MILLENIUM}, /* "millenium" relative time units */
  2207. {"mils", UNITS, DTK_MILLENIUM}, /* "millenia" relative time units */
  2208. {"millenia", UNITS, DTK_MILLENIUM}, /* "millenia" relative time units */
  2209. {DMILLENIUM, UNITS, DTK_MILLENIUM}, /* "millenium" relative time units */
  2210. {"millisecon", UNITS, DTK_MILLISEC}, /* relative time units */
  2211. {"min", UNITS, DTK_MINUTE}, /* "minute" relative time units */
  2212. {"mins", UNITS, DTK_MINUTE},/* "minutes" relative time units */
  2213. {"mins", UNITS, DTK_MINUTE},/* "minutes" relative time units */
  2214. {DMINUTE, UNITS, DTK_MINUTE}, /* "minute" relative time units */
  2215. {"minutes", UNITS, DTK_MINUTE}, /* "minutes" relative time units */
  2216. {"mon", UNITS, DTK_MONTH}, /* "months" relative time units */
  2217. {"mons", UNITS, DTK_MONTH}, /* "months" relative time units */
  2218. {DMONTH, UNITS, DTK_MONTH}, /* "month" relative time units */
  2219. {"months", UNITS, DTK_MONTH},
  2220. {"ms", UNITS, DTK_MILLISEC},
  2221. {"msec", UNITS, DTK_MILLISEC},
  2222. {DMILLISEC, UNITS, DTK_MILLISEC},
  2223. {"mseconds", UNITS, DTK_MILLISEC},
  2224. {"msecs", UNITS, DTK_MILLISEC},
  2225. {"qtr", UNITS, DTK_QUARTER},/* "quarter" relative time */
  2226. {DQUARTER, UNITS, DTK_QUARTER}, /* "quarter" relative time */
  2227. {"reltime", IGNORE, 0}, /* for pre-v6.1 "Undefined Reltime" */
  2228. {"s", UNITS, DTK_SECOND},
  2229. {"sec", UNITS, DTK_SECOND},
  2230. {DSECOND, UNITS, DTK_SECOND},
  2231. {"seconds", UNITS, DTK_SECOND},
  2232. {"secs", UNITS, DTK_SECOND},
  2233. {DTIMEZONE, UNITS, DTK_TZ}, /* "timezone" time offset */
  2234. {"tz", UNITS, DTK_TZ}, /* "timezone" time offset */
  2235. {"tz_hour", UNITS, DTK_TZ_HOUR}, /* timezone hour units */
  2236. {"tz_minute", UNITS, DTK_TZ_MINUTE}, /* timezone minutes units */
  2237. {"undefined", RESERV, DTK_INVALID}, /* pre-v6.1 invalid time */
  2238. {"us", UNITS, DTK_MICROSEC},/* "microsecond" relative time units */
  2239. {"usec", UNITS, DTK_MICROSEC}, /* "microsecond" relative time
  2240.  * units */
  2241. {DMICROSEC, UNITS, DTK_MICROSEC}, /* "microsecond" relative time
  2242.  * units */
  2243. {"useconds", UNITS, DTK_MICROSEC}, /* "microseconds" relative time
  2244.  * units */
  2245. {"usecs", UNITS, DTK_MICROSEC}, /* "microseconds" relative time
  2246.  * units */
  2247. {"w", UNITS, DTK_WEEK}, /* "week" relative time units */
  2248. {DWEEK, UNITS, DTK_WEEK}, /* "week" relative time units */
  2249. {"weeks", UNITS, DTK_WEEK}, /* "weeks" relative time units */
  2250. {"y", UNITS, DTK_YEAR}, /* "year" relative time units */
  2251. {DYEAR, UNITS, DTK_YEAR}, /* "year" relative time units */
  2252. {"years", UNITS, DTK_YEAR}, /* "years" relative time units */
  2253. {"yr", UNITS, DTK_YEAR}, /* "year" relative time units */
  2254. {"yrs", UNITS, DTK_YEAR}, /* "years" relative time units */
  2255. };
  2257. static unsigned int szdeltatktbl = sizeof deltatktbl / sizeof deltatktbl[0];
  2259. #if USE_DATE_CACHE
  2260. datetkn    *datecache[MAXDATEFIELDS] = {NULL};
  2262. datetkn    *deltacache[MAXDATEFIELDS] = {NULL};
  2264. #endif
  2267. /*
  2268.  * Calendar time to Julian date conversions.
  2269.  * Julian date is commonly used in astronomical applications,
  2270.  * since it is numerically accurate and computationally simple.
  2271.  * The algorithms here will accurately convert between Julian day
  2272.  * and calendar date for all non-negative Julian days
  2273.  * (i.e. from Nov 23, -4713 on).
  2274.  *
  2275.  * Ref: Explanatory Supplement to the Astronomical Almanac, 1992.
  2276.  * University Science Books, 20 Edgehill Rd. Mill Valley CA 94941.
  2277.  *
  2278.  * Use the algorithm by Henry Fliegel, a former NASA/JPL colleague
  2279.  * now at Aerospace Corp. (hi, Henry!)
  2280.  *
  2281.  * These routines will be used by other date/time packages - tgl 97/02/25
  2282.  */
  2284. int
  2285. date2j(int y, int m, int d)
  2286. {
  2287. int m12 = (m - 14) / 12;
  2289. return ((1461 * (y + 4800 + m12)) / 4 + (367 * (m - 2 - 12 * (m12))) / 12
  2290. - (3 * ((y + 4900 + m12) / 100)) / 4 + d - 32075);
  2291. } /* date2j() */
  2293. void
  2294. j2date(int jd, int *year, int *month, int *day)
  2295. {
  2296. int j,
  2297. y,
  2298. m,
  2299. d;
  2301. int i,
  2302. l,
  2303. n;
  2305. l = jd + 68569;
  2306. n = (4 * l) / 146097;
  2307. l -= (146097 * n + 3) / 4;
  2308. i = (4000 * (l + 1)) / 1461001;
  2309. l += 31 - (1461 * i) / 4;
  2310. j = (80 * l) / 2447;
  2311. d = l - (2447 * j) / 80;
  2312. l = j / 11;
  2313. m = (j + 2) - (12 * l);
  2314. y = 100 * (n - 49) + i + l;
  2316. *year = y;
  2317. *month = m;
  2318. *day = d;
  2319. return;
  2320. } /* j2date() */
  2322. static int
  2323. j2day(int date)
  2324. {
  2325. int day;
  2327. day = (date + 1) % 7;
  2329. return day;
  2330. } /* j2day() */
  2333. /* datetime2tm()
  2334.  * Convert datetime data type to POSIX time structure.
  2335.  * Note that year is _not_ 1900-based, but is an explicit full value.
  2336.  * Also, month is one-based, _not_ zero-based.
  2337.  * Returns:
  2338.  *  0 on success
  2339.  * -1 on out of range
  2340.  *
  2341.  * For dates within the system-supported time_t range, convert to the
  2342.  * local time zone. If out of this range, leave as GMT. - tgl 97/05/27
  2343.  */
  2344. int
  2345. datetime2tm(DateTime dt, int *tzp, struct tm * tm, double *fsec, char **tzn)
  2346. {
  2347. double date,
  2348. date0,
  2349. time,
  2350. sec;
  2351. time_t utime;
  2353. #ifdef USE_POSIX_TIME
  2354. struct tm  *tx;
  2356. #endif
  2358. date0 = date2j(2000, 1, 1);
  2360. time = dt;
  2361. TMODULO(time, date, 86400e0);
  2363. if (time < 0)
  2364. {
  2365. time += 86400;
  2366. date -= 1;
  2367. }
  2369. /* Julian day routine does not work for negative Julian days */
  2370. if (date < -date0)
  2371. return -1;
  2373. /* add offset to go from J2000 back to standard Julian date */
  2374. date += date0;
  2376. #ifdef DATEDEBUG
  2377. printf("datetime2tm- date is %f (%f %f)n", dt, date, time);
  2378. #endif
  2380. j2date((int) date, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
  2381. dt2time(time, &tm->tm_hour, &tm->tm_min, &sec);
  2383. #ifdef DATEDEBUG
  2384. printf("datetime2tm- date is %d.%02d.%02dn", tm->tm_year, tm->tm_mon, tm->tm_mday);
  2385. printf("datetime2tm- time is %02d:%02d:%02.0fn", tm->tm_hour, tm->tm_min, sec);
  2386. #endif
  2388. *fsec = JROUND(sec);
  2389. TMODULO(*fsec, tm->tm_sec, 1e0);
  2391. #ifdef DATEDEBUG
  2392. printf("datetime2tm- time is %02d:%02d:%02d %.7fn", tm->tm_hour, tm->tm_min, tm->tm_sec, *fsec);
  2393. #endif
  2395. if (tzp != NULL)
  2396. {
  2397. if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon, tm->tm_mday))
  2398. {
  2399. utime = (dt + (date0 - date2j(1970, 1, 1)) * 86400);
  2401. #ifdef USE_POSIX_TIME
  2402. tx = localtime(&utime);
  2403. #ifdef DATEDEBUG
  2404. #if defined(HAVE_TM_ZONE)
  2405. printf("datetime2tm- (localtime) %d.%02d.%02d %02d:%02d:%02.0f %s dst=%dn",
  2406.    tx->tm_year, tx->tm_mon, tx->tm_mday, tx->tm_hour, tx->tm_min, sec,
  2407.    tx->tm_zone, tx->tm_isdst);
  2408. #elif defined(HAVE_INT_TIMEZONE)
  2409. printf("datetime2tm- (localtime) %d.%02d.%02d %02d:%02d:%02.0f %s %s dst=%dn",
  2410.    tx->tm_year, tx->tm_mon, tx->tm_mday, tx->tm_hour, tx->tm_min, sec,
  2411.    tzname[0], tzname[1], tx->tm_isdst);
  2412. #else
  2413. #error USE_POSIX_TIME is defined but neither HAVE_TM_ZONE or HAVE_INT_TIMEZONE are defined
  2414. #endif
  2415. #endif
  2416. tm->tm_year = tx->tm_year + 1900;
  2417. tm->tm_mon = tx->tm_mon + 1;
  2418. tm->tm_mday = tx->tm_mday;
  2419. tm->tm_hour = tx->tm_hour;
  2420. tm->tm_min = tx->tm_min;
  2421. #if NOT_USED
  2422. /* XXX HACK
  2423.  * Argh! My Linux box puts in a 1 second offset for dates less than 1970
  2424.  * but only if the seconds field was non-zero. So, don't copy the seconds
  2425.  * field and instead carry forward from the original - tgl 97/06/18
  2426.  * Note that GNU/Linux uses the standard freeware zic package as do
  2427.  * many other platforms so this may not be GNU/Linux/ix86-specific.
  2428.  */
  2429. tm->tm_sec = tx->tm_sec;
  2430. #endif
  2431. tm->tm_isdst = tx->tm_isdst;
  2433. #if defined(HAVE_TM_ZONE)
  2434. tm->tm_gmtoff = tx->tm_gmtoff;
  2435. tm->tm_zone = tx->tm_zone;
  2437. *tzp = -(tm->tm_gmtoff); /* tm_gmtoff is Sun/DEC-ism */
  2438. if (tzn != NULL)
  2439. *tzn = (char *) tm->tm_zone;
  2440. #elif defined(HAVE_INT_TIMEZONE)
  2441. #ifdef __CYGWIN__
  2442. *tzp = (tm->tm_isdst ? (_timezone - 3600) : _timezone);
  2443. #else
  2444. *tzp = (tm->tm_isdst ? (timezone - 3600) : timezone);
  2445. #endif
  2446. if (tzn != NULL)
  2447. *tzn = tzname[(tm->tm_isdst > 0)];
  2448. #else
  2449. #error USE_POSIX_TIME is defined but neither HAVE_TM_ZONE or HAVE_INT_TIMEZONE are defined
  2450. #endif
  2452. #else /* !USE_POSIX_TIME */
  2453. *tzp = CTimeZone; /* V7 conventions; don't know timezone? */
  2454. if (tzn != NULL)
  2455. *tzn = CTZName;
  2456. #endif
  2458. }
  2459. else
  2460. {
  2461. *tzp = 0;
  2462. tm->tm_isdst = 0;
  2463. if (tzn != NULL)
  2464. *tzn = NULL;
  2465. }
  2467. dt = dt2local(dt, *tzp);
  2469. }
  2470. else
  2471. {
  2472. tm->tm_isdst = 0;
  2473. if (tzn != NULL)
  2474. *tzn = NULL;
  2475. }
  2477. #ifdef DATEDEBUG
  2478. printf("datetime2tm- date is %d.%02d.%02dn", tm->tm_year, tm->tm_mon, tm->tm_mday);
  2479. printf("datetime2tm- time is %02d:%02d:%02d %.7fn", tm->tm_hour, tm->tm_min, tm->tm_sec, *fsec);
  2480. #endif
  2482. #ifdef DATEDEBUG
  2483. #ifdef USE_POSIX_TIME
  2484. #if defined(HAVE_TM_ZONE)
  2485. printf("datetime2tm- timezone is %s; offset is %dn",
  2486.    tm->tm_zone, ((tzp != NULL) ? *tzp : 0));
  2487. #elif defined(HAVE_INT_TIMEZONE)
  2488. printf("datetime2tm- timezone is %s; offset is %d (%d); daylight is %dn",
  2489.    tzname[tm->tm_isdst != 0], ((tzp != NULL) ? *tzp : 0), CTimeZone, CDayLight);
  2490. #endif
  2491. #endif
  2492. #endif
  2494. return 0;
  2495. } /* datetime2tm() */
  2498. /* tm2datetime()
  2499.  * Convert a tm structure to a datetime data type.
  2500.  * Note that year is _not_ 1900-based, but is an explicit full value.
  2501.  * Also, month is one-based, _not_ zero-based.
  2502.  */
  2503. int
  2504. tm2datetime(struct tm * tm, double fsec, int *tzp, DateTime *result)
  2505. {
  2507. double date,
  2508. time;
  2510. /* Julian day routines are not correct for negative Julian days */
  2511. if (!IS_VALID_JULIAN(tm->tm_year, tm->tm_mon, tm->tm_mday))
  2512. return -1;
  2514. date = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1);
  2515. time = time2t(tm->tm_hour, tm->tm_min, (tm->tm_sec + fsec));
  2516. *result = (date * 86400 + time);
  2517. #ifdef DATEDEBUG
  2518. printf("tm2datetime- date is %f (%f %f %d)n", *result, date, time, (((tm->tm_hour * 60) + tm->tm_min) * 60 + tm->tm_sec));
  2519. printf("tm2datetime- time is %f %02d:%02d:%02d %fn", time, tm->tm_hour, tm->tm_min, tm->tm_sec, fsec);
  2520. #endif
  2521. if (tzp != NULL)
  2522. *result = dt2local(*result, -(*tzp));
  2524. return 0;
  2525. } /* tm2datetime() */
  2528. /* timespan2tm()
  2529.  * Convert a timespan data type to a tm structure.
  2530.  */
  2531. static int
  2532. timespan2tm(TimeSpan span, struct tm * tm, float8 *fsec)
  2533. {
  2534. double time;
  2536. if (span.month != 0)
  2537. {
  2538. tm->tm_year = span.month / 12;
  2539. tm->tm_mon = span.month % 12;
  2541. }
  2542. else
  2543. {
  2544. tm->tm_year = 0;
  2545. tm->tm_mon = 0;
  2546. }
  2548. #ifdef ROUND_ALL
  2549. time = JROUND(span.time);
  2550. #else
  2551. time = span.time;
  2552. #endif
  2554. TMODULO(time, tm->tm_mday, 86400e0);
  2555. TMODULO(time, tm->tm_hour, 3600e0);
  2556. TMODULO(time, tm->tm_min, 60e0);
  2557. TMODULO(time, tm->tm_sec, 1e0);
  2558. *fsec = time;
  2560. #ifdef DATEDEBUG
  2561. printf("timespan2tm- %d %f = %04d-%02d-%02d %02d:%02d:%02d %.2fn", span.month, span.time,
  2562.    tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, *fsec);
  2563. #endif
  2565. return 0;
  2566. } /* timespan2tm() */
  2568. static int
  2569. tm2timespan(struct tm * tm, double fsec, TimeSpan *span)
  2570. {
  2571. span->month = ((tm->tm_year * 12) + tm->tm_mon);
  2572. span->time = ((((((tm->tm_mday * 24) + tm->tm_hour) * 60) + tm->tm_min) * 60) + tm->tm_sec);
  2573. span->time = JROUND(span->time + fsec);
  2575. #ifdef DATEDEBUG
  2576. printf("tm2timespan- %d %f = %04d-%02d-%02d %02d:%02d:%02d %.2fn", span->month, span->time,
  2577.    tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, fsec);
  2578. #endif
  2580. return 0;
  2581. } /* tm2timespan() */
  2584. static DateTime
  2585. dt2local(DateTime dt, int tz)
  2586. {
  2587. dt -= tz;
  2588. dt = JROUND(dt);
  2589. return dt;
  2590. } /* dt2local() */
  2592. static double
  2593. time2t(const int hour, const int min, const double sec)
  2594. {
  2595. return (((hour * 60) + min) * 60) + sec;
  2596. } /* time2t() */
  2598. static void
  2599. dt2time(DateTime jd, int *hour, int *min, double *sec)
  2600. {
  2601. double time;
  2603. time = jd;
  2605. *hour = (time / 3600);
  2606. time -= ((*hour) * 3600);
  2607. *min = (time / 60);
  2608. time -= ((*min) * 60);
  2609. *sec = JROUND(time);
  2611. return;
  2612. } /* dt2time() */
  2615. /*
  2616.  * parse and convert date in timestr (the normal interface)
  2617.  *
  2618.  * Returns the number of seconds since epoch (J2000)
  2619.  */
  2621. /* ParseDateTime()
  2622.  * Break string into tokens based on a date/time context.
  2623.  */
  2624. int
  2625. ParseDateTime(char *timestr, char *lowstr,
  2626.   char **field, int *ftype, int maxfields, int *numfields)
  2627. {
  2628. int nf = 0;
  2629. char    *cp = timestr;
  2630. char    *lp = lowstr;
  2632. #ifdef DATEDEBUG
  2633. printf("ParseDateTime- input string is %sn", timestr);
  2634. #endif
  2635. /* outer loop through fields */
  2636. while (*cp != '')
  2637. {
  2638. field[nf] = lp;
  2640. /* leading digit? then date or time */
  2641. if (isdigit(*cp) || (*cp == '.'))
  2642. {
  2643. *lp++ = *cp++;
  2644. while (isdigit(*cp))
  2645. *lp++ = *cp++;
  2646. /* time field? */
  2647. if (*cp == ':')
  2648. {
  2649. ftype[nf] = DTK_TIME;
  2650. while (isdigit(*cp) || (*cp == ':') || (*cp == '.'))
  2651. *lp++ = *cp++;
  2653. }
  2654. /* date field? allow embedded text month */
  2655. else if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
  2656. {
  2657. ftype[nf] = DTK_DATE;
  2658. while (isalnum(*cp) || (*cp == '-') || (*cp == '/') || (*cp == '.'))
  2659. *lp++ = tolower(*cp++);
  2661. }
  2663. /*
  2664.  * otherwise, number only and will determine year, month, or
  2665.  * day later
  2666.  */
  2667. else
  2668. ftype[nf] = DTK_NUMBER;
  2670. }
  2672. /*
  2673.  * text? then date string, month, day of week, special, or
  2674.  * timezone
  2675.  */
  2676. else if (isalpha(*cp))
  2677. {
  2678. ftype[nf] = DTK_STRING;
  2679. *lp++ = tolower(*cp++);
  2680. while (isalpha(*cp))
  2681. *lp++ = tolower(*cp++);
  2683. /* full date string with leading text month? */
  2684. if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
  2685. {
  2686. ftype[nf] = DTK_DATE;
  2687. while (isdigit(*cp) || (*cp == '-') || (*cp == '/') || (*cp == '.'))
  2688. *lp++ = tolower(*cp++);
  2689. }
  2691. /* skip leading spaces */
  2692. }
  2693. else if (isspace(*cp))
  2694. {
  2695. cp++;
  2696. continue;
  2698. /* sign? then special or numeric timezone */
  2699. }
  2700. else if ((*cp == '+') || (*cp == '-'))
  2701. {
  2702. *lp++ = *cp++;
  2703. /* soak up leading whitespace */
  2704. while (isspace(*cp))
  2705. cp++;
  2706. /* numeric timezone? */
  2707. if (isdigit(*cp))
  2708. {
  2709. ftype[nf] = DTK_TZ;
  2710. *lp++ = *cp++;
  2711. while (isdigit(*cp) || (*cp == ':'))
  2712. *lp++ = *cp++;
  2714. /* special? */
  2715. }
  2716. else if (isalpha(*cp))
  2717. {
  2718. ftype[nf] = DTK_SPECIAL;
  2719. *lp++ = tolower(*cp++);
  2720. while (isalpha(*cp))
  2721. *lp++ = tolower(*cp++);
  2723. /* otherwise something wrong... */
  2724. }
  2725. else
  2726. return -1;
  2728. /* ignore punctuation but use as delimiter */
  2729. }
  2730. else if (ispunct(*cp))
  2731. {
  2732. cp++;
  2733. continue;
  2735. }
  2736. else
  2737. return -1;
  2739. /* force in a delimiter */
  2740. *lp++ = '';
  2741. nf++;
  2742. if (nf > MAXDATEFIELDS)
  2743. return -1;
  2744. #ifdef DATEDEBUG
  2745. printf("ParseDateTime- set field[%d] to %s type %dn", (nf - 1), field[nf - 1], ftype[nf - 1]);
  2746. #endif
  2747. }
  2749. *numfields = nf;
  2751. return 0;
  2752. } /* ParseDateTime() */
  2755. /* DecodeDateTime()
  2756.  * Interpret previously parsed fields for general date and time.
  2757.  * Return 0 if full date, 1 if only time, and -1 if problems.
  2758.  * External format(s):
  2759.  * "<weekday> <month>-<day>-<year> <hour>:<minute>:<second>"
  2760.  * "Fri Feb-7-1997 15:23:27"
  2761.  * "Feb-7-1997 15:23:27"
  2762.  * "2-7-1997 15:23:27"
  2763.  * "1997-2-7 15:23:27"
  2764.  * "1997.038 15:23:27" (day of year 1-366)
  2765.  * Also supports input in compact time:
  2766.  * "970207 152327"
  2767.  * "97038 152327"
  2768.  *
  2769.  * Use the system-provided functions to get the current time zone
  2770.  * if not specified in the input string.
  2771.  * If the date is outside the time_t system-supported time range,
  2772.  * then assume GMT time zone. - tgl 97/05/27
  2773.  */
  2774. int
  2775. DecodeDateTime(char **field, int *ftype, int nf,
  2776.    int *dtype, struct tm * tm, double *fsec, int *tzp)
  2777. {
  2778. int fmask = 0,
  2779. tmask,
  2780. type;
  2781. int i;
  2782. int flen,
  2783. val;
  2784. int mer = HR24;
  2785. int haveTextMonth = FALSE;
  2786. int is2digits = FALSE;
  2787. int bc = FALSE;
  2789. *dtype = DTK_DATE;
  2790. tm->tm_hour = 0;
  2791. tm->tm_min = 0;
  2792. tm->tm_sec = 0;
  2793. *fsec = 0;
  2794. tm->tm_isdst = -1; /* don't know daylight savings time status
  2795.  * apriori */
  2796. if (tzp != NULL)
  2797. *tzp = 0;
  2799. for (i = 0; i < nf; i++)
  2800. {
  2801. #ifdef DATEDEBUG
  2802. printf("DecodeDateTime- field[%d] is %s (type %d)n", i, field[i], ftype[i]);
  2803. #endif
  2804. switch (ftype[i])
  2805. {
  2806. case DTK_DATE:
  2807. if (DecodeDate(field[i], fmask, &tmask, tm) != 0)
  2808. return -1;
  2809. break;
  2811. case DTK_TIME:
  2812. if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
  2813. return -1;
  2815. /*
  2816.  * check upper limit on hours; other limits checked in
  2817.  * DecodeTime()
  2818.  */
  2819. if (tm->tm_hour > 23)
  2820. return -1;
  2821. break;
  2823. case DTK_TZ:
  2824. if (tzp == NULL)
  2825. return -1;
  2826. if (DecodeTimezone(field[i], tzp) != 0)
  2827. return -1;
  2828. tmask = DTK_M(TZ);
  2829. break;
  2831. case DTK_NUMBER:
  2832. flen = strlen(field[i]);
  2834. /*
  2835.  * long numeric string and either no date or no time read
  2836.  * yet? then interpret as a concatenated date or time...
  2837.  */
  2838. if ((flen > 4) && !((fmask & DTK_DATE_M) && (fmask & DTK_TIME_M)))
  2839. {
  2840. if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec, &is2digits) != 0)
  2841. return -1;
  2843. }
  2844. /* otherwise it is a single date/time field... */
  2845. else
  2846. {
  2847. if (DecodeNumber(flen, field[i], fmask, &tmask, tm, fsec, &is2digits) != 0)
  2848. return -1;
  2849. }
  2850. break;
  2852. case DTK_STRING:
  2853. case DTK_SPECIAL:
  2854. type = DecodeSpecial(i, field[i], &val);
  2855. #ifdef DATEDEBUG
  2856. printf("DecodeDateTime- special field[%d] %s type=%d value=%dn", i, field[i], type, val);
  2857. #endif
  2858. if (type == IGNORE)
  2859. continue;
  2861. tmask = DTK_M(type);
  2862. switch (type)
  2863. {
  2864. case RESERV:
  2865. #ifdef DATEDEBUG
  2866. printf("DecodeDateTime- RESERV field %s value is %dn", field[i], val);
  2867. #endif
  2868. switch (val)
  2869. {
  2870. case DTK_NOW:
  2871. tmask = (DTK_DATE_M | DTK_TIME_M | DTK_M(TZ));
  2872. *dtype = DTK_DATE;
  2873. GetCurrentTime(tm);
  2874. if (tzp != NULL)
  2875. *tzp = CTimeZone;
  2876. break;
  2878. case DTK_YESTERDAY:
  2879. tmask = DTK_DATE_M;
  2880. *dtype = DTK_DATE;
  2881. GetCurrentTime(tm);
  2882. j2date((date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - 1),
  2883. &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
  2884. tm->tm_hour = 0;
  2885. tm->tm_min = 0;
  2886. tm->tm_sec = 0;
  2887. break;
  2889. case DTK_TODAY:
  2890. tmask = DTK_DATE_M;
  2891. *dtype = DTK_DATE;
  2892. GetCurrentTime(tm);
  2893. tm->tm_hour = 0;
  2894. tm->tm_min = 0;
  2895. tm->tm_sec = 0;
  2896. break;
  2898. case DTK_TOMORROW:
  2899. tmask = DTK_DATE_M;
  2900. *dtype = DTK_DATE;
  2901. GetCurrentTime(tm);
  2902. j2date((date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) + 1),
  2903. &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
  2904. tm->tm_hour = 0;
  2905. tm->tm_min = 0;
  2906. tm->tm_sec = 0;
  2907. break;
  2909. case DTK_ZULU:
  2910. tmask = (DTK_TIME_M | DTK_M(TZ));
  2911. *dtype = DTK_DATE;
  2912. tm->tm_hour = 0;
  2913. tm->tm_min = 0;
  2914. tm->tm_sec = 0;
  2915. if (tzp != NULL)
  2916. *tzp = 0;
  2917. break;
  2919. default:
  2920. *dtype = val;
  2921. }
  2923. break;
  2925. case MONTH:
  2926. #ifdef DATEDEBUG
  2927. printf("DecodeDateTime- month field %s value is %dn", field[i], val);
  2928. #endif
  2930. /*
  2931.  * already have a (numeric) month? then see if we
  2932.  * can substitute...
  2933.  */
  2934. if ((fmask & DTK_M(MONTH)) && (!haveTextMonth)
  2935. && (!(fmask & DTK_M(DAY)))
  2936. && ((tm->tm_mon >= 1) && (tm->tm_mon <= 31)))
  2937. {
  2938. tm->tm_mday = tm->tm_mon;
  2939. tmask = DTK_M(DAY);
  2940. #ifdef DATEDEBUG
  2941. printf("DecodeNumber- misidentified month previously; assign as day %dn", tm->tm_mday);
  2942. #endif
  2943. }
  2944. haveTextMonth = TRUE;
  2945. tm->tm_mon = val;
  2946. break;
  2948. case DTZMOD:
  2950. /*
  2951.  * daylight savings time modifier (solves "MET
  2952.  * DST" syntax)
  2953.  */
  2954. tmask |= DTK_M(DTZ);
  2955. tm->tm_isdst = 1;
  2956. if (tzp == NULL)
  2957. return -1;
  2958. *tzp += val * 60;
  2959. break;
  2961. case DTZ:
  2963. /*
  2964.  * set mask for TZ here _or_ check for DTZ later
  2965.  * when getting default timezone
  2966.  */
  2967. tmask |= DTK_M(TZ);
  2968. tm->tm_isdst = 1;
  2969. if (tzp == NULL)
  2970. return -1;
  2971. *tzp = val * 60;
  2972. break;
  2974. case TZ:
  2975. tm->tm_isdst = 0;
  2976. if (tzp == NULL)
  2977. return -1;
  2978. *tzp = val * 60;
  2979. break;
  2981. case IGNORE:
  2982. break;
  2984. case AMPM:
  2985. mer = val;
  2986. break;
  2988. case ADBC:
  2989. bc = (val == BC);
  2990. break;
  2992. case DOW:
  2993. tm->tm_wday = val;
  2994. break;
  2996. default:
  2997. return -1;
  2998. }
  2999. break;
  3001. default:
  3002. return -1;
  3003. }
  3005. #ifdef DATEDEBUG
  3006. printf("DecodeDateTime- field[%d] %s (%08x/%08x) value is %dn",
  3007.    i, field[i], fmask, tmask, val);
  3008. #endif
  3010. if (tmask & fmask)
  3011. return -1;
  3012. fmask |= tmask;
  3013. }
  3015. /* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */
  3016. if (bc)
  3017. {
  3018. if (tm->tm_year > 0)
  3019. tm->tm_year = -(tm->tm_year - 1);
  3020. else
  3021. elog(ERROR, "Inconsistant use of year %04d and 'BC'", tm->tm_year);
  3022. }
  3023. else if (is2digits)
  3024. {
  3025. if (tm->tm_year < 70)
  3026. tm->tm_year += 2000;
  3027. else if (tm->tm_year < 100)
  3028. tm->tm_year += 1900;
  3029. }
  3031. if ((mer != HR24) && (tm->tm_hour > 12))
  3032. return -1;
  3033. if ((mer == AM) && (tm->tm_hour == 12))
  3034. tm->tm_hour = 0;
  3035. else if ((mer == PM) && (tm->tm_hour != 12))
  3036. tm->tm_hour += 12;
  3038. #ifdef DATEDEBUG
  3039. printf("DecodeDateTime- mask %08x (%08x)", fmask, DTK_DATE_M);
  3040. printf(" set y%04d m%02d d%02d", tm->tm_year, tm->tm_mon, tm->tm_mday);
  3041. printf(" %02d:%02d:%02dn", tm->tm_hour, tm->tm_min, tm->tm_sec);
  3042. #endif
  3044. /* do additional checking for full date specs... */
  3045. if (*dtype == DTK_DATE)
  3046. {
  3047. if ((fmask & DTK_DATE_M) != DTK_DATE_M)
  3048. return ((fmask & DTK_TIME_M) == DTK_TIME_M) ? 1 : -1;
  3050. /*
  3051.  * check for valid day of month, now that we know for sure the
  3052.  * month and year...
  3053.  */
  3054. if ((tm->tm_mday < 1)
  3055.  || (tm->tm_mday > day_tab[isleap(tm->tm_year)][tm->tm_mon - 1]))
  3056. return -1;
  3058. /* timezone not specified? then find local timezone if possible */
  3059. if (((fmask & DTK_DATE_M) == DTK_DATE_M)
  3060. && (tzp != NULL) && (!(fmask & DTK_M(TZ))))
  3061. {
  3063. /*
  3064.  * daylight savings time modifier but no standard timezone?
  3065.  * then error
  3066.  */
  3067. if (fmask & DTK_M(DTZMOD))
  3068. return -1;
  3070. if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon, tm->tm_mday))
  3071. {
  3072. #ifdef USE_POSIX_TIME
  3073. tm->tm_year -= 1900;
  3074. tm->tm_mon -= 1;
  3075. tm->tm_isdst = -1;
  3076. mktime(tm);
  3077. tm->tm_year += 1900;
  3078. tm->tm_mon += 1;
  3080. #if defined(HAVE_TM_ZONE)
  3081. *tzp = -(tm->tm_gmtoff); /* tm_gmtoff is
  3082.  * Sun/DEC-ism */
  3083. #elif defined(HAVE_INT_TIMEZONE)
  3084. #ifdef __CYGWIN__
  3085. *tzp = ((tm->tm_isdst > 0) ? (_timezone - 3600) : _timezone);
  3086. #else
  3087. *tzp = ((tm->tm_isdst > 0) ? (timezone - 3600) : timezone);
  3088. #endif
  3089. #else
  3090. #error USE_POSIX_TIME is defined but neither HAVE_TM_ZONE or HAVE_INT_TIMEZONE are defined
  3091. #endif
  3093. #else /* !USE_POSIX_TIME */
  3094. *tzp = CTimeZone;
  3095. #endif
  3096. }
  3097. else
  3098. {
  3099. tm->tm_isdst = 0;
  3100. *tzp = 0;
  3101. }
  3102. }
  3103. }
  3105. return 0;
  3106. } /* DecodeDateTime() */
  3109. /* DecodeTimeOnly()
  3110.  * Interpret parsed string as time fields only.
  3111.  */
  3112. int
  3113. DecodeTimeOnly(char **field, int *ftype, int nf, int *dtype, struct tm * tm, double *fsec)
  3114. {
  3115. int fmask,
  3116. tmask,
  3117. type;
  3118. int i;
  3119. int flen,
  3120. val;
  3121. int is2digits = FALSE;
  3122. int mer = HR24;
  3124. *dtype = DTK_TIME;
  3125. tm->tm_hour = 0;
  3126. tm->tm_min = 0;
  3127. tm->tm_sec = 0;
  3128. tm->tm_isdst = -1; /* don't know daylight savings time status
  3129.  * apriori */
  3130. *fsec = 0;
  3132. fmask = DTK_DATE_M;
  3134. for (i = 0; i < nf; i++)
  3135. {
  3136. #ifdef DATEDEBUG
  3137. printf("DecodeTimeOnly- field[%d] is %s (type %d)n", i, field[i], ftype[i]);
  3138. #endif
  3139. switch (ftype[i])
  3140. {
  3141. case DTK_TIME:
  3142. if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
  3143. return -1;
  3144. break;
  3146. case DTK_NUMBER:
  3147. flen = strlen(field[i]);
  3149. if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec, &is2digits) != 0)
  3150. return -1;
  3151. break;
  3153. case DTK_STRING:
  3154. case DTK_SPECIAL:
  3155. type = DecodeSpecial(i, field[i], &val);
  3156. #ifdef DATEDEBUG
  3157. printf("DecodeTimeOnly- special field[%d] %s type=%d value=%dn", i, field[i], type, val);
  3158. #endif
  3159. if (type == IGNORE)
  3160. continue;
  3162. tmask = DTK_M(type);
  3163. switch (type)
  3164. {
  3165. case RESERV:
  3166. #ifdef DATEDEBUG
  3167. printf("DecodeTimeOnly- RESERV field %s value is %dn", field[i], val);
  3168. #endif
  3169. switch (val)
  3170. {
  3171. case DTK_NOW:
  3172. tmask = DTK_TIME_M;
  3173. *dtype = DTK_TIME;
  3174. GetCurrentTime(tm);
  3175. break;
  3177. case DTK_ZULU:
  3178. tmask = (DTK_TIME_M | DTK_M(TZ));
  3179. *dtype = DTK_TIME;
  3180. tm->tm_hour = 0;
  3181. tm->tm_min = 0;
  3182. tm->tm_sec = 0;
  3183. tm->tm_isdst = 0;
  3184. break;
  3186. default:
  3187. return -1;
  3188. }
  3190. break;
  3192. case IGNORE:
  3193. break;
  3195. case AMPM:
  3196. mer = val;
  3197. break;
  3199. default:
  3200. return -1;
  3201. }
  3202. break;
  3204. default:
  3205. return -1;
  3206. }
  3208. if (tmask & fmask)
  3209. return -1;
  3210. fmask |= tmask;
  3212. #ifdef DATEDEBUG
  3213. printf("DecodeTimeOnly- field[%d] %s value is %dn", i, field[i], val);
  3214. #endif
  3215. }
  3217. #ifdef DATEDEBUG
  3218. printf("DecodeTimeOnly- mask %08x (%08x)", fmask, DTK_TIME_M);
  3219. printf(" %02d:%02d:%02d (%f)n", tm->tm_hour, tm->tm_min, tm->tm_sec, *fsec);
  3220. #endif
  3222. if ((mer != HR24) && (tm->tm_hour > 12))
  3223. return -1;
  3224. if ((mer == AM) && (tm->tm_hour == 12))
  3225. tm->tm_hour = 0;
  3226. else if ((mer == PM) && (tm->tm_hour != 12))
  3227. tm->tm_hour += 12;
  3229. if (((tm->tm_hour < 0) || (tm->tm_hour > 23))
  3230. || ((tm->tm_min < 0) || (tm->tm_min > 59))
  3231. || ((tm->tm_sec < 0) || ((tm->tm_sec + *fsec) >= 60)))
  3232. return -1;
  3234. if ((fmask & DTK_TIME_M) != DTK_TIME_M)
  3235. return -1;
  3237. return 0;
  3238. } /* DecodeTimeOnly() */
  3241. /* DecodeDate()
  3242.  * Decode date string which includes delimiters.
  3243.  * Insist on a complete set of fields.
  3244.  */
  3245. static int
  3246. DecodeDate(char *str, int fmask, int *tmask, struct tm * tm)
  3247. {
  3248. double fsec;
  3250. int nf = 0;
  3251. int i,
  3252. len;
  3253. int bc = FALSE;
  3254. int is2digits = FALSE;
  3255. int type,
  3256. val,
  3257. dmask = 0;
  3258. char    *field[MAXDATEFIELDS];
  3260. /* parse this string... */
  3261. while ((*str != '') && (nf < MAXDATEFIELDS))
  3262. {
  3263. /* skip field separators */
  3264. while (!isalnum(*str))
  3265. str++;
  3267. field[nf] = str;
  3268. if (isdigit(*str))
  3269. {
  3270. while (isdigit(*str))
  3271. str++;
  3272. }
  3273. else if (isalpha(*str))
  3274. {
  3275. while (isalpha(*str))
  3276. str++;
  3277. }
  3279. if (*str != '')
  3280. *str++ = '';
  3281. nf++;
  3282. }
  3284. #if 0
  3285. /* don't allow too many fields */
  3286. if (nf > 3)
  3287. return -1;
  3288. #endif
  3290. *tmask = 0;
  3292. /* look first for text fields, since that will be unambiguous month */
  3293. for (i = 0; i < nf; i++)
  3294. {
  3295. if (isalpha(*field[i]))
  3296. {
  3297. type = DecodeSpecial(i, field[i], &val);
  3298. if (type == IGNORE)
  3299. continue;
  3301. dmask = DTK_M(type);
  3302. switch (type)
  3303. {
  3304. case MONTH:
  3305. #ifdef DATEDEBUG
  3306. printf("DecodeDate- month field %s value is %dn", field[i], val);
  3307. #endif
  3308. tm->tm_mon = val;
  3309. break;
  3311. case ADBC:
  3312. bc = (val == BC);
  3313. break;
  3315. default:
  3316. #ifdef DATEDEBUG
  3317. printf("DecodeDate- illegal field %s value is %dn", field[i], val);
  3318. #endif
  3319. return -1;
  3320. }
  3321. if (fmask & dmask)
  3322. return -1;
  3324. fmask |= dmask;
  3325. *tmask |= dmask;
  3327. /* mark this field as being completed */
  3328. field[i] = NULL;
  3329. }
  3330. }
  3332. /* now pick up remaining numeric fields */
  3333. for (i = 0; i < nf; i++)
  3334. {
  3335. if (field[i] == NULL)
  3336. continue;
  3338. if ((len = strlen(field[i])) <= 0)
  3339. return -1;
  3341. if (DecodeNumber(len, field[i], fmask, &dmask, tm, &fsec, &is2digits) != 0)
  3342. return -1;
  3344. if (fmask & dmask)
  3345. return -1;
  3347. fmask |= dmask;
  3348. *tmask |= dmask;
  3349. }
  3351. if ((fmask & ~(DTK_M(DOY) | DTK_M(TZ))) != DTK_DATE_M)
  3352. return -1;
  3354. /* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */
  3355. if (bc)
  3356. {
  3357. if (tm->tm_year > 0)
  3358. tm->tm_year = -(tm->tm_year - 1);
  3359. else
  3360. elog(ERROR, "Inconsistant use of year %04d and 'BC'", tm->tm_year);
  3361. }
  3362. else if (is2digits)
  3363. {
  3364. if (tm->tm_year < 70)
  3365. tm->tm_year += 2000;
  3366. else if (tm->tm_year < 100)
  3367. tm->tm_year += 1900;
  3368. }
  3370. return 0;
  3371. } /* DecodeDate() */
  3374. /* DecodeTime()
  3375.  * Decode time string which includes delimiters.
  3376.  * Only check the lower limit on hours, since this same code
  3377.  * can be used to represent time spans.
  3378.  */
  3379. static int
  3380. DecodeTime(char *str, int fmask, int *tmask, struct tm * tm, double *fsec)
  3381. {
  3382. char    *cp;
  3384. *tmask = DTK_TIME_M;
  3386. tm->tm_hour = strtol(str, &cp, 10);
  3387. if (*cp != ':')
  3388. return -1;
  3389. str = cp + 1;
  3390. tm->tm_min = strtol(str, &cp, 10);
  3391. if (*cp == '')
  3392. {
  3393. tm->tm_sec = 0;
  3394. *fsec = 0;
  3396. }
  3397. else if (*cp != ':')
  3398. {
  3399. return -1;
  3401. }
  3402. else
  3403. {
  3404. str = cp + 1;
  3405. tm->tm_sec = strtol(str, &cp, 10);
  3406. if (*cp == '')
  3407. *fsec = 0;
  3408. else if (*cp == '.')
  3409. {
  3410. str = cp;
  3411. *fsec = strtod(str, &cp);
  3412. if (cp == str)
  3413. return -1;
  3414. }
  3415. else
  3416. return -1;
  3417. }
  3419. /* do a sanity check */
  3420. if ((tm->tm_hour < 0)
  3421. || (tm->tm_min < 0) || (tm->tm_min > 59)
  3422. || (tm->tm_sec < 0) || (tm->tm_sec > 59))
  3423. return -1;
  3425. return 0;
  3426. } /* DecodeTime() */
  3429. /* DecodeNumber()
  3430.  * Interpret numeric field as a date value in context.
  3431.  */
  3432. static int
  3433. DecodeNumber(int flen, char *str, int fmask,
  3434.  int *tmask, struct tm * tm, double *fsec, int *is2digits)
  3435. {
  3436. int val;
  3437. char    *cp;
  3439. *tmask = 0;
  3441. val = strtol(str, &cp, 10);
  3442. if (cp == str)
  3443. return -1;
  3444. if (*cp == '.')
  3445. {
  3446. *fsec = strtod(cp, &cp);
  3447. if (*cp != '')
  3448. return -1;
  3449. }
  3451. #ifdef DATEDEBUG
  3452. printf("DecodeNumber- %s is %d fmask=%08x tmask=%08xn", str, val, fmask, *tmask);
  3453. #endif
  3455. /* Special case day of year? */
  3456. if ((flen == 3) && (fmask & DTK_M(YEAR))
  3457. && ((val >= 1) && (val <= 366)))
  3458. {
  3459. *tmask = (DTK_M(DOY) | DTK_M(MONTH) | DTK_M(DAY));
  3460. tm->tm_yday = val;
  3461. j2date((date2j(tm->tm_year, 1, 1) + tm->tm_yday - 1),
  3462.    &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
  3464. }
  3466. /*
  3467.  * Enough digits to be unequivocal year? Used to test for 4 digits or
  3468.  * more, but we now test first for a three-digit doy so anything
  3469.  * bigger than two digits had better be an explicit year. - thomas
  3470.  * 1999-01-09
  3471.  */
  3472. else if (flen > 2)
  3473. {
  3474. #ifdef DATEDEBUG
  3475. printf("DecodeNumber- match %d (%s) as yearn", val, str);
  3476. #endif
  3477. *tmask = DTK_M(YEAR);
  3479. /* already have a year? then see if we can substitute... */
  3480. if ((fmask & DTK_M(YEAR)) && (!(fmask & DTK_M(DAY)))
  3481. && ((tm->tm_year >= 1) && (tm->tm_year <= 31)))
  3482. {
  3483. tm->tm_mday = tm->tm_year;
  3484. *tmask = DTK_M(DAY);
  3485. #ifdef DATEDEBUG
  3486. printf("DecodeNumber- misidentified year previously; assign as day %dn", tm->tm_mday);
  3487. #endif
  3488. }
  3490. tm->tm_year = val;
  3492. }
  3493. /* already have year? then could be month */
  3494. else if ((fmask & DTK_M(YEAR)) && (!(fmask & DTK_M(MONTH)))
  3495.  && ((val >= 1) && (val <= 12)))
  3496. {
  3497. #ifdef DATEDEBUG
  3498. printf("DecodeNumber- match %d (%s) as monthn", val, str);
  3499. #endif
  3500. *tmask = DTK_M(MONTH);
  3501. tm->tm_mon = val;
  3503. /* no year and EuroDates enabled? then could be day */
  3504. }
  3505. else if ((EuroDates || (fmask & DTK_M(MONTH)))
  3506.  && (!(fmask & DTK_M(YEAR)) && !(fmask & DTK_M(DAY)))
  3507.  && ((val >= 1) && (val <= 31)))
  3508. {
  3509. #ifdef DATEDEBUG
  3510. printf("DecodeNumber- match %d (%s) as dayn", val, str);
  3511. #endif
  3512. *tmask = DTK_M(DAY);
  3513. tm->tm_mday = val;
  3515. }
  3516. else if ((!(fmask & DTK_M(MONTH)))
  3517.  && ((val >= 1) && (val <= 12)))
  3518. {
  3519. #ifdef DATEDEBUG
  3520. printf("DecodeNumber- (2) match %d (%s) as monthn", val, str);
  3521. #endif
  3522. *tmask = DTK_M(MONTH);
  3523. tm->tm_mon = val;
  3525. }
  3526. else if ((!(fmask & DTK_M(DAY)))
  3527.  && ((val >= 1) && (val <= 31)))
  3528. {
  3529. #ifdef DATEDEBUG
  3530. printf("DecodeNumber- (2) match %d (%s) as dayn", val, str);
  3531. #endif
  3532. *tmask = DTK_M(DAY);
  3533. tm->tm_mday = val;
  3535. }
  3536. else if (!(fmask & DTK_M(YEAR)))
  3537. {
  3538. #ifdef DATEDEBUG
  3539. printf("DecodeNumber- (2) match %d (%s) as yearn", val, str);
  3540. #endif
  3541. *tmask = DTK_M(YEAR);
  3542. tm->tm_year = val;
  3544. /* adjust ONLY if exactly two digits... */
  3545. *is2digits = (flen == 2);
  3547. }
  3548. else
  3549. return -1;
  3551. return 0;
  3552. } /* DecodeNumber() */
  3555. /* DecodeNumberField()
  3556.  * Interpret numeric string as a concatenated date field.
  3557.  */
  3558. static int
  3559. DecodeNumberField(int len, char *str, int fmask,
  3560. int *tmask, struct tm * tm, double *fsec, int *is2digits)
  3561. {
  3562. char    *cp;
  3564. /* yyyymmdd? */
  3565. if (len == 8)
  3566. {
  3567. #ifdef DATEDEBUG
  3568. printf("DecodeNumberField- %s is 8 character date fmask=%08x tmask=%08xn", str, fmask, *tmask);
  3569. #endif
  3571. *tmask = DTK_DATE_M;
  3573. tm->tm_mday = atoi(str + 6);
  3574. *(str + 6) = '';
  3575. tm->tm_mon = atoi(str + 4);
  3576. *(str + 4) = '';
  3577. tm->tm_year = atoi(str + 0);
  3579. /* yymmdd or hhmmss? */
  3580. }
  3581. else if (len == 6)
  3582. {
  3583. #ifdef DATEDEBUG
  3584. printf("DecodeNumberField- %s is 6 characters fmask=%08x tmask=%08xn", str, fmask, *tmask);
  3585. #endif
  3586. if (fmask & DTK_DATE_M)
  3587. {
  3588. #ifdef DATEDEBUG
  3589. printf("DecodeNumberField- %s is time field fmask=%08x tmask=%08xn", str, fmask, *tmask);
  3590. #endif
  3591. *tmask = DTK_TIME_M;
  3592. tm->tm_sec = atoi(str + 4);
  3593. *(str + 4) = '';
  3594. tm->tm_min = atoi(str + 2);
  3595. *(str + 2) = '';
  3596. tm->tm_hour = atoi(str + 0);
  3598. }
  3599. else
  3600. {
  3601. #ifdef DATEDEBUG
  3602. printf("DecodeNumberField- %s is date field fmask=%08x tmask=%08xn", str, fmask, *tmask);
  3603. #endif
  3604. *tmask = DTK_DATE_M;
  3605. tm->tm_mday = atoi(str + 4);
  3606. *(str + 4) = '';
  3607. tm->tm_mon = atoi(str + 2);
  3608. *(str + 2) = '';
  3609. tm->tm_year = atoi(str + 0);
  3610. *is2digits = TRUE;
  3611. }
  3613. }
  3614. else if ((len == 5) && !(fmask & DTK_DATE_M))
  3615. {
  3616. #ifdef DATEDEBUG
  3617. printf("DecodeNumberField- %s is 5 characters fmask=%08x tmask=%08xn", str, fmask, *tmask);
  3618. #endif
  3619. *tmask = DTK_DATE_M;
  3620. tm->tm_mday = atoi(str + 2);
  3621. *(str + 2) = '';
  3622. tm->tm_mon = 1;
  3623. tm->tm_year = atoi(str + 0);
  3624. *is2digits = TRUE;
  3625. }
  3626. else if (strchr(str, '.') != NULL)
  3627. {
  3628. #ifdef DATEDEBUG
  3629. printf("DecodeNumberField- %s is time field fmask=%08x tmask=%08xn", str, fmask, *tmask);
  3630. #endif
  3631. *tmask = DTK_TIME_M;
  3632. tm->tm_sec = strtod((str + 4), &cp);
  3633. if (cp == (str + 4))
  3634. return -1;
  3635. if (*cp == '.')
  3636. *fsec = strtod(cp, NULL);
  3637. *(str + 4) = '';
  3638. tm->tm_min = strtod((str + 2), &cp);
  3639. *(str + 2) = '';
  3640. tm->tm_hour = strtod((str + 0), &cp);
  3642. }
  3643. else
  3644. return -1;
  3646. return 0;
  3647. } /* DecodeNumberField() */
  3650. /* DecodeTimezone()
  3651.  * Interpret string as a numeric timezone.
  3652.  */
  3653. static int
  3654. DecodeTimezone(char *str, int *tzp)
  3655. {
  3656. int tz;
  3657. int hr,
  3658. min;
  3659. char    *cp;
  3660. int len;
  3662. /* assume leading character is "+" or "-" */
  3663. hr = strtol((str + 1), &cp, 10);
  3665. /* explicit delimiter? */
  3666. if (*cp == ':')
  3667. {
  3668. min = strtol((cp + 1), &cp, 10);
  3670. /* otherwise, might have run things together... */
  3671. }
  3672. else if ((*cp == '') && ((len = strlen(str)) > 3))
  3673. {
  3674. min = strtol((str + len - 2), &cp, 10);
  3675. *(str + len - 2) = '';
  3676. hr = strtol((str + 1), &cp, 10);
  3678. }
  3679. else
  3680. min = 0;
  3682. tz = (hr * 60 + min) * 60;
  3683. if (*str == '-')
  3684. tz = -tz;
  3686. *tzp = -tz;
  3687. return *cp != '';
  3688. } /* DecodeTimezone() */
  3691. /* DecodeSpecial()
  3692.  * Decode text string using lookup table.
  3693.  * Implement a cache lookup since it is likely that dates
  3694.  * will be related in format.
  3695.  */
  3696. static int
  3697. DecodeSpecial(int field, char *lowtoken, int *val)
  3698. {
  3699. int type;
  3700. datetkn    *tp;
  3702. #if USE_DATE_CACHE
  3703. if ((datecache[field] != NULL)
  3704. && (strncmp(lowtoken, datecache[field]->token, TOKMAXLEN) == 0))
  3705. tp = datecache[field];
  3706. else
  3707. {
  3708. #endif
  3709. tp = datebsearch(lowtoken, datetktbl, szdatetktbl);
  3710. #if USE_DATE_CACHE
  3711. }
  3712. datecache[field] = tp;
  3713. #endif
  3714. if (tp == NULL)
  3715. {
  3716. type = IGNORE;
  3717. *val = 0;
  3718. }
  3719. else
  3720. {
  3721. type = tp->type;
  3722. switch (type)
  3723. {
  3724. case TZ:
  3725. case DTZ:
  3726. case DTZMOD:
  3727. *val = FROMVAL(tp);
  3728. break;
  3730. default:
  3731. *val = tp->value;
  3732. break;
  3733. }
  3734. }
  3736. return type;
  3737. } /* DecodeSpecial() */
  3740. /* DecodeDateDelta()
  3741.  * Interpret previously parsed fields for general time interval.
  3742.  * Return 0 if decoded and -1 if problems.
  3743.  *
  3744.  * Allow "date" field DTK_DATE since this could be just
  3745.  * an unsigned floating point number. - thomas 1997-11-16
  3746.  *
  3747.  * Allow ISO-style time span, with implicit units on number of days
  3748.  * preceeding an hh:mm:ss field. - thomas 1998-04-30
  3749.  */
  3750. int
  3751. DecodeDateDelta(char **field, int *ftype, int nf, int *dtype, struct tm * tm, double *fsec)
  3752. {
  3753. int is_before = FALSE;
  3755. char    *cp;
  3756. int fmask = 0,
  3757. tmask,
  3758. type;
  3759. int i;
  3760. int flen,
  3761. val;
  3762. double fval;
  3763. double sec;
  3765. *dtype = DTK_DELTA;
  3767. type = DTK_SECOND;
  3768. tm->tm_year = 0;
  3769. tm->tm_mon = 0;
  3770. tm->tm_mday = 0;
  3771. tm->tm_hour = 0;
  3772. tm->tm_min = 0;
  3773. tm->tm_sec = 0;
  3774. *fsec = 0;
  3776. /* read through list backwards to pick up units before values */
  3777. for (i = nf - 1; i >= 0; i--)
  3778. {
  3779. #ifdef DATEDEBUG
  3780. printf("DecodeDateDelta- field[%d] is %s (type %d)n", i, field[i], ftype[i]);
  3781. #endif
  3782. switch (ftype[i])
  3783. {
  3784. case DTK_TIME:
  3785. if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
  3786. return -1;
  3787. type = DTK_DAY;
  3788. break;
  3790. case DTK_TZ:
  3792. /*
  3793.  * Timezone is a token with a leading sign character and
  3794.  * otherwise the same as a non-signed numeric field
  3795.  */
  3796. case DTK_DATE:
  3797. case DTK_NUMBER:
  3798. val = strtol(field[i], &cp, 10);
  3799. if (*cp == '.')
  3800. {
  3801. fval = strtod(cp, &cp);
  3802. if (*cp != '')
  3803. return -1;
  3805. if (val < 0)
  3806. fval = -(fval);
  3807. }
  3808. else if (*cp == '')
  3809. fval = 0;
  3810. else
  3811. return -1;
  3813. flen = strlen(field[i]);
  3814. tmask = 0; /* DTK_M(type); */
  3816. switch (type)
  3817. {
  3818. case DTK_MICROSEC:
  3819. *fsec += ((val + fval) * 1e-6);
  3820. break;
  3822. case DTK_MILLISEC:
  3823. *fsec += ((val + fval) * 1e-3);
  3824. break;
  3826. case DTK_SECOND:
  3827. tm->tm_sec += val;
  3828. *fsec += fval;
  3829. tmask = DTK_M(SECOND);
  3830. break;
  3832. case DTK_MINUTE:
  3833. tm->tm_min += val;
  3834. if (fval != 0)
  3835. tm->tm_sec += (fval * 60);
  3836. tmask = DTK_M(MINUTE);
  3837. break;
  3839. case DTK_HOUR:
  3840. tm->tm_hour += val;
  3841. if (fval != 0)
  3842. tm->tm_sec += (fval * 3600);
  3843. tmask = DTK_M(HOUR);
  3844. break;
  3846. case DTK_DAY:
  3847. tm->tm_mday += val;
  3848. if (fval != 0)
  3849. tm->tm_sec += (fval * 86400);
  3850. tmask = ((fmask & DTK_M(DAY)) ? 0 : DTK_M(DAY));
  3851. break;
  3853. case DTK_WEEK:
  3854. tm->tm_mday += val * 7;
  3855. if (fval != 0)
  3856. tm->tm_sec += (fval * (7 * 86400));
  3857. tmask = ((fmask & DTK_M(DAY)) ? 0 : DTK_M(DAY));
  3858. break;
  3860. case DTK_MONTH:
  3861. tm->tm_mon += val;
  3862. if (fval != 0)
  3863. tm->tm_sec += (fval * (30 * 86400));
  3864. tmask = DTK_M(MONTH);
  3865. break;
  3867. case DTK_YEAR:
  3868. tm->tm_year += val;
  3869. if (fval != 0)
  3870. tm->tm_mon += (fval * 12);
  3871. tmask = ((fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR));
  3872. break;
  3874. case DTK_DECADE:
  3875. tm->tm_year += val * 10;
  3876. if (fval != 0)
  3877. tm->tm_mon += (fval * 120);
  3878. tmask = ((fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR));
  3879. break;
  3881. case DTK_CENTURY:
  3882. tm->tm_year += val * 100;
  3883. if (fval != 0)
  3884. tm->tm_mon += (fval * 1200);
  3885. tmask = ((fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR));
  3886. break;
  3888. case DTK_MILLENIUM:
  3889. tm->tm_year += val * 1000;
  3890. if (fval != 0)
  3891. tm->tm_mon += (fval * 12000);
  3892. tmask = ((fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR));
  3893. break;
  3895. default:
  3896. return -1;
  3897. }
  3898. break;
  3900. case DTK_STRING:
  3901. case DTK_SPECIAL:
  3902. type = DecodeUnits(i, field[i], &val);
  3903. #ifdef DATEDEBUG
  3904. printf("DecodeDateDelta- special field[%d] %s type=%d value=%dn", i, field[i], type, val);
  3905. #endif
  3906. if (type == IGNORE)
  3907. continue;
  3909. tmask = 0; /* DTK_M(type); */
  3910. switch (type)
  3911. {
  3912. case UNITS:
  3913. #ifdef DATEDEBUG
  3914. printf("DecodeDateDelta- UNITS field %s value is %dn", field[i], val);
  3915. #endif
  3916. type = val;
  3917. break;
  3919. case AGO:
  3920. is_before = TRUE;
  3921. type = val;
  3922. break;
  3924. case RESERV:
  3925. tmask = (DTK_DATE_M || DTK_TIME_M);
  3926. *dtype = val;
  3927. break;
  3929. default:
  3930. return -1;
  3931. }
  3932. break;
  3934. default:
  3935. return -1;
  3936. }
  3938. #ifdef DATEDEBUG
  3939. printf("DecodeDateDelta- (%08x/%08x) field[%d] %s value is %dn",
  3940.    fmask, tmask, i, field[i], val);
  3941. #endif
  3943. if (tmask & fmask)
  3944. return -1;
  3945. fmask |= tmask;
  3946. }
  3948. if (*fsec != 0)
  3949. {
  3950. TMODULO(*fsec, sec, 1e0);
  3951. tm->tm_sec += sec;
  3952. }
  3954. if (is_before)
  3955. {
  3956. *fsec = -(*fsec);
  3957. tm->tm_sec = -(tm->tm_sec);
  3958. tm->tm_min = -(tm->tm_min);
  3959. tm->tm_hour = -(tm->tm_hour);
  3960. tm->tm_mday = -(tm->tm_mday);
  3961. tm->tm_mon = -(tm->tm_mon);
  3962. tm->tm_year = -(tm->tm_year);
  3963. }
  3965. #ifdef DATEDEBUG
  3966. printf("DecodeDateDelta- mask %08x (%08x)", fmask, DTK_DATE_M);
  3967. printf(" set y%04d m%02d d%02d", tm->tm_year, tm->tm_mon, tm->tm_mday);
  3968. printf(" %02d:%02d:%02dn", tm->tm_hour, tm->tm_min, tm->tm_sec);
  3969. #endif
  3971. /* ensure that at least one time field has been found */
  3972. return (fmask != 0) ? 0 : -1;
  3973. } /* DecodeDateDelta() */
  3976. /* DecodeUnits()
  3977.  * Decode text string using lookup table.
  3978.  * This routine supports time interval decoding.
  3979.  */
  3980. static int
  3981. DecodeUnits(int field, char *lowtoken, int *val)
  3982. {
  3983. int type;
  3984. datetkn    *tp;
  3986. #if USE_DATE_CACHE
  3987. if ((deltacache[field] != NULL)
  3988. && (strncmp(lowtoken, deltacache[field]->token, TOKMAXLEN) == 0))
  3989. tp = deltacache[field];
  3990. else
  3991. {
  3992. #endif
  3993. tp = datebsearch(lowtoken, deltatktbl, szdeltatktbl);
  3994. #if USE_DATE_CACHE
  3995. }
  3996. deltacache[field] = tp;
  3997. #endif
  3998. if (tp == NULL)
  3999. {
  4000. type = IGNORE;
  4001. *val = 0;
  4002. }
  4003. else
  4004. {
  4005. type = tp->type;
  4006. if ((type == TZ) || (type == DTZ))
  4007. *val = FROMVAL(tp);
  4008. else
  4009. *val = tp->value;
  4010. }
  4012. return type;
  4013. } /* DecodeUnits() */
  4016. /* datebsearch()
  4017.  * Binary search -- from Knuth (6.2.1) Algorithm B.  Special case like this
  4018.  * is WAY faster than the generic bsearch().
  4019.  */
  4020. static datetkn *
  4021. datebsearch(char *key, datetkn *base, unsigned int nel)
  4022. {
  4023. datetkn    *last = base + nel - 1,
  4024.    *position;
  4025. int result;
  4027. while (last >= base)
  4028. {
  4029. position = base + ((last - base) >> 1);
  4030. result = key[0] - position->token[0];
  4031. if (result == 0)
  4032. {
  4033. result = strncmp(key, position->token, TOKMAXLEN);
  4034. if (result == 0)
  4035. return position;
  4036. }
  4037. if (result < 0)
  4038. last = position - 1;
  4039. else
  4040. base = position + 1;
  4041. }
  4042. return NULL;
  4043. }
  4046. /* EncodeSpecialDateTime()
  4047.  * Convert reserved datetime data type to string.
  4048.  */
  4049. static int
  4050. EncodeSpecialDateTime(DateTime dt, char *str)
  4051. {
  4052. if (DATETIME_IS_RESERVED(dt))
  4053. {
  4054. if (DATETIME_IS_INVALID(dt))
  4055. {
  4056. strcpy(str, INVALID);
  4058. }
  4059. else if (DATETIME_IS_NOBEGIN(dt))
  4060. {
  4061. strcpy(str, EARLY);
  4063. }
  4064. else if (DATETIME_IS_NOEND(dt))
  4065. {
  4066. strcpy(str, LATE);
  4068. }
  4069. else if (DATETIME_IS_CURRENT(dt))
  4070. {
  4071. strcpy(str, DCURRENT);
  4073. }
  4074. else if (DATETIME_IS_EPOCH(dt))
  4075. {
  4076. strcpy(str, EPOCH);
  4078. }
  4079. else
  4080. {
  4081. #ifdef DATEDEBUG
  4082. printf("EncodeSpecialDateTime- unrecognized daten");
  4083. #endif
  4084. strcpy(str, INVALID);
  4085. }
  4086. return TRUE;
  4087. }
  4089. return FALSE;
  4090. } /* EncodeSpecialDateTime() */
  4093. /* EncodeDateOnly()
  4094.  * Encode date as local time.
  4095.  */
  4096. int
  4097. EncodeDateOnly(struct tm * tm, int style, char *str)
  4098. {
  4099. if ((tm->tm_mon < 1) || (tm->tm_mon > 12))
  4100. return -1;
  4102. switch (style)
  4103. {
  4104. /* compatible with ISO date formats */
  4105. case USE_ISO_DATES:
  4106. if (tm->tm_year > 0)
  4107. sprintf(str, "%04d-%02d-%02d",
  4108. tm->tm_year, tm->tm_mon, tm->tm_mday);
  4109. else
  4110. sprintf(str, "%04d-%02d-%02d %s",
  4111.   -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, "BC");
  4112. break;
  4114. /* compatible with Oracle/Ingres date formats */
  4115. case USE_SQL_DATES:
  4116. if (EuroDates)
  4117. sprintf(str, "%02d/%02d", tm->tm_mday, tm->tm_mon);
  4118. else
  4119. sprintf(str, "%02d/%02d", tm->tm_mon, tm->tm_mday);
  4120. if (tm->tm_year > 0)
  4121. sprintf((str + 5), "/%04d", tm->tm_year);
  4122. else
  4123. sprintf((str + 5), "/%04d %s", -(tm->tm_year - 1), "BC");
  4124. break;
  4126. /* German-style date format */
  4127. case USE_GERMAN_DATES:
  4128. sprintf(str, "%02d.%02d", tm->tm_mday, tm->tm_mon);
  4129. if (tm->tm_year > 0)
  4130. sprintf((str + 5), ".%04d", tm->tm_year);
  4131. else
  4132. sprintf((str + 5), ".%04d %s", -(tm->tm_year - 1), "BC");
  4133. break;
  4135. /* traditional date-only style for Postgres */
  4136. case USE_POSTGRES_DATES:
  4137. default:
  4138. if (EuroDates)
  4139. sprintf(str, "%02d-%02d", tm->tm_mday, tm->tm_mon);
  4140. else
  4141. sprintf(str, "%02d-%02d", tm->tm_mon, tm->tm_mday);
  4142. if (tm->tm_year > 0)
  4143. sprintf((str + 5), "-%04d", tm->tm_year);
  4144. else
  4145. sprintf((str + 5), "-%04d %s", -(tm->tm_year - 1), "BC");
  4146. break;
  4147. }
  4149. #ifdef DATEDEBUG
  4150. printf("EncodeDateOnly- date result is %sn", str);
  4151. #endif
  4153. return TRUE;
  4154. } /* EncodeDateOnly() */
  4157. /* EncodeTimeOnly()
  4158.  * Encode time fields only.
  4159.  */
  4160. int
  4161. EncodeTimeOnly(struct tm * tm, double fsec, int style, char *str)
  4162. {
  4163. double sec;
  4165. if ((tm->tm_hour < 0) || (tm->tm_hour > 24))
  4166. return -1;
  4168. sec = (tm->tm_sec + fsec);
  4170. sprintf(str, "%02d:%02d:", tm->tm_hour, tm->tm_min);
  4171. sprintf((str + 6), ((fsec != 0) ? "%05.2f" : "%02.0f"), sec);
  4173. #ifdef DATEDEBUG
  4174. printf("EncodeTimeOnly- time result is %sn", str);
  4175. #endif
  4177. return TRUE;
  4178. } /* EncodeTimeOnly() */
  4181. /* EncodeDateTime()
  4182.  * Encode date and time interpreted as local time.
  4183.  * Support several date styles:
  4184.  * Postgres - day mon hh:mm:ss yyyy tz
  4185.  * SQL - mm/dd/yyyy hh:mm:ss.ss tz
  4186.  * ISO - yyyy-mm-dd hh:mm:ss+/-tz
  4187.  * German - dd.mm/yyyy hh:mm:ss tz
  4188.  * Variants (affects order of month and day for Postgres and SQL styles):
  4189.  * US - mm/dd/yyyy
  4190.  * European - dd/mm/yyyy
  4191.  */
  4192. int
  4193. EncodeDateTime(struct tm * tm, double fsec, int *tzp, char **tzn, int style, char *str)
  4194. {
  4195. int day,
  4196. hour,
  4197. min;
  4198. double sec;
  4200. if ((tm->tm_mon < 1) || (tm->tm_mon > 12))
  4201. return -1;
  4203. sec = (tm->tm_sec + fsec);
  4205. #ifdef DATEDEBUG
  4206. #ifdef USE_POSIX_TIME
  4207. #if defined(HAVE_TM_ZONE)
  4208. printf("EncodeDateTime- timezone is %s (%s); offset is %ld (%d); daylight is %d (%d)n",
  4209.    *tzn, tm->tm_zone, (-tm->tm_gmtoff), CTimeZone, tm->tm_isdst, CDayLight);
  4210. #elif defined(HAVE_INT_TIMEZONE)
  4211. printf("EncodeDateTime- timezone is %s (%s); offset is %d (%d); daylight is %d (%d)n",
  4212.    *tzn, tzname[0], *tzp, CTimeZone, tm->tm_isdst, CDayLight);
  4213. #else
  4214. #error USE_POSIX_TIME is defined but neither HAVE_TM_ZONE or HAVE_INT_TIMEZONE are defined
  4215. #endif
  4216. #else
  4217. printf("EncodeDateTime- timezone is %s (%s); offset is %d; daylight is %dn",
  4218.    *tzn, CTZName, CTimeZone, CDayLight);
  4219. #endif
  4220. #endif
  4222. switch (style)
  4223. {
  4224. /* compatible with ISO date formats */
  4226. case USE_ISO_DATES:
  4227. if (tm->tm_year > 0)
  4228. {
  4229. sprintf(str, "%04d-%02d-%02d %02d:%02d:",
  4230. tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min);
  4231. sprintf((str + 17), ((fsec != 0) ? "%05.2f" : "%02.0f"), sec);
  4233. if ((*tzn != NULL) && (tm->tm_isdst >= 0))
  4234. {
  4235. if (tzp != NULL)
  4236. {
  4237. hour = -(*tzp / 3600);
  4238. min = ((abs(*tzp) / 60) % 60);
  4239. }
  4240. else
  4241. {
  4242. hour = 0;
  4243. min = 0;
  4244. }
  4245. sprintf((str + strlen(str)), ((min != 0) ? "%+03d:%02d" : "%+03d"), hour, min);
  4246. }
  4248. }
  4249. else
  4250. {
  4251. if (tm->tm_hour || tm->tm_min)
  4252. sprintf(str, "%04d-%02d-%02d %02d:%02d %s",
  4253. -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, "BC");
  4254. else
  4255. sprintf(str, "%04d-%02d-%02d %s",
  4256.   -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, "BC");
  4257. }
  4258. break;
  4260. /* compatible with Oracle/Ingres date formats */
  4261. case USE_SQL_DATES:
  4262. if (EuroDates)
  4263. sprintf(str, "%02d/%02d", tm->tm_mday, tm->tm_mon);
  4264. else
  4265. sprintf(str, "%02d/%02d", tm->tm_mon, tm->tm_mday);
  4267. if (tm->tm_year > 0)
  4268. {
  4269. sprintf((str + 5), "/%04d %02d:%02d:%05.2f",
  4270. tm->tm_year, tm->tm_hour, tm->tm_min, sec);
  4272. if ((*tzn != NULL) && (tm->tm_isdst >= 0))
  4273. {
  4274. strcpy((str + 22), " ");
  4275. strcpy((str + 23), *tzn);
  4276. }
  4278. }
  4279. else
  4280. sprintf((str + 5), "/%04d %02d:%02d %s",
  4281.   -(tm->tm_year - 1), tm->tm_hour, tm->tm_min, "BC");
  4282. break;
  4284. /* German variant on European style */
  4285. case USE_GERMAN_DATES:
  4286. sprintf(str, "%02d.%02d", tm->tm_mday, tm->tm_mon);
  4287. if (tm->tm_year > 0)
  4288. {
  4289. sprintf((str + 5), ".%04d %02d:%02d:%05.2f",
  4290. tm->tm_year, tm->tm_hour, tm->tm_min, sec);
  4292. if ((*tzn != NULL) && (tm->tm_isdst >= 0))
  4293. {
  4294. strcpy((str + 22), " ");
  4295. strcpy((str + 23), *tzn);
  4296. }
  4298. }
  4299. else
  4300. sprintf((str + 5), ".%04d %02d:%02d %s",
  4301.   -(tm->tm_year - 1), tm->tm_hour, tm->tm_min, "BC");
  4302. break;
  4304. /* backward-compatible with traditional Postgres abstime dates */
  4305. case USE_POSTGRES_DATES:
  4306. default:
  4307. day = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday);
  4308. #ifdef DATEDEBUG
  4309. printf("EncodeDateTime- day is %dn", day);
  4310. #endif
  4311. tm->tm_wday = j2day(day);
  4313. strncpy(str, days[tm->tm_wday], 3);
  4314. strcpy((str + 3), " ");
  4316. if (EuroDates)
  4317. sprintf((str + 4), "%02d %3s", tm->tm_mday, months[tm->tm_mon - 1]);
  4318. else
  4319. sprintf((str + 4), "%3s %02d", months[tm->tm_mon - 1], tm->tm_mday);
  4321. if (tm->tm_year > 0)
  4322. {
  4323. sprintf((str + 10), " %02d:%02d", tm->tm_hour, tm->tm_min);
  4324. if (fsec != 0)
  4325. {
  4326. sprintf((str + 16), ":%05.2f %04d", sec, tm->tm_year);
  4327. if ((*tzn != NULL) && (tm->tm_isdst >= 0))
  4328. {
  4329. strcpy((str + 27), " ");
  4330. strcpy((str + 28), *tzn);
  4331. }
  4332. }
  4333. else
  4334. {
  4335. sprintf((str + 16), ":%02.0f %04d", sec, tm->tm_year);
  4336. if ((*tzn != NULL) && (tm->tm_isdst >= 0))
  4337. {
  4338. strcpy((str + 24), " ");
  4339. strcpy((str + 25), *tzn);
  4340. }
  4341. }
  4343. }
  4344. else
  4345. {
  4346. sprintf((str + 10), " %02d:%02d %04d %s",
  4347.   tm->tm_hour, tm->tm_min, -(tm->tm_year - 1), "BC");
  4348. }
  4349. break;
  4350. }
  4352. #ifdef DATEDEBUG
  4353. printf("EncodeDateTime- date result is %sn", str);
  4354. #endif
  4356. return TRUE;
  4357. } /* EncodeDateTime() */
  4360. /* EncodeTimeSpan()
  4361.  * Interpret time structure as a delta time and convert to string.
  4362.  *
  4363.  * Support "traditional Postgres" and ISO-8601 styles.
  4364.  * Actually, afaik ISO does not address time interval formatting,
  4365.  * but this looks similar to the spec for absolute date/time.
  4366.  * - thomas 1998-04-30
  4367.  */
  4368. int
  4369. EncodeTimeSpan(struct tm * tm, double fsec, int style, char *str)
  4370. {
  4371. int is_before = FALSE;
  4372. int is_nonzero = FALSE;
  4373. char    *cp = str;
  4375. switch (style)
  4376. {
  4377. /* compatible with ISO date formats */
  4378. case USE_ISO_DATES:
  4379. break;
  4381. default:
  4382. strcpy(cp, "@ ");
  4383. cp += strlen(cp);
  4384. break;
  4385. }
  4387. if (tm->tm_year != 0)
  4388. {
  4389. is_before |= (tm->tm_year < 0);
  4390. sprintf(cp, "%d year%s",
  4391. abs(tm->tm_year), ((abs(tm->tm_year) != 1) ? "s" : ""));
  4392. cp += strlen(cp);
  4393. is_nonzero = TRUE;
  4394. }
  4396. if (tm->tm_mon != 0)
  4397. {
  4398. is_before |= (tm->tm_mon < 0);
  4399. sprintf(cp, "%s%d mon%s", (is_nonzero ? " " : ""),
  4400. abs(tm->tm_mon), ((abs(tm->tm_mon) != 1) ? "s" : ""));
  4401. cp += strlen(cp);
  4402. is_nonzero = TRUE;
  4403. }
  4405. switch (style)
  4406. {
  4407. /* compatible with ISO date formats */
  4408. case USE_ISO_DATES:
  4409. if (tm->tm_mday != 0)
  4410. {
  4411. is_before |= (tm->tm_mday < 0);
  4412. sprintf(cp, "%s%d", (is_nonzero ? " " : ""), abs(tm->tm_mday));
  4413. cp += strlen(cp);
  4414. is_nonzero = TRUE;
  4415. }
  4416. is_before |= ((tm->tm_hour < 0) || (tm->tm_min < 0));
  4417. sprintf(cp, "%s%02d:%02d", (is_nonzero ? " " : ""),
  4418. abs(tm->tm_hour), abs(tm->tm_min));
  4419. cp += strlen(cp);
  4420. if ((tm->tm_hour != 0) || (tm->tm_min != 0))
  4421. is_nonzero = TRUE;
  4423. /* fractional seconds? */
  4424. if (fsec != 0)
  4425. {
  4426. fsec += tm->tm_sec;
  4427. is_before |= (fsec < 0);
  4428. sprintf(cp, ":%05.2f", fabs(fsec));
  4429. cp += strlen(cp);
  4430. is_nonzero = TRUE;
  4432. /* otherwise, integer seconds only? */
  4433. }
  4434. else if (tm->tm_sec != 0)
  4435. {
  4436. is_before |= (tm->tm_sec < 0);
  4437. sprintf(cp, ":%02d", abs(tm->tm_sec));
  4438. cp += strlen(cp);
  4439. is_nonzero = TRUE;
  4440. }
  4441. break;
  4443. case USE_POSTGRES_DATES:
  4444. default:
  4445. if (tm->tm_mday != 0)
  4446. {
  4447. is_before |= (tm->tm_mday < 0);
  4448. sprintf(cp, "%s%d day%s", (is_nonzero ? " " : ""),
  4449.  abs(tm->tm_mday), ((abs(tm->tm_mday) != 1) ? "s" : ""));
  4450. cp += strlen(cp);
  4451. is_nonzero = TRUE;
  4452. }
  4453. if (tm->tm_hour != 0)
  4454. {
  4455. is_before |= (tm->tm_hour < 0);
  4456. sprintf(cp, "%s%d hour%s", (is_nonzero ? " " : ""),
  4457.  abs(tm->tm_hour), ((abs(tm->tm_hour) != 1) ? "s" : ""));
  4458. cp += strlen(cp);
  4459. is_nonzero = TRUE;
  4460. }
  4462. if (tm->tm_min != 0)
  4463. {
  4464. is_before |= (tm->tm_min < 0);
  4465. sprintf(cp, "%s%d min%s", (is_nonzero ? " " : ""),
  4466.    abs(tm->tm_min), ((abs(tm->tm_min) != 1) ? "s" : ""));
  4467. cp += strlen(cp);
  4468. is_nonzero = TRUE;
  4469. }
  4471. /* fractional seconds? */
  4472. if (fsec != 0)
  4473. {
  4474. fsec += tm->tm_sec;
  4475. is_before |= (fsec < 0);
  4476. sprintf(cp, "%s%.2f secs", (is_nonzero ? " " : ""), fabs(fsec));
  4477. cp += strlen(cp);
  4478. is_nonzero = TRUE;
  4480. /* otherwise, integer seconds only? */
  4481. }
  4482. else if (tm->tm_sec != 0)
  4483. {
  4484. is_before |= (tm->tm_sec < 0);
  4485. sprintf(cp, "%s%d sec%s", (is_nonzero ? " " : ""),
  4486.    abs(tm->tm_sec), ((abs(tm->tm_sec) != 1) ? "s" : ""));
  4487. cp += strlen(cp);
  4488. is_nonzero = TRUE;
  4489. }
  4490. break;
  4491. }
  4493. /* identically zero? then put in a unitless zero... */
  4494. if (!is_nonzero)
  4495. {
  4496. strcat(cp, "0");
  4497. cp += strlen(cp);
  4498. }
  4500. if (is_before)
  4501. {
  4502. strcat(cp, " ago");
  4503. cp += strlen(cp);
  4504. }
  4506. #ifdef DATEDEBUG
  4507. printf("EncodeTimeSpan- result is %sn", str);
  4508. #endif
  4510. return 0;
  4511. } /* EncodeTimeSpan() */
  4514. #if defined(linux) && defined(__powerpc__)
  4515. int
  4516. datetime_is_epoch(double j)
  4517. {
  4518. static union
  4519. {
  4520. double epoch;
  4521. unsigned char c[8];
  4522. } u;
  4524. u.c[0] = 0x80; /* sign bit */
  4525. u.c[1] = 0x10; /* DBL_MIN */
  4527. return j == u.epoch;
  4528. }
  4529. int
  4530. datetime_is_current(double j)
  4531. {
  4532. static union
  4533. {
  4534. double current;
  4535. unsigned char c[8];
  4536. } u;
  4538. u.c[1] = 0x10; /* DBL_MIN */
  4540. return j == u.current;
  4541. }
  4543. #endif