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

Repair inconsistent rounding behavior for timestamp, time, interval,

Browse Source 
per gripe from Csaba Nagy.  There is still potential for platform-specific
behavior for values that are exactly halfway between integers, but at
least we now get the expected answer for all other cases.
WIN32_DEV
Tom Lane 23 years ago
parent 2cd00f0bac
commit fb715e05f5
2 changed files with 56 additions and 105 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. 57
      src/backend/utils/adt/date.c
  2. 104
      src/backend/utils/adt/timestamp.c

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

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.74 2002/11/21 23:31:20 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.75 2003/01/09 01:06:57 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -630,12 +630,12 @@ AdjustTimeForTypmod(TimeADT *time, int32 typmod)
};
static const int64 TimeOffsets[MAX_TIMESTAMP_PRECISION + 1] = {
INT64CONST(-500000),
INT64CONST(-50000),
INT64CONST(-5000),
INT64CONST(-500),
INT64CONST(-50),
INT64CONST(-5),
INT64CONST(500000),
INT64CONST(50000),
INT64CONST(5000),
INT64CONST(500),
INT64CONST(50),
INT64CONST(5),
INT64CONST(0)
};
@ -649,52 +649,33 @@ AdjustTimeForTypmod(TimeADT *time, int32 typmod)
100000,
1000000
};
static const double TimeOffsets[MAX_TIMESTAMP_PRECISION + 1] = {
0.5,
0.05,
0.005,
0.0005,
0.00005,
0.000005,
0.0000005
};
#endif
if ((typmod >= 0) && (typmod <= MAX_TIME_PRECISION))
{
/*
* Note: this round-to-nearest code is not completely consistent
* about rounding values that are exactly halfway between integral
* values. On most platforms, rint() will implement round-to-nearest,
* but the integer code always rounds up (away from zero). Is it
* worth trying to be consistent?
*/
#ifdef HAVE_INT64_TIMESTAMP
/* we have different truncation behavior depending on sign */
if (*time >= INT64CONST(0))
{
*time = ((*time / TimeScales[typmod])
* TimeScales[typmod]);
}
else
{
*time = (((*time + TimeOffsets[typmod]) / TimeScales[typmod])
* TimeScales[typmod]);
}
#else
/* we have different truncation behavior depending on sign */
if (*time >= 0)
{
*time = (rint(((double) *time) * TimeScales[typmod])
/ TimeScales[typmod]);
}
else
{
/*
* Scale and truncate first, then add to help the rounding
* behavior
*/
*time = (rint((((double) *time) * TimeScales[typmod]) + TimeOffsets[typmod])
/ TimeScales[typmod]);
*time = - ((((- *time) + TimeOffsets[typmod]) / TimeScales[typmod])
* TimeScales[typmod]);
}
#else
*time = (rint(((double) *time) * TimeScales[typmod])
/ TimeScales[typmod]);
#endif
}
return;
}

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

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.75 2002/11/12 00:39:08 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.76 2003/01/09 01:06:57 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -175,12 +175,12 @@ AdjustTimestampForTypmod(Timestamp *time, int32 typmod)
};
static const int64 TimestampOffsets[MAX_TIMESTAMP_PRECISION + 1] = {
INT64CONST(-500000),
INT64CONST(-50000),
INT64CONST(-5000),
INT64CONST(-500),
INT64CONST(-50),
INT64CONST(-5),
INT64CONST(500000),
INT64CONST(50000),
INT64CONST(5000),
INT64CONST(500),
INT64CONST(50),
INT64CONST(5),
INT64CONST(0)
};
@ -194,16 +194,6 @@ AdjustTimestampForTypmod(Timestamp *time, int32 typmod)
100000,
1000000
};
static const double TimestampOffsets[MAX_TIMESTAMP_PRECISION + 1] = {
0.5,
0.05,
0.005,
0.0005,
0.00005,
0.000005,
0.0000005
};
#endif
if (!TIMESTAMP_NOT_FINITE(*time)
@ -213,34 +203,27 @@ AdjustTimestampForTypmod(Timestamp *time, int32 typmod)
elog(ERROR, "TIMESTAMP(%d) precision must be between %d and %d",
typmod, 0, MAX_TIMESTAMP_PRECISION);
/*
* Note: this round-to-nearest code is not completely consistent
* about rounding values that are exactly halfway between integral
* values. On most platforms, rint() will implement round-to-nearest,
* but the integer code always rounds up (away from zero). Is it
* worth trying to be consistent?
*/
#ifdef HAVE_INT64_TIMESTAMP
/* we have different truncation behavior depending on sign */
if (*time >= INT64CONST(0))
{
*time = ((*time / TimestampScales[typmod])
* TimestampScales[typmod]);
}
else
{
*time = (((*time + TimestampOffsets[typmod]) / TimestampScales[typmod])
* TimestampScales[typmod]);
}
#else
/* we have different truncation behavior depending on sign */
if (*time >= 0)
{
*time = (rint(((double) *time) * TimestampScales[typmod])
/ TimestampScales[typmod]);
}
else
{
/*
* Scale and truncate first, then add to help the rounding
* behavior
*/
*time = (rint((((double) *time) * TimestampScales[typmod]) + TimestampOffsets[typmod])
/ TimestampScales[typmod]);
*time = - ((((- *time) + TimestampOffsets[typmod]) / TimestampScales[typmod])
* TimestampScales[typmod]);
}
#else
*time = (rint(((double) *time) * TimestampScales[typmod])
/ TimestampScales[typmod]);
#endif
}
}
@ -474,12 +457,12 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
};
static const int64 IntervalOffsets[MAX_INTERVAL_PRECISION + 1] = {
INT64CONST(-500000),
INT64CONST(-50000),
INT64CONST(-5000),
INT64CONST(-500),
INT64CONST(-50),
INT64CONST(-5),
INT64CONST(500000),
INT64CONST(50000),
INT64CONST(5000),
INT64CONST(500),
INT64CONST(50),
INT64CONST(5),
INT64CONST(0)
};
@ -493,16 +476,6 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
100000,
1000000
};
static const double IntervalOffsets[MAX_INTERVAL_PRECISION + 1] = {
0.5,
0.05,
0.005,
0.0005,
0.00005,
0.000005,
0.0000005
};
#endif
/*
@ -701,30 +674,27 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
elog(ERROR, "INTERVAL(%d) precision must be between %d and %d",
precision, 0, MAX_INTERVAL_PRECISION);
/*
* Note: this round-to-nearest code is not completely consistent
* about rounding values that are exactly halfway between integral
* values. On most platforms, rint() will implement round-to-nearest,
* but the integer code always rounds up (away from zero). Is it
* worth trying to be consistent?
*/
#ifdef HAVE_INT64_TIMESTAMP
/* we have different truncation behavior depending on sign */
if (interval->time >= INT64CONST(0))
{
interval->time = ((interval->time / IntervalScales[precision])
* IntervalScales[precision]);
}
else
{
interval->time = (((interval->time + IntervalOffsets[precision]) / IntervalScales[precision])
* IntervalScales[precision]);
}
#else
/* we have different truncation behavior depending on sign */
if (interval->time >= 0)
{
interval->time = (rint(((double) interval->time) * IntervalScales[precision])
/ IntervalScales[precision]);
}
else
{
interval->time = (rint((((double) interval->time) + IntervalOffsets[precision])
* IntervalScales[precision]) / IntervalScales[precision]);
interval->time = - (((-interval->time + IntervalOffsets[precision]) / IntervalScales[precision])
* IntervalScales[precision]);
}
#else
interval->time = (rint(((double) interval->time) * IntervalScales[precision])
/ IntervalScales[precision]);
#endif
}
}

Write Preview
Loading…
Cancel
Save