Debian Codegraph @

src/backend/utils/adt/date.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * date.c
4 * implements DATE and TIME data types specified in SQL standard
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994-5, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/utils/adt/date.c
12 *
13 *-------------------------------------------------------------------------
14 */
15
16 #include "postgres.h"
17
18 #include <ctype.h>
19 #include <limits.h>
20 #include <float.h>
21 #include <math.h>
22 #include <time.h>
23
24 #include "access/xact.h"
25 #include "catalog/pg_type.h"
26 #include "common/hashfn.h"
27 #include "common/int.h"
28 #include "libpq/pqformat.h"
29 #include "miscadmin.h"
30 #include "nodes/supportnodes.h"
31 #include "parser/scansup.h"
32 #include "utils/array.h"
33 #include "utils/builtins.h"
34 #include "utils/date.h"
35 #include "utils/datetime.h"
36 #include "utils/numeric.h"
37 #include "utils/skipsupport.h"
38 #include "utils/sortsupport.h"
39
40 /*
41 * gcc's -ffast-math switch breaks routines that expect exact results from
42 * expressions like timeval / SECS_PER_HOUR, where timeval is double.
43 */
44 #ifdef __FAST_MATH__
45 #error -ffast-math is known to break this code
46 #endif
47
48
49 /* common code for timetypmodin and timetztypmodin */
50 static int32
51 anytime_typmodin(bool istz, ArrayType *ta)
52 {
53 int32 *tl;
54 int n;
55
56 tl = ArrayGetIntegerTypmods(ta, &n);
57
58 /*
59 * we're not too tense about good error message here because grammar
60 * shouldn't allow wrong number of modifiers for TIME
61 */
62 if (n != 1)
63 ereport(ERROR,
64 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
65 errmsg("invalid type modifier")));
66
67 return anytime_typmod_check(istz, tl[0]);
68 }
69
70 /* exported so parse_expr.c can use it */
71 int32
72 anytime_typmod_check(bool istz, int32 typmod)
73 {
74 if (typmod < 0)
75 ereport(ERROR,
76 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
77 errmsg("TIME(%d)%s precision must not be negative",
78 typmod, (istz ? " WITH TIME ZONE" : ""))));
79 if (typmod > MAX_TIME_PRECISION)
80 {
81 ereport(WARNING,
82 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
83 errmsg("TIME(%d)%s precision reduced to maximum allowed, %d",
84 typmod, (istz ? " WITH TIME ZONE" : ""),
85 MAX_TIME_PRECISION)));
86 typmod = MAX_TIME_PRECISION;
87 }
88
89 return typmod;
90 }
91
92 /* common code for timetypmodout and timetztypmodout */
93 static char *
94 anytime_typmodout(bool istz, int32 typmod)
95 {
96 const char *tz = istz ? " with time zone" : " without time zone";
97
98 if (typmod >= 0)
99 return psprintf("(%d)%s", (int) typmod, tz);
100 else
101 return pstrdup(tz);
102 }
103
104
105 /*****************************************************************************
106 * Date ADT
107 *****************************************************************************/
108
109
110 /* date_in()
111 * Given date text string, convert to internal date format.
112 */
113 Datum
114 date_in(PG_FUNCTION_ARGS)
115 {
116 char *str = PG_GETARG_CSTRING(0);
117 Node *escontext = fcinfo->context;
118 DateADT date;
119 fsec_t fsec;
120 struct pg_tm tt,
121 *tm = &tt;
122 int tzp;
123 int dtype;
124 int nf;
125 int dterr;
126 char *field[MAXDATEFIELDS];
127 int ftype[MAXDATEFIELDS];
128 char workbuf[MAXDATELEN + 1];
129 DateTimeErrorExtra extra;
130
131 dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
132 field, ftype, MAXDATEFIELDS, &nf);
133 if (dterr == 0)
134 dterr = DecodeDateTime(field, ftype, nf,
135 &dtype, tm, &fsec, &tzp, &extra);
136 if (dterr != 0)
137 {
138 DateTimeParseError(dterr, &extra, str, "date", escontext);
139 PG_RETURN_NULL();
140 }
141
142 switch (dtype)
143 {
144 case DTK_DATE:
145 break;
146
147 case DTK_EPOCH:
148 GetEpochTime(tm);
149 break;
150
151 case DTK_LATE:
152 DATE_NOEND(date);
153 PG_RETURN_DATEADT(date);
154
155 case DTK_EARLY:
156 DATE_NOBEGIN(date);
157 PG_RETURN_DATEADT(date);
158
159 default:
160 DateTimeParseError(DTERR_BAD_FORMAT, &extra, str, "date", escontext);
161 PG_RETURN_NULL();
162 }
163
164 /* Prevent overflow in Julian-day routines */
165 if (!IS_VALID_JULIAN(tm->tm_year, tm->tm_mon, tm->tm_mday))
166 ereturn(escontext, (Datum) 0,
167 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
168 errmsg("date out of range: \"%s\"", str)));
169
170 date = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - POSTGRES_EPOCH_JDATE;
171
172 /* Now check for just-out-of-range dates */
173 if (!IS_VALID_DATE(date))
174 ereturn(escontext, (Datum) 0,
175 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
176 errmsg("date out of range: \"%s\"", str)));
177
178 PG_RETURN_DATEADT(date);
179 }
180
181 /* date_out()
182 * Given internal format date, convert to text string.
183 */
184 Datum
185 date_out(PG_FUNCTION_ARGS)
186 {
187 DateADT date = PG_GETARG_DATEADT(0);
188 char *result;
189 struct pg_tm tt,
190 *tm = &tt;
191 char buf[MAXDATELEN + 1];
192
193 if (DATE_NOT_FINITE(date))
194 EncodeSpecialDate(date, buf);
195 else
196 {
197 j2date(date + POSTGRES_EPOCH_JDATE,
198 &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
199 EncodeDateOnly(tm, DateStyle, buf);
200 }
201
202 result = pstrdup(buf);
203 PG_RETURN_CSTRING(result);
204 }
205
206 /*
207 * date_recv - converts external binary format to date
208 */
209 Datum
210 date_recv(PG_FUNCTION_ARGS)
211 {
212 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
213 DateADT result;
214
215 result = (DateADT) pq_getmsgint(buf, sizeof(DateADT));
216
217 /* Limit to the same range that date_in() accepts. */
218 if (DATE_NOT_FINITE(result))
219 /* ok */ ;
220 else if (!IS_VALID_DATE(result))
221 ereport(ERROR,
222 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
223 errmsg("date out of range")));
224
225 PG_RETURN_DATEADT(result);
226 }
227
228 /*
229 * date_send - converts date to binary format
230 */
231 Datum
232 date_send(PG_FUNCTION_ARGS)
233 {
234 DateADT date = PG_GETARG_DATEADT(0);
235 StringInfoData buf;
236
237 pq_begintypsend(&buf);
238 pq_sendint32(&buf, date);
239 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
240 }
241
242 /*
243 * make_date - date constructor
244 */
245 Datum
246 make_date(PG_FUNCTION_ARGS)
247 {
248 struct pg_tm tm;
249 DateADT date;
250 int dterr;
251 bool bc = false;
252
253 tm.tm_year = PG_GETARG_INT32(0);
254 tm.tm_mon = PG_GETARG_INT32(1);
255 tm.tm_mday = PG_GETARG_INT32(2);
256
257 /* Handle negative years as BC */
258 if (tm.tm_year < 0)
259 {
260 int year = tm.tm_year;
261
262 bc = true;
263 if (pg_neg_s32_overflow(year, &year))
264 ereport(ERROR,
265 (errcode(ERRCODE_DATETIME_FIELD_OVERFLOW),
266 errmsg("date field value out of range: %d-%02d-%02d",
267 tm.tm_year, tm.tm_mon, tm.tm_mday)));
268 tm.tm_year = year;
269 }
270
271 dterr = ValidateDate(DTK_DATE_M, false, false, bc, &tm);
272
273 if (dterr != 0)
274 ereport(ERROR,
275 (errcode(ERRCODE_DATETIME_FIELD_OVERFLOW),
276 errmsg("date field value out of range: %d-%02d-%02d",
277 tm.tm_year, tm.tm_mon, tm.tm_mday)));
278
279 /* Prevent overflow in Julian-day routines */
280 if (!IS_VALID_JULIAN(tm.tm_year, tm.tm_mon, tm.tm_mday))
281 ereport(ERROR,
282 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
283 errmsg("date out of range: %d-%02d-%02d",
284 tm.tm_year, tm.tm_mon, tm.tm_mday)));
285
286 date = date2j(tm.tm_year, tm.tm_mon, tm.tm_mday) - POSTGRES_EPOCH_JDATE;
287
288 /* Now check for just-out-of-range dates */
289 if (!IS_VALID_DATE(date))
290 ereport(ERROR,
291 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
292 errmsg("date out of range: %d-%02d-%02d",
293 tm.tm_year, tm.tm_mon, tm.tm_mday)));
294
295 PG_RETURN_DATEADT(date);
296 }
297
298 /*
299 * Convert reserved date values to string.
300 */
301 void
302 EncodeSpecialDate(DateADT dt, char *str)
303 {
304 if (DATE_IS_NOBEGIN(dt))
305 strcpy(str, EARLY);
306 else if (DATE_IS_NOEND(dt))
307 strcpy(str, LATE);
308 else /* shouldn't happen */
309 elog(ERROR, "invalid argument for EncodeSpecialDate");
310 }
311
312
313 /*
314 * GetSQLCurrentDate -- implements CURRENT_DATE
315 */
316 DateADT
317 GetSQLCurrentDate(void)
318 {
319 struct pg_tm tm;
320
321 static int cache_year = 0;
322 static int cache_mon = 0;
323 static int cache_mday = 0;
324 static DateADT cache_date;
325
326 GetCurrentDateTime(&tm);
327
328 /*
329 * date2j involves several integer divisions; moreover, unless our session
330 * lives across local midnight, we don't really have to do it more than
331 * once. So it seems worth having a separate cache here.
332 */
333 if (tm.tm_year != cache_year ||
334 tm.tm_mon != cache_mon ||
335 tm.tm_mday != cache_mday)
336 {
337 cache_date = date2j(tm.tm_year, tm.tm_mon, tm.tm_mday) - POSTGRES_EPOCH_JDATE;
338 cache_year = tm.tm_year;
339 cache_mon = tm.tm_mon;
340 cache_mday = tm.tm_mday;
341 }
342
343 return cache_date;
344 }
345
346 /*
347 * GetSQLCurrentTime -- implements CURRENT_TIME, CURRENT_TIME(n)
348 */
349 TimeTzADT *
350 GetSQLCurrentTime(int32 typmod)
351 {
352 TimeTzADT *result;
353 struct pg_tm tt,
354 *tm = &tt;
355 fsec_t fsec;
356 int tz;
357
358 GetCurrentTimeUsec(tm, &fsec, &tz);
359
360 result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
361 tm2timetz(tm, fsec, tz, result);
362 AdjustTimeForTypmod(&(result->time), typmod);
363 return result;
364 }
365
366 /*
367 * GetSQLLocalTime -- implements LOCALTIME, LOCALTIME(n)
368 */
369 TimeADT
370 GetSQLLocalTime(int32 typmod)
371 {
372 TimeADT result;
373 struct pg_tm tt,
374 *tm = &tt;
375 fsec_t fsec;
376 int tz;
377
378 GetCurrentTimeUsec(tm, &fsec, &tz);
379
380 tm2time(tm, fsec, &result);
381 AdjustTimeForTypmod(&result, typmod);
382 return result;
383 }
384
385
386 /*
387 * Comparison functions for dates
388 */
389
390 Datum
391 date_eq(PG_FUNCTION_ARGS)
392 {
393 DateADT dateVal1 = PG_GETARG_DATEADT(0);
394 DateADT dateVal2 = PG_GETARG_DATEADT(1);
395
396 PG_RETURN_BOOL(dateVal1 == dateVal2);
397 }
398
399 Datum
400 date_ne(PG_FUNCTION_ARGS)
401 {
402 DateADT dateVal1 = PG_GETARG_DATEADT(0);
403 DateADT dateVal2 = PG_GETARG_DATEADT(1);
404
405 PG_RETURN_BOOL(dateVal1 != dateVal2);
406 }
407
408 Datum
409 date_lt(PG_FUNCTION_ARGS)
410 {
411 DateADT dateVal1 = PG_GETARG_DATEADT(0);
412 DateADT dateVal2 = PG_GETARG_DATEADT(1);
413
414 PG_RETURN_BOOL(dateVal1 < dateVal2);
415 }
416
417 Datum
418 date_le(PG_FUNCTION_ARGS)
419 {
420 DateADT dateVal1 = PG_GETARG_DATEADT(0);
421 DateADT dateVal2 = PG_GETARG_DATEADT(1);
422
423 PG_RETURN_BOOL(dateVal1 <= dateVal2);
424 }
425
426 Datum
427 date_gt(PG_FUNCTION_ARGS)
428 {
429 DateADT dateVal1 = PG_GETARG_DATEADT(0);
430 DateADT dateVal2 = PG_GETARG_DATEADT(1);
431
432 PG_RETURN_BOOL(dateVal1 > dateVal2);
433 }
434
435 Datum
436 date_ge(PG_FUNCTION_ARGS)
437 {
438 DateADT dateVal1 = PG_GETARG_DATEADT(0);
439 DateADT dateVal2 = PG_GETARG_DATEADT(1);
440
441 PG_RETURN_BOOL(dateVal1 >= dateVal2);
442 }
443
444 Datum
445 date_cmp(PG_FUNCTION_ARGS)
446 {
447 DateADT dateVal1 = PG_GETARG_DATEADT(0);
448 DateADT dateVal2 = PG_GETARG_DATEADT(1);
449
450 if (dateVal1 < dateVal2)
451 PG_RETURN_INT32(-1);
452 else if (dateVal1 > dateVal2)
453 PG_RETURN_INT32(1);
454 PG_RETURN_INT32(0);
455 }
456
457 Datum
458 date_sortsupport(PG_FUNCTION_ARGS)
459 {
460 SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
461
462 ssup->comparator = ssup_datum_int32_cmp;
463 PG_RETURN_VOID();
464 }
465
466 static Datum
467 date_decrement(Relation rel, Datum existing, bool *underflow)
468 {
469 DateADT dexisting = DatumGetDateADT(existing);
470
471 if (dexisting == DATEVAL_NOBEGIN)
472 {
473 /* return value is undefined */
474 *underflow = true;
475 return (Datum) 0;
476 }
477
478 *underflow = false;
479 return DateADTGetDatum(dexisting - 1);
480 }
481
482 static Datum
483 date_increment(Relation rel, Datum existing, bool *overflow)
484 {
485 DateADT dexisting = DatumGetDateADT(existing);
486
487 if (dexisting == DATEVAL_NOEND)
488 {
489 /* return value is undefined */
490 *overflow = true;
491 return (Datum) 0;
492 }
493
494 *overflow = false;
495 return DateADTGetDatum(dexisting + 1);
496 }
497
498 Datum
499 date_skipsupport(PG_FUNCTION_ARGS)
500 {
501 SkipSupport sksup = (SkipSupport) PG_GETARG_POINTER(0);
502
503 sksup->decrement = date_decrement;
504 sksup->increment = date_increment;
505 sksup->low_elem = DateADTGetDatum(DATEVAL_NOBEGIN);
506 sksup->high_elem = DateADTGetDatum(DATEVAL_NOEND);
507
508 PG_RETURN_VOID();
509 }
510
511 Datum
512 hashdate(PG_FUNCTION_ARGS)
513 {
514 return hash_uint32(PG_GETARG_DATEADT(0));
515 }
516
517 Datum
518 hashdateextended(PG_FUNCTION_ARGS)
519 {
520 return hash_uint32_extended(PG_GETARG_DATEADT(0), PG_GETARG_INT64(1));
521 }
522
523 Datum
524 date_finite(PG_FUNCTION_ARGS)
525 {
526 DateADT date = PG_GETARG_DATEADT(0);
527
528 PG_RETURN_BOOL(!DATE_NOT_FINITE(date));
529 }
530
531 Datum
532 date_larger(PG_FUNCTION_ARGS)
533 {
534 DateADT dateVal1 = PG_GETARG_DATEADT(0);
535 DateADT dateVal2 = PG_GETARG_DATEADT(1);
536
537 PG_RETURN_DATEADT((dateVal1 > dateVal2) ? dateVal1 : dateVal2);
538 }
539
540 Datum
541 date_smaller(PG_FUNCTION_ARGS)
542 {
543 DateADT dateVal1 = PG_GETARG_DATEADT(0);
544 DateADT dateVal2 = PG_GETARG_DATEADT(1);
545
546 PG_RETURN_DATEADT((dateVal1 < dateVal2) ? dateVal1 : dateVal2);
547 }
548
549 /* Compute difference between two dates in days.
550 */
551 Datum
552 date_mi(PG_FUNCTION_ARGS)
553 {
554 DateADT dateVal1 = PG_GETARG_DATEADT(0);
555 DateADT dateVal2 = PG_GETARG_DATEADT(1);
556
557 if (DATE_NOT_FINITE(dateVal1) || DATE_NOT_FINITE(dateVal2))
558 ereport(ERROR,
559 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
560 errmsg("cannot subtract infinite dates")));
561
562 PG_RETURN_INT32((int32) (dateVal1 - dateVal2));
563 }
564
565 /* Add a number of days to a date, giving a new date.
566 * Must handle both positive and negative numbers of days.
567 */
568 Datum
569 date_pli(PG_FUNCTION_ARGS)
570 {
571 DateADT dateVal = PG_GETARG_DATEADT(0);
572 int32 days = PG_GETARG_INT32(1);
573 DateADT result;
574
575 if (DATE_NOT_FINITE(dateVal))
576 PG_RETURN_DATEADT(dateVal); /* can't change infinity */
577
578 result = dateVal + days;
579
580 /* Check for integer overflow and out-of-allowed-range */
581 if ((days >= 0 ? (result < dateVal) : (result > dateVal)) ||
582 !IS_VALID_DATE(result))
583 ereport(ERROR,
584 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
585 errmsg("date out of range")));
586
587 PG_RETURN_DATEADT(result);
588 }
589
590 /* Subtract a number of days from a date, giving a new date.
591 */
592 Datum
593 date_mii(PG_FUNCTION_ARGS)
594 {
595 DateADT dateVal = PG_GETARG_DATEADT(0);
596 int32 days = PG_GETARG_INT32(1);
597 DateADT result;
598
599 if (DATE_NOT_FINITE(dateVal))
600 PG_RETURN_DATEADT(dateVal); /* can't change infinity */
601
602 result = dateVal - days;
603
604 /* Check for integer overflow and out-of-allowed-range */
605 if ((days >= 0 ? (result > dateVal) : (result < dateVal)) ||
606 !IS_VALID_DATE(result))
607 ereport(ERROR,
608 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
609 errmsg("date out of range")));
610
611 PG_RETURN_DATEADT(result);
612 }
613
614
615 /*
616 * Promote date to timestamp.
617 *
618 * On successful conversion, *overflow is set to zero if it's not NULL.
619 *
620 * If the date is finite but out of the valid range for timestamp, then:
621 * if overflow is NULL, we throw an out-of-range error.
622 * if overflow is not NULL, we store +1 or -1 there to indicate the sign
623 * of the overflow, and return the appropriate timestamp infinity.
624 *
625 * Note: *overflow = -1 is actually not possible currently, since both
626 * datatypes have the same lower bound, Julian day zero.
627 */
628 Timestamp
629 date2timestamp_opt_overflow(DateADT dateVal, int *overflow)
630 {
631 Timestamp result;
632
633 if (overflow)
634 *overflow = 0;
635
636 if (DATE_IS_NOBEGIN(dateVal))
637 TIMESTAMP_NOBEGIN(result);
638 else if (DATE_IS_NOEND(dateVal))
639 TIMESTAMP_NOEND(result);
640 else
641 {
642 /*
643 * Since dates have the same minimum values as timestamps, only upper
644 * boundary need be checked for overflow.
645 */
646 if (dateVal >= (TIMESTAMP_END_JULIAN - POSTGRES_EPOCH_JDATE))
647 {
648 if (overflow)
649 {
650 *overflow = 1;
651 TIMESTAMP_NOEND(result);
652 return result;
653 }
654 else
655 {
656 ereport(ERROR,
657 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
658 errmsg("date out of range for timestamp")));
659 }
660 }
661
662 /* date is days since 2000, timestamp is microseconds since same... */
663 result = dateVal * USECS_PER_DAY;
664 }
665
666 return result;
667 }
668
669 /*
670 * Promote date to timestamp, throwing error for overflow.
671 */
672 static TimestampTz
673 date2timestamp(DateADT dateVal)
674 {
675 return date2timestamp_opt_overflow(dateVal, NULL);
676 }
677
678 /*
679 * Promote date to timestamp with time zone.
680 *
681 * On successful conversion, *overflow is set to zero if it's not NULL.
682 *
683 * If the date is finite but out of the valid range for timestamptz, then:
684 * if overflow is NULL, we throw an out-of-range error.
685 * if overflow is not NULL, we store +1 or -1 there to indicate the sign
686 * of the overflow, and return the appropriate timestamptz infinity.
687 */
688 TimestampTz
689 date2timestamptz_opt_overflow(DateADT dateVal, int *overflow)
690 {
691 TimestampTz result;
692 struct pg_tm tt,
693 *tm = &tt;
694 int tz;
695
696 if (overflow)
697 *overflow = 0;
698
699 if (DATE_IS_NOBEGIN(dateVal))
700 TIMESTAMP_NOBEGIN(result);
701 else if (DATE_IS_NOEND(dateVal))
702 TIMESTAMP_NOEND(result);
703 else
704 {
705 /*
706 * Since dates have the same minimum values as timestamps, only upper
707 * boundary need be checked for overflow.
708 */
709 if (dateVal >= (TIMESTAMP_END_JULIAN - POSTGRES_EPOCH_JDATE))
710 {
711 if (overflow)
712 {
713 *overflow = 1;
714 TIMESTAMP_NOEND(result);
715 return result;
716 }
717 else
718 {
719 ereport(ERROR,
720 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
721 errmsg("date out of range for timestamp")));
722 }
723 }
724
725 j2date(dateVal + POSTGRES_EPOCH_JDATE,
726 &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
727 tm->tm_hour = 0;
728 tm->tm_min = 0;
729 tm->tm_sec = 0;
730 tz = DetermineTimeZoneOffset(tm, session_timezone);
731
732 result = dateVal * USECS_PER_DAY + tz * USECS_PER_SEC;
733
734 /*
735 * Since it is possible to go beyond allowed timestamptz range because
736 * of time zone, check for allowed timestamp range after adding tz.
737 */
738 if (!IS_VALID_TIMESTAMP(result))
739 {
740 if (overflow)
741 {
742 if (result < MIN_TIMESTAMP)
743 {
744 *overflow = -1;
745 TIMESTAMP_NOBEGIN(result);
746 }
747 else
748 {
749 *overflow = 1;
750 TIMESTAMP_NOEND(result);
751 }
752 }
753 else
754 {
755 ereport(ERROR,
756 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
757 errmsg("date out of range for timestamp")));
758 }
759 }
760 }
761
762 return result;
763 }
764
765 /*
766 * Promote date to timestamptz, throwing error for overflow.
767 */
768 static TimestampTz
769 date2timestamptz(DateADT dateVal)
770 {
771 return date2timestamptz_opt_overflow(dateVal, NULL);
772 }
773
774 /*
775 * date2timestamp_no_overflow
776 *
777 * This is chartered to produce a double value that is numerically
778 * equivalent to the corresponding Timestamp value, if the date is in the
779 * valid range of Timestamps, but in any case not throw an overflow error.
780 * We can do this since the numerical range of double is greater than
781 * that of non-erroneous timestamps. The results are currently only
782 * used for statistical estimation purposes.
783 */
784 double
785 date2timestamp_no_overflow(DateADT dateVal)
786 {
787 double result;
788
789 if (DATE_IS_NOBEGIN(dateVal))
790 result = -DBL_MAX;
791 else if (DATE_IS_NOEND(dateVal))
792 result = DBL_MAX;
793 else
794 {
795 /* date is days since 2000, timestamp is microseconds since same... */
796 result = dateVal * (double) USECS_PER_DAY;
797 }
798
799 return result;
800 }
801
802
803 /*
804 * Crosstype comparison functions for dates
805 */
806
807 int32
808 date_cmp_timestamp_internal(DateADT dateVal, Timestamp dt2)
809 {
810 Timestamp dt1;
811 int overflow;
812
813 dt1 = date2timestamp_opt_overflow(dateVal, &overflow);
814 if (overflow > 0)
815 {
816 /* dt1 is larger than any finite timestamp, but less than infinity */
817 return TIMESTAMP_IS_NOEND(dt2) ? -1 : +1;
818 }
819 Assert(overflow == 0); /* -1 case cannot occur */
820
821 return timestamp_cmp_internal(dt1, dt2);
822 }
823
824 Datum
825 date_eq_timestamp(PG_FUNCTION_ARGS)
826 {
827 DateADT dateVal = PG_GETARG_DATEADT(0);
828 Timestamp dt2 = PG_GETARG_TIMESTAMP(1);
829
830 PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) == 0);
831 }
832
833 Datum
834 date_ne_timestamp(PG_FUNCTION_ARGS)
835 {
836 DateADT dateVal = PG_GETARG_DATEADT(0);
837 Timestamp dt2 = PG_GETARG_TIMESTAMP(1);
838
839 PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) != 0);
840 }
841
842 Datum
843 date_lt_timestamp(PG_FUNCTION_ARGS)
844 {
845 DateADT dateVal = PG_GETARG_DATEADT(0);
846 Timestamp dt2 = PG_GETARG_TIMESTAMP(1);
847
848 PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) < 0);
849 }
850
851 Datum
852 date_gt_timestamp(PG_FUNCTION_ARGS)
853 {
854 DateADT dateVal = PG_GETARG_DATEADT(0);
855 Timestamp dt2 = PG_GETARG_TIMESTAMP(1);
856
857 PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) > 0);
858 }
859
860 Datum
861 date_le_timestamp(PG_FUNCTION_ARGS)
862 {
863 DateADT dateVal = PG_GETARG_DATEADT(0);
864 Timestamp dt2 = PG_GETARG_TIMESTAMP(1);
865
866 PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) <= 0);
867 }
868
869 Datum
870 date_ge_timestamp(PG_FUNCTION_ARGS)
871 {
872 DateADT dateVal = PG_GETARG_DATEADT(0);
873 Timestamp dt2 = PG_GETARG_TIMESTAMP(1);
874
875 PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt2) >= 0);
876 }
877
878 Datum
879 date_cmp_timestamp(PG_FUNCTION_ARGS)
880 {
881 DateADT dateVal = PG_GETARG_DATEADT(0);
882 Timestamp dt2 = PG_GETARG_TIMESTAMP(1);
883
884 PG_RETURN_INT32(date_cmp_timestamp_internal(dateVal, dt2));
885 }
886
887 int32
888 date_cmp_timestamptz_internal(DateADT dateVal, TimestampTz dt2)
889 {
890 TimestampTz dt1;
891 int overflow;
892
893 dt1 = date2timestamptz_opt_overflow(dateVal, &overflow);
894 if (overflow > 0)
895 {
896 /* dt1 is larger than any finite timestamp, but less than infinity */
897 return TIMESTAMP_IS_NOEND(dt2) ? -1 : +1;
898 }
899 if (overflow < 0)
900 {
901 /* dt1 is less than any finite timestamp, but more than -infinity */
902 return TIMESTAMP_IS_NOBEGIN(dt2) ? +1 : -1;
903 }
904
905 return timestamptz_cmp_internal(dt1, dt2);
906 }
907
908 Datum
909 date_eq_timestamptz(PG_FUNCTION_ARGS)
910 {
911 DateADT dateVal = PG_GETARG_DATEADT(0);
912 TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
913
914 PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) == 0);
915 }
916
917 Datum
918 date_ne_timestamptz(PG_FUNCTION_ARGS)
919 {
920 DateADT dateVal = PG_GETARG_DATEADT(0);
921 TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
922
923 PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) != 0);
924 }
925
926 Datum
927 date_lt_timestamptz(PG_FUNCTION_ARGS)
928 {
929 DateADT dateVal = PG_GETARG_DATEADT(0);
930 TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
931
932 PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) < 0);
933 }
934
935 Datum
936 date_gt_timestamptz(PG_FUNCTION_ARGS)
937 {
938 DateADT dateVal = PG_GETARG_DATEADT(0);
939 TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
940
941 PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) > 0);
942 }
943
944 Datum
945 date_le_timestamptz(PG_FUNCTION_ARGS)
946 {
947 DateADT dateVal = PG_GETARG_DATEADT(0);
948 TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
949
950 PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) <= 0);
951 }
952
953 Datum
954 date_ge_timestamptz(PG_FUNCTION_ARGS)
955 {
956 DateADT dateVal = PG_GETARG_DATEADT(0);
957 TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
958
959 PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt2) >= 0);
960 }
961
962 Datum
963 date_cmp_timestamptz(PG_FUNCTION_ARGS)
964 {
965 DateADT dateVal = PG_GETARG_DATEADT(0);
966 TimestampTz dt2 = PG_GETARG_TIMESTAMPTZ(1);
967
968 PG_RETURN_INT32(date_cmp_timestamptz_internal(dateVal, dt2));
969 }
970
971 Datum
972 timestamp_eq_date(PG_FUNCTION_ARGS)
973 {
974 Timestamp dt1 = PG_GETARG_TIMESTAMP(0);
975 DateADT dateVal = PG_GETARG_DATEADT(1);
976
977 PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) == 0);
978 }
979
980 Datum
981 timestamp_ne_date(PG_FUNCTION_ARGS)
982 {
983 Timestamp dt1 = PG_GETARG_TIMESTAMP(0);
984 DateADT dateVal = PG_GETARG_DATEADT(1);
985
986 PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) != 0);
987 }
988
989 Datum
990 timestamp_lt_date(PG_FUNCTION_ARGS)
991 {
992 Timestamp dt1 = PG_GETARG_TIMESTAMP(0);
993 DateADT dateVal = PG_GETARG_DATEADT(1);
994
995 PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) > 0);
996 }
997
998 Datum
999 timestamp_gt_date(PG_FUNCTION_ARGS)
1000 {
1001 Timestamp dt1 = PG_GETARG_TIMESTAMP(0);
1002 DateADT dateVal = PG_GETARG_DATEADT(1);
1003
1004 PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) < 0);
1005 }
1006
1007 Datum
1008 timestamp_le_date(PG_FUNCTION_ARGS)
1009 {
1010 Timestamp dt1 = PG_GETARG_TIMESTAMP(0);
1011 DateADT dateVal = PG_GETARG_DATEADT(1);
1012
1013 PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) >= 0);
1014 }
1015
1016 Datum
1017 timestamp_ge_date(PG_FUNCTION_ARGS)
1018 {
1019 Timestamp dt1 = PG_GETARG_TIMESTAMP(0);
1020 DateADT dateVal = PG_GETARG_DATEADT(1);
1021
1022 PG_RETURN_BOOL(date_cmp_timestamp_internal(dateVal, dt1) <= 0);
1023 }
1024
1025 Datum
1026 timestamp_cmp_date(PG_FUNCTION_ARGS)
1027 {
1028 Timestamp dt1 = PG_GETARG_TIMESTAMP(0);
1029 DateADT dateVal = PG_GETARG_DATEADT(1);
1030
1031 PG_RETURN_INT32(-date_cmp_timestamp_internal(dateVal, dt1));
1032 }
1033
1034 Datum
1035 timestamptz_eq_date(PG_FUNCTION_ARGS)
1036 {
1037 TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
1038 DateADT dateVal = PG_GETARG_DATEADT(1);
1039
1040 PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) == 0);
1041 }
1042
1043 Datum
1044 timestamptz_ne_date(PG_FUNCTION_ARGS)
1045 {
1046 TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
1047 DateADT dateVal = PG_GETARG_DATEADT(1);
1048
1049 PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) != 0);
1050 }
1051
1052 Datum
1053 timestamptz_lt_date(PG_FUNCTION_ARGS)
1054 {
1055 TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
1056 DateADT dateVal = PG_GETARG_DATEADT(1);
1057
1058 PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) > 0);
1059 }
1060
1061 Datum
1062 timestamptz_gt_date(PG_FUNCTION_ARGS)
1063 {
1064 TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
1065 DateADT dateVal = PG_GETARG_DATEADT(1);
1066
1067 PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) < 0);
1068 }
1069
1070 Datum
1071 timestamptz_le_date(PG_FUNCTION_ARGS)
1072 {
1073 TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
1074 DateADT dateVal = PG_GETARG_DATEADT(1);
1075
1076 PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) >= 0);
1077 }
1078
1079 Datum
1080 timestamptz_ge_date(PG_FUNCTION_ARGS)
1081 {
1082 TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
1083 DateADT dateVal = PG_GETARG_DATEADT(1);
1084
1085 PG_RETURN_BOOL(date_cmp_timestamptz_internal(dateVal, dt1) <= 0);
1086 }
1087
1088 Datum
1089 timestamptz_cmp_date(PG_FUNCTION_ARGS)
1090 {
1091 TimestampTz dt1 = PG_GETARG_TIMESTAMPTZ(0);
1092 DateADT dateVal = PG_GETARG_DATEADT(1);
1093
1094 PG_RETURN_INT32(-date_cmp_timestamptz_internal(dateVal, dt1));
1095 }
1096
1097 /*
1098 * in_range support function for date.
1099 *
1100 * We implement this by promoting the dates to timestamp (without time zone)
1101 * and then using the timestamp-and-interval in_range function.
1102 */
1103 Datum
1104 in_range_date_interval(PG_FUNCTION_ARGS)
1105 {
1106 DateADT val = PG_GETARG_DATEADT(0);
1107 DateADT base = PG_GETARG_DATEADT(1);
1108 Interval *offset = PG_GETARG_INTERVAL_P(2);
1109 bool sub = PG_GETARG_BOOL(3);
1110 bool less = PG_GETARG_BOOL(4);
1111 Timestamp valStamp;
1112 Timestamp baseStamp;
1113
1114 /* XXX we could support out-of-range cases here, perhaps */
1115 valStamp = date2timestamp(val);
1116 baseStamp = date2timestamp(base);
1117
1118 return DirectFunctionCall5(in_range_timestamp_interval,
1119 TimestampGetDatum(valStamp),
1120 TimestampGetDatum(baseStamp),
1121 IntervalPGetDatum(offset),
1122 BoolGetDatum(sub),
1123 BoolGetDatum(less));
1124 }
1125
1126
1127 /* extract_date()
1128 * Extract specified field from date type.
1129 */
1130 Datum
1131 extract_date(PG_FUNCTION_ARGS)
1132 {
1133 text *units = PG_GETARG_TEXT_PP(0);
1134 DateADT date = PG_GETARG_DATEADT(1);
1135 int64 intresult;
1136 int type,
1137 val;
1138 char *lowunits;
1139 int year,
1140 mon,
1141 mday;
1142
1143 lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
1144 VARSIZE_ANY_EXHDR(units),
1145 false);
1146
1147 type = DecodeUnits(0, lowunits, &val);
1148 if (type == UNKNOWN_FIELD)
1149 type = DecodeSpecial(0, lowunits, &val);
1150
1151 if (DATE_NOT_FINITE(date) && (type == UNITS || type == RESERV))
1152 {
1153 switch (val)
1154 {
1155 /* Oscillating units */
1156 case DTK_DAY:
1157 case DTK_MONTH:
1158 case DTK_QUARTER:
1159 case DTK_WEEK:
1160 case DTK_DOW:
1161 case DTK_ISODOW:
1162 case DTK_DOY:
1163 PG_RETURN_NULL();
1164 break;
1165
1166 /* Monotonically-increasing units */
1167 case DTK_YEAR:
1168 case DTK_DECADE:
1169 case DTK_CENTURY:
1170 case DTK_MILLENNIUM:
1171 case DTK_JULIAN:
1172 case DTK_ISOYEAR:
1173 case DTK_EPOCH:
1174 if (DATE_IS_NOBEGIN(date))
1175 PG_RETURN_NUMERIC(DatumGetNumeric(DirectFunctionCall3(numeric_in,
1176 CStringGetDatum("-Infinity"),
1177 ObjectIdGetDatum(InvalidOid),
1178 Int32GetDatum(-1))));
1179 else
1180 PG_RETURN_NUMERIC(DatumGetNumeric(DirectFunctionCall3(numeric_in,
1181 CStringGetDatum("Infinity"),
1182 ObjectIdGetDatum(InvalidOid),
1183 Int32GetDatum(-1))));
1184 default:
1185 ereport(ERROR,
1186 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1187 errmsg("unit \"%s\" not supported for type %s",
1188 lowunits, format_type_be(DATEOID))));
1189 }
1190 }
1191 else if (type == UNITS)
1192 {
1193 j2date(date + POSTGRES_EPOCH_JDATE, &year, &mon, &mday);
1194
1195 switch (val)
1196 {
1197 case DTK_DAY:
1198 intresult = mday;
1199 break;
1200
1201 case DTK_MONTH:
1202 intresult = mon;
1203 break;
1204
1205 case DTK_QUARTER:
1206 intresult = (mon - 1) / 3 + 1;
1207 break;
1208
1209 case DTK_WEEK:
1210 intresult = date2isoweek(year, mon, mday);
1211 break;
1212
1213 case DTK_YEAR:
1214 if (year > 0)
1215 intresult = year;
1216 else
1217 /* there is no year 0, just 1 BC and 1 AD */
1218 intresult = year - 1;
1219 break;
1220
1221 case DTK_DECADE:
1222 /* see comments in timestamp_part */
1223 if (year >= 0)
1224 intresult = year / 10;
1225 else
1226 intresult = -((8 - (year - 1)) / 10);
1227 break;
1228
1229 case DTK_CENTURY:
1230 /* see comments in timestamp_part */
1231 if (year > 0)
1232 intresult = (year + 99) / 100;
1233 else
1234 intresult = -((99 - (year - 1)) / 100);
1235 break;
1236
1237 case DTK_MILLENNIUM:
1238 /* see comments in timestamp_part */
1239 if (year > 0)
1240 intresult = (year + 999) / 1000;
1241 else
1242 intresult = -((999 - (year - 1)) / 1000);
1243 break;
1244
1245 case DTK_JULIAN:
1246 intresult = date + POSTGRES_EPOCH_JDATE;
1247 break;
1248
1249 case DTK_ISOYEAR:
1250 intresult = date2isoyear(year, mon, mday);
1251 /* Adjust BC years */
1252 if (intresult <= 0)
1253 intresult -= 1;
1254 break;
1255
1256 case DTK_DOW:
1257 case DTK_ISODOW:
1258 intresult = j2day(date + POSTGRES_EPOCH_JDATE);
1259 if (val == DTK_ISODOW && intresult == 0)
1260 intresult = 7;
1261 break;
1262
1263 case DTK_DOY:
1264 intresult = date2j(year, mon, mday) - date2j(year, 1, 1) + 1;
1265 break;
1266
1267 default:
1268 ereport(ERROR,
1269 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1270 errmsg("unit \"%s\" not supported for type %s",
1271 lowunits, format_type_be(DATEOID))));
1272 intresult = 0;
1273 }
1274 }
1275 else if (type == RESERV)
1276 {
1277 switch (val)
1278 {
1279 case DTK_EPOCH:
1280 intresult = ((int64) date + POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY;
1281 break;
1282
1283 default:
1284 ereport(ERROR,
1285 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1286 errmsg("unit \"%s\" not supported for type %s",
1287 lowunits, format_type_be(DATEOID))));
1288 intresult = 0;
1289 }
1290 }
1291 else
1292 {
1293 ereport(ERROR,
1294 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1295 errmsg("unit \"%s\" not recognized for type %s",
1296 lowunits, format_type_be(DATEOID))));
1297 intresult = 0;
1298 }
1299
1300 PG_RETURN_NUMERIC(int64_to_numeric(intresult));
1301 }
1302
1303
1304 /* Add an interval to a date, giving a new date.
1305 * Must handle both positive and negative intervals.
1306 *
1307 * We implement this by promoting the date to timestamp (without time zone)
1308 * and then using the timestamp plus interval function.
1309 */
1310 Datum
1311 date_pl_interval(PG_FUNCTION_ARGS)
1312 {
1313 DateADT dateVal = PG_GETARG_DATEADT(0);
1314 Interval *span = PG_GETARG_INTERVAL_P(1);
1315 Timestamp dateStamp;
1316
1317 dateStamp = date2timestamp(dateVal);
1318
1319 return DirectFunctionCall2(timestamp_pl_interval,
1320 TimestampGetDatum(dateStamp),
1321 PointerGetDatum(span));
1322 }
1323
1324 /* Subtract an interval from a date, giving a new date.
1325 * Must handle both positive and negative intervals.
1326 *
1327 * We implement this by promoting the date to timestamp (without time zone)
1328 * and then using the timestamp minus interval function.
1329 */
1330 Datum
1331 date_mi_interval(PG_FUNCTION_ARGS)
1332 {
1333 DateADT dateVal = PG_GETARG_DATEADT(0);
1334 Interval *span = PG_GETARG_INTERVAL_P(1);
1335 Timestamp dateStamp;
1336
1337 dateStamp = date2timestamp(dateVal);
1338
1339 return DirectFunctionCall2(timestamp_mi_interval,
1340 TimestampGetDatum(dateStamp),
1341 PointerGetDatum(span));
1342 }
1343
1344 /* date_timestamp()
1345 * Convert date to timestamp data type.
1346 */
1347 Datum
1348 date_timestamp(PG_FUNCTION_ARGS)
1349 {
1350 DateADT dateVal = PG_GETARG_DATEADT(0);
1351 Timestamp result;
1352
1353 result = date2timestamp(dateVal);
1354
1355 PG_RETURN_TIMESTAMP(result);
1356 }
1357
1358 /* timestamp_date()
1359 * Convert timestamp to date data type.
1360 */
1361 Datum
1362 timestamp_date(PG_FUNCTION_ARGS)
1363 {
1364 Timestamp timestamp = PG_GETARG_TIMESTAMP(0);
1365 DateADT result;
1366 struct pg_tm tt,
1367 *tm = &tt;
1368 fsec_t fsec;
1369
1370 if (TIMESTAMP_IS_NOBEGIN(timestamp))
1371 DATE_NOBEGIN(result);
1372 else if (TIMESTAMP_IS_NOEND(timestamp))
1373 DATE_NOEND(result);
1374 else
1375 {
1376 if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0)
1377 ereport(ERROR,
1378 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
1379 errmsg("timestamp out of range")));
1380
1381 result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - POSTGRES_EPOCH_JDATE;
1382 }
1383
1384 PG_RETURN_DATEADT(result);
1385 }
1386
1387
1388 /* date_timestamptz()
1389 * Convert date to timestamp with time zone data type.
1390 */
1391 Datum
1392 date_timestamptz(PG_FUNCTION_ARGS)
1393 {
1394 DateADT dateVal = PG_GETARG_DATEADT(0);
1395 TimestampTz result;
1396
1397 result = date2timestamptz(dateVal);
1398
1399 PG_RETURN_TIMESTAMP(result);
1400 }
1401
1402
1403 /* timestamptz_date()
1404 * Convert timestamp with time zone to date data type.
1405 */
1406 Datum
1407 timestamptz_date(PG_FUNCTION_ARGS)
1408 {
1409 TimestampTz timestamp = PG_GETARG_TIMESTAMP(0);
1410 DateADT result;
1411 struct pg_tm tt,
1412 *tm = &tt;
1413 fsec_t fsec;
1414 int tz;
1415
1416 if (TIMESTAMP_IS_NOBEGIN(timestamp))
1417 DATE_NOBEGIN(result);
1418 else if (TIMESTAMP_IS_NOEND(timestamp))
1419 DATE_NOEND(result);
1420 else
1421 {
1422 if (timestamp2tm(timestamp, &tz, tm, &fsec, NULL, NULL) != 0)
1423 ereport(ERROR,
1424 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
1425 errmsg("timestamp out of range")));
1426
1427 result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - POSTGRES_EPOCH_JDATE;
1428 }
1429
1430 PG_RETURN_DATEADT(result);
1431 }
1432
1433
1434 /*****************************************************************************
1435 * Time ADT
1436 *****************************************************************************/
1437
1438 Datum
1439 time_in(PG_FUNCTION_ARGS)
1440 {
1441 char *str = PG_GETARG_CSTRING(0);
1442 #ifdef NOT_USED
1443 Oid typelem = PG_GETARG_OID(1);
1444 #endif
1445 int32 typmod = PG_GETARG_INT32(2);
1446 Node *escontext = fcinfo->context;
1447 TimeADT result;
1448 fsec_t fsec;
1449 struct pg_tm tt,
1450 *tm = &tt;
1451 int tz;
1452 int nf;
1453 int dterr;
1454 char workbuf[MAXDATELEN + 1];
1455 char *field[MAXDATEFIELDS];
1456 int dtype;
1457 int ftype[MAXDATEFIELDS];
1458 DateTimeErrorExtra extra;
1459
1460 dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
1461 field, ftype, MAXDATEFIELDS, &nf);
1462 if (dterr == 0)
1463 dterr = DecodeTimeOnly(field, ftype, nf,
1464 &dtype, tm, &fsec, &tz, &extra);
1465 if (dterr != 0)
1466 {
1467 DateTimeParseError(dterr, &extra, str, "time", escontext);
1468 PG_RETURN_NULL();
1469 }
1470
1471 tm2time(tm, fsec, &result);
1472 AdjustTimeForTypmod(&result, typmod);
1473
1474 PG_RETURN_TIMEADT(result);
1475 }
1476
1477 /* tm2time()
1478 * Convert a tm structure to a time data type.
1479 */
1480 int
1481 tm2time(struct pg_tm *tm, fsec_t fsec, TimeADT *result)
1482 {
1483 *result = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec)
1484 * USECS_PER_SEC) + fsec;
1485 return 0;
1486 }
1487
1488 /* time_overflows()
1489 * Check to see if a broken-down time-of-day is out of range.
1490 */
1491 bool
1492 time_overflows(int hour, int min, int sec, fsec_t fsec)
1493 {
1494 /* Range-check the fields individually. */
1495 if (hour < 0 || hour > HOURS_PER_DAY ||
1496 min < 0 || min >= MINS_PER_HOUR ||
1497 sec < 0 || sec > SECS_PER_MINUTE ||
1498 fsec < 0 || fsec > USECS_PER_SEC)
1499 return true;
1500
1501 /*
1502 * Because we allow, eg, hour = 24 or sec = 60, we must check separately
1503 * that the total time value doesn't exceed 24:00:00.
1504 */
1505 if ((((((hour * MINS_PER_HOUR + min) * SECS_PER_MINUTE)
1506 + sec) * USECS_PER_SEC) + fsec) > USECS_PER_DAY)
1507 return true;
1508
1509 return false;
1510 }
1511
1512 /* float_time_overflows()
1513 * Same, when we have seconds + fractional seconds as one "double" value.
1514 */
1515 bool
1516 float_time_overflows(int hour, int min, double sec)
1517 {
1518 /* Range-check the fields individually. */
1519 if (hour < 0 || hour > HOURS_PER_DAY ||
1520 min < 0 || min >= MINS_PER_HOUR)
1521 return true;
1522
1523 /*
1524 * "sec", being double, requires extra care. Cope with NaN, and round off
1525 * before applying the range check to avoid unexpected errors due to
1526 * imprecise input. (We assume rint() behaves sanely with infinities.)
1527 */
1528 if (isnan(sec))
1529 return true;
1530 sec = rint(sec * USECS_PER_SEC);
1531 if (sec < 0 || sec > SECS_PER_MINUTE * USECS_PER_SEC)
1532 return true;
1533
1534 /*
1535 * Because we allow, eg, hour = 24 or sec = 60, we must check separately
1536 * that the total time value doesn't exceed 24:00:00. This must match the
1537 * way that callers will convert the fields to a time.
1538 */
1539 if (((((hour * MINS_PER_HOUR + min) * SECS_PER_MINUTE)
1540 * USECS_PER_SEC) + (int64) sec) > USECS_PER_DAY)
1541 return true;
1542
1543 return false;
1544 }
1545
1546
1547 /* time2tm()
1548 * Convert time data type to POSIX time structure.
1549 *
1550 * Note that only the hour/min/sec/fractional-sec fields are filled in.
1551 */
1552 int
1553 time2tm(TimeADT time, struct pg_tm *tm, fsec_t *fsec)
1554 {
1555 tm->tm_hour = time / USECS_PER_HOUR;
1556 time -= tm->tm_hour * USECS_PER_HOUR;
1557 tm->tm_min = time / USECS_PER_MINUTE;
1558 time -= tm->tm_min * USECS_PER_MINUTE;
1559 tm->tm_sec = time / USECS_PER_SEC;
1560 time -= tm->tm_sec * USECS_PER_SEC;
1561 *fsec = time;
1562 return 0;
1563 }
1564
1565 Datum
1566 time_out(PG_FUNCTION_ARGS)
1567 {
1568 TimeADT time = PG_GETARG_TIMEADT(0);
1569 char *result;
1570 struct pg_tm tt,
1571 *tm = &tt;
1572 fsec_t fsec;
1573 char buf[MAXDATELEN + 1];
1574
1575 time2tm(time, tm, &fsec);
1576 EncodeTimeOnly(tm, fsec, false, 0, DateStyle, buf);
1577
1578 result = pstrdup(buf);
1579 PG_RETURN_CSTRING(result);
1580 }
1581
1582 /*
1583 * time_recv - converts external binary format to time
1584 */
1585 Datum
1586 time_recv(PG_FUNCTION_ARGS)
1587 {
1588 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
1589
1590 #ifdef NOT_USED
1591 Oid typelem = PG_GETARG_OID(1);
1592 #endif
1593 int32 typmod = PG_GETARG_INT32(2);
1594 TimeADT result;
1595
1596 result = pq_getmsgint64(buf);
1597
1598 if (result < INT64CONST(0) || result > USECS_PER_DAY)
1599 ereport(ERROR,
1600 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
1601 errmsg("time out of range")));
1602
1603 AdjustTimeForTypmod(&result, typmod);
1604
1605 PG_RETURN_TIMEADT(result);
1606 }
1607
1608 /*
1609 * time_send - converts time to binary format
1610 */
1611 Datum
1612 time_send(PG_FUNCTION_ARGS)
1613 {
1614 TimeADT time = PG_GETARG_TIMEADT(0);
1615 StringInfoData buf;
1616
1617 pq_begintypsend(&buf);
1618 pq_sendint64(&buf, time);
1619 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
1620 }
1621
1622 Datum
1623 timetypmodin(PG_FUNCTION_ARGS)
1624 {
1625 ArrayType *ta = PG_GETARG_ARRAYTYPE_P(0);
1626
1627 PG_RETURN_INT32(anytime_typmodin(false, ta));
1628 }
1629
1630 Datum
1631 timetypmodout(PG_FUNCTION_ARGS)
1632 {
1633 int32 typmod = PG_GETARG_INT32(0);
1634
1635 PG_RETURN_CSTRING(anytime_typmodout(false, typmod));
1636 }
1637
1638 /*
1639 * make_time - time constructor
1640 */
1641 Datum
1642 make_time(PG_FUNCTION_ARGS)
1643 {
1644 int tm_hour = PG_GETARG_INT32(0);
1645 int tm_min = PG_GETARG_INT32(1);
1646 double sec = PG_GETARG_FLOAT8(2);
1647 TimeADT time;
1648
1649 /* Check for time overflow */
1650 if (float_time_overflows(tm_hour, tm_min, sec))
1651 ereport(ERROR,
1652 (errcode(ERRCODE_DATETIME_FIELD_OVERFLOW),
1653 errmsg("time field value out of range: %d:%02d:%02g",
1654 tm_hour, tm_min, sec)));
1655
1656 /* This should match tm2time */
1657 time = (((tm_hour * MINS_PER_HOUR + tm_min) * SECS_PER_MINUTE)
1658 * USECS_PER_SEC) + (int64) rint(sec * USECS_PER_SEC);
1659
1660 PG_RETURN_TIMEADT(time);
1661 }
1662
1663
1664 /* time_support()
1665 *
1666 * Planner support function for the time_scale() and timetz_scale()
1667 * length coercion functions (we need not distinguish them here).
1668 */
1669 Datum
1670 time_support(PG_FUNCTION_ARGS)
1671 {
1672 Node *rawreq = (Node *) PG_GETARG_POINTER(0);
1673 Node *ret = NULL;
1674
1675 if (IsA(rawreq, SupportRequestSimplify))
1676 {
1677 SupportRequestSimplify *req = (SupportRequestSimplify *) rawreq;
1678
1679 ret = TemporalSimplify(MAX_TIME_PRECISION, (Node *) req->fcall);
1680 }
1681
1682 PG_RETURN_POINTER(ret);
1683 }
1684
1685 /* time_scale()
1686 * Adjust time type for specified scale factor.
1687 * Used by PostgreSQL type system to stuff columns.
1688 */
1689 Datum
1690 time_scale(PG_FUNCTION_ARGS)
1691 {
1692 TimeADT time = PG_GETARG_TIMEADT(0);
1693 int32 typmod = PG_GETARG_INT32(1);
1694 TimeADT result;
1695
1696 result = time;
1697 AdjustTimeForTypmod(&result, typmod);
1698
1699 PG_RETURN_TIMEADT(result);
1700 }
1701
1702 /* AdjustTimeForTypmod()
1703 * Force the precision of the time value to a specified value.
1704 * Uses *exactly* the same code as in AdjustTimestampForTypmod()
1705 * but we make a separate copy because those types do not
1706 * have a fundamental tie together but rather a coincidence of
1707 * implementation. - thomas
1708 */
1709 void
1710 AdjustTimeForTypmod(TimeADT *time, int32 typmod)
1711 {
1712 static const int64 TimeScales[MAX_TIME_PRECISION + 1] = {
1713 INT64CONST(1000000),
1714 INT64CONST(100000),
1715 INT64CONST(10000),
1716 INT64CONST(1000),
1717 INT64CONST(100),
1718 INT64CONST(10),
1719 INT64CONST(1)
1720 };
1721
1722 static const int64 TimeOffsets[MAX_TIME_PRECISION + 1] = {
1723 INT64CONST(500000),
1724 INT64CONST(50000),
1725 INT64CONST(5000),
1726 INT64CONST(500),
1727 INT64CONST(50),
1728 INT64CONST(5),
1729 INT64CONST(0)
1730 };
1731
1732 if (typmod >= 0 && typmod <= MAX_TIME_PRECISION)
1733 {
1734 if (*time >= INT64CONST(0))
1735 *time = ((*time + TimeOffsets[typmod]) / TimeScales[typmod]) *
1736 TimeScales[typmod];
1737 else
1738 *time = -((((-*time) + TimeOffsets[typmod]) / TimeScales[typmod]) *
1739 TimeScales[typmod]);
1740 }
1741 }
1742
1743
1744 Datum
1745 time_eq(PG_FUNCTION_ARGS)
1746 {
1747 TimeADT time1 = PG_GETARG_TIMEADT(0);
1748 TimeADT time2 = PG_GETARG_TIMEADT(1);
1749
1750 PG_RETURN_BOOL(time1 == time2);
1751 }
1752
1753 Datum
1754 time_ne(PG_FUNCTION_ARGS)
1755 {
1756 TimeADT time1 = PG_GETARG_TIMEADT(0);
1757 TimeADT time2 = PG_GETARG_TIMEADT(1);
1758
1759 PG_RETURN_BOOL(time1 != time2);
1760 }
1761
1762 Datum
1763 time_lt(PG_FUNCTION_ARGS)
1764 {
1765 TimeADT time1 = PG_GETARG_TIMEADT(0);
1766 TimeADT time2 = PG_GETARG_TIMEADT(1);
1767
1768 PG_RETURN_BOOL(time1 < time2);
1769 }
1770
1771 Datum
1772 time_le(PG_FUNCTION_ARGS)
1773 {
1774 TimeADT time1 = PG_GETARG_TIMEADT(0);
1775 TimeADT time2 = PG_GETARG_TIMEADT(1);
1776
1777 PG_RETURN_BOOL(time1 <= time2);
1778 }
1779
1780 Datum
1781 time_gt(PG_FUNCTION_ARGS)
1782 {
1783 TimeADT time1 = PG_GETARG_TIMEADT(0);
1784 TimeADT time2 = PG_GETARG_TIMEADT(1);
1785
1786 PG_RETURN_BOOL(time1 > time2);
1787 }
1788
1789 Datum
1790 time_ge(PG_FUNCTION_ARGS)
1791 {
1792 TimeADT time1 = PG_GETARG_TIMEADT(0);
1793 TimeADT time2 = PG_GETARG_TIMEADT(1);
1794
1795 PG_RETURN_BOOL(time1 >= time2);
1796 }
1797
1798 Datum
1799 time_cmp(PG_FUNCTION_ARGS)
1800 {
1801 TimeADT time1 = PG_GETARG_TIMEADT(0);
1802 TimeADT time2 = PG_GETARG_TIMEADT(1);
1803
1804 if (time1 < time2)
1805 PG_RETURN_INT32(-1);
1806 if (time1 > time2)
1807 PG_RETURN_INT32(1);
1808 PG_RETURN_INT32(0);
1809 }
1810
1811 Datum
1812 time_hash(PG_FUNCTION_ARGS)
1813 {
1814 return hashint8(fcinfo);
1815 }
1816
1817 Datum
1818 time_hash_extended(PG_FUNCTION_ARGS)
1819 {
1820 return hashint8extended(fcinfo);
1821 }
1822
1823 Datum
1824 time_larger(PG_FUNCTION_ARGS)
1825 {
1826 TimeADT time1 = PG_GETARG_TIMEADT(0);
1827 TimeADT time2 = PG_GETARG_TIMEADT(1);
1828
1829 PG_RETURN_TIMEADT((time1 > time2) ? time1 : time2);
1830 }
1831
1832 Datum
1833 time_smaller(PG_FUNCTION_ARGS)
1834 {
1835 TimeADT time1 = PG_GETARG_TIMEADT(0);
1836 TimeADT time2 = PG_GETARG_TIMEADT(1);
1837
1838 PG_RETURN_TIMEADT((time1 < time2) ? time1 : time2);
1839 }
1840
1841 /* overlaps_time() --- implements the SQL OVERLAPS operator.
1842 *
1843 * Algorithm is per SQL spec. This is much harder than you'd think
1844 * because the spec requires us to deliver a non-null answer in some cases
1845 * where some of the inputs are null.
1846 */
1847 Datum
1848 overlaps_time(PG_FUNCTION_ARGS)
1849 {
1850 /*
1851 * The arguments are TimeADT, but we leave them as generic Datums to avoid
1852 * dereferencing nulls (TimeADT is pass-by-reference!)
1853 */
1854 Datum ts1 = PG_GETARG_DATUM(0);
1855 Datum te1 = PG_GETARG_DATUM(1);
1856 Datum ts2 = PG_GETARG_DATUM(2);
1857 Datum te2 = PG_GETARG_DATUM(3);
1858 bool ts1IsNull = PG_ARGISNULL(0);
1859 bool te1IsNull = PG_ARGISNULL(1);
1860 bool ts2IsNull = PG_ARGISNULL(2);
1861 bool te2IsNull = PG_ARGISNULL(3);
1862
1863 #define TIMEADT_GT(t1,t2) \
1864 (DatumGetTimeADT(t1) > DatumGetTimeADT(t2))
1865 #define TIMEADT_LT(t1,t2) \
1866 (DatumGetTimeADT(t1) < DatumGetTimeADT(t2))
1867
1868 /*
1869 * If both endpoints of interval 1 are null, the result is null (unknown).
1870 * If just one endpoint is null, take ts1 as the non-null one. Otherwise,
1871 * take ts1 as the lesser endpoint.
1872 */
1873 if (ts1IsNull)
1874 {
1875 if (te1IsNull)
1876 PG_RETURN_NULL();
1877 /* swap null for non-null */
1878 ts1 = te1;
1879 te1IsNull = true;
1880 }
1881 else if (!te1IsNull)
1882 {
1883 if (TIMEADT_GT(ts1, te1))
1884 {
1885 Datum tt = ts1;
1886
1887 ts1 = te1;
1888 te1 = tt;
1889 }
1890 }
1891
1892 /* Likewise for interval 2. */
1893 if (ts2IsNull)
1894 {
1895 if (te2IsNull)
1896 PG_RETURN_NULL();
1897 /* swap null for non-null */
1898 ts2 = te2;
1899 te2IsNull = true;
1900 }
1901 else if (!te2IsNull)
1902 {
1903 if (TIMEADT_GT(ts2, te2))
1904 {
1905 Datum tt = ts2;
1906
1907 ts2 = te2;
1908 te2 = tt;
1909 }
1910 }
1911
1912 /*
1913 * At this point neither ts1 nor ts2 is null, so we can consider three
1914 * cases: ts1 > ts2, ts1 < ts2, ts1 = ts2
1915 */
1916 if (TIMEADT_GT(ts1, ts2))
1917 {
1918 /*
1919 * This case is ts1 < te2 OR te1 < te2, which may look redundant but
1920 * in the presence of nulls it's not quite completely so.
1921 */
1922 if (te2IsNull)
1923 PG_RETURN_NULL();
1924 if (TIMEADT_LT(ts1, te2))
1925 PG_RETURN_BOOL(true);
1926 if (te1IsNull)
1927 PG_RETURN_NULL();
1928
1929 /*
1930 * If te1 is not null then we had ts1 <= te1 above, and we just found
1931 * ts1 >= te2, hence te1 >= te2.
1932 */
1933 PG_RETURN_BOOL(false);
1934 }
1935 else if (TIMEADT_LT(ts1, ts2))
1936 {
1937 /* This case is ts2 < te1 OR te2 < te1 */
1938 if (te1IsNull)
1939 PG_RETURN_NULL();
1940 if (TIMEADT_LT(ts2, te1))
1941 PG_RETURN_BOOL(true);
1942 if (te2IsNull)
1943 PG_RETURN_NULL();
1944
1945 /*
1946 * If te2 is not null then we had ts2 <= te2 above, and we just found
1947 * ts2 >= te1, hence te2 >= te1.
1948 */
1949 PG_RETURN_BOOL(false);
1950 }
1951 else
1952 {
1953 /*
1954 * For ts1 = ts2 the spec says te1 <> te2 OR te1 = te2, which is a
1955 * rather silly way of saying "true if both are nonnull, else null".
1956 */
1957 if (te1IsNull || te2IsNull)
1958 PG_RETURN_NULL();
1959 PG_RETURN_BOOL(true);
1960 }
1961
1962 #undef TIMEADT_GT
1963 #undef TIMEADT_LT
1964 }
1965
1966 /* timestamp_time()
1967 * Convert timestamp to time data type.
1968 */
1969 Datum
1970 timestamp_time(PG_FUNCTION_ARGS)
1971 {
1972 Timestamp timestamp = PG_GETARG_TIMESTAMP(0);
1973 TimeADT result;
1974 struct pg_tm tt,
1975 *tm = &tt;
1976 fsec_t fsec;
1977
1978 if (TIMESTAMP_NOT_FINITE(timestamp))
1979 PG_RETURN_NULL();
1980
1981 if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) != 0)
1982 ereport(ERROR,
1983 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
1984 errmsg("timestamp out of range")));
1985
1986 /*
1987 * Could also do this with time = (timestamp / USECS_PER_DAY *
1988 * USECS_PER_DAY) - timestamp;
1989 */
1990 result = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
1991 USECS_PER_SEC) + fsec;
1992
1993 PG_RETURN_TIMEADT(result);
1994 }
1995
1996 /* timestamptz_time()
1997 * Convert timestamptz to time data type.
1998 */
1999 Datum
2000 timestamptz_time(PG_FUNCTION_ARGS)
2001 {
2002 TimestampTz timestamp = PG_GETARG_TIMESTAMP(0);
2003 TimeADT result;
2004 struct pg_tm tt,
2005 *tm = &tt;
2006 int tz;
2007 fsec_t fsec;
2008
2009 if (TIMESTAMP_NOT_FINITE(timestamp))
2010 PG_RETURN_NULL();
2011
2012 if (timestamp2tm(timestamp, &tz, tm, &fsec, NULL, NULL) != 0)
2013 ereport(ERROR,
2014 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2015 errmsg("timestamp out of range")));
2016
2017 /*
2018 * Could also do this with time = (timestamp / USECS_PER_DAY *
2019 * USECS_PER_DAY) - timestamp;
2020 */
2021 result = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
2022 USECS_PER_SEC) + fsec;
2023
2024 PG_RETURN_TIMEADT(result);
2025 }
2026
2027 /* datetime_timestamp()
2028 * Convert date and time to timestamp data type.
2029 */
2030 Datum
2031 datetime_timestamp(PG_FUNCTION_ARGS)
2032 {
2033 DateADT date = PG_GETARG_DATEADT(0);
2034 TimeADT time = PG_GETARG_TIMEADT(1);
2035 Timestamp result;
2036
2037 result = date2timestamp(date);
2038 if (!TIMESTAMP_NOT_FINITE(result))
2039 {
2040 result += time;
2041 if (!IS_VALID_TIMESTAMP(result))
2042 ereport(ERROR,
2043 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2044 errmsg("timestamp out of range")));
2045 }
2046
2047 PG_RETURN_TIMESTAMP(result);
2048 }
2049
2050 /* time_interval()
2051 * Convert time to interval data type.
2052 */
2053 Datum
2054 time_interval(PG_FUNCTION_ARGS)
2055 {
2056 TimeADT time = PG_GETARG_TIMEADT(0);
2057 Interval *result;
2058
2059 result = (Interval *) palloc(sizeof(Interval));
2060
2061 result->time = time;
2062 result->day = 0;
2063 result->month = 0;
2064
2065 PG_RETURN_INTERVAL_P(result);
2066 }
2067
2068 /* interval_time()
2069 * Convert interval to time data type.
2070 *
2071 * This is defined as producing the fractional-day portion of the interval.
2072 * Therefore, we can just ignore the months field. It is not real clear
2073 * what to do with negative intervals, but we choose to subtract the floor,
2074 * so that, say, '-2 hours' becomes '22:00:00'.
2075 */
2076 Datum
2077 interval_time(PG_FUNCTION_ARGS)
2078 {
2079 Interval *span = PG_GETARG_INTERVAL_P(0);
2080 TimeADT result;
2081
2082 if (INTERVAL_NOT_FINITE(span))
2083 ereport(ERROR,
2084 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2085 errmsg("cannot convert infinite interval to time")));
2086
2087 result = span->time % USECS_PER_DAY;
2088 if (result < 0)
2089 result += USECS_PER_DAY;
2090
2091 PG_RETURN_TIMEADT(result);
2092 }
2093
2094 /* time_mi_time()
2095 * Subtract two times to produce an interval.
2096 */
2097 Datum
2098 time_mi_time(PG_FUNCTION_ARGS)
2099 {
2100 TimeADT time1 = PG_GETARG_TIMEADT(0);
2101 TimeADT time2 = PG_GETARG_TIMEADT(1);
2102 Interval *result;
2103
2104 result = (Interval *) palloc(sizeof(Interval));
2105
2106 result->month = 0;
2107 result->day = 0;
2108 result->time = time1 - time2;
2109
2110 PG_RETURN_INTERVAL_P(result);
2111 }
2112
2113 /* time_pl_interval()
2114 * Add interval to time.
2115 */
2116 Datum
2117 time_pl_interval(PG_FUNCTION_ARGS)
2118 {
2119 TimeADT time = PG_GETARG_TIMEADT(0);
2120 Interval *span = PG_GETARG_INTERVAL_P(1);
2121 TimeADT result;
2122
2123 if (INTERVAL_NOT_FINITE(span))
2124 ereport(ERROR,
2125 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2126 errmsg("cannot add infinite interval to time")));
2127
2128 result = time + span->time;
2129 result -= result / USECS_PER_DAY * USECS_PER_DAY;
2130 if (result < INT64CONST(0))
2131 result += USECS_PER_DAY;
2132
2133 PG_RETURN_TIMEADT(result);
2134 }
2135
2136 /* time_mi_interval()
2137 * Subtract interval from time.
2138 */
2139 Datum
2140 time_mi_interval(PG_FUNCTION_ARGS)
2141 {
2142 TimeADT time = PG_GETARG_TIMEADT(0);
2143 Interval *span = PG_GETARG_INTERVAL_P(1);
2144 TimeADT result;
2145
2146 if (INTERVAL_NOT_FINITE(span))
2147 ereport(ERROR,
2148 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2149 errmsg("cannot subtract infinite interval from time")));
2150
2151 result = time - span->time;
2152 result -= result / USECS_PER_DAY * USECS_PER_DAY;
2153 if (result < INT64CONST(0))
2154 result += USECS_PER_DAY;
2155
2156 PG_RETURN_TIMEADT(result);
2157 }
2158
2159 /*
2160 * in_range support function for time.
2161 */
2162 Datum
2163 in_range_time_interval(PG_FUNCTION_ARGS)
2164 {
2165 TimeADT val = PG_GETARG_TIMEADT(0);
2166 TimeADT base = PG_GETARG_TIMEADT(1);
2167 Interval *offset = PG_GETARG_INTERVAL_P(2);
2168 bool sub = PG_GETARG_BOOL(3);
2169 bool less = PG_GETARG_BOOL(4);
2170 TimeADT sum;
2171
2172 /*
2173 * Like time_pl_interval/time_mi_interval, we disregard the month and day
2174 * fields of the offset. So our test for negative should too. This also
2175 * catches -infinity, so we only need worry about +infinity below.
2176 */
2177 if (offset->time < 0)
2178 ereport(ERROR,
2179 (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
2180 errmsg("invalid preceding or following size in window function")));
2181
2182 /*
2183 * We can't use time_pl_interval/time_mi_interval here, because their
2184 * wraparound behavior would give wrong (or at least undesirable) answers.
2185 * Fortunately the equivalent non-wrapping behavior is trivial, except
2186 * that adding an infinite (or very large) interval might cause integer
2187 * overflow. Subtraction cannot overflow here.
2188 */
2189 if (sub)
2190 sum = base - offset->time;
2191 else if (pg_add_s64_overflow(base, offset->time, &sum))
2192 PG_RETURN_BOOL(less);
2193
2194 if (less)
2195 PG_RETURN_BOOL(val <= sum);
2196 else
2197 PG_RETURN_BOOL(val >= sum);
2198 }
2199
2200
2201 /* time_part() and extract_time()
2202 * Extract specified field from time type.
2203 */
2204 static Datum
2205 time_part_common(PG_FUNCTION_ARGS, bool retnumeric)
2206 {
2207 text *units = PG_GETARG_TEXT_PP(0);
2208 TimeADT time = PG_GETARG_TIMEADT(1);
2209 int64 intresult;
2210 int type,
2211 val;
2212 char *lowunits;
2213
2214 lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
2215 VARSIZE_ANY_EXHDR(units),
2216 false);
2217
2218 type = DecodeUnits(0, lowunits, &val);
2219 if (type == UNKNOWN_FIELD)
2220 type = DecodeSpecial(0, lowunits, &val);
2221
2222 if (type == UNITS)
2223 {
2224 fsec_t fsec;
2225 struct pg_tm tt,
2226 *tm = &tt;
2227
2228 time2tm(time, tm, &fsec);
2229
2230 switch (val)
2231 {
2232 case DTK_MICROSEC:
2233 intresult = tm->tm_sec * INT64CONST(1000000) + fsec;
2234 break;
2235
2236 case DTK_MILLISEC:
2237 if (retnumeric)
2238 /*---
2239 * tm->tm_sec * 1000 + fsec / 1000
2240 * = (tm->tm_sec * 1'000'000 + fsec) / 1000
2241 */
2242 PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + fsec, 3));
2243 else
2244 PG_RETURN_FLOAT8(tm->tm_sec * 1000.0 + fsec / 1000.0);
2245 break;
2246
2247 case DTK_SECOND:
2248 if (retnumeric)
2249 /*---
2250 * tm->tm_sec + fsec / 1'000'000
2251 * = (tm->tm_sec * 1'000'000 + fsec) / 1'000'000
2252 */
2253 PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + fsec, 6));
2254 else
2255 PG_RETURN_FLOAT8(tm->tm_sec + fsec / 1000000.0);
2256 break;
2257
2258 case DTK_MINUTE:
2259 intresult = tm->tm_min;
2260 break;
2261
2262 case DTK_HOUR:
2263 intresult = tm->tm_hour;
2264 break;
2265
2266 case DTK_TZ:
2267 case DTK_TZ_MINUTE:
2268 case DTK_TZ_HOUR:
2269 case DTK_DAY:
2270 case DTK_MONTH:
2271 case DTK_QUARTER:
2272 case DTK_YEAR:
2273 case DTK_DECADE:
2274 case DTK_CENTURY:
2275 case DTK_MILLENNIUM:
2276 case DTK_ISOYEAR:
2277 default:
2278 ereport(ERROR,
2279 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2280 errmsg("unit \"%s\" not supported for type %s",
2281 lowunits, format_type_be(TIMEOID))));
2282 intresult = 0;
2283 }
2284 }
2285 else if (type == RESERV && val == DTK_EPOCH)
2286 {
2287 if (retnumeric)
2288 PG_RETURN_NUMERIC(int64_div_fast_to_numeric(time, 6));
2289 else
2290 PG_RETURN_FLOAT8(time / 1000000.0);
2291 }
2292 else
2293 {
2294 ereport(ERROR,
2295 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2296 errmsg("unit \"%s\" not recognized for type %s",
2297 lowunits, format_type_be(TIMEOID))));
2298 intresult = 0;
2299 }
2300
2301 if (retnumeric)
2302 PG_RETURN_NUMERIC(int64_to_numeric(intresult));
2303 else
2304 PG_RETURN_FLOAT8(intresult);
2305 }
2306
2307 Datum
2308 time_part(PG_FUNCTION_ARGS)
2309 {
2310 return time_part_common(fcinfo, false);
2311 }
2312
2313 Datum
2314 extract_time(PG_FUNCTION_ARGS)
2315 {
2316 return time_part_common(fcinfo, true);
2317 }
2318
2319
2320 /*****************************************************************************
2321 * Time With Time Zone ADT
2322 *****************************************************************************/
2323
2324 /* tm2timetz()
2325 * Convert a tm structure to a time data type.
2326 */
2327 int
2328 tm2timetz(struct pg_tm *tm, fsec_t fsec, int tz, TimeTzADT *result)
2329 {
2330 result->time = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
2331 USECS_PER_SEC) + fsec;
2332 result->zone = tz;
2333
2334 return 0;
2335 }
2336
2337 Datum
2338 timetz_in(PG_FUNCTION_ARGS)
2339 {
2340 char *str = PG_GETARG_CSTRING(0);
2341 #ifdef NOT_USED
2342 Oid typelem = PG_GETARG_OID(1);
2343 #endif
2344 int32 typmod = PG_GETARG_INT32(2);
2345 Node *escontext = fcinfo->context;
2346 TimeTzADT *result;
2347 fsec_t fsec;
2348 struct pg_tm tt,
2349 *tm = &tt;
2350 int tz;
2351 int nf;
2352 int dterr;
2353 char workbuf[MAXDATELEN + 1];
2354 char *field[MAXDATEFIELDS];
2355 int dtype;
2356 int ftype[MAXDATEFIELDS];
2357 DateTimeErrorExtra extra;
2358
2359 dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
2360 field, ftype, MAXDATEFIELDS, &nf);
2361 if (dterr == 0)
2362 dterr = DecodeTimeOnly(field, ftype, nf,
2363 &dtype, tm, &fsec, &tz, &extra);
2364 if (dterr != 0)
2365 {
2366 DateTimeParseError(dterr, &extra, str, "time with time zone",
2367 escontext);
2368 PG_RETURN_NULL();
2369 }
2370
2371 result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
2372 tm2timetz(tm, fsec, tz, result);
2373 AdjustTimeForTypmod(&(result->time), typmod);
2374
2375 PG_RETURN_TIMETZADT_P(result);
2376 }
2377
2378 Datum
2379 timetz_out(PG_FUNCTION_ARGS)
2380 {
2381 TimeTzADT *time = PG_GETARG_TIMETZADT_P(0);
2382 char *result;
2383 struct pg_tm tt,
2384 *tm = &tt;
2385 fsec_t fsec;
2386 int tz;
2387 char buf[MAXDATELEN + 1];
2388
2389 timetz2tm(time, tm, &fsec, &tz);
2390 EncodeTimeOnly(tm, fsec, true, tz, DateStyle, buf);
2391
2392 result = pstrdup(buf);
2393 PG_RETURN_CSTRING(result);
2394 }
2395
2396 /*
2397 * timetz_recv - converts external binary format to timetz
2398 */
2399 Datum
2400 timetz_recv(PG_FUNCTION_ARGS)
2401 {
2402 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
2403
2404 #ifdef NOT_USED
2405 Oid typelem = PG_GETARG_OID(1);
2406 #endif
2407 int32 typmod = PG_GETARG_INT32(2);
2408 TimeTzADT *result;
2409
2410 result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
2411
2412 result->time = pq_getmsgint64(buf);
2413
2414 if (result->time < INT64CONST(0) || result->time > USECS_PER_DAY)
2415 ereport(ERROR,
2416 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2417 errmsg("time out of range")));
2418
2419 result->zone = pq_getmsgint(buf, sizeof(result->zone));
2420
2421 /* Check for sane GMT displacement; see notes in datatype/timestamp.h */
2422 if (result->zone <= -TZDISP_LIMIT || result->zone >= TZDISP_LIMIT)
2423 ereport(ERROR,
2424 (errcode(ERRCODE_INVALID_TIME_ZONE_DISPLACEMENT_VALUE),
2425 errmsg("time zone displacement out of range")));
2426
2427 AdjustTimeForTypmod(&(result->time), typmod);
2428
2429 PG_RETURN_TIMETZADT_P(result);
2430 }
2431
2432 /*
2433 * timetz_send - converts timetz to binary format
2434 */
2435 Datum
2436 timetz_send(PG_FUNCTION_ARGS)
2437 {
2438 TimeTzADT *time = PG_GETARG_TIMETZADT_P(0);
2439 StringInfoData buf;
2440
2441 pq_begintypsend(&buf);
2442 pq_sendint64(&buf, time->time);
2443 pq_sendint32(&buf, time->zone);
2444 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
2445 }
2446
2447 Datum
2448 timetztypmodin(PG_FUNCTION_ARGS)
2449 {
2450 ArrayType *ta = PG_GETARG_ARRAYTYPE_P(0);
2451
2452 PG_RETURN_INT32(anytime_typmodin(true, ta));
2453 }
2454
2455 Datum
2456 timetztypmodout(PG_FUNCTION_ARGS)
2457 {
2458 int32 typmod = PG_GETARG_INT32(0);
2459
2460 PG_RETURN_CSTRING(anytime_typmodout(true, typmod));
2461 }
2462
2463
2464 /* timetz2tm()
2465 * Convert TIME WITH TIME ZONE data type to POSIX time structure.
2466 */
2467 int
2468 timetz2tm(TimeTzADT *time, struct pg_tm *tm, fsec_t *fsec, int *tzp)
2469 {
2470 TimeOffset trem = time->time;
2471
2472 tm->tm_hour = trem / USECS_PER_HOUR;
2473 trem -= tm->tm_hour * USECS_PER_HOUR;
2474 tm->tm_min = trem / USECS_PER_MINUTE;
2475 trem -= tm->tm_min * USECS_PER_MINUTE;
2476 tm->tm_sec = trem / USECS_PER_SEC;
2477 *fsec = trem - tm->tm_sec * USECS_PER_SEC;
2478
2479 if (tzp != NULL)
2480 *tzp = time->zone;
2481
2482 return 0;
2483 }
2484
2485 /* timetz_scale()
2486 * Adjust time type for specified scale factor.
2487 * Used by PostgreSQL type system to stuff columns.
2488 */
2489 Datum
2490 timetz_scale(PG_FUNCTION_ARGS)
2491 {
2492 TimeTzADT *time = PG_GETARG_TIMETZADT_P(0);
2493 int32 typmod = PG_GETARG_INT32(1);
2494 TimeTzADT *result;
2495
2496 result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
2497
2498 result->time = time->time;
2499 result->zone = time->zone;
2500
2501 AdjustTimeForTypmod(&(result->time), typmod);
2502
2503 PG_RETURN_TIMETZADT_P(result);
2504 }
2505
2506
2507 static int
2508 timetz_cmp_internal(TimeTzADT *time1, TimeTzADT *time2)
2509 {
2510 TimeOffset t1,
2511 t2;
2512
2513 /* Primary sort is by true (GMT-equivalent) time */
2514 t1 = time1->time + (time1->zone * USECS_PER_SEC);
2515 t2 = time2->time + (time2->zone * USECS_PER_SEC);
2516
2517 if (t1 > t2)
2518 return 1;
2519 if (t1 < t2)
2520 return -1;
2521
2522 /*
2523 * If same GMT time, sort by timezone; we only want to say that two
2524 * timetz's are equal if both the time and zone parts are equal.
2525 */
2526 if (time1->zone > time2->zone)
2527 return 1;
2528 if (time1->zone < time2->zone)
2529 return -1;
2530
2531 return 0;
2532 }
2533
2534 Datum
2535 timetz_eq(PG_FUNCTION_ARGS)
2536 {
2537 TimeTzADT *time1 = PG_GETARG_TIMETZADT_P(0);
2538 TimeTzADT *time2 = PG_GETARG_TIMETZADT_P(1);
2539
2540 PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) == 0);
2541 }
2542
2543 Datum
2544 timetz_ne(PG_FUNCTION_ARGS)
2545 {
2546 TimeTzADT *time1 = PG_GETARG_TIMETZADT_P(0);
2547 TimeTzADT *time2 = PG_GETARG_TIMETZADT_P(1);
2548
2549 PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) != 0);
2550 }
2551
2552 Datum
2553 timetz_lt(PG_FUNCTION_ARGS)
2554 {
2555 TimeTzADT *time1 = PG_GETARG_TIMETZADT_P(0);
2556 TimeTzADT *time2 = PG_GETARG_TIMETZADT_P(1);
2557
2558 PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) < 0);
2559 }
2560
2561 Datum
2562 timetz_le(PG_FUNCTION_ARGS)
2563 {
2564 TimeTzADT *time1 = PG_GETARG_TIMETZADT_P(0);
2565 TimeTzADT *time2 = PG_GETARG_TIMETZADT_P(1);
2566
2567 PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) <= 0);
2568 }
2569
2570 Datum
2571 timetz_gt(PG_FUNCTION_ARGS)
2572 {
2573 TimeTzADT *time1 = PG_GETARG_TIMETZADT_P(0);
2574 TimeTzADT *time2 = PG_GETARG_TIMETZADT_P(1);
2575
2576 PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) > 0);
2577 }
2578
2579 Datum
2580 timetz_ge(PG_FUNCTION_ARGS)
2581 {
2582 TimeTzADT *time1 = PG_GETARG_TIMETZADT_P(0);
2583 TimeTzADT *time2 = PG_GETARG_TIMETZADT_P(1);
2584
2585 PG_RETURN_BOOL(timetz_cmp_internal(time1, time2) >= 0);
2586 }
2587
2588 Datum
2589 timetz_cmp(PG_FUNCTION_ARGS)
2590 {
2591 TimeTzADT *time1 = PG_GETARG_TIMETZADT_P(0);
2592 TimeTzADT *time2 = PG_GETARG_TIMETZADT_P(1);
2593
2594 PG_RETURN_INT32(timetz_cmp_internal(time1, time2));
2595 }
2596
2597 Datum
2598 timetz_hash(PG_FUNCTION_ARGS)
2599 {
2600 TimeTzADT *key = PG_GETARG_TIMETZADT_P(0);
2601 uint32 thash;
2602
2603 /*
2604 * To avoid any problems with padding bytes in the struct, we figure the
2605 * field hashes separately and XOR them.
2606 */
2607 thash = DatumGetUInt32(DirectFunctionCall1(hashint8,
2608 Int64GetDatumFast(key->time)));
2609 thash ^= DatumGetUInt32(hash_uint32(key->zone));
2610 PG_RETURN_UINT32(thash);
2611 }
2612
2613 Datum
2614 timetz_hash_extended(PG_FUNCTION_ARGS)
2615 {
2616 TimeTzADT *key = PG_GETARG_TIMETZADT_P(0);
2617 Datum seed = PG_GETARG_DATUM(1);
2618 uint64 thash;
2619
2620 /* Same approach as timetz_hash */
2621 thash = DatumGetUInt64(DirectFunctionCall2(hashint8extended,
2622 Int64GetDatumFast(key->time),
2623 seed));
2624 thash ^= DatumGetUInt64(hash_uint32_extended(key->zone,
2625 DatumGetInt64(seed)));
2626 PG_RETURN_UINT64(thash);
2627 }
2628
2629 Datum
2630 timetz_larger(PG_FUNCTION_ARGS)
2631 {
2632 TimeTzADT *time1 = PG_GETARG_TIMETZADT_P(0);
2633 TimeTzADT *time2 = PG_GETARG_TIMETZADT_P(1);
2634 TimeTzADT *result;
2635
2636 if (timetz_cmp_internal(time1, time2) > 0)
2637 result = time1;
2638 else
2639 result = time2;
2640 PG_RETURN_TIMETZADT_P(result);
2641 }
2642
2643 Datum
2644 timetz_smaller(PG_FUNCTION_ARGS)
2645 {
2646 TimeTzADT *time1 = PG_GETARG_TIMETZADT_P(0);
2647 TimeTzADT *time2 = PG_GETARG_TIMETZADT_P(1);
2648 TimeTzADT *result;
2649
2650 if (timetz_cmp_internal(time1, time2) < 0)
2651 result = time1;
2652 else
2653 result = time2;
2654 PG_RETURN_TIMETZADT_P(result);
2655 }
2656
2657 /* timetz_pl_interval()
2658 * Add interval to timetz.
2659 */
2660 Datum
2661 timetz_pl_interval(PG_FUNCTION_ARGS)
2662 {
2663 TimeTzADT *time = PG_GETARG_TIMETZADT_P(0);
2664 Interval *span = PG_GETARG_INTERVAL_P(1);
2665 TimeTzADT *result;
2666
2667 if (INTERVAL_NOT_FINITE(span))
2668 ereport(ERROR,
2669 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2670 errmsg("cannot add infinite interval to time")));
2671
2672 result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
2673
2674 result->time = time->time + span->time;
2675 result->time -= result->time / USECS_PER_DAY * USECS_PER_DAY;
2676 if (result->time < INT64CONST(0))
2677 result->time += USECS_PER_DAY;
2678
2679 result->zone = time->zone;
2680
2681 PG_RETURN_TIMETZADT_P(result);
2682 }
2683
2684 /* timetz_mi_interval()
2685 * Subtract interval from timetz.
2686 */
2687 Datum
2688 timetz_mi_interval(PG_FUNCTION_ARGS)
2689 {
2690 TimeTzADT *time = PG_GETARG_TIMETZADT_P(0);
2691 Interval *span = PG_GETARG_INTERVAL_P(1);
2692 TimeTzADT *result;
2693
2694 if (INTERVAL_NOT_FINITE(span))
2695 ereport(ERROR,
2696 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2697 errmsg("cannot subtract infinite interval from time")));
2698
2699 result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
2700
2701 result->time = time->time - span->time;
2702 result->time -= result->time / USECS_PER_DAY * USECS_PER_DAY;
2703 if (result->time < INT64CONST(0))
2704 result->time += USECS_PER_DAY;
2705
2706 result->zone = time->zone;
2707
2708 PG_RETURN_TIMETZADT_P(result);
2709 }
2710
2711 /*
2712 * in_range support function for timetz.
2713 */
2714 Datum
2715 in_range_timetz_interval(PG_FUNCTION_ARGS)
2716 {
2717 TimeTzADT *val = PG_GETARG_TIMETZADT_P(0);
2718 TimeTzADT *base = PG_GETARG_TIMETZADT_P(1);
2719 Interval *offset = PG_GETARG_INTERVAL_P(2);
2720 bool sub = PG_GETARG_BOOL(3);
2721 bool less = PG_GETARG_BOOL(4);
2722 TimeTzADT sum;
2723
2724 /*
2725 * Like timetz_pl_interval/timetz_mi_interval, we disregard the month and
2726 * day fields of the offset. So our test for negative should too. This
2727 * also catches -infinity, so we only need worry about +infinity below.
2728 */
2729 if (offset->time < 0)
2730 ereport(ERROR,
2731 (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
2732 errmsg("invalid preceding or following size in window function")));
2733
2734 /*
2735 * We can't use timetz_pl_interval/timetz_mi_interval here, because their
2736 * wraparound behavior would give wrong (or at least undesirable) answers.
2737 * Fortunately the equivalent non-wrapping behavior is trivial, except
2738 * that adding an infinite (or very large) interval might cause integer
2739 * overflow. Subtraction cannot overflow here.
2740 */
2741 if (sub)
2742 sum.time = base->time - offset->time;
2743 else if (pg_add_s64_overflow(base->time, offset->time, &sum.time))
2744 PG_RETURN_BOOL(less);
2745 sum.zone = base->zone;
2746
2747 if (less)
2748 PG_RETURN_BOOL(timetz_cmp_internal(val, &sum) <= 0);
2749 else
2750 PG_RETURN_BOOL(timetz_cmp_internal(val, &sum) >= 0);
2751 }
2752
2753 /* overlaps_timetz() --- implements the SQL OVERLAPS operator.
2754 *
2755 * Algorithm is per SQL spec. This is much harder than you'd think
2756 * because the spec requires us to deliver a non-null answer in some cases
2757 * where some of the inputs are null.
2758 */
2759 Datum
2760 overlaps_timetz(PG_FUNCTION_ARGS)
2761 {
2762 /*
2763 * The arguments are TimeTzADT *, but we leave them as generic Datums for
2764 * convenience of notation --- and to avoid dereferencing nulls.
2765 */
2766 Datum ts1 = PG_GETARG_DATUM(0);
2767 Datum te1 = PG_GETARG_DATUM(1);
2768 Datum ts2 = PG_GETARG_DATUM(2);
2769 Datum te2 = PG_GETARG_DATUM(3);
2770 bool ts1IsNull = PG_ARGISNULL(0);
2771 bool te1IsNull = PG_ARGISNULL(1);
2772 bool ts2IsNull = PG_ARGISNULL(2);
2773 bool te2IsNull = PG_ARGISNULL(3);
2774
2775 #define TIMETZ_GT(t1,t2) \
2776 DatumGetBool(DirectFunctionCall2(timetz_gt,t1,t2))
2777 #define TIMETZ_LT(t1,t2) \
2778 DatumGetBool(DirectFunctionCall2(timetz_lt,t1,t2))
2779
2780 /*
2781 * If both endpoints of interval 1 are null, the result is null (unknown).
2782 * If just one endpoint is null, take ts1 as the non-null one. Otherwise,
2783 * take ts1 as the lesser endpoint.
2784 */
2785 if (ts1IsNull)
2786 {
2787 if (te1IsNull)
2788 PG_RETURN_NULL();
2789 /* swap null for non-null */
2790 ts1 = te1;
2791 te1IsNull = true;
2792 }
2793 else if (!te1IsNull)
2794 {
2795 if (TIMETZ_GT(ts1, te1))
2796 {
2797 Datum tt = ts1;
2798
2799 ts1 = te1;
2800 te1 = tt;
2801 }
2802 }
2803
2804 /* Likewise for interval 2. */
2805 if (ts2IsNull)
2806 {
2807 if (te2IsNull)
2808 PG_RETURN_NULL();
2809 /* swap null for non-null */
2810 ts2 = te2;
2811 te2IsNull = true;
2812 }
2813 else if (!te2IsNull)
2814 {
2815 if (TIMETZ_GT(ts2, te2))
2816 {
2817 Datum tt = ts2;
2818
2819 ts2 = te2;
2820 te2 = tt;
2821 }
2822 }
2823
2824 /*
2825 * At this point neither ts1 nor ts2 is null, so we can consider three
2826 * cases: ts1 > ts2, ts1 < ts2, ts1 = ts2
2827 */
2828 if (TIMETZ_GT(ts1, ts2))
2829 {
2830 /*
2831 * This case is ts1 < te2 OR te1 < te2, which may look redundant but
2832 * in the presence of nulls it's not quite completely so.
2833 */
2834 if (te2IsNull)
2835 PG_RETURN_NULL();
2836 if (TIMETZ_LT(ts1, te2))
2837 PG_RETURN_BOOL(true);
2838 if (te1IsNull)
2839 PG_RETURN_NULL();
2840
2841 /*
2842 * If te1 is not null then we had ts1 <= te1 above, and we just found
2843 * ts1 >= te2, hence te1 >= te2.
2844 */
2845 PG_RETURN_BOOL(false);
2846 }
2847 else if (TIMETZ_LT(ts1, ts2))
2848 {
2849 /* This case is ts2 < te1 OR te2 < te1 */
2850 if (te1IsNull)
2851 PG_RETURN_NULL();
2852 if (TIMETZ_LT(ts2, te1))
2853 PG_RETURN_BOOL(true);
2854 if (te2IsNull)
2855 PG_RETURN_NULL();
2856
2857 /*
2858 * If te2 is not null then we had ts2 <= te2 above, and we just found
2859 * ts2 >= te1, hence te2 >= te1.
2860 */
2861 PG_RETURN_BOOL(false);
2862 }
2863 else
2864 {
2865 /*
2866 * For ts1 = ts2 the spec says te1 <> te2 OR te1 = te2, which is a
2867 * rather silly way of saying "true if both are nonnull, else null".
2868 */
2869 if (te1IsNull || te2IsNull)
2870 PG_RETURN_NULL();
2871 PG_RETURN_BOOL(true);
2872 }
2873
2874 #undef TIMETZ_GT
2875 #undef TIMETZ_LT
2876 }
2877
2878
2879 Datum
2880 timetz_time(PG_FUNCTION_ARGS)
2881 {
2882 TimeTzADT *timetz = PG_GETARG_TIMETZADT_P(0);
2883 TimeADT result;
2884
2885 /* swallow the time zone and just return the time */
2886 result = timetz->time;
2887
2888 PG_RETURN_TIMEADT(result);
2889 }
2890
2891
2892 Datum
2893 time_timetz(PG_FUNCTION_ARGS)
2894 {
2895 TimeADT time = PG_GETARG_TIMEADT(0);
2896 TimeTzADT *result;
2897 struct pg_tm tt,
2898 *tm = &tt;
2899 fsec_t fsec;
2900 int tz;
2901
2902 GetCurrentDateTime(tm);
2903 time2tm(time, tm, &fsec);
2904 tz = DetermineTimeZoneOffset(tm, session_timezone);
2905
2906 result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
2907
2908 result->time = time;
2909 result->zone = tz;
2910
2911 PG_RETURN_TIMETZADT_P(result);
2912 }
2913
2914
2915 /* timestamptz_timetz()
2916 * Convert timestamp to timetz data type.
2917 */
2918 Datum
2919 timestamptz_timetz(PG_FUNCTION_ARGS)
2920 {
2921 TimestampTz timestamp = PG_GETARG_TIMESTAMP(0);
2922 TimeTzADT *result;
2923 struct pg_tm tt,
2924 *tm = &tt;
2925 int tz;
2926 fsec_t fsec;
2927
2928 if (TIMESTAMP_NOT_FINITE(timestamp))
2929 PG_RETURN_NULL();
2930
2931 if (timestamp2tm(timestamp, &tz, tm, &fsec, NULL, NULL) != 0)
2932 ereport(ERROR,
2933 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2934 errmsg("timestamp out of range")));
2935
2936 result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
2937
2938 tm2timetz(tm, fsec, tz, result);
2939
2940 PG_RETURN_TIMETZADT_P(result);
2941 }
2942
2943
2944 /* datetimetz_timestamptz()
2945 * Convert date and timetz to timestamp with time zone data type.
2946 * Timestamp is stored in GMT, so add the time zone
2947 * stored with the timetz to the result.
2948 * - thomas 2000-03-10
2949 */
2950 Datum
2951 datetimetz_timestamptz(PG_FUNCTION_ARGS)
2952 {
2953 DateADT date = PG_GETARG_DATEADT(0);
2954 TimeTzADT *time = PG_GETARG_TIMETZADT_P(1);
2955 TimestampTz result;
2956
2957 if (DATE_IS_NOBEGIN(date))
2958 TIMESTAMP_NOBEGIN(result);
2959 else if (DATE_IS_NOEND(date))
2960 TIMESTAMP_NOEND(result);
2961 else
2962 {
2963 /*
2964 * Date's range is wider than timestamp's, so check for boundaries.
2965 * Since dates have the same minimum values as timestamps, only upper
2966 * boundary need be checked for overflow.
2967 */
2968 if (date >= (TIMESTAMP_END_JULIAN - POSTGRES_EPOCH_JDATE))
2969 ereport(ERROR,
2970 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2971 errmsg("date out of range for timestamp")));
2972 result = date * USECS_PER_DAY + time->time + time->zone * USECS_PER_SEC;
2973
2974 /*
2975 * Since it is possible to go beyond allowed timestamptz range because
2976 * of time zone, check for allowed timestamp range after adding tz.
2977 */
2978 if (!IS_VALID_TIMESTAMP(result))
2979 ereport(ERROR,
2980 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2981 errmsg("date out of range for timestamp")));
2982 }
2983
2984 PG_RETURN_TIMESTAMP(result);
2985 }
2986
2987
2988 /* timetz_part() and extract_timetz()
2989 * Extract specified field from time type.
2990 */
2991 static Datum
2992 timetz_part_common(PG_FUNCTION_ARGS, bool retnumeric)
2993 {
2994 text *units = PG_GETARG_TEXT_PP(0);
2995 TimeTzADT *time = PG_GETARG_TIMETZADT_P(1);
2996 int64 intresult;
2997 int type,
2998 val;
2999 char *lowunits;
3000
3001 lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
3002 VARSIZE_ANY_EXHDR(units),
3003 false);
3004
3005 type = DecodeUnits(0, lowunits, &val);
3006 if (type == UNKNOWN_FIELD)
3007 type = DecodeSpecial(0, lowunits, &val);
3008
3009 if (type == UNITS)
3010 {
3011 int tz;
3012 fsec_t fsec;
3013 struct pg_tm tt,
3014 *tm = &tt;
3015
3016 timetz2tm(time, tm, &fsec, &tz);
3017
3018 switch (val)
3019 {
3020 case DTK_TZ:
3021 intresult = -tz;
3022 break;
3023
3024 case DTK_TZ_MINUTE:
3025 intresult = (-tz / SECS_PER_MINUTE) % MINS_PER_HOUR;
3026 break;
3027
3028 case DTK_TZ_HOUR:
3029 intresult = -tz / SECS_PER_HOUR;
3030 break;
3031
3032 case DTK_MICROSEC:
3033 intresult = tm->tm_sec * INT64CONST(1000000) + fsec;
3034 break;
3035
3036 case DTK_MILLISEC:
3037 if (retnumeric)
3038 /*---
3039 * tm->tm_sec * 1000 + fsec / 1000
3040 * = (tm->tm_sec * 1'000'000 + fsec) / 1000
3041 */
3042 PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + fsec, 3));
3043 else
3044 PG_RETURN_FLOAT8(tm->tm_sec * 1000.0 + fsec / 1000.0);
3045 break;
3046
3047 case DTK_SECOND:
3048 if (retnumeric)
3049 /*---
3050 * tm->tm_sec + fsec / 1'000'000
3051 * = (tm->tm_sec * 1'000'000 + fsec) / 1'000'000
3052 */
3053 PG_RETURN_NUMERIC(int64_div_fast_to_numeric(tm->tm_sec * INT64CONST(1000000) + fsec, 6));
3054 else
3055 PG_RETURN_FLOAT8(tm->tm_sec + fsec / 1000000.0);
3056 break;
3057
3058 case DTK_MINUTE:
3059 intresult = tm->tm_min;
3060 break;
3061
3062 case DTK_HOUR:
3063 intresult = tm->tm_hour;
3064 break;
3065
3066 case DTK_DAY:
3067 case DTK_MONTH:
3068 case DTK_QUARTER:
3069 case DTK_YEAR:
3070 case DTK_DECADE:
3071 case DTK_CENTURY:
3072 case DTK_MILLENNIUM:
3073 default:
3074 ereport(ERROR,
3075 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3076 errmsg("unit \"%s\" not supported for type %s",
3077 lowunits, format_type_be(TIMETZOID))));
3078 intresult = 0;
3079 }
3080 }
3081 else if (type == RESERV && val == DTK_EPOCH)
3082 {
3083 if (retnumeric)
3084 /*---
3085 * time->time / 1'000'000 + time->zone
3086 * = (time->time + time->zone * 1'000'000) / 1'000'000
3087 */
3088 PG_RETURN_NUMERIC(int64_div_fast_to_numeric(time->time + time->zone * INT64CONST(1000000), 6));
3089 else
3090 PG_RETURN_FLOAT8(time->time / 1000000.0 + time->zone);
3091 }
3092 else
3093 {
3094 ereport(ERROR,
3095 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3096 errmsg("unit \"%s\" not recognized for type %s",
3097 lowunits, format_type_be(TIMETZOID))));
3098 intresult = 0;
3099 }
3100
3101 if (retnumeric)
3102 PG_RETURN_NUMERIC(int64_to_numeric(intresult));
3103 else
3104 PG_RETURN_FLOAT8(intresult);
3105 }
3106
3107
3108 Datum
3109 timetz_part(PG_FUNCTION_ARGS)
3110 {
3111 return timetz_part_common(fcinfo, false);
3112 }
3113
3114 Datum
3115 extract_timetz(PG_FUNCTION_ARGS)
3116 {
3117 return timetz_part_common(fcinfo, true);
3118 }
3119
3120 /* timetz_zone()
3121 * Encode time with time zone type with specified time zone.
3122 * Applies DST rules as of the transaction start time.
3123 */
3124 Datum
3125 timetz_zone(PG_FUNCTION_ARGS)
3126 {
3127 text *zone = PG_GETARG_TEXT_PP(0);
3128 TimeTzADT *t = PG_GETARG_TIMETZADT_P(1);
3129 TimeTzADT *result;
3130 int tz;
3131 char tzname[TZ_STRLEN_MAX + 1];
3132 int type,
3133 val;
3134 pg_tz *tzp;
3135
3136 /*
3137 * Look up the requested timezone.
3138 */
3139 text_to_cstring_buffer(zone, tzname, sizeof(tzname));
3140
3141 type = DecodeTimezoneName(tzname, &val, &tzp);
3142
3143 if (type == TZNAME_FIXED_OFFSET)
3144 {
3145 /* fixed-offset abbreviation */
3146 tz = -val;
3147 }
3148 else if (type == TZNAME_DYNTZ)
3149 {
3150 /* dynamic-offset abbreviation, resolve using transaction start time */
3151 TimestampTz now = GetCurrentTransactionStartTimestamp();
3152 int isdst;
3153
3154 tz = DetermineTimeZoneAbbrevOffsetTS(now, tzname, tzp, &isdst);
3155 }
3156 else
3157 {
3158 /* Get the offset-from-GMT that is valid now for the zone name */
3159 TimestampTz now = GetCurrentTransactionStartTimestamp();
3160 struct pg_tm tm;
3161 fsec_t fsec;
3162
3163 if (timestamp2tm(now, &tz, &tm, &fsec, NULL, tzp) != 0)
3164 ereport(ERROR,
3165 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
3166 errmsg("timestamp out of range")));
3167 }
3168
3169 result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
3170
3171 result->time = t->time + (t->zone - tz) * USECS_PER_SEC;
3172 /* C99 modulo has the wrong sign convention for negative input */
3173 while (result->time < INT64CONST(0))
3174 result->time += USECS_PER_DAY;
3175 if (result->time >= USECS_PER_DAY)
3176 result->time %= USECS_PER_DAY;
3177
3178 result->zone = tz;
3179
3180 PG_RETURN_TIMETZADT_P(result);
3181 }
3182
3183 /* timetz_izone()
3184 * Encode time with time zone type with specified time interval as time zone.
3185 */
3186 Datum
3187 timetz_izone(PG_FUNCTION_ARGS)
3188 {
3189 Interval *zone = PG_GETARG_INTERVAL_P(0);
3190 TimeTzADT *time = PG_GETARG_TIMETZADT_P(1);
3191 TimeTzADT *result;
3192 int tz;
3193
3194 if (INTERVAL_NOT_FINITE(zone))
3195 ereport(ERROR,
3196 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3197 errmsg("interval time zone \"%s\" must be finite",
3198 DatumGetCString(DirectFunctionCall1(interval_out,
3199 PointerGetDatum(zone))))));
3200
3201 if (zone->month != 0 || zone->day != 0)
3202 ereport(ERROR,
3203 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3204 errmsg("interval time zone \"%s\" must not include months or days",
3205 DatumGetCString(DirectFunctionCall1(interval_out,
3206 PointerGetDatum(zone))))));
3207
3208 tz = -(zone->time / USECS_PER_SEC);
3209
3210 result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
3211
3212 result->time = time->time + (time->zone - tz) * USECS_PER_SEC;
3213 /* C99 modulo has the wrong sign convention for negative input */
3214 while (result->time < INT64CONST(0))
3215 result->time += USECS_PER_DAY;
3216 if (result->time >= USECS_PER_DAY)
3217 result->time %= USECS_PER_DAY;
3218
3219 result->zone = tz;
3220
3221 PG_RETURN_TIMETZADT_P(result);
3222 }
3223
3224 /* timetz_at_local()
3225 *
3226 * Unlike for timestamp[tz]_at_local, the type for timetz does not flip between
3227 * time with/without time zone, so we cannot just call the conversion function.
3228 */
3229 Datum
3230 timetz_at_local(PG_FUNCTION_ARGS)
3231 {
3232 Datum time = PG_GETARG_DATUM(0);
3233 const char *tzn = pg_get_timezone_name(session_timezone);
3234 Datum zone = PointerGetDatum(cstring_to_text(tzn));
3235
3236 return DirectFunctionCall2(timetz_zone, zone, time);
3237 }