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

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

数据库系统

开发平台：

Unix_Linux

datetime.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * datetime.c
  4.  *   implements DATE and TIME data types specified in SQL-92 standard
  5.  *
  6.  * Copyright (c) 1994-5, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.33.2.1 1999/08/02 05:24:51 scrappy Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. #include <limits.h>
  16. #include "postgres.h"
  17. #ifdef HAVE_FLOAT_H
  18. #include <float.h>
  19. #endif
  20. #include "miscadmin.h"
  21. #include "utils/builtins.h"
  23. static int date2tm(DateADT dateVal, int *tzp, struct tm * tm, double *fsec, char **tzn);
  26. /*****************************************************************************
  27.  *  Date ADT
  28.  *****************************************************************************/
  31. /* date_in()
  32.  * Given date text string, convert to internal date format.
  33.  */
  34. DateADT
  35. date_in(char *str)
  36. {
  37. DateADT date;
  38. double fsec;
  39. struct tm tt,
  40.    *tm = &tt;
  41. int tzp;
  42. int dtype;
  43. int nf;
  44. char    *field[MAXDATEFIELDS];
  45. int ftype[MAXDATEFIELDS];
  46. char lowstr[MAXDATELEN + 1];
  48. if (!PointerIsValid(str))
  49. elog(ERROR, "Bad (null) date external representation", NULL);
  51. #ifdef DATEDEBUG
  52. printf("date_in- input string is %sn", str);
  53. #endif
  54. if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
  55.  || (DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tzp) != 0))
  56. elog(ERROR, "Bad date external representation '%s'", str);
  58. switch (dtype)
  59. {
  60. case DTK_DATE:
  61. break;
  63. case DTK_CURRENT:
  64. GetCurrentTime(tm);
  65. break;
  67. case DTK_EPOCH:
  68. tm->tm_year = 1970;
  69. tm->tm_mon = 1;
  70. tm->tm_mday = 1;
  71. break;
  73. default:
  74. elog(ERROR, "Unrecognized date external representation '%s'", str);
  75. }
  77. date = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1));
  79. return date;
  80. } /* date_in() */
  82. /* date_out()
  83.  * Given internal format date, convert to text string.
  84.  */
  85. char *
  86. date_out(DateADT date)
  87. {
  88. char    *result;
  89. struct tm tt,
  90.    *tm = &tt;
  91. char buf[MAXDATELEN + 1];
  93. j2date((date + date2j(2000, 1, 1)),
  94.    &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
  96. EncodeDateOnly(tm, DateStyle, buf);
  98. result = palloc(strlen(buf) + 1);
  100. strcpy(result, buf);
  102. return result;
  103. } /* date_out() */
  105. bool
  106. date_eq(DateADT dateVal1, DateADT dateVal2)
  107. {
  108. return dateVal1 == dateVal2;
  109. }
  111. bool
  112. date_ne(DateADT dateVal1, DateADT dateVal2)
  113. {
  114. return dateVal1 != dateVal2;
  115. }
  117. bool
  118. date_lt(DateADT dateVal1, DateADT dateVal2)
  119. {
  120. return dateVal1 < dateVal2;
  121. } /* date_lt() */
  123. bool
  124. date_le(DateADT dateVal1, DateADT dateVal2)
  125. {
  126. return dateVal1 <= dateVal2;
  127. } /* date_le() */
  129. bool
  130. date_gt(DateADT dateVal1, DateADT dateVal2)
  131. {
  132. return dateVal1 > dateVal2;
  133. } /* date_gt() */
  135. bool
  136. date_ge(DateADT dateVal1, DateADT dateVal2)
  137. {
  138. return dateVal1 >= dateVal2;
  139. } /* date_ge() */
  141. int
  142. date_cmp(DateADT dateVal1, DateADT dateVal2)
  143. {
  144. if (dateVal1 < dateVal2)
  145. return -1;
  146. else if (dateVal1 > dateVal2)
  147. return 1;
  148. return 0;
  149. } /* date_cmp() */
  151. DateADT
  152. date_larger(DateADT dateVal1, DateADT dateVal2)
  153. {
  154. return date_gt(dateVal1, dateVal2) ? dateVal1 : dateVal2;
  155. } /* date_larger() */
  157. DateADT
  158. date_smaller(DateADT dateVal1, DateADT dateVal2)
  159. {
  160. return date_lt(dateVal1, dateVal2) ? dateVal1 : dateVal2;
  161. } /* date_smaller() */
  163. /* Compute difference between two dates in days.
  164.  */
  165. int4
  166. date_mi(DateADT dateVal1, DateADT dateVal2)
  167. {
  168. return dateVal1 - dateVal2;
  169. } /* date_mi() */
  171. /* Add a number of days to a date, giving a new date.
  172.  * Must handle both positive and negative numbers of days.
  173.  */
  174. DateADT
  175. date_pli(DateADT dateVal, int4 days)
  176. {
  177. return dateVal + days;
  178. } /* date_pli() */
  180. /* Subtract a number of days from a date, giving a new date.
  181.  */
  182. DateADT
  183. date_mii(DateADT dateVal, int4 days)
  184. {
  185. return date_pli(dateVal, -days);
  186. } /* date_mii() */
  189. /* date_datetime()
  190.  * Convert date to datetime data type.
  191.  */
  192. DateTime   *
  193. date_datetime(DateADT dateVal)
  194. {
  195. DateTime   *result;
  196. struct tm tt,
  197.    *tm = &tt;
  198. int tz;
  199. double fsec = 0;
  200. char    *tzn;
  202. result = palloc(sizeof(DateTime));
  204. if (date2tm(dateVal, &tz, tm, &fsec, &tzn) != 0)
  205. elog(ERROR, "Unable to convert date to datetime", NULL);
  207. #ifdef DATEDEBUG
  208. printf("date_datetime- date is %d.%02d.%02dn", tm->tm_year, tm->tm_mon, tm->tm_mday);
  209. printf("date_datetime- time is %02d:%02d:%02d %.7fn", tm->tm_hour, tm->tm_min, tm->tm_sec, fsec);
  210. #endif
  212. if (tm2datetime(tm, fsec, &tz, result) != 0)
  213. elog(ERROR, "Datetime out of range", NULL);
  215. return result;
  216. } /* date_datetime() */
  219. /* datetime_date()
  220.  * Convert datetime to date data type.
  221.  */
  222. DateADT
  223. datetime_date(DateTime *datetime)
  224. {
  225. DateADT result;
  226. struct tm tt,
  227.    *tm = &tt;
  228. int tz;
  229. double fsec;
  230. char    *tzn;
  232. if (!PointerIsValid(datetime))
  233. elog(ERROR, "Unable to convert null datetime to date", NULL);
  235. if (DATETIME_NOT_FINITE(*datetime))
  236. elog(ERROR, "Unable to convert datetime to date", NULL);
  238. if (DATETIME_IS_EPOCH(*datetime))
  239. {
  240. datetime2tm(SetDateTime(*datetime), NULL, tm, &fsec, NULL);
  242. }
  243. else if (DATETIME_IS_CURRENT(*datetime))
  244. {
  245. datetime2tm(SetDateTime(*datetime), &tz, tm, &fsec, &tzn);
  247. }
  248. else
  249. {
  250. if (datetime2tm(*datetime, &tz, tm, &fsec, &tzn) != 0)
  251. elog(ERROR, "Unable to convert datetime to date", NULL);
  252. }
  254. result = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1));
  256. return result;
  257. } /* datetime_date() */
  260. /* abstime_date()
  261.  * Convert abstime to date data type.
  262.  */
  263. DateADT
  264. abstime_date(AbsoluteTime abstime)
  265. {
  266. DateADT result;
  267. struct tm tt,
  268.    *tm = &tt;
  269. int tz;
  271. switch (abstime)
  272. {
  273. case INVALID_ABSTIME:
  274. case NOSTART_ABSTIME:
  275. case NOEND_ABSTIME:
  276. elog(ERROR, "Unable to convert reserved abstime value to date", NULL);
  278. /*
  279.  * pretend to drop through to make compiler think that result
  280.  * will be set
  281.  */
  283. case EPOCH_ABSTIME:
  284. result = date2j(1970, 1, 1) - date2j(2000, 1, 1);
  285. break;
  287. case CURRENT_ABSTIME:
  288. GetCurrentTime(tm);
  289. result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1);
  290. break;
  292. default:
  293. abstime2tm(abstime, &tz, tm, NULL);
  294. result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1);
  295. break;
  296. }
  298. return result;
  299. } /* abstime_date() */
  302. /* date2tm()
  303.  * Convert date to time structure.
  304.  * Note that date is an implicit local time, but the system calls assume
  305.  * that everything is GMT. So, convert to GMT, rotate to local time,
  306.  * and then convert again to try to get the time zones correct.
  307.  */
  308. static int
  309. date2tm(DateADT dateVal, int *tzp, struct tm * tm, double *fsec, char **tzn)
  310. {
  311. struct tm  *tx;
  312. time_t utime;
  314. *fsec = 0;
  316. j2date((dateVal + date2j(2000, 1, 1)), &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
  317. tm->tm_hour = 0;
  318. tm->tm_min = 0;
  319. tm->tm_sec = 0;
  320. tm->tm_isdst = -1;
  322. if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon, tm->tm_mday))
  323. {
  325. /* convert to system time */
  326. utime = ((dateVal + (date2j(2000, 1, 1) - date2j(1970, 1, 1))) * 86400);
  327. /* rotate to noon to get the right day in time zone */
  328. utime += (12 * 60 * 60);
  330. #ifdef USE_POSIX_TIME
  331. tx = localtime(&utime);
  333. #ifdef DATEDEBUG
  334. #if defined(HAVE_TM_ZONE)
  335. printf("date2tm- (localtime) %d.%02d.%02d %02d:%02d:%02.0f %s dst=%dn",
  336.    tx->tm_year, tx->tm_mon, tx->tm_mday, tx->tm_hour, tx->tm_min, (double) tm->tm_sec,
  337.    tx->tm_zone, tx->tm_isdst);
  338. #elif defined(HAVE_INT_TIMEZONE)
  339. printf("date2tm- (localtime) %d.%02d.%02d %02d:%02d:%02.0f %s %s dst=%dn",
  340.    tx->tm_year, tx->tm_mon, tx->tm_mday, tx->tm_hour, tx->tm_min, (double) tm->tm_sec,
  341.    tzname[0], tzname[1], tx->tm_isdst);
  342. #endif
  343. #endif
  344. tm->tm_year = tx->tm_year + 1900;
  345. tm->tm_mon = tx->tm_mon + 1;
  346. tm->tm_mday = tx->tm_mday;
  347. tm->tm_isdst = tx->tm_isdst;
  349. #if defined(HAVE_TM_ZONE)
  350. tm->tm_gmtoff = tx->tm_gmtoff;
  351. tm->tm_zone = tx->tm_zone;
  353. /* tm_gmtoff is Sun/DEC-ism */
  354. *tzp = -(tm->tm_gmtoff);
  355. if (tzn != NULL)
  356. *tzn = (char *) tm->tm_zone;
  357. #elif defined(HAVE_INT_TIMEZONE)
  358. #ifdef __CYGWIN__
  359. *tzp = (tm->tm_isdst ? (_timezone - 3600) : _timezone);
  360. #else
  361. *tzp = (tm->tm_isdst ? (timezone - 3600) : timezone);
  362. #endif
  363. if (tzn != NULL)
  364. *tzn = tzname[(tm->tm_isdst > 0)];
  365. #else
  366. #error USE_POSIX_TIME is defined but neither HAVE_TM_ZONE or HAVE_INT_TIMEZONE are defined
  367. #endif
  368. #else /* !USE_POSIX_TIME */
  369. *tzp = CTimeZone; /* V7 conventions; don't know timezone? */
  370. if (tzn != NULL)
  371. *tzn = CTZName;
  372. #endif
  374. /* otherwise, outside of timezone range so convert to GMT... */
  375. }
  376. else
  377. {
  378. #ifdef DATEDEBUG
  379. printf("date2tm- convert %d-%d-%d %d:%d%d to datetimen",
  380.    tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
  381. #endif
  383. *tzp = 0;
  384. tm->tm_isdst = 0;
  385. if (tzn != NULL)
  386. *tzn = NULL;
  387. }
  389. #ifdef DATEDEBUG
  390. #if defined(HAVE_TM_ZONE)
  391. printf("date2tm- %d.%02d.%02d %02d:%02d:%02.0f (%d %s) dst=%dn",
  392.    tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, (double) tm->tm_sec,
  393.    *tzp, tm->tm_zone, tm->tm_isdst);
  394. #elif defined(HAVE_INT_TIMEZONE)
  395. printf("date2tm- %d.%02d.%02d %02d:%02d:%02.0f (%d %s %s) dst=%dn",
  396.    tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, (double) tm->tm_sec,
  397.    *tzp, tzname[0], tzname[1], tm->tm_isdst);
  398. #endif
  399. #endif
  401. return 0;
  402. } /* date2tm() */
  405. /*****************************************************************************
  406.  *  Time ADT
  407.  *****************************************************************************/
  410. TimeADT    *
  411. time_in(char *str)
  412. {
  413. TimeADT    *time;
  415. double fsec;
  416. struct tm tt,
  417.    *tm = &tt;
  419. int nf;
  420. char lowstr[MAXDATELEN + 1];
  421. char    *field[MAXDATEFIELDS];
  422. int dtype;
  423. int ftype[MAXDATEFIELDS];
  425. if (!PointerIsValid(str))
  426. elog(ERROR, "Bad (null) time external representation", NULL);
  428. if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
  429. || (DecodeTimeOnly(field, ftype, nf, &dtype, tm, &fsec) != 0))
  430. elog(ERROR, "Bad time external representation '%s'", str);
  432. time = palloc(sizeof(TimeADT));
  434. *time = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec + fsec);
  436. return time;
  437. } /* time_in() */
  440. char *
  441. time_out(TimeADT *time)
  442. {
  443. char    *result;
  444. struct tm tt,
  445.    *tm = &tt;
  447. double fsec;
  448. char buf[MAXDATELEN + 1];
  450. if (!PointerIsValid(time))
  451. return NULL;
  453. tm->tm_hour = (*time / (60 * 60));
  454. tm->tm_min = (((int) (*time / 60)) % 60);
  455. tm->tm_sec = (((int) *time) % 60);
  457. fsec = 0;
  459. EncodeTimeOnly(tm, fsec, DateStyle, buf);
  461. result = palloc(strlen(buf) + 1);
  463. strcpy(result, buf);
  465. return result;
  466. } /* time_out() */
  469. bool
  470. time_eq(TimeADT *time1, TimeADT *time2)
  471. {
  472. if (!PointerIsValid(time1) || !PointerIsValid(time2))
  473. return FALSE;
  475. return *time1 == *time2;
  476. } /* time_eq() */
  478. bool
  479. time_ne(TimeADT *time1, TimeADT *time2)
  480. {
  481. if (!PointerIsValid(time1) || !PointerIsValid(time2))
  482. return FALSE;
  484. return *time1 != *time2;
  485. } /* time_eq() */
  487. bool
  488. time_lt(TimeADT *time1, TimeADT *time2)
  489. {
  490. if (!PointerIsValid(time1) || !PointerIsValid(time2))
  491. return FALSE;
  493. return *time1 < *time2;
  494. } /* time_eq() */
  496. bool
  497. time_le(TimeADT *time1, TimeADT *time2)
  498. {
  499. if (!PointerIsValid(time1) || !PointerIsValid(time2))
  500. return FALSE;
  502. return *time1 <= *time2;
  503. } /* time_eq() */
  505. bool
  506. time_gt(TimeADT *time1, TimeADT *time2)
  507. {
  508. if (!PointerIsValid(time1) || !PointerIsValid(time2))
  509. return FALSE;
  511. return *time1 > *time2;
  512. } /* time_eq() */
  514. bool
  515. time_ge(TimeADT *time1, TimeADT *time2)
  516. {
  517. if (!PointerIsValid(time1) || !PointerIsValid(time2))
  518. return FALSE;
  520. return *time1 >= *time2;
  521. } /* time_eq() */
  523. int
  524. time_cmp(TimeADT *time1, TimeADT *time2)
  525. {
  526. return (*time1 < *time2) ? -1 : (((*time1 > *time2) ? 1 : 0));
  527. } /* time_cmp() */
  530. /* datetime_time()
  531.  * Convert datetime to time data type.
  532.  */
  533. TimeADT    *
  534. datetime_time(DateTime *datetime)
  535. {
  536. TimeADT    *result;
  537. struct tm tt,
  538.    *tm = &tt;
  539. int tz;
  540. double fsec;
  541. char    *tzn;
  543. if (!PointerIsValid(datetime))
  544. elog(ERROR, "Unable to convert null datetime to date", NULL);
  546. if (DATETIME_NOT_FINITE(*datetime))
  547. elog(ERROR, "Unable to convert datetime to date", NULL);
  549. if (DATETIME_IS_EPOCH(*datetime))
  550. {
  551. datetime2tm(SetDateTime(*datetime), NULL, tm, &fsec, NULL);
  553. }
  554. else if (DATETIME_IS_CURRENT(*datetime))
  555. {
  556. datetime2tm(SetDateTime(*datetime), &tz, tm, &fsec, &tzn);
  558. }
  559. else
  560. {
  561. if (datetime2tm(*datetime, &tz, tm, &fsec, &tzn) != 0)
  562. elog(ERROR, "Unable to convert datetime to date", NULL);
  563. }
  565. result = palloc(sizeof(TimeADT));
  567. *result = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec + fsec);
  569. return result;
  570. } /* datetime_time() */
  573. /* datetime_datetime()
  574.  * Convert date and time to datetime data type.
  575.  */
  576. DateTime   *
  577. datetime_datetime(DateADT date, TimeADT *time)
  578. {
  579. DateTime   *result;
  581. if (!PointerIsValid(time))
  582. {
  583. result = palloc(sizeof(DateTime));
  584. DATETIME_INVALID(*result);
  585. }
  586. else
  587. {
  588. result = date_datetime(date);
  589. *result += *time;
  590. }
  592. return result;
  593. } /* datetime_datetime() */
  596. int32 /* RelativeTime */
  597. int4reltime(int32 timevalue)
  598. {
  599. return timevalue;
  600. }