open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add 'day' field to INTERVAL so 1 day interval can be distinguished from

Browse Source 
24 hours. This is very helpful for daylight savings time:

	select '2005-05-03 00:00:00 EST'::timestamp with time zone + '24 hours';
	      ?column?
	----------------------
	2005-05-04 01:00:00-04

	select '2005-05-03 00:00:00 EST'::timestamp with time zone + '1 day';
	      ?column?
	----------------------
	2005-05-04 01:00:00-04

Michael Glaesemann
REL8_1_STABLE
Bruce Momjian 20 years ago
parent 826604f9e6
commit db05f4a7eb
12 changed files with 286 additions and 181 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 18
      doc/src/sgml/func.sgml
  2. 12
      src/backend/commands/variable.c
  3. 6
      src/backend/utils/adt/date.c
  4. 6
      src/backend/utils/adt/formatting.c
  5. 38
      src/backend/utils/adt/nabstime.c
  6. 9
      src/backend/utils/adt/selfuncs.c
  7. 314
      src/backend/utils/adt/timestamp.c
  8. 6
      src/include/catalog/pg_proc.h
  9. 4
      src/include/catalog/pg_type.h
  10. 30
      src/include/utils/timestamp.h
  11. 10
      src/interfaces/ecpg/pgtypeslib/interval.c
  12. 14
      src/test/regress/expected/interval.out

18
doc/src/sgml/func.sgml
Unescape View File

@ -1,5 +1,5 @@
<!--
$PostgreSQL: pgsql/doc/src/sgml/func.sgml,v 1.267 2005/07/18 22:34:14 tgl Exp $
$PostgreSQL: pgsql/doc/src/sgml/func.sgml,v 1.268 2005/07/20 16:42:29 momjian Exp $
PostgreSQL documentation
-->
@ -5144,6 +5144,22 @@ SELECT SUBSTRING('XY1234Z', 'Y*?([0-9]{1,3})');
<entry><literal>true</literal></entry>
</row>
<row>
<entry><literal><function>justify_hours</function>(<type>interval</type>)</literal></entry>
<entry><type>interval</type></entry>
<entry>Adjust interval so 24-hour time periods are represented as days</entry>
<entry><literal>justify_hours(interval '24 hours')</literal></entry>
<entry><literal>1 day</literal></entry>
</row>
<row>
<entry><literal><function>justify_days</function>(<type>interval</type>)</literal></entry>
<entry><type>interval</type></entry>
<entry>Adjust interval so 30-day time periods are represented as months</entry>
<entry><literal>justify_days(interval '30 days')</literal></entry>
<entry><literal>1 month</literal></entry>
</row>
<row>
<entry><literal><function>localtime</function></literal></entry>
<entry><type>time</type></entry>

12
src/backend/commands/variable.c
Unescape View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/variable.c,v 1.109 2005/06/28 05:08:55 tgl Exp $
* $PostgreSQL: pgsql/src/backend/commands/variable.c,v 1.110 2005/07/20 16:42:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -292,6 +292,15 @@ assign_timezone(const char *value, bool doit, GucSource source)
pfree(interval);
return NULL;
}
if (interval->day != 0)
{
if (source >= PGC_S_INTERACTIVE)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid interval value for time zone: day not allowed")));
pfree(interval);
return NULL;
}
if (doit)
{
/* Here we change from SQL to Unix sign convention */
@ -414,6 +423,7 @@ show_timezone(void)
Interval interval;
interval.month = 0;
interval.day = 0;
#ifdef HAVE_INT64_TIMESTAMP
interval.time = -(CTimeZone * USECS_PER_SEC);
#else

6
src/backend/utils/adt/date.c
Unescape View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/date.c,v 1.112 2005/07/12 15:17:44 momjian Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/date.c,v 1.113 2005/07/20 16:42:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -1423,6 +1423,7 @@ time_interval(PG_FUNCTION_ARGS)
result = (Interval *) palloc(sizeof(Interval));
result->time = time;
result->day = 0;
result->month = 0;
PG_RETURN_INTERVAL_P(result);
@ -1477,8 +1478,9 @@ time_mi_time(PG_FUNCTION_ARGS)
result = (Interval *) palloc(sizeof(Interval));
result->time = (time1 - time2);
result->month = 0;
result->day = 0;
result->time = time1 - time2;
PG_RETURN_INTERVAL_P(result);
}

6
src/backend/utils/adt/formatting.c
Unescape View File

@ -1,7 +1,7 @@
/* -----------------------------------------------------------------------
* formatting.c
*
* $PostgreSQL: pgsql/src/backend/utils/adt/formatting.c,v 1.90 2005/06/24 01:10:11 neilc Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/formatting.c,v 1.91 2005/07/20 16:42:30 momjian Exp $
*
*
* Portions Copyright (c) 1999-2005, PostgreSQL Global Development Group
@ -899,7 +899,7 @@ static char *str_tolower(char *buff);
/* static int is_acdc(char *str, int *len); */
static int seq_search(char *name, char **array, int type, int max, int *len);
static void do_to_timestamp(text *date_txt, text *fmt,
struct pg_tm * tm, fsec_t *fsec);
struct pg_tm *tm, fsec_t *fsec);
static char *fill_str(char *str, int c, int max);
static FormatNode *NUM_cache(int len, NUMDesc *Num, char *pars_str, bool *shouldFree);
static char *int_to_roman(int number);
@ -3028,7 +3028,7 @@ to_date(PG_FUNCTION_ARGS)
*/
static void
do_to_timestamp(text *date_txt, text *fmt,
struct pg_tm * tm, fsec_t *fsec)
struct pg_tm *tm, fsec_t *fsec)
{
FormatNode *format;
TmFromChar tmfc;

38
src/backend/utils/adt/nabstime.c
Unescape View File

@ -10,7 +10,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/nabstime.c,v 1.135 2005/07/12 16:04:56 momjian Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/nabstime.c,v 1.136 2005/07/20 16:42:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -829,7 +829,8 @@ interval_reltime(PG_FUNCTION_ARGS)
Interval *interval = PG_GETARG_INTERVAL_P(0);
RelativeTime time;
int year,
month;
month,
day;
#ifdef HAVE_INT64_TIMESTAMP
int64 span;
@ -837,28 +838,17 @@ interval_reltime(PG_FUNCTION_ARGS)
double span;
#endif
if (interval->month == 0)
{
year = 0;
month = 0;
}
else if (abs(interval->month) >=12)
{
year = (interval->month / 12);
month = (interval->month % 12);
}
else
{
year = 0;
month = interval->month;
}
year = interval->month / 12;
month = interval->month % 12;
day = interval->day;
#ifdef HAVE_INT64_TIMESTAMP
span = ((INT64CONST(365250000) * year + INT64CONST(30000000) * month) *
INT64CONST(86400)) + interval->time;
span = ((INT64CONST(365250000) * year + INT64CONST(30000000) * month +
INT64CONST(1000000) * day) * INT64CONST(86400)) +
interval->time;
span /= USECS_PER_SEC;
#else
span = (365.25 * year + 30.0 * month) * SECS_PER_DAY + interval->time;
span = (365.25 * year + 30.0 * month + day) * SECS_PER_DAY + interval->time;
#endif
if (span < INT_MIN || span > INT_MAX)
@ -876,7 +866,8 @@ reltime_interval(PG_FUNCTION_ARGS)
RelativeTime reltime = PG_GETARG_RELATIVETIME(0);
Interval *result;
int year,
month;
month,
day;
result = (Interval *) palloc(sizeof(Interval));
@ -887,6 +878,7 @@ reltime_interval(PG_FUNCTION_ARGS)
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot convert reltime \"invalid\" to interval")));
result->time = 0;
result->day = 0;
result->month = 0;
break;
@ -896,15 +888,19 @@ reltime_interval(PG_FUNCTION_ARGS)
reltime -= (year * (36525 * 864));
month = (reltime / (30 * SECS_PER_DAY));
reltime -= (month * (30 * SECS_PER_DAY));
day = reltime / SECS_PER_DAY;
reltime -= day * SECS_PER_DAY;
result->time = (reltime * USECS_PER_SEC);
#else
TMODULO(reltime, year, 36525 * 864);
TMODULO(reltime, month, 30 * SECS_PER_DAY);
TMODULO(reltime, day, SECS_PER_DAY);
result->time = reltime;
#endif
result->month = 12 * year + month;
result->day = day;
break;
}

9
src/backend/utils/adt/selfuncs.c
Unescape View File

@ -15,7 +15,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.184 2005/07/12 16:04:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.185 2005/07/20 16:42:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -2784,10 +2784,11 @@ convert_timevalue_to_scalar(Datum value, Oid typid)
* too accurate, but plenty good enough for our purposes.
*/
#ifdef HAVE_INT64_TIMESTAMP
return (interval->time + (interval->month * ((365.25 / 12.0) * 86400000000.0)));
return interval->time + interval->day * (double)USECS_PER_DAY +
interval->month * ((365.25 / 12.0) * USECS_PER_DAY);
#else
return interval->time +
interval ->month * (365.25 / 12.0 * 24.0 * 60.0 * 60.0);
return interval->time + interval->day * SECS_PER_DAY +
interval->month * ((365.25 / 12.0) * (double)SECS_PER_DAY);
#endif
}
case RELTIMEOID:

314
src/backend/utils/adt/timestamp.c
Unescape View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/timestamp.c,v 1.133 2005/07/20 03:50:24 momjian Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/timestamp.c,v 1.134 2005/07/20 16:42:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -596,6 +596,7 @@ interval_recv(PG_FUNCTION_ARGS)
#else
interval->time = pq_getmsgfloat8(buf);
#endif
interval->day = pq_getmsgint(buf, sizeof(interval->day));
interval->month = pq_getmsgint(buf, sizeof(interval->month));
AdjustIntervalForTypmod(interval, typmod);
@ -618,6 +619,7 @@ interval_send(PG_FUNCTION_ARGS)
#else
pq_sendfloat8(&buf, interval->time);
#endif
pq_sendint(&buf, interval->day, sizeof(interval->day));
pq_sendint(&buf, interval->month, sizeof(interval->month));
PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}
@ -697,48 +699,37 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
else if (range == INTERVAL_MASK(YEAR))
{
interval->month = (interval->month / 12) * 12;
interval->day = 0;
interval->time = 0;
}
else if (range == INTERVAL_MASK(MONTH))
{
interval->month %= 12;
interval->day = 0;
interval->time = 0;
}
/* YEAR TO MONTH */
else if (range == (INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH)))
{
/* month is already year to month */
interval->day = 0;
interval->time = 0;
}
else if (range == INTERVAL_MASK(DAY))
{
interval->month = 0;
#ifdef HAVE_INT64_TIMESTAMP
interval->time = ((int) (interval->time / USECS_PER_DAY)) *
USECS_PER_DAY;
#else
interval->time = ((int) (interval->time / SECS_PER_DAY)) * SECS_PER_DAY;
#endif
interval->time = 0;
}
else if (range == INTERVAL_MASK(HOUR))
{
#ifdef HAVE_INT64_TIMESTAMP
int64 day;
#else
double day;
#endif
interval->month = 0;
interval->day = 0;
#ifdef HAVE_INT64_TIMESTAMP
day = interval->time / USECS_PER_DAY;
interval->time -= day * USECS_PER_DAY;
interval->time = (interval->time / USECS_PER_HOUR) *
USECS_PER_HOUR;
#else
TMODULO(interval->time, day, (double)SECS_PER_DAY);
interval->time = ((int) (interval->time / 3600)) * 3600.0;
interval->time = ((int)(interval->time / 3600)) * 3600.0;
#endif
}
else if (range == INTERVAL_MASK(MINUTE))
@ -750,6 +741,7 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
#endif
interval->month = 0;
interval->day = 0;
#ifdef HAVE_INT64_TIMESTAMP
hour = interval->time / USECS_PER_HOUR;
@ -759,27 +751,26 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
#else
TMODULO(interval->time, hour, 3600.0);
interval->time = ((int) (interval->time / 60)) * 60;
interval->time = ((int)(interval->time / 60)) * 60.0;
#endif
}
else if (range == INTERVAL_MASK(SECOND))
{
#ifdef HAVE_INT64_TIMESTAMP
int64 minute;
#else
double minute;
#endif
interval->month = 0;
interval->day = 0;
#ifdef HAVE_INT64_TIMESTAMP
minute = interval->time / USECS_PER_MINUTE;
interval->time -= minute * USECS_PER_MINUTE;
#else
TMODULO(interval->time, minute, 60.0);
/* interval->time = (int)(interval->time); */
/* return subseconds too */
#endif
}
/* DAY TO HOUR */
@ -791,9 +782,8 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
#ifdef HAVE_INT64_TIMESTAMP
interval->time = (interval->time / USECS_PER_HOUR) *
USECS_PER_HOUR;
#else
interval->time = ((int) (interval->time / 3600)) * 3600;
interval->time = ((int) (interval->time / 3600)) * 3600.0;
#endif
}
/* DAY TO MINUTE */
@ -806,9 +796,8 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
#ifdef HAVE_INT64_TIMESTAMP
interval->time = (interval->time / USECS_PER_MINUTE) *
USECS_PER_MINUTE;
#else
interval->time = ((int) (interval->time / 60)) * 60;
interval->time = ((int)(interval->time / 60)) * 60.0;
#endif
}
/* DAY TO SECOND */
@ -822,24 +811,14 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
else if (range == (INTERVAL_MASK(HOUR) |
INTERVAL_MASK(MINUTE)))
{
#ifdef HAVE_INT64_TIMESTAMP
int64 day;
#else
double day;
#endif
interval->month = 0;
interval->day = 0;
#ifdef HAVE_INT64_TIMESTAMP
day = (interval->time / USECS_PER_DAY);
interval->time -= day * USECS_PER_DAY;
interval->time = (interval->time / USECS_PER_MINUTE) *
USECS_PER_MINUTE;
#else
TMODULO(interval->time, day, (double)SECS_PER_DAY);
interval->time = ((int) (interval->time / 60)) * 60;
interval->time = ((int)(interval->time / 60)) * 60.0;
#endif
}
/* HOUR TO SECOND */
@ -847,22 +826,9 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
INTERVAL_MASK(MINUTE) |
INTERVAL_MASK(SECOND)))
{
#ifdef HAVE_INT64_TIMESTAMP
int64 day;
#else
double day;
#endif
interval->month = 0;
#ifdef HAVE_INT64_TIMESTAMP
day = interval->time / USECS_PER_DAY;
interval->time -= day * USECS_PER_DAY;
#else
TMODULO(interval->time, day, (double)SECS_PER_DAY);
#endif
interval->day = 0;
/* return subseconds too */
}
/* MINUTE TO SECOND */
else if (range == (INTERVAL_MASK(MINUTE) |
@ -876,6 +842,7 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
#endif
interval->month = 0;
interval->day = 0;
#ifdef HAVE_INT64_TIMESTAMP
hour = interval->time / USECS_PER_HOUR;
@ -1029,7 +996,7 @@ dt2time(Timestamp jd, int *hour, int *min, int *sec, fsec_t *fsec)
* timezone) will be used.
*/
int
timestamp2tm(Timestamp dt, int *tzp, struct pg_tm * tm, fsec_t *fsec, char **tzn, pg_tz *attimezone)
timestamp2tm(Timestamp dt, int *tzp, struct pg_tm *tm, fsec_t *fsec, char **tzn, pg_tz *attimezone)
{
Timestamp date;
Timestamp time;
@ -1165,7 +1132,7 @@ timestamp2tm(Timestamp dt, int *tzp, struct pg_tm * tm, fsec_t *fsec, char **tzn
* Returns -1 on failure (value out of range).
*/
int
tm2timestamp(struct pg_tm * tm, fsec_t fsec, int *tzp, Timestamp *result)
tm2timestamp(struct pg_tm *tm, fsec_t fsec, int *tzp, Timestamp *result)
{
#ifdef HAVE_INT64_TIMESTAMP
int date;
@ -1205,7 +1172,7 @@ tm2timestamp(struct pg_tm * tm, fsec_t fsec, int *tzp, Timestamp *result)
* Convert a interval data type to a tm structure.
*/
int
interval2tm(Interval span, struct pg_tm * tm, fsec_t *fsec)
interval2tm(Interval span, struct pg_tm *tm, fsec_t *fsec)
{
#ifdef HAVE_INT64_TIMESTAMP
int64 time;
@ -1213,23 +1180,12 @@ interval2tm(Interval span, struct pg_tm * tm, fsec_t *fsec)
double time;
#endif
if (span.month != 0)
{
tm->tm_year = span.month / 12;
tm->tm_mon = span.month % 12;
}
else
{
tm->tm_year = 0;
tm->tm_mon = 0;
}
tm->tm_year = span.month / 12;
tm->tm_mon = span.month % 12;
tm->tm_mday = span.day;
time = span.time;
#ifdef HAVE_INT64_TIMESTAMP
tm->tm_mday = (time / USECS_PER_DAY);
time -= (tm->tm_mday * USECS_PER_DAY);
tm->tm_hour = (time / USECS_PER_HOUR);
time -= (tm->tm_hour * USECS_PER_HOUR);
tm->tm_min = (time / USECS_PER_MINUTE);
@ -1237,7 +1193,6 @@ interval2tm(Interval span, struct pg_tm * tm, fsec_t *fsec)
tm->tm_sec = (time / USECS_PER_SEC);
*fsec = (time - (tm->tm_sec * USECS_PER_SEC));
#else
TMODULO(time, tm->tm_mday, (double)SECS_PER_DAY);
TMODULO(time, tm->tm_hour, 3600.0);
TMODULO(time, tm->tm_min, 60.0);
TMODULO(time, tm->tm_sec, 1.0);
@ -1248,17 +1203,16 @@ interval2tm(Interval span, struct pg_tm * tm, fsec_t *fsec)
}
int
tm2interval(struct pg_tm * tm, fsec_t fsec, Interval *span)
tm2interval(struct pg_tm *tm, fsec_t fsec, Interval *span)
{
span->month = tm->tm_year * 12 + tm->tm_mon;
span->day = tm->tm_mday;
#ifdef HAVE_INT64_TIMESTAMP
span->time = (((((((tm->tm_mday * INT64CONST(24)) +
tm->tm_hour) * INT64CONST(60)) +
span->time = (((((tm->tm_hour * INT64CONST(60)) +
tm->tm_min) * INT64CONST(60)) +
tm->tm_sec) * USECS_PER_SEC) + fsec;
#else
span->time = (((((tm->tm_mday * 24.0) +
tm->tm_hour) * 60.0) +
span->time = (((tm->tm_hour * 60.0) +
tm->tm_min) * 60.0) +
tm->tm_sec;
span->time = JROUND(span->time + fsec);
@ -1320,7 +1274,7 @@ interval_finite(PG_FUNCTION_ARGS)
*---------------------------------------------------------*/
void
GetEpochTime(struct pg_tm * tm)
GetEpochTime(struct pg_tm *tm)
{
struct pg_tm *t0;
pg_time_t epoch = 0;
@ -1654,15 +1608,15 @@ interval_cmp_internal(Interval *interval1, Interval *interval2)
span2 = interval2->time;
#ifdef HAVE_INT64_TIMESTAMP
if (interval1->month != 0)
span1 += interval1->month * INT64CONST(30) * USECS_PER_DAY;
if (interval2->month != 0)
span2 += interval2->month * INT64CONST(30) * USECS_PER_DAY;
span1 += interval1->month * INT64CONST(30) * USECS_PER_DAY;
span1 += interval1->day * INT64CONST(24) * USECS_PER_HOUR;
span2 += interval2->month * INT64CONST(30) * USECS_PER_DAY;
span2 += interval2->day * INT64CONST(24) * USECS_PER_HOUR;
#else
if (interval1->month != 0)
span1 += interval1->month * (30.0 * SECS_PER_DAY);
if (interval2->month != 0)
span2 += interval2->month * (30.0 * SECS_PER_DAY);
span1 += interval1->month * (30.0 * SECS_PER_DAY);
span1 += interval1->day * (24.0 * SECS_PER_HOUR);
span2 += interval2->month * (30.0 * SECS_PER_DAY);
span2 += interval2->day * (24.0 * SECS_PER_HOUR);
#endif
return ((span1 < span2) ? -1 : (span1 > span2) ? 1 : 0);
@ -1744,7 +1698,8 @@ interval_hash(PG_FUNCTION_ARGS)
* sizeof(Interval), so that any garbage pad bytes in the structure
* won't be included in the hash!
*/
return hash_any((unsigned char *) key, sizeof(key->time) + sizeof(key->month));
return hash_any((unsigned char *) key,
sizeof(key->time) + sizeof(key->day) + sizeof(key->month));
}
/* overlaps_timestamp() --- implements the SQL92 OVERLAPS operator.
@ -1934,18 +1889,76 @@ timestamp_mi(PG_FUNCTION_ARGS)
#endif
result->month = 0;
result->day = 0;
result = DatumGetIntervalP(DirectFunctionCall1(interval_justify_hours,
IntervalPGetDatum(result)));
PG_RETURN_INTERVAL_P(result);
}
/* interval_justify_hours()
* Adjust interval so 'time' contains less than a whole day, and
* 'day' contains an integral number of days. This is useful for
* situations (such as non-TZ) where '1 day' = '24 hours' is valid,
* e.g. interval subtraction and division. The SQL standard requires
* such conversion in these cases, but not the conversion of days to months.
*/
Datum
interval_justify_hours(PG_FUNCTION_ARGS)
{
Interval *span = PG_GETARG_INTERVAL_P(0);
Interval *result;
result = (Interval *) palloc(sizeof(Interval));
result->month = span->month;
result->time = span->time;
#ifdef HAVE_INT64_TIMESTAMP
result->time += span->day * USECS_PER_DAY;
result->day = result->time / USECS_PER_DAY;
result->time -= result->day * USECS_PER_DAY;
#else
result->time += span->day * (double)SECS_PER_DAY;
TMODULO(result->time, result->day, (double)SECS_PER_DAY);
#endif
PG_RETURN_INTERVAL_P(result);
}
/* interval_justify_days()
* Adjust interval so 'time' contains less than 30 days, and
* adds as months.
*/
Datum
interval_justify_days(PG_FUNCTION_ARGS)
{
Interval *span = PG_GETARG_INTERVAL_P(0);
Interval *result;
result = (Interval *) palloc(sizeof(Interval));
result->day = span->day;
result->time = span->time;
#ifdef HAVE_INT64_TIMESTAMP
result->day += span->month * 30.0;
result->month = span->day / 30;
result->day -= result->month * 30;
#else
result->day += span->month * 30.0;
TMODULO(result->day, result->month, 30.0);
#endif
PG_RETURN_INTERVAL_P(result);
}
/* timestamp_pl_interval()
* Add a interval to a timestamp data type.
* Note that interval has provisions for qualitative year/month
* Note that interval has provisions for qualitative year/month and day
* units, so try to do the right thing with them.
* To add a month, increment the month, and use the same day of month.
* Then, if the next month has fewer days, set the day of month
* to the last day of month.
* To add a day, increment the mday, and use the same time of day.
* Lastly, add in the "quantitative time".
*/
Datum
@ -1957,7 +1970,6 @@ timestamp_pl_interval(PG_FUNCTION_ARGS)
if (TIMESTAMP_NOT_FINITE(timestamp))
result = timestamp;
else
{
if (span->month != 0)
@ -1993,7 +2005,29 @@ timestamp_pl_interval(PG_FUNCTION_ARGS)
errmsg("timestamp out of range")));
}
timestamp +=span->time;
if (span->day != 0)
{
struct pg_tm tt,
*tm = &tt;
fsec_t fsec;
int julian;
if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) !=0)
ereport(ERROR,
(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
errmsg("timestamp out of range")));
/* Add days by converting to and from julian */
julian = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) + span->day;
j2date(julian, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
if (tm2timestamp(tm, fsec, NULL, &timestamp) !=0)
ereport(ERROR,
(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
errmsg("timestamp out of range")));
}
timestamp += span->time;
result = timestamp;
}
@ -2008,6 +2042,7 @@ timestamp_mi_interval(PG_FUNCTION_ARGS)
Interval tspan;
tspan.month = -span->month;
tspan.day = -span->day;
tspan.time = -span->time;
return DirectFunctionCall2(timestamp_pl_interval,
@ -2036,7 +2071,6 @@ timestamptz_pl_interval(PG_FUNCTION_ARGS)
if (TIMESTAMP_NOT_FINITE(timestamp))
result = timestamp;
else
{
if (span->month != 0)
@ -2074,7 +2108,31 @@ timestamptz_pl_interval(PG_FUNCTION_ARGS)
errmsg("timestamp out of range")));
}
timestamp +=span->time;
if (span->day != 0)
{
struct pg_tm tt,
*tm = &tt;
fsec_t fsec;
int julian;
if (timestamp2tm(timestamp, &tz, tm, &fsec, &tzn, NULL) !=0)
ereport(ERROR,
(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
errmsg("timestamp out of range")));
/* Add days by converting to and from julian */
julian = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) + span->day;
j2date(julian, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
tz = DetermineLocalTimeZone(tm);
if (tm2timestamp(tm, fsec, &tz, &timestamp) !=0)
ereport(ERROR,
(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
errmsg("timestamp out of range")));
}
timestamp += span->time;
result = timestamp;
}
@ -2089,6 +2147,7 @@ timestamptz_mi_interval(PG_FUNCTION_ARGS)
Interval tspan;
tspan.month = -span->month;
tspan.day = -span->day;
tspan.time = -span->time;
return DirectFunctionCall2(timestamptz_pl_interval,
@ -2106,6 +2165,7 @@ interval_um(PG_FUNCTION_ARGS)
result = (Interval *) palloc(sizeof(Interval));
result->time = -(interval->time);
result->day = -(interval->day);
result->month = -(interval->month);
PG_RETURN_INTERVAL_P(result);
@ -2151,6 +2211,7 @@ interval_pl(PG_FUNCTION_ARGS)
result = (Interval *) palloc(sizeof(Interval));
result->month = (span1->month + span2->month);
result->day = (span1->day + span2->day);
#ifdef HAVE_INT64_TIMESTAMP
result->time = (span1->time + span2->time);
#else
@ -2170,6 +2231,7 @@ interval_mi(PG_FUNCTION_ARGS)
result = (Interval *) palloc(sizeof(Interval));
result->month = (span1->month - span2->month);
result->day = (span1->day - span2->day);
#ifdef HAVE_INT64_TIMESTAMP
result->time = (span1->time - span2->time);
#else
@ -2188,23 +2250,30 @@ interval_mul(PG_FUNCTION_ARGS)
#ifdef HAVE_INT64_TIMESTAMP
int64 months;
int64 days;
#else
double months;
double days;
#endif
result = (Interval *) palloc(sizeof(Interval));
months = (span1->month * factor);
days = (span1->day * factor);
#ifdef HAVE_INT64_TIMESTAMP
result->month = months;
result->day = days;
result->time = (span1->time * factor);
result->time += (months - result->month) * INT64CONST(30) *
USECS_PER_DAY;
result->time += (months - result->month) * INT64CONST(30) * USECS_PER_DAY;
result->time += (days - result->day) * INT64CONST(24) * USECS_PER_HOUR;
#else
result->month = (int)months;
result->day = (int)days;
result->time = JROUND(span1->time * factor);
/* evaluate fractional months as 30 days */
result->time += JROUND((months - result->month) * 30 * SECS_PER_DAY);
/* evaluate fractional days as 24 hours */
result->time += JROUND((days - result->day) * 24 * SECS_PER_HOUR);
#endif
PG_RETURN_INTERVAL_P(result);
@ -2225,12 +2294,9 @@ interval_div(PG_FUNCTION_ARGS)
{
Interval *span = PG_GETARG_INTERVAL_P(0);
float8 factor = PG_GETARG_FLOAT8(1);
double month_remainder, day_remainder;
Interval *result;
#ifndef HAVE_INT64_TIMESTAMP
double months;
#endif
result = (Interval *) palloc(sizeof(Interval));
if (factor == 0.0)
@ -2238,20 +2304,29 @@ interval_div(PG_FUNCTION_ARGS)
(errcode(ERRCODE_DIVISION_BY_ZERO),
errmsg("division by zero")));
result->month = span->month / factor;
result->day = span->day / factor;
result->time = span->time / factor;
/* Computer remainders */
month_remainder = (span->month - result->month * factor) / factor;
day_remainder = (span->day - result->day * factor) / factor;
/* Cascade fractions to lower units */
/* fractional months full days into days */
result->day += month_remainder * 30;
/* fractional months partial days into time */
day_remainder += (month_remainder * 30) - (int)(month_remainder * 30);
#ifdef HAVE_INT64_TIMESTAMP
result->month = (span->month / factor);
result->time = (span->time / factor);
/* evaluate fractional months as 30 days */
result->time += ((span->month - (result->month * factor)) *
INT64CONST(30) * USECS_PER_DAY) / factor;
result->time += day_remainder * USECS_PER_DAY;
#else
months = span->month / factor;
result->month = (int)months;
result->time = JROUND(span->time / factor);
/* evaluate fractional months as 30 days */
result->time += JROUND((months - result->month) * 30 * SECS_PER_DAY);
result->time += day_remainder * SECS_PER_DAY;
result->time = JROUND(result->time);
#endif
result = DatumGetIntervalP(DirectFunctionCall1(interval_justify_hours,
IntervalPGetDatum(result)));
PG_RETURN_INTERVAL_P(result);
}
@ -2276,9 +2351,8 @@ interval_accum(PG_FUNCTION_ARGS)
Interval *newsum;
ArrayType *result;
/* We assume the input is array of interval */
deconstruct_array(transarray,
INTERVALOID, 12, false, 'd',
INTERVALOID, sizeof(Interval), false, 'd',
&transdatums, &ndatums);
if (ndatums != 2)
elog(ERROR, "expected 2-element interval array");
@ -2304,7 +2378,7 @@ interval_accum(PG_FUNCTION_ARGS)
transdatums[1] = IntervalPGetDatum(&N);
result = construct_array(transdatums, 2,
INTERVALOID, 12, false, 'd');
INTERVALOID, sizeof(Interval), false, 'd');
PG_RETURN_ARRAYTYPE_P(result);
}
@ -2318,9 +2392,8 @@ interval_avg(PG_FUNCTION_ARGS)
Interval sumX,
N;
/* We assume the input is array of interval */
deconstruct_array(transarray,
INTERVALOID, 12, false, 'd',
INTERVALOID, sizeof(Interval), false, 'd',
&transdatums, &ndatums);
if (ndatums != 2)
elog(ERROR, "expected 2-element interval array");
@ -2721,7 +2794,7 @@ interval_text(PG_FUNCTION_ARGS)
result = palloc(len);
VARATT_SIZEP(result) = len;
memmove(VARDATA(result), str, (len - VARHDRSZ));
memmove(VARDATA(result), str, len - VARHDRSZ);
pfree(str);
@ -3080,6 +3153,7 @@ interval_trunc(PG_FUNCTION_ARGS)
{
switch (val)
{
/* fall through */
case DTK_MILLENNIUM:
/* caution: C division may have negative remainder */
tm->tm_year = (tm->tm_year / 1000) * 1000;
@ -3830,11 +3904,9 @@ interval_part(PG_FUNCTION_ARGS)
#else
result = interval->time;
#endif
if (interval->month != 0)
{
result += (365.25 * SECS_PER_DAY) * (interval->month / 12);
result += (30.0 * SECS_PER_DAY) * (interval->month % 12);
}
result += (365.25 * SECS_PER_DAY) * (interval->month / 12);
result += (30.0 * SECS_PER_DAY) * (interval->month % 12);
result += interval->day * SECS_PER_DAY;
}
else
{

6
src/include/catalog/pg_proc.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/catalog/pg_proc.h,v 1.376 2005/07/10 21:13:59 tgl Exp $
* $PostgreSQL: pgsql/src/include/catalog/pg_proc.h,v 1.377 2005/07/20 16:42:31 momjian Exp $
*
* NOTES
* The script catalog/genbki.sh reads this file and generates .bki
@ -1497,6 +1497,10 @@ DATA(insert OID = 1173 ( timestamptz PGNSP PGUID 12 f f t f i 1 1184 "702" _
DESCR("convert abstime to timestamp with time zone");
DATA(insert OID = 1174 ( timestamptz PGNSP PGUID 12 f f t f s 1 1184 "1082" _null_ _null_ _null_ date_timestamptz - _null_ ));
DESCR("convert date to timestamp with time zone");
DATA(insert OID = 1175 ( justify_hours PGNSP PGUID 12 f f t f i 1 1186 "1186" _null_ _null_ _null_ interval_justify_hours - _null_ ));
DESCR("promote groups of 24 hours to numbers of days");
DATA(insert OID = 1295 ( justify_days PGNSP PGUID 12 f f t f i 1 1186 "1186" _null_ _null_ _null_ interval_justify_days - _null_ ));
DESCR("promote groups of 30 days to numbers of months");
DATA(insert OID = 1176 ( timestamptz PGNSP PGUID 14 f f t f s 2 1184 "1082 1083" _null_ _null_ _null_ "select cast(($1 + $2) as timestamp with time zone)" - _null_ ));
DESCR("convert date and time to timestamp with time zone");
DATA(insert OID = 1177 ( interval PGNSP PGUID 12 f f t f i 1 1186 "703" _null_ _null_ _null_ reltime_interval - _null_ ));

4
src/include/catalog/pg_type.h
Unescape View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/catalog/pg_type.h,v 1.163 2005/07/07 20:39:59 tgl Exp $
* $PostgreSQL: pgsql/src/include/catalog/pg_type.h,v 1.164 2005/07/20 16:42:32 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
@ -457,7 +457,7 @@ DATA(insert OID = 1184 ( timestamptz PGNSP PGUID 8 f b t \054 0 0 timestamptz_in
DESCR("date and time with time zone");
#define TIMESTAMPTZOID 1184
DATA(insert OID = 1185 ( _timestamptz PGNSP PGUID -1 f b t \054 0 1184 array_in array_out array_recv array_send - d x f 0 -1 0 _null_ _null_ ));
DATA(insert OID = 1186 ( interval PGNSP PGUID 12 f b t \054 0 0 interval_in interval_out interval_recv interval_send - d p f 0 -1 0 _null_ _null_ ));
DATA(insert OID = 1186 ( interval PGNSP PGUID 16 f b t \054 0 0 interval_in interval_out interval_recv interval_send - d p f 0 -1 0 _null_ _null_ ));
DESCR("@ <number> <units>, time interval");
#define INTERVALOID 1186
DATA(insert OID = 1187 ( _interval PGNSP PGUID -1 f b t \054 0 1186 array_in array_out array_recv array_send - d x f 0 -1 0 _null_ _null_ ));

30
src/include/utils/timestamp.h
Unescape View File

@ -6,7 +6,7 @@
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/utils/timestamp.h,v 1.46 2005/06/29 22:51:57 tgl Exp $
* $PostgreSQL: pgsql/src/include/utils/timestamp.h,v 1.47 2005/07/20 16:42:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -25,9 +25,9 @@
/*
* Timestamp represents absolute time.
* Interval represents delta time. Keep track of months (and years)
* separately since the elapsed time spanned is unknown until instantiated
* relative to an absolute time.
* Interval represents delta time. Keep track of months (and years), days,
* and time separately since the elapsed time spanned is unknown until
* instantiated relative to an absolute time.
*
* Note that Postgres uses "time interval" to mean a bounded interval,
* consisting of a beginning and ending time, not a time span - thomas 97/03/20
@ -45,12 +45,13 @@ typedef double TimestampTz;
typedef struct
{
#ifdef HAVE_INT64_TIMESTAMP
int64 time; /* all time units other than months and
* years */
int64 time; /* all time units other than days,
* months and years */
#else
double time; /* all time units other than months and
* years */
double time; /* all time units other than days,
* months and years */
#endif
int32 day; /* days, after time for alignment */
int32 month; /* months and years, after time for
* alignment */
} Interval;
@ -60,6 +61,7 @@ typedef struct
#define MAX_INTERVAL_PRECISION 6
#define SECS_PER_DAY 86400
#define SECS_PER_HOUR 3600
#ifdef HAVE_INT64_TIMESTAMP
#define USECS_PER_DAY INT64CONST(86400000000)
#define USECS_PER_HOUR INT64CONST(3600000000)
@ -212,6 +214,8 @@ extern Datum interval_cmp(PG_FUNCTION_ARGS);
extern Datum interval_hash(PG_FUNCTION_ARGS);
extern Datum interval_smaller(PG_FUNCTION_ARGS);
extern Datum interval_larger(PG_FUNCTION_ARGS);
extern Datum interval_justify_hours(PG_FUNCTION_ARGS);
extern Datum interval_justify_days(PG_FUNCTION_ARGS);
extern Datum timestamp_text(PG_FUNCTION_ARGS);
extern Datum text_timestamp(PG_FUNCTION_ARGS);
@ -266,16 +270,16 @@ extern Datum pgsql_postmaster_start_time(PG_FUNCTION_ARGS);
extern TimestampTz GetCurrentTimestamp(void);
extern int tm2timestamp(struct pg_tm * tm, fsec_t fsec, int *tzp, Timestamp *dt);
extern int timestamp2tm(Timestamp dt, int *tzp, struct pg_tm * tm,
extern int tm2timestamp(struct pg_tm *tm, fsec_t fsec, int *tzp, Timestamp *dt);
extern int timestamp2tm(Timestamp dt, int *tzp, struct pg_tm *tm,
fsec_t *fsec, char **tzn, pg_tz *attimezone);
extern void dt2time(Timestamp dt, int *hour, int *min, int *sec, fsec_t *fsec);
extern int interval2tm(Interval span, struct pg_tm * tm, fsec_t *fsec);
extern int tm2interval(struct pg_tm * tm, fsec_t fsec, Interval *span);
extern int interval2tm(Interval span, struct pg_tm *tm, fsec_t *fsec);
extern int tm2interval(struct pg_tm *tm, fsec_t fsec, Interval *span);
extern Timestamp SetEpochTimestamp(void);
extern void GetEpochTime(struct pg_tm * tm);
extern void GetEpochTime(struct pg_tm *tm);
extern int timestamp_cmp_internal(Timestamp dt1, Timestamp dt2);

10
src/interfaces/ecpg/pgtypeslib/interval.c
Unescape View File

@ -33,7 +33,7 @@ TrimTrailingZeros(char *str)
* can be used to represent time spans.
*/
static int
DecodeTime(char *str, int fmask, int *tmask, struct tm * tm, fsec_t *fsec)
DecodeTime(char *str, int fmask, int *tmask, struct tm *tm, fsec_t *fsec)
{
char *cp;
@ -107,7 +107,7 @@ DecodeTime(char *str, int fmask, int *tmask, struct tm * tm, fsec_t *fsec)
* preceding an hh:mm:ss field. - thomas 1998-04-30
*/
int
DecodeInterval(char **field, int *ftype, int nf, int *dtype, struct tm * tm, fsec_t *fsec)
DecodeInterval(char **field, int *ftype, int nf, int *dtype, struct tm *tm, fsec_t *fsec)
{
int is_before = FALSE;
@ -445,7 +445,7 @@ DecodeInterval(char **field, int *ftype, int nf, int *dtype, struct tm * tm, fse
* - thomas 1998-04-30
*/
int
EncodeInterval(struct tm * tm, fsec_t fsec, int style, char *str)
EncodeInterval(struct tm *tm, fsec_t fsec, int style, char *str)
{
int is_before = FALSE;
int is_nonzero = FALSE;
@ -670,7 +670,7 @@ EncodeInterval(struct tm * tm, fsec_t fsec, int style, char *str)
* Convert a interval data type to a tm structure.
*/
static int
interval2tm(interval span, struct tm * tm, fsec_t *fsec)
interval2tm(interval span, struct tm *tm, fsec_t *fsec)
{
#ifdef HAVE_INT64_TIMESTAMP
int64 time;
@ -713,7 +713,7 @@ interval2tm(interval span, struct tm * tm, fsec_t *fsec)
} /* interval2tm() */
static int
tm2interval(struct tm * tm, fsec_t fsec, interval *span)
tm2interval(struct tm *tm, fsec_t fsec, interval *span)
{
span->month = tm->tm_year * 12 + tm->tm_mon;
#ifdef HAVE_INT64_TIMESTAMP

14
src/test/regress/expected/interval.out
Unescape View File

@ -28,21 +28,21 @@ SELECT INTERVAL '-05' AS "Five hours";
(1 row)
SELECT INTERVAL '-1 +02:03' AS "22 hours ago...";
22 hours ago...
-----------------
-21:57:00
22 hours ago...
-------------------
-1 days +02:03:00
(1 row)
SELECT INTERVAL '-1 days +02:03' AS "22 hours ago...";
22 hours ago...
-----------------
-21:57:00
22 hours ago...
-------------------
-1 days +02:03:00
(1 row)
SELECT INTERVAL '10 years -11 month -12 days +13:14' AS "9 years...";
9 years...
----------------------------------
9 years 1 mon -11 days -10:46:00
9 years 1 mon -12 days +13:14:00
(1 row)
CREATE TABLE INTERVAL_TBL (f1 interval);

Write Preview
Loading…
Cancel
Save