?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix pg_dump bug in the database-level collation patch. "datcollate" and
[PostgreSQL.git] / src / interfaces / ecpg / pgtypeslib / timestamp.c
blobe9fa5d5a621210a42ee0ee3b57db90ae00d52b31
1 /*
2 * $PostgreSQL:$
3 */
4 #include "postgres_fe.h"
5
6 #include <time.h>
7 #include <float.h>
8 #include <limits.h>
9 #include <math.h>
10
11 #ifdef __FAST_MATH__
12 #error -ffast-math is known to break this code
13 #endif
14
15 #include "extern.h"
16 #include "dt.h"
17 #include "pgtypes_timestamp.h"
18 #include "pgtypes_date.h"
19
20
21 int PGTYPEStimestamp_defmt_scan(char **, char *, timestamp *, int *, int *, int *,
22 int *, int *, int *, int *);
23
24 #ifdef HAVE_INT64_TIMESTAMP
25 static int64
26 time2t(const int hour, const int min, const int sec, const fsec_t fsec)
27 {
28 return (((((hour * MINS_PER_HOUR) + min) * SECS_PER_MINUTE) + sec) * USECS_PER_SEC) + fsec;
29 } /* time2t() */
30 #else
31 static double
32 time2t(const int hour, const int min, const int sec, const fsec_t fsec)
33 {
34 return (((hour * MINS_PER_HOUR) + min) * SECS_PER_MINUTE) + sec + fsec;
35 } /* time2t() */
36 #endif
37
38 static timestamp
39 dt2local(timestamp dt, int tz)
40 {
41 #ifdef HAVE_INT64_TIMESTAMP
42 dt -= (tz * USECS_PER_SEC);
43 #else
44 dt -= tz;
45 #endif
46 return dt;
47 } /* dt2local() */
48
49 /* tm2timestamp()
50 * Convert a tm structure to a timestamp data type.
51 * Note that year is _not_ 1900-based, but is an explicit full value.
52 * Also, month is one-based, _not_ zero-based.
53 *
54 * Returns -1 on failure (overflow).
55 */
56 int
57 tm2timestamp(struct tm * tm, fsec_t fsec, int *tzp, timestamp * result)
58 {
59 #ifdef HAVE_INT64_TIMESTAMP
60 int dDate;
61 int64 time;
62 #else
63 double dDate,
64 time;
65 #endif
66
67 /* Julian day routines are not correct for negative Julian days */
68 if (!IS_VALID_JULIAN(tm->tm_year, tm->tm_mon, tm->tm_mday))
69 return -1;
70
71 dDate = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1);
72 time = time2t(tm->tm_hour, tm->tm_min, tm->tm_sec, fsec);
73 #ifdef HAVE_INT64_TIMESTAMP
74 *result = (dDate * USECS_PER_DAY) + time;
75 /* check for major overflow */
76 if ((*result - time) / USECS_PER_DAY != dDate)
77 return -1;
78 /* check for just-barely overflow (okay except time-of-day wraps) */
79 if ((*result < 0 && dDate >= 0) ||
80 (*result >= 0 && dDate < 0))
81 return -1;
82 #else
83 *result = dDate * SECS_PER_DAY + time;
84 #endif
85 if (tzp != NULL)
86 *result = dt2local(*result, -(*tzp));
87
88 return 0;
89 } /* tm2timestamp() */
90
91 static timestamp
92 SetEpochTimestamp(void)
93 {
94 timestamp dt;
95 struct tm tt,
96 *tm = &tt;
97
98 GetEpochTime(tm);
99 tm2timestamp(tm, 0, NULL, &dt);
100 return dt;
101 } /* SetEpochTimestamp() */
102
103 /* timestamp2tm()
104 * Convert timestamp data type to POSIX time structure.
105 * Note that year is _not_ 1900-based, but is an explicit full value.
106 * Also, month is one-based, _not_ zero-based.
107 * Returns:
108 * 0 on success
109 * -1 on out of range
110 *
111 * For dates within the system-supported time_t range, convert to the
112 * local time zone. If out of this range, leave as GMT. - tgl 97/05/27
113 */
114 static int
115 timestamp2tm(timestamp dt, int *tzp, struct tm * tm, fsec_t *fsec, char **tzn)
116 {
117 #ifdef HAVE_INT64_TIMESTAMP
118 int64 dDate,
119 date0;
120 int64 time;
121 #else
122 double dDate,
123 date0;
124 double time;
125 #endif
126 time_t utime;
127
128 #if defined(HAVE_TM_ZONE) || defined(HAVE_INT_TIMEZONE)
129 struct tm *tx;
130 #endif
131
132 date0 = date2j(2000, 1, 1);
133
134 #ifdef HAVE_INT64_TIMESTAMP
135 time = dt;
136 TMODULO(time, dDate, USECS_PER_DAY);
137
138 if (time < INT64CONST(0))
139 {
140 time += USECS_PER_DAY;
141 dDate -= 1;
142 }
143
144 /* add offset to go from J2000 back to standard Julian date */
145 dDate += date0;
146
147 /* Julian day routine does not work for negative Julian days */
148 if (dDate < 0 || dDate > (timestamp) INT_MAX)
149 return -1;
150
151 j2date((int) dDate, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
152 dt2time(time, &tm->tm_hour, &tm->tm_min, &tm->tm_sec, fsec);
153 #else
154 time = dt;
155 TMODULO(time, dDate, (double) SECS_PER_DAY);
156
157 if (time < 0)
158 {
159 time += SECS_PER_DAY;
160 dDate -= 1;
161 }
162
163 /* add offset to go from J2000 back to standard Julian date */
164 dDate += date0;
165
166 recalc_d:
167 /* Julian day routine does not work for negative Julian days */
168 if (dDate < 0 || dDate > (timestamp) INT_MAX)
169 return -1;
170
171 j2date((int) dDate, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
172 recalc_t:
173 dt2time(time, &tm->tm_hour, &tm->tm_min, &tm->tm_sec, fsec);
174
175 *fsec = TSROUND(*fsec);
176 /* roundoff may need to propagate to higher-order fields */
177 if (*fsec >= 1.0)
178 {
179 time = ceil(time);
180 if (time >= (double) SECS_PER_DAY)
181 {
182 time = 0;
183 dDate += 1;
184 goto recalc_d;
185 }
186 goto recalc_t;
187 }
188 #endif
189
190 if (tzp != NULL)
191 {
192 /*
193 * Does this fall within the capabilities of the localtime()
194 * interface? Then use this to rotate to the local time zone.
195 */
196 if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon, tm->tm_mday))
197 {
198 #ifdef HAVE_INT64_TIMESTAMP
199 utime = dt / USECS_PER_SEC +
200 ((date0 - date2j(1970, 1, 1)) * INT64CONST(86400));
201 #else
202 utime = dt + (date0 - date2j(1970, 1, 1)) * SECS_PER_DAY;
203 #endif
204
205 #if defined(HAVE_TM_ZONE) || defined(HAVE_INT_TIMEZONE)
206 tx = localtime(&utime);
207 tm->tm_year = tx->tm_year + 1900;
208 tm->tm_mon = tx->tm_mon + 1;
209 tm->tm_mday = tx->tm_mday;
210 tm->tm_hour = tx->tm_hour;
211 tm->tm_min = tx->tm_min;
212 tm->tm_isdst = tx->tm_isdst;
213
214 #if defined(HAVE_TM_ZONE)
215 tm->tm_gmtoff = tx->tm_gmtoff;
216 tm->tm_zone = tx->tm_zone;
217
218 *tzp = -tm->tm_gmtoff; /* tm_gmtoff is Sun/DEC-ism */
219 if (tzn != NULL)
220 *tzn = (char *) tm->tm_zone;
221 #elif defined(HAVE_INT_TIMEZONE)
222 *tzp = (tm->tm_isdst > 0) ? TIMEZONE_GLOBAL - SECS_PER_HOUR : TIMEZONE_GLOBAL;
223 if (tzn != NULL)
224 *tzn = TZNAME_GLOBAL[(tm->tm_isdst > 0)];
225 #endif
226 #else /* not (HAVE_TM_ZONE || HAVE_INT_TIMEZONE) */
227 *tzp = 0;
228 /* Mark this as *no* time zone available */
229 tm->tm_isdst = -1;
230 if (tzn != NULL)
231 *tzn = NULL;
232 #endif
233
234 dt = dt2local(dt, *tzp);
235 }
236 else
237 {
238 *tzp = 0;
239 /* Mark this as *no* time zone available */
240 tm->tm_isdst = -1;
241 if (tzn != NULL)
242 *tzn = NULL;
243 }
244 }
245 else
246 {
247 tm->tm_isdst = -1;
248 if (tzn != NULL)
249 *tzn = NULL;
250 }
251
252 return 0;
253 } /* timestamp2tm() */
254
255 /* EncodeSpecialTimestamp()
256 * * Convert reserved timestamp data type to string.
257 * */
258 static int
259 EncodeSpecialTimestamp(timestamp dt, char *str)
260 {
261 if (TIMESTAMP_IS_NOBEGIN(dt))
262 strcpy(str, EARLY);
263 else if (TIMESTAMP_IS_NOEND(dt))
264 strcpy(str, LATE);
265 else
266 return FALSE;
267
268 return TRUE;
269 } /* EncodeSpecialTimestamp() */
270
271 timestamp
272 PGTYPEStimestamp_from_asc(char *str, char **endptr)
273 {
274 timestamp result;
275
276 #ifdef HAVE_INT64_TIMESTAMP
277 int64 noresult = 0;
278 #else
279 double noresult = 0.0;
280 #endif
281 fsec_t fsec;
282 struct tm tt,
283 *tm = &tt;
284 int dtype;
285 int nf;
286 char *field[MAXDATEFIELDS];
287 int ftype[MAXDATEFIELDS];
288 char lowstr[MAXDATELEN + MAXDATEFIELDS];
289 char *realptr;
290 char **ptr = (endptr != NULL) ? endptr : &realptr;
291
292 if (strlen(str) >= sizeof(lowstr))
293 {
294 errno = PGTYPES_TS_BAD_TIMESTAMP;
295 return (noresult);
296 }
297
298 if (ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf, ptr) != 0 ||
299 DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, 0) != 0)
300 {
301 errno = PGTYPES_TS_BAD_TIMESTAMP;
302 return (noresult);
303 }
304
305 switch (dtype)
306 {
307 case DTK_DATE:
308 if (tm2timestamp(tm, fsec, NULL, &result) != 0)
309 {
310 errno = PGTYPES_TS_BAD_TIMESTAMP;
311 return (noresult);
312 }
313 break;
314
315 case DTK_EPOCH:
316 result = SetEpochTimestamp();
317 break;
318
319 case DTK_LATE:
320 TIMESTAMP_NOEND(result);
321 break;
322
323 case DTK_EARLY:
324 TIMESTAMP_NOBEGIN(result);
325 break;
326
327 case DTK_INVALID:
328 errno = PGTYPES_TS_BAD_TIMESTAMP;
329 return (noresult);
330
331 default:
332 errno = PGTYPES_TS_BAD_TIMESTAMP;
333 return (noresult);
334 }
335
336 /* AdjustTimestampForTypmod(&result, typmod); */
337
338 /*
339 * Since it's difficult to test for noresult, make sure errno is 0 if no
340 * error occured.
341 */
342 errno = 0;
343 return result;
344 }
345
346 char *
347 PGTYPEStimestamp_to_asc(timestamp tstamp)
348 {
349 struct tm tt,
350 *tm = &tt;
351 char buf[MAXDATELEN + 1];
352 char *tzn = NULL;
353 fsec_t fsec;
354 int DateStyle = 1; /* this defaults to ISO_DATES, shall we make
355 * it an option? */
356
357 if (TIMESTAMP_NOT_FINITE(tstamp))
358 EncodeSpecialTimestamp(tstamp, buf);
359 else if (timestamp2tm(tstamp, NULL, tm, &fsec, NULL) == 0)
360 EncodeDateTime(tm, fsec, NULL, &tzn, DateStyle, buf, 0);
361 else
362 {
363 errno = PGTYPES_TS_BAD_TIMESTAMP;
364 return NULL;
365 }
366 return pgtypes_strdup(buf);
367 }
368
369 void
370 PGTYPEStimestamp_current(timestamp * ts)
371 {
372 struct tm tm;
373
374 GetCurrentDateTime(&tm);
375 tm2timestamp(&tm, 0, NULL, ts);
376 return;
377 }
378
379 static int
380 dttofmtasc_replace(timestamp * ts, date dDate, int dow, struct tm * tm,
381 char *output, int *pstr_len, char *fmtstr)
382 {
383 union un_fmt_comb replace_val;
384 int replace_type;
385 int i;
386 char *p = fmtstr;
387 char *q = output;
388
389 while (*p)
390 {
391 if (*p == '%')
392 {
393 p++;
394 /* fix compiler warning */
395 replace_type = PGTYPES_TYPE_NOTHING;
396 switch (*p)
397 {
398 /* the abbreviated name of the day in the week */
399 /* XXX should be locale aware */
400 case 'a':
401 replace_val.str_val = pgtypes_date_weekdays_short[dow];
402 replace_type = PGTYPES_TYPE_STRING_CONSTANT;
403 break;
404 /* the full name of the day in the week */
405 /* XXX should be locale aware */
406 case 'A':
407 replace_val.str_val = days[dow];
408 replace_type = PGTYPES_TYPE_STRING_CONSTANT;
409 break;
410 /* the abbreviated name of the month */
411 /* XXX should be locale aware */
412 case 'b':
413 case 'h':
414 replace_val.str_val = months[tm->tm_mon];
415 replace_type = PGTYPES_TYPE_STRING_CONSTANT;
416 break;
417 /* the full name name of the month */
418 /* XXX should be locale aware */
419 case 'B':
420 replace_val.str_val = pgtypes_date_months[tm->tm_mon];
421 replace_type = PGTYPES_TYPE_STRING_CONSTANT;
422 break;
423
424 /*
425 * The preferred date and time representation for
426 * the current locale.
427 */
428 case 'c':
429 /* XXX */
430 break;
431 /* the century number with leading zeroes */
432 case 'C':
433 replace_val.uint_val = tm->tm_year / 100;
434 replace_type = PGTYPES_TYPE_UINT_2_LZ;
435 break;
436 /* day with leading zeroes (01 - 31) */
437 case 'd':
438 replace_val.uint_val = tm->tm_mday;
439 replace_type = PGTYPES_TYPE_UINT_2_LZ;
440 break;
441 /* the date in the format mm/dd/yy */
442 case 'D':
443
444 /*
445 * ts, dDate, dow, tm is information about the timestamp
446 *
447 * q is the start of the current output buffer
448 *
449 * pstr_len is a pointer to the remaining size of output,
450 * i.e. the size of q
451 */
452 i = dttofmtasc_replace(ts, dDate, dow, tm,
453 q, pstr_len,
454 "%m/%d/%y");
455 if (i)
456 return i;
457 break;
458 /* day with leading spaces (01 - 31) */
459 case 'e':
460 replace_val.uint_val = tm->tm_mday;
461 replace_type = PGTYPES_TYPE_UINT_2_LS;
462 break;
463
464 /*
465 * alternative format modifier
466 */
467 case 'E':
468 {
469 char tmp[4] = "%Ex";
470
471 p++;
472 if (*p == '\0')
473 return -1;
474 tmp[2] = *p;
475
476 /*
477 * strftime's month is 0 based, ours is 1 based
478 */
479 tm->tm_mon -= 1;
480 i = strftime(q, *pstr_len, tmp, tm);
481 if (i == 0)
482 return -1;
483 while (*q)
484 {
485 q++;
486 (*pstr_len)--;
487 }
488 tm->tm_mon += 1;
489 replace_type = PGTYPES_TYPE_NOTHING;
490 break;
491 }
492
493 /*
494 * The ISO 8601 year with century as a decimal number. The
495 * 4-digit year corresponding to the ISO week number.
496 */
497 case 'G':
498 tm->tm_mon -= 1;
499 i = strftime(q, *pstr_len, "%G", tm);
500 if (i == 0)
501 return -1;
502 while (*q)
503 {
504 q++;
505 (*pstr_len)--;
506 }
507 tm->tm_mon += 1;
508 replace_type = PGTYPES_TYPE_NOTHING;
509 break;
510
511 /*
512 * Like %G, but without century, i.e., with a 2-digit year
513 * (00-99).
514 */
515 case 'g':
516 {
517 const char *fmt = "%g"; /* Keep compiler quiet about
518 * 2-digit year */
519
520 tm->tm_mon -= 1;
521 i = strftime(q, *pstr_len, fmt, tm);
522 if (i == 0)
523 return -1;
524 while (*q)
525 {
526 q++;
527 (*pstr_len)--;
528 }
529 tm->tm_mon += 1;
530 replace_type = PGTYPES_TYPE_NOTHING;
531 }
532 break;
533 /* hour (24 hour clock) with leading zeroes */
534 case 'H':
535 replace_val.uint_val = tm->tm_hour;
536 replace_type = PGTYPES_TYPE_UINT_2_LZ;
537 break;
538 /* hour (12 hour clock) with leading zeroes */
539 case 'I':
540 replace_val.uint_val = tm->tm_hour % 12;
541 replace_type = PGTYPES_TYPE_UINT_2_LZ;
542 break;
543
544 /*
545 * The day of the year as a decimal number with leading
546 * zeroes. It ranges from 001 to 366.
547 */
548 case 'j':
549 replace_val.uint_val = tm->tm_yday;
550 replace_type = PGTYPES_TYPE_UINT_3_LZ;
551 break;
552
553 /*
554 * The hour (24 hour clock). Leading zeroes will be turned
555 * into spaces.
556 */
557 case 'k':
558 replace_val.uint_val = tm->tm_hour;
559 replace_type = PGTYPES_TYPE_UINT_2_LS;
560 break;
561
562 /*
563 * The hour (12 hour clock). Leading zeroes will be turned
564 * into spaces.
565 */
566 case 'l':
567 replace_val.uint_val = tm->tm_hour % 12;
568 replace_type = PGTYPES_TYPE_UINT_2_LS;
569 break;
570 /* The month as a decimal number with a leading zero */
571 case 'm':
572 replace_val.uint_val = tm->tm_mon;
573 replace_type = PGTYPES_TYPE_UINT_2_LZ;
574 break;
575 /* The minute as a decimal number with a leading zero */
576 case 'M':
577 replace_val.uint_val = tm->tm_min;
578 replace_type = PGTYPES_TYPE_UINT_2_LZ;
579 break;
580 /* A newline character */
581 case 'n':
582 replace_val.char_val = '\n';
583 replace_type = PGTYPES_TYPE_CHAR;
584 break;
585 /* the AM/PM specifier (uppercase) */
586 /* XXX should be locale aware */
587 case 'p':
588 if (tm->tm_hour < 12)
589 replace_val.str_val = "AM";
590 else
591 replace_val.str_val = "PM";
592 replace_type = PGTYPES_TYPE_STRING_CONSTANT;
593 break;
594 /* the AM/PM specifier (lowercase) */
595 /* XXX should be locale aware */
596 case 'P':
597 if (tm->tm_hour < 12)
598 replace_val.str_val = "am";
599 else
600 replace_val.str_val = "pm";
601 replace_type = PGTYPES_TYPE_STRING_CONSTANT;
602 break;
603 /* the time in the format %I:%M:%S %p */
604 /* XXX should be locale aware */
605 case 'r':
606 i = dttofmtasc_replace(ts, dDate, dow, tm,
607 q, pstr_len,
608 "%I:%M:%S %p");
609 if (i)
610 return i;
611 break;
612 /* The time in 24 hour notation (%H:%M) */
613 case 'R':
614 i = dttofmtasc_replace(ts, dDate, dow, tm,
615 q, pstr_len,
616 "%H:%M");
617 if (i)
618 return i;
619 break;
620 /* The number of seconds since the Epoch (1970-01-01) */
621 case 's':
622 #ifdef HAVE_INT64_TIMESTAMP
623 replace_val.int64_val = (*ts - SetEpochTimestamp()) / 1000000.0;
624 replace_type = PGTYPES_TYPE_INT64;
625 #else
626 replace_val.double_val = *ts - SetEpochTimestamp();
627 replace_type = PGTYPES_TYPE_DOUBLE_NF;
628 #endif
629 break;
630 /* seconds as a decimal number with leading zeroes */
631 case 'S':
632 replace_val.uint_val = tm->tm_sec;
633 replace_type = PGTYPES_TYPE_UINT_2_LZ;
634 break;
635 /* A tabulator */
636 case 't':
637 replace_val.char_val = '\t';
638 replace_type = PGTYPES_TYPE_CHAR;
639 break;
640 /* The time in 24 hour notation (%H:%M:%S) */
641 case 'T':
642 i = dttofmtasc_replace(ts, dDate, dow, tm,
643 q, pstr_len,
644 "%H:%M:%S");
645 if (i)
646 return i;
647 break;
648
649 /*
650 * The day of the week as a decimal, Monday = 1, Sunday =
651 * 7
652 */
653 case 'u':
654 replace_val.uint_val = dow;
655 if (replace_val.uint_val == 0)
656 replace_val.uint_val = 7;
657 replace_type = PGTYPES_TYPE_UINT;
658 break;
659 /* The week number of the year as a decimal number */
660 case 'U':
661 tm->tm_mon -= 1;
662 i = strftime(q, *pstr_len, "%U", tm);
663 if (i == 0)
664 return -1;
665 while (*q)
666 {
667 q++;
668 (*pstr_len)--;
669 }
670 tm->tm_mon += 1;
671 replace_type = PGTYPES_TYPE_NOTHING;
672 break;
673
674 /*
675 * The ISO 8601:1988 week number of the current year as a
676 * decimal number.
677 */
678 case 'V':
679 i = strftime(q, *pstr_len, "%V", tm);
680 if (i == 0)
681 return -1;
682 while (*q)
683 {
684 q++;
685 (*pstr_len)--;
686 }
687 replace_type = PGTYPES_TYPE_NOTHING;
688 break;
689
690 /*
691 * The day of the week as a decimal, Sunday being 0 and
692 * Monday 1.
693 */
694 case 'w':
695 replace_val.uint_val = dow;
696 replace_type = PGTYPES_TYPE_UINT;
697 break;
698 /* The week number of the year (another definition) */
699 case 'W':
700 tm->tm_mon -= 1;
701 i = strftime(q, *pstr_len, "%U", tm);
702 if (i == 0)
703 return -1;
704 while (*q)
705 {
706 q++;
707 (*pstr_len)--;
708 }
709 tm->tm_mon += 1;
710 replace_type = PGTYPES_TYPE_NOTHING;
711 break;
712
713 /*
714 * The preferred date representation for the current
715 * locale without the time.
716 */
717 case 'x':
718 {
719 const char *fmt = "%x"; /* Keep compiler quiet about
720 * 2-digit year */
721
722 tm->tm_mon -= 1;
723 i = strftime(q, *pstr_len, fmt, tm);
724 if (i == 0)
725 return -1;
726 while (*q)
727 {
728 q++;
729 (*pstr_len)--;
730 }
731 tm->tm_mon += 1;
732 replace_type = PGTYPES_TYPE_NOTHING;
733 }
734 break;
735
736 /*
737 * The preferred time representation for the current
738 * locale without the date.
739 */
740 case 'X':
741 tm->tm_mon -= 1;
742 i = strftime(q, *pstr_len, "%X", tm);
743 if (i == 0)
744 return -1;
745 while (*q)
746 {
747 q++;
748 (*pstr_len)--;
749 }
750 tm->tm_mon += 1;
751 replace_type = PGTYPES_TYPE_NOTHING;
752 break;
753 /* The year without the century (2 digits, leading zeroes) */
754 case 'y':
755 replace_val.uint_val = tm->tm_year % 100;
756 replace_type = PGTYPES_TYPE_UINT_2_LZ;
757 break;
758 /* The year with the century (4 digits) */
759 case 'Y':
760 replace_val.uint_val = tm->tm_year;
761 replace_type = PGTYPES_TYPE_UINT;
762 break;
763 /* The time zone offset from GMT */
764 case 'z':
765 tm->tm_mon -= 1;
766 i = strftime(q, *pstr_len, "%z", tm);
767 if (i == 0)
768 return -1;
769 while (*q)
770 {
771 q++;
772 (*pstr_len)--;
773 }
774 tm->tm_mon += 1;
775 replace_type = PGTYPES_TYPE_NOTHING;
776 break;
777 /* The name or abbreviation of the time zone */
778 case 'Z':
779 tm->tm_mon -= 1;
780 i = strftime(q, *pstr_len, "%Z", tm);
781 if (i == 0)
782 return -1;
783 while (*q)
784 {
785 q++;
786 (*pstr_len)--;
787 }
788 tm->tm_mon += 1;
789 replace_type = PGTYPES_TYPE_NOTHING;
790 break;
791 /* A % sign */
792 case '%':
793 replace_val.char_val = '%';
794 replace_type = PGTYPES_TYPE_CHAR;
795 break;
796 case '\0':
797 /* fmtstr: foo%' - The string ends with a % sign */
798
799 /*
800 * this is not compliant to the specification
801 */
802 return -1;
803 default:
804
805 /*
806 * if we don't know the pattern, we just copy it
807 */
808 if (*pstr_len > 1)
809 {
810 *q = '%';
811 q++;
812 (*pstr_len)--;
813 if (*pstr_len > 1)
814 {
815 *q = *p;
816 q++;
817 (*pstr_len)--;
818 }
819 else
820 {
821 *q = '\0';
822 return -1;
823 }
824 *q = '\0';
825 }
826 else
827 return -1;
828 break;
829 }
830 i = pgtypes_fmt_replace(replace_val, replace_type, &q, pstr_len);
831 if (i)
832 return i;
833 }
834 else
835 {
836 if (*pstr_len > 1)
837 {
838 *q = *p;
839 (*pstr_len)--;
840 q++;
841 *q = '\0';
842 }
843 else
844 return -1;
845 }
846 p++;
847 }
848 return 0;
849 }
850
851
852 int
853 PGTYPEStimestamp_fmt_asc(timestamp * ts, char *output, int str_len, char *fmtstr)
854 {
855 struct tm tm;
856 fsec_t fsec;
857 date dDate;
858 int dow;
859
860 dDate = PGTYPESdate_from_timestamp(*ts);
861 dow = PGTYPESdate_dayofweek(dDate);
862 timestamp2tm(*ts, NULL, &tm, &fsec, NULL);
863
864 return dttofmtasc_replace(ts, dDate, dow, &tm, output, &str_len, fmtstr);
865 }
866
867 int
868 PGTYPEStimestamp_sub(timestamp * ts1, timestamp * ts2, interval * iv)
869 {
870 if (TIMESTAMP_NOT_FINITE(*ts1) || TIMESTAMP_NOT_FINITE(*ts2))
871 return PGTYPES_TS_ERR_EINFTIME;
872 else
873 iv->time = (*ts1 - *ts2);
874
875 iv->month = 0;
876
877 return 0;
878 }
879
880 int
881 PGTYPEStimestamp_defmt_asc(char *str, char *fmt, timestamp * d)
882 {
883 int year,
884 month,
885 day;
886 int hour,
887 minute,
888 second;
889 int tz;
890
891 int i;
892 char *mstr;
893 char *mfmt;
894
895 if (!fmt)
896 fmt = "%Y-%m-%d %H:%M:%S";
897 if (!fmt[0])
898 return 1;
899
900 mstr = pgtypes_strdup(str);
901 mfmt = pgtypes_strdup(fmt);
902
903 /*
904 * initialize with impossible values so that we can see if the fields
905 * where specified at all
906 */
907 /* XXX ambiguity with 1 BC for year? */
908 year = -1;
909 month = -1;
910 day = -1;
911 hour = 0;
912 minute = -1;
913 second = -1;
914 tz = 0;
915
916 i = PGTYPEStimestamp_defmt_scan(&mstr, mfmt, d, &year, &month, &day, &hour, &minute, &second, &tz);
917 free(mstr);
918 free(mfmt);
919 return i;
920 }
921
922 /*
923 * add an interval to a time stamp
924 *
925 * *tout = tin + span
926 *
927 * returns 0 if successful
928 * returns -1 if it fails
929 *
930 */
931
932 int
933 PGTYPEStimestamp_add_interval(timestamp * tin, interval * span, timestamp * tout)
934 {
935
936
937 if (TIMESTAMP_NOT_FINITE(*tin))
938 *tout = *tin;
939
940
941 else
942 {
943 if (span->month != 0)
944 {
945 struct tm tt,
946 *tm = &tt;
947 fsec_t fsec;
948
949
950 if (timestamp2tm(*tin, NULL, tm, &fsec, NULL) != 0)
951 return -1;
952 tm->tm_mon += span->month;
953 if (tm->tm_mon > MONTHS_PER_YEAR)
954 {
955 tm->tm_year += (tm->tm_mon - 1) / MONTHS_PER_YEAR;
956 tm->tm_mon = (tm->tm_mon - 1) % MONTHS_PER_YEAR + 1;
957 }
958 else if (tm->tm_mon < 1)
959 {
960 tm->tm_year += tm->tm_mon / MONTHS_PER_YEAR - 1;
961 tm->tm_mon = tm->tm_mon % MONTHS_PER_YEAR + MONTHS_PER_YEAR;
962 }
963
964
965 /* adjust for end of month boundary problems... */
966 if (tm->tm_mday > day_tab[isleap(tm->tm_year)][tm->tm_mon - 1])
967 tm->tm_mday = (day_tab[isleap(tm->tm_year)][tm->tm_mon - 1]);
968
969
970 if (tm2timestamp(tm, fsec, NULL, tin) != 0)
971 return -1;
972 }
973
974
975 *tin += span->time;
976 *tout = *tin;
977 }
978 return 0;
979
980 }
981
982
983 /*
984 * subtract an interval from a time stamp
985 *
986 * *tout = tin - span
987 *
988 * returns 0 if successful
989 * returns -1 if it fails
990 *
991 */
992
993 int
994 PGTYPEStimestamp_sub_interval(timestamp * tin, interval * span, timestamp * tout)
995 {
996 interval tspan;
997
998 tspan.month = -span->month;
999 tspan.time = -span->time;
1000
1001
1002 return PGTYPEStimestamp_add_interval(tin, &tspan, tout);
1003 }
PostgreSQL from CVS