*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/variable.c,v 1.110 2005/07/20 16:42:30 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/variable.c,v 1.111 2005/07/21 03:56:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (doit)
{
/* Here we change from SQL to Unix sign convention */
- CTimeZone = -hours * 3600;
+ CTimeZone = -hours * SECS_PER_HOUR;
HasCTZSet = true;
}
}
if (!result)
return NULL;
snprintf(result, 64, "%.5f",
- (double) (-CTimeZone) / 3600.0);
+ (double) (-CTimeZone) / (double)SECS_PER_HOUR);
}
else
result = strdup(value);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/postmaster/postmaster.c,v 1.459 2005/07/14 05:13:40 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/postmaster/postmaster.c,v 1.460 2005/07/21 03:56:11 momjian Exp $
*
* NOTES
*
* less than an hour ...
*/
now = time(NULL);
- if (now - last_touch_time >= 58 * 60)
+ if (now - last_touch_time >= 58 * SECS_PER_MINUTE)
{
TouchSocketFile();
TouchSocketLockFile();
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/postmaster/syslogger.c,v 1.16 2005/07/04 04:51:47 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/postmaster/syslogger.c,v 1.17 2005/07/21 03:56:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "storage/pg_shmem.h"
#include "utils/guc.h"
#include "utils/ps_status.h"
-
+#include "utils/timestamp.h"
/*
* We really want line-buffered mode for logfile output, but Windows does
* start, but the rest can change at SIGHUP.
*/
bool Redirect_stderr = false;
-int Log_RotationAge = 24 * 60;
+int Log_RotationAge = HOURS_PER_DAY * SECS_PER_MINUTE;
int Log_RotationSize = 10 * 1024;
char *Log_directory = NULL;
char *Log_filename = NULL;
* fairly loosely. In this version we align to local time rather than
* GMT.
*/
- rotinterval = Log_RotationAge * 60; /* convert to seconds */
+ rotinterval = Log_RotationAge * SECS_PER_MINUTE; /* convert to seconds */
now = time(NULL);
tm = pg_localtime(&now, global_timezone);
now += tm->tm_gmtoff;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/tcop/postgres.c,v 1.454 2005/07/14 05:13:41 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/tcop/postgres.c,v 1.455 2005/07/21 03:56:11 momjian Exp $
*
* NOTES
* this is the "main" module of the postgres backend and
end.tv_sec -= port->session_start.tv_sec;
end.tv_usec -= port->session_start.tv_usec;
- hours = end.tv_sec / 3600;
- end.tv_sec %= 3600;
- minutes = end.tv_sec / 60;
- seconds = end.tv_sec % 60;
+ hours = end.tv_sec / SECS_PER_HOUR;
+ end.tv_sec %= SECS_PER_HOUR;
+ minutes = end.tv_sec / SECS_PER_MINUTE;
+ seconds = end.tv_sec % SECS_PER_MINUTE;
/* if time has gone backwards for some reason say so, or print time */
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/date.c,v 1.113 2005/07/20 16:42:30 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/date.c,v 1.114 2005/07/21 03:56:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* gcc's -ffast-math switch breaks routines that expect exact results from
- * expressions like timeval / 3600, where timeval is double.
+ * expressions like timeval / SECS_PER_HOUR, where timeval is double.
*/
#ifdef __FAST_MATH__
#error -ffast-math is known to break this code
tm2time(struct pg_tm * tm, fsec_t fsec, TimeADT *result)
{
#ifdef HAVE_INT64_TIMESTAMP
- *result = ((((tm->tm_hour * 60 + tm->tm_min) * 60) + tm->tm_sec)
+ *result = ((((tm->tm_hour * SECS_PER_MINUTE + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec)
* USECS_PER_SEC) + fsec;
#else
- *result = ((tm->tm_hour * 60 + tm->tm_min) * 60) + tm->tm_sec + fsec;
+ *result = ((tm->tm_hour * SECS_PER_MINUTE + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec + fsec;
#endif
return 0;
}
double trem;
trem = time;
- TMODULO(trem, tm->tm_hour, 3600.0);
- TMODULO(trem, tm->tm_min, 60.0);
+ TMODULO(trem, tm->tm_hour, (double)SECS_PER_HOUR);
+ TMODULO(trem, tm->tm_min, (double)SECS_PER_MINUTE);
TMODULO(trem, tm->tm_sec, 1.0);
*fsec = trem;
#endif
* Could also do this with time = (timestamp / USECS_PER_DAY *
* USECS_PER_DAY) - timestamp;
*/
- result = ((((tm->tm_hour * 60 + tm->tm_min) * 60) + tm->tm_sec) *
+ result = ((((tm->tm_hour * SECS_PER_MINUTE + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
USECS_PER_SEC) + fsec;
#else
- result = ((tm->tm_hour * 60 + tm->tm_min) * 60) + tm->tm_sec + fsec;
+ result = ((tm->tm_hour * SECS_PER_MINUTE + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec + fsec;
#endif
PG_RETURN_TIMEADT(result);
* Could also do this with time = (timestamp / USECS_PER_DAY *
* USECS_PER_DAY) - timestamp;
*/
- result = ((((tm->tm_hour * 60 + tm->tm_min) * 60) + tm->tm_sec) *
+ result = ((((tm->tm_hour * SECS_PER_MINUTE + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
USECS_PER_SEC) + fsec;
#else
- result = ((tm->tm_hour * 60 + tm->tm_min) * 60) + tm->tm_sec + fsec;
+ result = ((tm->tm_hour * SECS_PER_MINUTE + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec + fsec;
#endif
PG_RETURN_TIMEADT(result);
tm2timetz(struct pg_tm * tm, fsec_t fsec, int tz, TimeTzADT *result)
{
#ifdef HAVE_INT64_TIMESTAMP
- result->time = ((((tm->tm_hour * 60 + tm->tm_min) * 60) + tm->tm_sec) *
+ result->time = ((((tm->tm_hour * SECS_PER_MINUTE + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
USECS_PER_SEC) + fsec;
#else
- result->time = ((tm->tm_hour * 60 + tm->tm_min) * 60) + tm->tm_sec + fsec;
+ result->time = ((tm->tm_hour * SECS_PER_MINUTE + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec + fsec;
#endif
result->zone = tz;
#else
double trem = time->time;
- TMODULO(trem, tm->tm_hour, 3600.0);
- TMODULO(trem, tm->tm_min, 60.0);
+ TMODULO(trem, tm->tm_hour, (double)SECS_PER_HOUR);
+ TMODULO(trem, tm->tm_min, (double)SECS_PER_MINUTE);
TMODULO(trem, tm->tm_sec, 1.0);
*fsec = trem;
#endif
case DTK_TZ_MINUTE:
result = -tz;
- result /= 60;
- FMODULO(result, dummy, 60.0);
+ result /= SECS_PER_MINUTE;
+ FMODULO(result, dummy, (double)SECS_PER_MINUTE);
break;
case DTK_TZ_HOUR:
dummy = -tz;
- FMODULO(dummy, result, 3600.0);
+ FMODULO(dummy, result, (double)SECS_PER_HOUR);
break;
case DTK_MICROSEC:
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/datetime.c,v 1.152 2005/07/12 15:17:44 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/datetime.c,v 1.153 2005/07/21 03:56:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
tm->tm_isdst = 1;
if (tzp == NULL)
return DTERR_BAD_FORMAT;
- *tzp += val * 60;
+ *tzp += val * SECS_PER_MINUTE;
break;
case DTZ:
tm->tm_isdst = 1;
if (tzp == NULL)
return DTERR_BAD_FORMAT;
- *tzp = val * 60;
+ *tzp = val * SECS_PER_MINUTE;
ftype[i] = DTK_TZ;
break;
tm->tm_isdst = 0;
if (tzp == NULL)
return DTERR_BAD_FORMAT;
- *tzp = val * 60;
+ *tzp = val * SECS_PER_MINUTE;
ftype[i] = DTK_TZ;
break;
/* check for valid month */
if (fmask & DTK_M(MONTH))
{
- if (tm->tm_mon < 1 || tm->tm_mon > 12)
+ if (tm->tm_mon < 1 || tm->tm_mon > MONTHS_PER_YEAR)
return DTERR_MD_FIELD_OVERFLOW;
}
day = ((pg_time_t) date) *SECS_PER_DAY;
if (day / SECS_PER_DAY != date)
goto overflow;
- sec = tm->tm_sec + (tm->tm_min + tm->tm_hour * 60) * 60;
+ sec = tm->tm_sec + (tm->tm_min + tm->tm_hour * SECS_PER_MINUTE) * SECS_PER_MINUTE;
mytime = day + sec;
/* since sec >= 0, overflow could only be from +day to -mytime */
if (mytime < 0 && day > 0)
* that DST boundaries can't be closer together than 48 hours, so
* backing up 24 hours and finding the "next" boundary will work.
*/
- prevtime = mytime - (24 * 60 * 60);
+ prevtime = mytime - (HOURS_PER_DAY * SECS_PER_MINUTE * SECS_PER_MINUTE);
if (mytime < 0 && prevtime > 0)
goto overflow;
tm->tm_isdst = 1;
if (tzp == NULL)
return DTERR_BAD_FORMAT;
- *tzp += val * 60;
+ *tzp += val * SECS_PER_MINUTE;
break;
case DTZ:
tm->tm_isdst = 1;
if (tzp == NULL)
return DTERR_BAD_FORMAT;
- *tzp = val * 60;
+ *tzp = val * SECS_PER_MINUTE;
ftype[i] = DTK_TZ;
break;
tm->tm_isdst = 0;
if (tzp == NULL)
return DTERR_BAD_FORMAT;
- *tzp = val * 60;
+ *tzp = val * SECS_PER_MINUTE;
ftype[i] = DTK_TZ;
break;
}
/* check for valid month */
- if (tm->tm_mon < 1 || tm->tm_mon > 12)
+ if (tm->tm_mon < 1 || tm->tm_mon > MONTHS_PER_YEAR)
return DTERR_MD_FIELD_OVERFLOW;
/* check for valid day */
if (min < 0 || min >= 60)
return DTERR_TZDISP_OVERFLOW;
- tz = (hr * 60 + min) * 60;
+ tz = (hr * SECS_PER_MINUTE + min) * SECS_PER_MINUTE;
if (*str == '-')
tz = -tz;
{
case DTZ:
case TZ:
- *tzp = (val * 60) - tz;
+ *tzp = (val * SECS_PER_MINUTE) - tz;
break;
default:
{
int sec;
- fval *= 60;
+ fval *= SECS_PER_MINUTE;
sec = fval;
tm->tm_sec += sec;
#ifdef HAVE_INT64_TIMESTAMP
{
int sec;
- fval *= 3600;
+ fval *= SECS_PER_HOUR;
sec = fval;
tm->tm_sec += sec;
#ifdef HAVE_INT64_TIMESTAMP
{
int sec;
- fval *= 30 * SECS_PER_DAY;
+ fval *= DAYS_PER_MONTH * SECS_PER_DAY;
sec = fval;
tm->tm_sec += sec;
#ifdef HAVE_INT64_TIMESTAMP
case DTK_YEAR:
tm->tm_year += val;
if (fval != 0)
- tm->tm_mon += fval * 12;
+ tm->tm_mon += fval * MONTHS_PER_YEAR;
tmask = (fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR);
break;
case DTK_DECADE:
tm->tm_year += val * 10;
if (fval != 0)
- tm->tm_mon += fval * 120;
+ tm->tm_mon += fval * MONTHS_PER_YEAR * 10;
tmask = (fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR);
break;
case DTK_CENTURY:
tm->tm_year += val * 100;
if (fval != 0)
- tm->tm_mon += fval * 1200;
+ tm->tm_mon += fval * MONTHS_PER_YEAR * 100;
tmask = (fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR);
break;
case DTK_MILLENNIUM:
tm->tm_year += val * 1000;
if (fval != 0)
- tm->tm_mon += fval * 12000;
+ tm->tm_mon += fval * MONTHS_PER_YEAR * 1000;
tmask = (fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR);
break;
int
EncodeDateOnly(struct pg_tm * tm, int style, char *str)
{
- if (tm->tm_mon < 1 || tm->tm_mon > 12)
+ if (tm->tm_mon < 1 || tm->tm_mon > MONTHS_PER_YEAR)
return -1;
switch (style)
int
EncodeTimeOnly(struct pg_tm * tm, fsec_t fsec, int *tzp, int style, char *str)
{
- if (tm->tm_hour < 0 || tm->tm_hour > 24)
+ if (tm->tm_hour < 0 || tm->tm_hour > HOURS_PER_DAY)
return -1;
sprintf(str, "%02d:%02d", tm->tm_hour, tm->tm_min);
int hour,
min;
- hour = -(*tzp / 3600);
- min = (abs(*tzp) / 60) % 60;
+ hour = -(*tzp / SECS_PER_HOUR);
+ min = (abs(*tzp) / SECS_PER_MINUTE) % SECS_PER_MINUTE;
sprintf(str + strlen(str), (min != 0) ? "%+03d:%02d" : "%+03d", hour, min);
}
/*
* Why are we checking only the month field? Change this to an
- * assert... if (tm->tm_mon < 1 || tm->tm_mon > 12) return -1;
+ * assert... if (tm->tm_mon < 1 || tm->tm_mon > MONTHS_PER_YEAR) return -1;
*/
- Assert(tm->tm_mon >= 1 && tm->tm_mon <= 12);
+ Assert(tm->tm_mon >= 1 && tm->tm_mon <= MONTHS_PER_YEAR);
switch (style)
{
*/
if (tzp != NULL && tm->tm_isdst >= 0)
{
- hour = -(*tzp / 3600);
- min = (abs(*tzp) / 60) % 60;
+ hour = -(*tzp / SECS_PER_HOUR);
+ min = (abs(*tzp) / SECS_PER_MINUTE) % SECS_PER_MINUTE;
sprintf(str + strlen(str), (min != 0) ? "%+03d:%02d" : "%+03d", hour, min);
}
sprintf(str + strlen(str), " %.*s", MAXTZLEN, *tzn);
else
{
- hour = -(*tzp / 3600);
- min = (abs(*tzp) / 60) % 60;
+ hour = -(*tzp / SECS_PER_HOUR);
+ min = (abs(*tzp) / SECS_PER_MINUTE) % SECS_PER_MINUTE;
sprintf(str + strlen(str), (min != 0) ? "%+03d:%02d" : "%+03d", hour, min);
}
}
sprintf(str + strlen(str), " %.*s", MAXTZLEN, *tzn);
else
{
- hour = -(*tzp / 3600);
- min = (abs(*tzp) / 60) % 60;
+ hour = -(*tzp / SECS_PER_HOUR);
+ min = (abs(*tzp) / SECS_PER_MINUTE) % SECS_PER_MINUTE;
sprintf(str + strlen(str), (min != 0) ? "%+03d:%02d" : "%+03d", hour, min);
}
}
* rejected by the date/time parser later. - thomas
* 2001-10-19
*/
- hour = -(*tzp / 3600);
- min = (abs(*tzp) / 60) % 60;
+ hour = -(*tzp / SECS_PER_HOUR);
+ min = (abs(*tzp) / SECS_PER_MINUTE) % SECS_PER_MINUTE;
sprintf(str + strlen(str), (min != 0) ? " %+03d:%02d" : " %+03d", hour, min);
}
}
/* -----------------------------------------------------------------------
* formatting.c
*
- * $PostgreSQL: pgsql/src/backend/utils/adt/formatting.c,v 1.91 2005/07/20 16:42:30 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/formatting.c,v 1.92 2005/07/21 03:56:16 momjian Exp $
*
*
* Portions Copyright (c) 1999-2005, PostgreSQL Global Development Group
if (flag == TO_CHAR)
{
strcpy(inout, ((tm->tm_hour > 11
- && tm->tm_hour < 24) ? P_M_STR : A_M_STR));
+ && tm->tm_hour < HOURS_PER_DAY) ? P_M_STR : A_M_STR));
return 3;
}
else if (flag == FROM_CHAR)
if (flag == TO_CHAR)
{
strcpy(inout, ((tm->tm_hour > 11
- && tm->tm_hour < 24) ? PM_STR : AM_STR));
+ && tm->tm_hour < HOURS_PER_DAY) ? PM_STR : AM_STR));
return 1;
}
else if (flag == FROM_CHAR)
if (flag == TO_CHAR)
{
strcpy(inout, ((tm->tm_hour > 11
- && tm->tm_hour < 24) ? p_m_STR : a_m_STR));
+ && tm->tm_hour < HOURS_PER_DAY) ? p_m_STR : a_m_STR));
return 3;
}
else if (flag == FROM_CHAR)
if (flag == TO_CHAR)
{
strcpy(inout, ((tm->tm_hour > 11
- && tm->tm_hour < 24) ? pm_STR : am_STR));
+ && tm->tm_hour < HOURS_PER_DAY) ? pm_STR : am_STR));
return 1;
}
else if (flag == FROM_CHAR)
case DCH_SSSS:
if (flag == TO_CHAR)
{
- sprintf(inout, "%d", tm->tm_hour * 3600 +
- tm->tm_min * 60 +
+ sprintf(inout, "%d", tm->tm_hour * SECS_PER_HOUR +
+ tm->tm_min * SECS_PER_MINUTE +
tm->tm_sec);
if (S_THth(suf))
str_numth(p_inout, inout, S_TH_TYPE(suf));
{
int x = tmfc.ssss;
- tm->tm_hour = x / 3600;
- x %= 3600;
- tm->tm_min = x / 60;
- x %= 60;
+ tm->tm_hour = x / SECS_PER_HOUR;
+ x %= SECS_PER_HOUR;
+ tm->tm_min = x / SECS_PER_MINUTE;
+ x %= SECS_PER_MINUTE;
tm->tm_sec = x;
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/nabstime.c,v 1.136 2005/07/20 16:42:30 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/nabstime.c,v 1.137 2005/07/21 03:56:18 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return INVALID_ABSTIME;
/* convert to seconds */
- sec = tm->tm_sec + tz + (tm->tm_min + (day * 24 + tm->tm_hour) * 60) * 60;
+ sec = tm->tm_sec + tz + (tm->tm_min + (day * HOURS_PER_DAY + tm->tm_hour) * SECS_PER_MINUTE) * SECS_PER_MINUTE;
/* check for overflow */
if ((day == MAX_DAYNUM && sec < 0) ||
switch (dtype)
{
case DTK_DELTA:
- result = ((tm->tm_hour * 60 + tm->tm_min) * 60) + tm->tm_sec;
- result += tm->tm_year * 36525 * 864 + ((tm->tm_mon * 30) + tm->tm_mday) * SECS_PER_DAY;
+ result = ((tm->tm_hour * SECS_PER_MINUTE + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec;
+ result += tm->tm_year * 36525 * 864 + ((tm->tm_mon * DAYS_PER_MONTH) + tm->tm_mday) * SECS_PER_DAY;
break;
default:
FMODULO(dtime, tm->tm_year, 31557600);
FMODULO(dtime, tm->tm_mon, 2592000);
FMODULO(dtime, tm->tm_mday, SECS_PER_DAY);
- FMODULO(dtime, tm->tm_hour, 3600);
- FMODULO(dtime, tm->tm_min, 60);
+ FMODULO(dtime, tm->tm_hour, SECS_PER_HOUR);
+ FMODULO(dtime, tm->tm_min, SECS_PER_MINUTE);
FMODULO(dtime, tm->tm_sec, 1);
}
double span;
#endif
- year = interval->month / 12;
- month = interval->month % 12;
+ year = interval->month / MONTHS_PER_YEAR;
+ month = interval->month % MONTHS_PER_YEAR;
day = interval->day;
#ifdef HAVE_INT64_TIMESTAMP
interval->time;
span /= USECS_PER_SEC;
#else
- span = (365.25 * year + 30.0 * month + day) * SECS_PER_DAY + interval->time;
+ span = (DAYS_PER_YEAR * year + (double)DAYS_PER_MONTH * month + day) * SECS_PER_DAY + interval->time;
#endif
if (span < INT_MIN || span > INT_MAX)
#ifdef HAVE_INT64_TIMESTAMP
year = (reltime / (36525 * 864));
reltime -= (year * (36525 * 864));
- month = (reltime / (30 * SECS_PER_DAY));
- reltime -= (month * (30 * SECS_PER_DAY));
+ month = (reltime / (DAYS_PER_MONTH * SECS_PER_DAY));
+ reltime -= (month * (DAYS_PER_MONTH * 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, month, DAYS_PER_MONTH * SECS_PER_DAY);
TMODULO(reltime, day, SECS_PER_DAY);
result->time = reltime;
#endif
- result->month = 12 * year + month;
+ result->month = MONTHS_PER_YEAR * year + month;
result->day = day;
break;
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.185 2005/07/20 16:42:30 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.186 2005/07/21 03:56:18 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
#ifdef HAVE_INT64_TIMESTAMP
return interval->time + interval->day * (double)USECS_PER_DAY +
- interval->month * ((365.25 / 12.0) * USECS_PER_DAY);
+ interval->month * ((DAYS_PER_YEAR / (double)MONTHS_PER_YEAR) * USECS_PER_DAY);
#else
return interval->time + interval->day * SECS_PER_DAY +
- interval->month * ((365.25 / 12.0) * (double)SECS_PER_DAY);
+ interval->month * ((DAYS_PER_YEAR / (double)MONTHS_PER_YEAR) * (double)SECS_PER_DAY);
#endif
}
case RELTIMEOID:
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/timestamp.c,v 1.134 2005/07/20 16:42:31 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/timestamp.c,v 1.135 2005/07/21 03:56:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* gcc's -ffast-math switch breaks routines that expect exact results from
- * expressions like timeval / 3600, where timeval is double.
+ * expressions like timeval / SECS_PER_HOUR, where timeval is double.
*/
#ifdef __FAST_MATH__
#error -ffast-math is known to break this code
}
else if (range == INTERVAL_MASK(YEAR))
{
- interval->month = (interval->month / 12) * 12;
+ interval->month = (interval->month / MONTHS_PER_YEAR) * MONTHS_PER_YEAR;
interval->day = 0;
interval->time = 0;
}
else if (range == INTERVAL_MASK(MONTH))
{
- interval->month %= 12;
+ interval->month %= MONTHS_PER_YEAR;
interval->day = 0;
interval->time = 0;
}
interval->time = (interval->time / USECS_PER_HOUR) *
USECS_PER_HOUR;
#else
- interval->time = ((int)(interval->time / 3600)) * 3600.0;
+ interval->time = ((int)(interval->time / SECS_PER_HOUR)) * (double)SECS_PER_HOUR;
#endif
}
else if (range == INTERVAL_MASK(MINUTE))
USECS_PER_MINUTE;
#else
- TMODULO(interval->time, hour, 3600.0);
- interval->time = ((int)(interval->time / 60)) * 60.0;
+ TMODULO(interval->time, hour, (double)SECS_PER_HOUR);
+ interval->time = ((int)(interval->time / SECS_PER_MINUTE)) * (double)SECS_PER_MINUTE;
#endif
}
else if (range == INTERVAL_MASK(SECOND))
minute = interval->time / USECS_PER_MINUTE;
interval->time -= minute * USECS_PER_MINUTE;
#else
- TMODULO(interval->time, minute, 60.0);
+ TMODULO(interval->time, minute, (double)SECS_PER_MINUTE);
/* return subseconds too */
#endif
}
interval->time = (interval->time / USECS_PER_HOUR) *
USECS_PER_HOUR;
#else
- interval->time = ((int) (interval->time / 3600)) * 3600.0;
+ interval->time = ((int) (interval->time / SECS_PER_HOUR)) * (double)SECS_PER_HOUR;
#endif
}
/* DAY TO MINUTE */
interval->time = (interval->time / USECS_PER_MINUTE) *
USECS_PER_MINUTE;
#else
- interval->time = ((int)(interval->time / 60)) * 60.0;
+ interval->time = ((int)(interval->time / SECS_PER_MINUTE)) * (double)SECS_PER_MINUTE;
#endif
}
/* DAY TO SECOND */
interval->time = (interval->time / USECS_PER_MINUTE) *
USECS_PER_MINUTE;
#else
- interval->time = ((int)(interval->time / 60)) * 60.0;
+ interval->time = ((int)(interval->time / SECS_PER_MINUTE)) * (double)SECS_PER_MINUTE;
#endif
}
/* HOUR TO SECOND */
hour = interval->time / USECS_PER_HOUR;
interval->time -= hour * USECS_PER_HOUR;
#else
- TMODULO(interval->time, hour, 3600.0);
+ TMODULO(interval->time, hour, (double)SECS_PER_HOUR);
#endif
}
else
*sec = time / USECS_PER_SEC;
*fsec = time - (*sec * USECS_PER_SEC);
#else
- *hour = time / 3600;
- time -= (*hour) * 3600;
- *min = time / 60;
- time -= (*min) * 60;
+ *hour = time / SECS_PER_HOUR;
+ time -= (*hour) * SECS_PER_HOUR;
+ *min = time / SECS_PER_MINUTE;
+ time -= (*min) * SECS_PER_MINUTE;
*sec = time;
*fsec = JROUND(time - *sec);
#endif
double time;
#endif
- tm->tm_year = span.month / 12;
- tm->tm_mon = span.month % 12;
+ tm->tm_year = span.month / MONTHS_PER_YEAR;
+ tm->tm_mon = span.month % MONTHS_PER_YEAR;
tm->tm_mday = span.day;
time = span.time;
tm->tm_sec = (time / USECS_PER_SEC);
*fsec = (time - (tm->tm_sec * USECS_PER_SEC));
#else
- TMODULO(time, tm->tm_hour, 3600.0);
- TMODULO(time, tm->tm_min, 60.0);
+ TMODULO(time, tm->tm_hour, (double)SECS_PER_HOUR);
+ TMODULO(time, tm->tm_min, (double)SECS_PER_MINUTE);
TMODULO(time, tm->tm_sec, 1.0);
*fsec = time;
#endif
int
tm2interval(struct pg_tm *tm, fsec_t fsec, Interval *span)
{
- span->month = tm->tm_year * 12 + tm->tm_mon;
+ span->month = tm->tm_year * MONTHS_PER_YEAR + tm->tm_mon;
span->day = tm->tm_mday;
#ifdef HAVE_INT64_TIMESTAMP
- span->time = (((((tm->tm_hour * INT64CONST(60)) +
- tm->tm_min) * INT64CONST(60)) +
+ span->time = (((((tm->tm_hour * INT64CONST(SECS_PER_MINUTE)) +
+ tm->tm_min) * INT64CONST(SECS_PER_MINUTE)) +
tm->tm_sec) * USECS_PER_SEC) + fsec;
#else
- span->time = (((tm->tm_hour * 60.0) +
- tm->tm_min) * 60.0) +
+ span->time = (((tm->tm_hour * (double)SECS_PER_MINUTE) +
+ tm->tm_min) * (double)SECS_PER_MINUTE) +
tm->tm_sec;
span->time = JROUND(span->time + fsec);
#endif
static int64
time2t(const int hour, const int min, const int sec, const fsec_t fsec)
{
- return (((((hour * 60) + min) * 60) + sec) * USECS_PER_SEC) + fsec;
+ return (((((hour * SECS_PER_MINUTE) + min) * SECS_PER_MINUTE) + sec) * USECS_PER_SEC) + fsec;
} /* time2t() */
#else
static double
time2t(const int hour, const int min, const int sec, const fsec_t fsec)
{
- return (((hour * 60) + min) * 60) + sec + fsec;
+ return (((hour * SECS_PER_MINUTE) + min) * SECS_PER_MINUTE) + sec + fsec;
} /* time2t() */
#endif
span2 = interval2->time;
#ifdef HAVE_INT64_TIMESTAMP
- 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;
+ span1 += interval1->month * INT64CONST(DAYS_PER_MONTH) * USECS_PER_DAY;
+ span1 += interval1->day * INT64CONST(HOURS_PER_DAY) * USECS_PER_HOUR;
+ span2 += interval2->month * INT64CONST(DAYS_PER_MONTH) * USECS_PER_DAY;
+ span2 += interval2->day * INT64CONST(HOURS_PER_DAY) * USECS_PER_HOUR;
#else
- 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);
+ span1 += interval1->month * ((double)DAYS_PER_MONTH * SECS_PER_DAY);
+ span1 += interval1->day * ((double)HOURS_PER_DAY * SECS_PER_HOUR);
+ span2 += interval2->month * ((double)DAYS_PER_MONTH * SECS_PER_DAY);
+ span2 += interval2->day * ((double)HOURS_PER_DAY * SECS_PER_HOUR);
#endif
return ((span1 < span2) ? -1 : (span1 > span2) ? 1 : 0);
result->time = span->time;
#ifdef HAVE_INT64_TIMESTAMP
- result->day += span->month * 30.0;
- result->month = span->day / 30;
- result->day -= result->month * 30;
+ result->day += span->month * (double)DAYS_PER_MONTH;
+ result->month = span->day / DAYS_PER_MONTH;
+ result->day -= result->month * DAYS_PER_MONTH;
#else
- result->day += span->month * 30.0;
- TMODULO(result->day, result->month, 30.0);
+ result->day += span->month * (double)DAYS_PER_MONTH;
+ TMODULO(result->day, result->month, (double)DAYS_PER_MONTH);
#endif
PG_RETURN_INTERVAL_P(result);
errmsg("timestamp out of range")));
tm->tm_mon += span->month;
- if (tm->tm_mon > 12)
+ if (tm->tm_mon > MONTHS_PER_YEAR)
{
- tm->tm_year += (tm->tm_mon - 1) / 12;
- tm->tm_mon = ((tm->tm_mon - 1) % 12) + 1;
+ tm->tm_year += (tm->tm_mon - 1) / MONTHS_PER_YEAR;
+ tm->tm_mon = ((tm->tm_mon - 1) % MONTHS_PER_YEAR) + 1;
}
else if (tm->tm_mon < 1)
{
- tm->tm_year += tm->tm_mon / 12 - 1;
- tm->tm_mon = tm->tm_mon % 12 + 12;
+ tm->tm_year += tm->tm_mon / MONTHS_PER_YEAR - 1;
+ tm->tm_mon = tm->tm_mon % MONTHS_PER_YEAR + MONTHS_PER_YEAR;
}
/* adjust for end of month boundary problems... */
errmsg("timestamp out of range")));
tm->tm_mon += span->month;
- if (tm->tm_mon > 12)
+ if (tm->tm_mon > MONTHS_PER_YEAR)
{
- tm->tm_year += (tm->tm_mon - 1) / 12;
- tm->tm_mon = ((tm->tm_mon - 1) % 12) + 1;
+ tm->tm_year += (tm->tm_mon - 1) / MONTHS_PER_YEAR;
+ tm->tm_mon = ((tm->tm_mon - 1) % MONTHS_PER_YEAR) + 1;
}
else if (tm->tm_mon < 1)
{
- tm->tm_year += tm->tm_mon / 12 - 1;
- tm->tm_mon = tm->tm_mon % 12 + 12;
+ tm->tm_year += tm->tm_mon / MONTHS_PER_YEAR - 1;
+ tm->tm_mon = tm->tm_mon % MONTHS_PER_YEAR + MONTHS_PER_YEAR;
}
/* adjust for end of month boundary problems... */
result->month = months;
result->day = days;
result->time = (span1->time * factor);
- result->time += (months - result->month) * INT64CONST(30) * USECS_PER_DAY;
- result->time += (days - result->day) * INT64CONST(24) * USECS_PER_HOUR;
+ result->time += (months - result->month) * INT64CONST(DAYS_PER_MONTH) * USECS_PER_DAY;
+ result->time += (days - result->day) * INT64CONST(HOURS_PER_DAY) * 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);
+ result->time += JROUND((months - result->month) * DAYS_PER_MONTH * SECS_PER_DAY);
/* evaluate fractional days as 24 hours */
- result->time += JROUND((days - result->day) * 24 * SECS_PER_HOUR);
+ result->time += JROUND((days - result->day) * HOURS_PER_DAY * SECS_PER_HOUR);
#endif
PG_RETURN_INTERVAL_P(result);
/* Cascade fractions to lower units */
/* fractional months full days into days */
- result->day += month_remainder * 30;
+ result->day += month_remainder * DAYS_PER_MONTH;
/* fractional months partial days into time */
- day_remainder += (month_remainder * 30) - (int)(month_remainder * 30);
+ day_remainder += (month_remainder * DAYS_PER_MONTH) - (int)(month_remainder * DAYS_PER_MONTH);
#ifdef HAVE_INT64_TIMESTAMP
result->time += day_remainder * USECS_PER_DAY;
while (tm->tm_sec < 0)
{
- tm->tm_sec += 60;
+ tm->tm_sec += SECS_PER_MINUTE;
tm->tm_min--;
}
while (tm->tm_min < 0)
{
- tm->tm_min += 60;
+ tm->tm_min += SECS_PER_MINUTE;
tm->tm_hour--;
}
while (tm->tm_hour < 0)
{
- tm->tm_hour += 24;
+ tm->tm_hour += HOURS_PER_DAY;
tm->tm_mday--;
}
while (tm->tm_mon < 0)
{
- tm->tm_mon += 12;
+ tm->tm_mon += MONTHS_PER_YEAR;
tm->tm_year--;
}
while (tm->tm_sec < 0)
{
- tm->tm_sec += 60;
+ tm->tm_sec += SECS_PER_MINUTE;
tm->tm_min--;
}
while (tm->tm_min < 0)
{
- tm->tm_min += 60;
+ tm->tm_min += SECS_PER_MINUTE;
tm->tm_hour--;
}
while (tm->tm_hour < 0)
{
- tm->tm_hour += 24;
+ tm->tm_hour += HOURS_PER_DAY;
tm->tm_mday--;
}
while (tm->tm_mon < 0)
{
- tm->tm_mon += 12;
+ tm->tm_mon += MONTHS_PER_YEAR;
tm->tm_year--;
}
*/
if (woy >= 52 && tm->tm_mon == 1)
--tm->tm_year;
- if (woy <= 1 && tm->tm_mon == 12)
+ if (woy <= 1 && tm->tm_mon == MONTHS_PER_YEAR)
++tm->tm_year;
isoweek2date(woy, &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
tm->tm_hour = 0;
*/
if (woy >= 52 && tm->tm_mon == 1)
--tm->tm_year;
- if (woy <= 1 && tm->tm_mon == 12)
+ if (woy <= 1 && tm->tm_mon == MONTHS_PER_YEAR)
++tm->tm_year;
isoweek2date(woy, &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
tm->tm_hour = 0;
case DTK_JULIAN:
result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday);
#ifdef HAVE_INT64_TIMESTAMP
- result += ((((tm->tm_hour * 60) + tm->tm_min) * 60) +
+ result += ((((tm->tm_hour * SECS_PER_MINUTE) + tm->tm_min) * SECS_PER_MINUTE) +
tm->tm_sec + (fsec / 1000000.0)) / (double)SECS_PER_DAY;
#else
- result += ((((tm->tm_hour * 60) + tm->tm_min) * 60) +
+ result += ((((tm->tm_hour * SECS_PER_MINUTE) + tm->tm_min) * SECS_PER_MINUTE) +
tm->tm_sec + fsec) / (double)SECS_PER_DAY;
#endif
break;
case DTK_TZ_MINUTE:
result = -tz;
- result /= 60;
- FMODULO(result, dummy, 60.0);
+ result /= SECS_PER_MINUTE;
+ FMODULO(result, dummy, (double)SECS_PER_MINUTE);
break;
case DTK_TZ_HOUR:
dummy = -tz;
- FMODULO(dummy, result, 3600.0);
+ FMODULO(dummy, result, (double)SECS_PER_HOUR);
break;
case DTK_MICROSEC:
case DTK_JULIAN:
result = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday);
#ifdef HAVE_INT64_TIMESTAMP
- result += ((((tm->tm_hour * 60) + tm->tm_min) * 60) +
+ result += ((((tm->tm_hour * SECS_PER_MINUTE) + tm->tm_min) * SECS_PER_MINUTE) +
tm->tm_sec + (fsec / 1000000.0)) / (double)SECS_PER_DAY;
#else
- result += ((((tm->tm_hour * 60) + tm->tm_min) * 60) +
+ result += ((((tm->tm_hour * SECS_PER_MINUTE) + tm->tm_min) * SECS_PER_MINUTE) +
tm->tm_sec + fsec) / (double)SECS_PER_DAY;
#endif
break;
#else
result = interval->time;
#endif
- result += (365.25 * SECS_PER_DAY) * (interval->month / 12);
- result += (30.0 * SECS_PER_DAY) * (interval->month % 12);
+ result += (DAYS_PER_YEAR * SECS_PER_DAY) * (interval->month / MONTHS_PER_YEAR);
+ result += ((double)DAYS_PER_MONTH * SECS_PER_DAY) * (interval->month % MONTHS_PER_YEAR);
result += interval->day * SECS_PER_DAY;
}
else
* Written by Peter Eisentraut <peter_e@gmx.net>.
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.274 2005/07/14 05:13:42 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.275 2005/07/21 03:56:21 momjian Exp $
*
*--------------------------------------------------------------------
*/
NULL
},
&Log_RotationAge,
- 24 * 60, 0, INT_MAX / 60, NULL, NULL
+ HOURS_PER_DAY * SECS_PER_MINUTE, 0, INT_MAX / SECS_PER_MINUTE, NULL, NULL
},
{
* 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.47 2005/07/20 16:42:32 momjian Exp $
+ * $PostgreSQL: pgsql/src/include/utils/timestamp.h,v 1.48 2005/07/21 03:56:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define MAX_TIMESTAMP_PRECISION 6
#define MAX_INTERVAL_PRECISION 6
+/* in both timestamp.h and ecpg/dt.h */
+#define DAYS_PER_YEAR 365.25
+#define MONTHS_PER_YEAR 12
+/* average days per month */
+#define DAYS_PER_MONTH 30
+#define HOURS_PER_DAY 24
+
#define SECS_PER_DAY 86400
#define SECS_PER_HOUR 3600
+#define SECS_PER_MINUTE 60
+
#ifdef HAVE_INT64_TIMESTAMP
#define USECS_PER_DAY INT64CONST(86400000000)
#define USECS_PER_HOUR INT64CONST(3600000000)
return -1;
}
- if (tm.tm_mon < 1 || tm.tm_mon > 12)
+ if (tm.tm_mon < 1 || tm.tm_mon > MONTHS_PER_YEAR)
{
errno = PGTYPES_DATE_BAD_MONTH;
return -1;
} while(0)
#endif
+/* in both timestamp.h and ecpg/dt.h */
+#define DAYS_PER_YEAR 365.25
+#define MONTHS_PER_YEAR 12
+/* average days per month */
+#define DAYS_PER_MONTH 30
+#define HOURS_PER_DAY 24
+
#define SECS_PER_DAY 86400
+#define SECS_PER_HOUR 3600
+#define SECS_PER_MINUTE 60
+
#ifdef HAVE_INT64_TIMESTAMP
#define USECS_PER_DAY INT64CONST(86400000000)
#define USECS_PER_HOUR INT64CONST(3600000000)
int
EncodeDateOnly(struct tm * tm, int style, char *str, bool EuroDates)
{
- if (tm->tm_mon < 1 || tm->tm_mon > 12)
+ if (tm->tm_mon < 1 || tm->tm_mon > MONTHS_PER_YEAR)
return -1;
switch (style)
*/
if (tzp != NULL && tm->tm_isdst >= 0)
{
- hour = -(*tzp / 3600);
- min = (abs(*tzp) / 60) % 60;
+ hour = -(*tzp / SECS_PER_HOUR);
+ min = (abs(*tzp) / SECS_PER_MINUTE) % SECS_PER_MINUTE;
sprintf(str + strlen(str), (min != 0) ? "%+03d:%02d" : "%+03d", hour, min);
}
break;
sprintf(str + strlen(str), " %.*s", MAXTZLEN, *tzn);
else
{
- hour = -(*tzp / 3600);
- min = (abs(*tzp) / 60) % 60;
+ hour = -(*tzp / SECS_PER_HOUR);
+ min = (abs(*tzp) / SECS_PER_MINUTE) % SECS_PER_MINUTE;
sprintf(str + strlen(str), (min != 0) ? "%+03d:%02d" : "%+03d", hour, min);
}
}
sprintf(str + strlen(str), " %.*s", MAXTZLEN, *tzn);
else
{
- hour = -(*tzp / 3600);
- min = (abs(*tzp) / 60) % 60;
+ hour = -(*tzp / SECS_PER_HOUR);
+ min = (abs(*tzp) / SECS_PER_MINUTE) % SECS_PER_MINUTE;
sprintf(str + strlen(str), (min != 0) ? "%+03d:%02d" : "%+03d", hour, min);
}
}
* rejected by the date/time parser later. - thomas
* 2001-10-19
*/
- hour = -(*tzp / 3600);
- min = (abs(*tzp) / 60) % 60;
+ hour = -(*tzp / SECS_PER_HOUR);
+ min = (abs(*tzp) / SECS_PER_MINUTE) % SECS_PER_MINUTE;
sprintf(str + strlen(str), (min != 0) ? " %+03d:%02d" : " %+03d", hour, min);
}
}
#elif defined(HAVE_INT_TIMEZONE)
if (tzp != NULL)
{
- *tzp = (tm->tm_isdst > 0) ? TIMEZONE_GLOBAL - 3600 : TIMEZONE_GLOBAL;
+ *tzp = (tm->tm_isdst > 0) ? TIMEZONE_GLOBAL - SECS_PER_HOUR : TIMEZONE_GLOBAL;
if (tzn != NULL)
{
/* tm_gmtoff is Sun/DEC-ism */
tz = -(tmp->tm_gmtoff);
#elif defined(HAVE_INT_TIMEZONE)
- tz = (tmp->tm_isdst > 0) ? TIMEZONE_GLOBAL - 3600 : TIMEZONE_GLOBAL;
+ tz = (tmp->tm_isdst > 0) ? TIMEZONE_GLOBAL - SECS_PER_HOUR : TIMEZONE_GLOBAL;
#endif /* HAVE_INT_TIMEZONE */
}
else
day = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) -
date2j(1970, 1, 1));
- mysec = tm->tm_sec + (tm->tm_min + (day * 24 + tm->tm_hour) * 60) * 60;
+ mysec = tm->tm_sec + (tm->tm_min + (day * HOURS_PER_DAY + tm->tm_hour) * SECS_PER_MINUTE) * SECS_PER_MINUTE;
mytime = (time_t) mysec;
/*
tmp = localtime(&mytime);
day = (date2j(tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday) -
date2j(1970, 1, 1));
- locsec = tmp->tm_sec + (tmp->tm_min + (day * 24 + tmp->tm_hour) * 60) * 60;
+ locsec = tmp->tm_sec + (tmp->tm_min + (day * HOURS_PER_DAY + tmp->tm_hour) * SECS_PER_MINUTE) * SECS_PER_MINUTE;
/*
* The local time offset corresponding to that GMT time is now
tmp = localtime(&mytime);
day = (date2j(tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday) -
date2j(1970, 1, 1));
- locsec = tmp->tm_sec + (tmp->tm_min + (day * 24 + tmp->tm_hour) * 60) * 60;
+ locsec = tmp->tm_sec + (tmp->tm_min + (day * HOURS_PER_DAY + tmp->tm_hour) * SECS_PER_MINUTE) * SECS_PER_MINUTE;
delta2 = mysec - locsec;
if (delta2 != delta1)
{
tmp = localtime(&mytime);
day = (date2j(tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday) -
date2j(1970, 1, 1));
- locsec = tmp->tm_sec + (tmp->tm_min + (day * 24 + tmp->tm_hour) * 60) * 60;
+ locsec = tmp->tm_sec + (tmp->tm_min + (day * HOURS_PER_DAY + tmp->tm_hour) * SECS_PER_MINUTE) * SECS_PER_MINUTE;
delta2 = mysec - locsec;
}
tm->tm_isdst = tmp->tm_isdst;
*sec = time / USECS_PER_SEC;
*fsec = time - (*sec * USECS_PER_SEC);
#else
- *hour = time / 3600;
- time -= (*hour) * 3600;
- *min = time / 60;
- time -= (*min) * 60;
+ *hour = time / SECS_PER_HOUR;
+ time -= (*hour) * SECS_PER_HOUR;
+ *min = time / SECS_PER_MINUTE;
+ time -= (*min) * SECS_PER_MINUTE;
*sec = time;
*fsec = JROUND(time - *sec);
#endif
}
/* already have year? then could be month */
- else if ((fmask & DTK_M(YEAR)) && !(fmask & DTK_M(MONTH)) && val >= 1 && val <= 12)
+ else if ((fmask & DTK_M(YEAR)) && !(fmask & DTK_M(MONTH)) && val >= 1 && val <= MONTHS_PER_YEAR)
{
*tmask = DTK_M(MONTH);
tm->tm_mon = val;
*tmask = DTK_M(DAY);
tm->tm_mday = val;
}
- else if (!(fmask & DTK_M(MONTH)) && val >= 1 && val <= 12)
+ else if (!(fmask & DTK_M(MONTH)) && val >= 1 && val <= MONTHS_PER_YEAR)
{
*tmask = DTK_M(MONTH);
tm->tm_mon = val;
else
min = 0;
- tz = (hr * 60 + min) * 60;
+ tz = (hr * SECS_PER_MINUTE + min) * SECS_PER_MINUTE;
if (*str == '-')
tz = -tz;
{
case DTZ:
case TZ:
- *tzp = (val * 60) - tz;
+ *tzp = (val * SECS_PER_MINUTE) - tz;
break;
default:
tm->tm_isdst = 1;
if (tzp == NULL)
return -1;
- *tzp += val * 60;
+ *tzp += val * SECS_PER_MINUTE;
break;
case DTZ:
tm->tm_isdst = 1;
if (tzp == NULL)
return -1;
- *tzp = val * 60;
+ *tzp = val * SECS_PER_MINUTE;
ftype[i] = DTK_TZ;
break;
tm->tm_isdst = 0;
if (tzp == NULL)
return -1;
- *tzp = val * 60;
+ *tzp = val * SECS_PER_MINUTE;
ftype[i] = DTK_TZ;
break;
* timezone value of the datetktbl table is in
* quarter hours
*/
- *tz = -15 * 60 * datetktbl[j].value;
+ *tz = -15 * SECS_PER_MINUTE * datetktbl[j].value;
break;
}
}
err = 1;
*hour = 0;
}
- if (*month > 12)
+ if (*month > MONTHS_PER_YEAR)
{
err = 1;
*month = 1;
{
int sec;
- fval *= 60;
+ fval *= SECS_PER_MINUTE;
sec = fval;
tm->tm_sec += sec;
#ifdef HAVE_INT64_TIMESTAMP
{
int sec;
- fval *= 3600;
+ fval *= SECS_PER_HOUR;
sec = fval;
tm->tm_sec += sec;
#ifdef HAVE_INT64_TIMESTAMP
{
int sec;
- fval *= 30 * SECS_PER_DAY;
+ fval *= DAYS_PER_MONTH * SECS_PER_DAY;
sec = fval;
tm->tm_sec += sec;
#ifdef HAVE_INT64_TIMESTAMP
case DTK_YEAR:
tm->tm_year += val;
if (fval != 0)
- tm->tm_mon += fval * 12;
+ tm->tm_mon += fval * MONTHS_PER_YEAR;
tmask = (fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR);
break;
case DTK_DECADE:
tm->tm_year += val * 10;
if (fval != 0)
- tm->tm_mon += fval * 120;
+ tm->tm_mon += fval * MONTHS_PER_YEAR * 10;
tmask = (fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR);
break;
case DTK_CENTURY:
tm->tm_year += val * 100;
if (fval != 0)
- tm->tm_mon += fval * 1200;
+ tm->tm_mon += fval * MONTHS_PER_YEAR * 100;
tmask = (fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR);
break;
case DTK_MILLENNIUM:
tm->tm_year += val * 1000;
if (fval != 0)
- tm->tm_mon += fval * 12000;
+ tm->tm_mon += fval * MONTHS_PER_YEAR * 1000;
tmask = (fmask & DTK_M(YEAR)) ? 0 : DTK_M(YEAR);
break;
if (span.month != 0)
{
- tm->tm_year = span.month / 12;
- tm->tm_mon = span.month % 12;
+ tm->tm_year = span.month / MONTHS_PER_YEAR;
+ tm->tm_mon = span.month % MONTHS_PER_YEAR;
}
else
*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_hour, (double)SECS_PER_HOUR);
+ TMODULO(time, tm->tm_min, (double)SECS_PER_MINUTE);
TMODULO(time, tm->tm_sec, 1.0);
*fsec = time;
#endif
static int
tm2interval(struct tm *tm, fsec_t fsec, interval *span)
{
- span->month = tm->tm_year * 12 + tm->tm_mon;
+ span->month = tm->tm_year * MONTHS_PER_YEAR + tm->tm_mon;
#ifdef HAVE_INT64_TIMESTAMP
- span->time = (((((((tm->tm_mday * INT64CONST(24)) +
- tm->tm_hour) * INT64CONST(60)) +
- tm->tm_min) * INT64CONST(60)) +
+ span->time = (((((((tm->tm_mday * INT64CONST(HOURS_PER_DAY)) +
+ tm->tm_hour) * INT64CONST(SECS_PER_MINUTE)) +
+ tm->tm_min) * INT64CONST(SECS_PER_MINUTE)) +
tm->tm_sec) * USECS_PER_SEC) + fsec;
#else
- span->time = (((((tm->tm_mday * 24.0) +
- tm->tm_hour) * 60.0) +
- tm->tm_min) * 60.0) +
+ span->time = (((((tm->tm_mday * (double)HOURS_PER_DAY) +
+ tm->tm_hour) * (double)SECS_PER_MINUTE) +
+ tm->tm_min) * (double)SECS_PER_MINUTE) +
tm->tm_sec;
span->time = JROUND(span->time + fsec);
#endif
static int64
time2t(const int hour, const int min, const int sec, const fsec_t fsec)
{
- return (((((hour * 60) + min) * 60) + sec) * USECS_PER_SEC) + fsec;
+ return (((((hour * SECS_PER_MINUTE) + min) * SECS_PER_MINUTE) + sec) * USECS_PER_SEC) + fsec;
} /* time2t() */
#else
static double
time2t(const int hour, const int min, const int sec, const fsec_t fsec)
{
- return (((hour * 60) + min) * 60) + sec + fsec;
+ return (((hour * SECS_PER_MINUTE) + min) * SECS_PER_MINUTE) + sec + fsec;
} /* time2t() */
#endif
*sec = time / USECS_PER_SEC;
*fsec = time - *sec * USECS_PER_SEC;
#else
- *hour = time / 3600;
- time -= (*hour) * 3600;
- *min = time / 60;
- time -= (*min) * 60;
+ *hour = time / SECS_PER_HOUR;
+ time -= (*hour) * SECS_PER_HOUR;
+ *min = time / SECS_PER_MINUTE;
+ time -= (*min) * SECS_PER_MINUTE;
*sec = time;
*fsec = JROUND(time - *sec);
#endif
if (tzn != NULL)
*tzn = (char *) tm->tm_zone;
#elif defined(HAVE_INT_TIMEZONE)
- *tzp = (tm->tm_isdst > 0) ? TIMEZONE_GLOBAL - 3600 : TIMEZONE_GLOBAL;
+ *tzp = (tm->tm_isdst > 0) ? TIMEZONE_GLOBAL - SECS_PER_HOUR : TIMEZONE_GLOBAL;
if (tzn != NULL)
*tzn = TZNAME_GLOBAL[(tm->tm_isdst > 0)];
#endif
if (timestamp2tm(*tin, NULL, tm, &fsec, NULL) !=0)
return -1;
tm->tm_mon += span->month;
- if (tm->tm_mon > 12)
+ if (tm->tm_mon > MONTHS_PER_YEAR)
{
- tm->tm_year += (tm->tm_mon - 1) / 12;
- tm->tm_mon = (tm->tm_mon - 1) % 12 + 1;
+ tm->tm_year += (tm->tm_mon - 1) / MONTHS_PER_YEAR;
+ tm->tm_mon = (tm->tm_mon - 1) % MONTHS_PER_YEAR + 1;
}
else if (tm->tm_mon < 1)
{
- tm->tm_year += tm->tm_mon / 12 - 1;
- tm->tm_mon = tm->tm_mon % 12 + 12;
+ tm->tm_year += tm->tm_mon / MONTHS_PER_YEAR - 1;
+ tm->tm_mon = tm->tm_mon % MONTHS_PER_YEAR + MONTHS_PER_YEAR;
}
projects / postgresql / commitdiff