Remove now-dead code for !HAVE_INT64_TIMESTAMP.

This is a basically mechanical removal of #ifdef HAVE_INT64_TIMESTAMP
tests and the negative-case controlled code.

Discussion: https://postgr.es/m/26788.1487455319@sss.pgh.pa.us

contrib/btree_gist/btree_time.c

@@ -179,11 +179,7 @@ gbt_timetz_compress(PG_FUNCTION_ARGS)
 		retval = palloc(sizeof(GISTENTRY));
 
 		/* We are using the time + zone only to compress */
-#ifdef HAVE_INT64_TIMESTAMP
 		tmp = tz->time + (tz->zone * INT64CONST(1000000));
-#else
-		tmp = (tz->time + tz->zone);
-#endif
 		r->lower = r->upper = tmp;
 		gistentryinit(*retval, PointerGetDatum(r),
 					  entry->rel, entry->page,
@@ -259,11 +255,7 @@ gbt_timetz_consistent(PG_FUNCTION_ARGS)
 	/* All cases served by this function are inexact */
 	*recheck = true;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	qqq = query->time + (query->zone * INT64CONST(1000000));
-#else
-	qqq = (query->time + query->zone);
-#endif
 
 	key.lower = (GBT_NUMKEY *) &kkk->lower;
 	key.upper = (GBT_NUMKEY *) &kkk->upper;

contrib/btree_gist/btree_ts.c

@@ -153,11 +153,7 @@ ts_dist(PG_FUNCTION_ARGS)
 
 		p->day = INT_MAX;
 		p->month = INT_MAX;
-#ifdef HAVE_INT64_TIMESTAMP
 		p->time = PG_INT64_MAX;
-#else
-		p->time = DBL_MAX;
-#endif
 		PG_RETURN_INTERVAL_P(p);
 	}
 	else
@@ -181,11 +177,7 @@ tstz_dist(PG_FUNCTION_ARGS)
 
 		p->day = INT_MAX;
 		p->month = INT_MAX;
-#ifdef HAVE_INT64_TIMESTAMP
 		p->time = PG_INT64_MAX;
-#else
-		p->time = DBL_MAX;
-#endif
 		PG_RETURN_INTERVAL_P(p);
 	}
 

contrib/btree_gist/btree_utils_num.h

@@ -82,17 +82,10 @@ typedef struct
  * (as a double).  Here because we need it for time/timetz as well as
  * interval.  See interval_cmp_internal for comparison.
  */
-#ifdef HAVE_INT64_TIMESTAMP
 #define INTERVAL_TO_SEC(ivp) \
 	(((double) (ivp)->time) / ((double) USECS_PER_SEC) + \
 	 (ivp)->day * (24.0 * SECS_PER_HOUR) + \
 	 (ivp)->month * (30.0 * SECS_PER_DAY))
-#else
-#define INTERVAL_TO_SEC(ivp) \
-	((ivp)->time + \
-	 (ivp)->day * (24.0 * SECS_PER_HOUR) + \
-	 (ivp)->month * (30.0 * SECS_PER_DAY))
-#endif
 
 #define GET_FLOAT_DISTANCE(t, arg1, arg2)	Abs( ((float8) *((const t *) (arg1))) - ((float8) *((const t *) (arg2))) )
 

src/backend/commands/variable.c

@@ -308,11 +308,7 @@ check_timezone(char **newval, void **extra, GucSource source)
 		}
 
 		/* Here we change from SQL to Unix sign convention */
-#ifdef HAVE_INT64_TIMESTAMP
 		gmtoffset = -(interval->time / USECS_PER_SEC);
-#else
-		gmtoffset = -interval->time;
-#endif
 		new_tz = pg_tzset_offset(gmtoffset);
 
 		pfree(interval);

src/backend/utils/adt/datetime.c

@@ -43,11 +43,6 @@ static int DecodeTime(char *str, int fmask, int range,
 static const datetkn *datebsearch(const char *key, const datetkn *base, int nel);
 static int DecodeDate(char *str, int fmask, int *tmask, bool *is2digits,
 		   struct pg_tm * tm);
-
-#ifndef HAVE_INT64_TIMESTAMP
-static char *TrimTrailingZeros(char *str);
-#endif   /* HAVE_INT64_TIMESTAMP */
-
 static char *AppendSeconds(char *cp, int sec, fsec_t fsec,
 			  int precision, bool fillzeros);
 static void AdjustFractSeconds(double frac, struct pg_tm * tm, fsec_t *fsec,
@@ -401,28 +396,6 @@ GetCurrentTimeUsec(struct pg_tm * tm, fsec_t *fsec, int *tzp)
 }
 
 
-/* TrimTrailingZeros()
- * ... resulting from printing numbers with full precision.
- *
- * Returns a pointer to the new end of string.  No NUL terminator is put
- * there; callers are responsible for NUL terminating str themselves.
- *
- * Before Postgres 8.4, this always left at least 2 fractional digits,
- * but conversations on the lists suggest this isn't desired
- * since showing '0.10' is misleading with values of precision(1).
- */
-#ifndef HAVE_INT64_TIMESTAMP
-static char *
-TrimTrailingZeros(char *str)
-{
-	int			len = strlen(str);
-
-	while (len > 1 && *(str + len - 1) == '0' && *(str + len - 2) != '.')
-		len--;
-	return str + len;
-}
-#endif   /* HAVE_INT64_TIMESTAMP */
-
 /*
  * Append seconds and fractional seconds (if any) at *cp.
  *
@@ -439,14 +412,12 @@ AppendSeconds(char *cp, int sec, fsec_t fsec, int precision, bool fillzeros)
 {
 	Assert(precision >= 0);
 
-#ifdef HAVE_INT64_TIMESTAMP
-	/* fsec_t is just an int32 */
-
 	if (fillzeros)
 		cp = pg_ltostr_zeropad(cp, Abs(sec), 2);
 	else
 		cp = pg_ltostr(cp, Abs(sec));
 
+	/* fsec_t is just an int32 */
 	if (fsec != 0)
 	{
 		int32		value = Abs(fsec);
@@ -490,25 +461,6 @@ AppendSeconds(char *cp, int sec, fsec_t fsec, int precision, bool fillzeros)
 	}
 	else
 		return cp;
-#else
-	/* fsec_t is a double */
-
-	if (fsec == 0)
-	{
-		if (fillzeros)
-			return pg_ltostr_zeropad(cp, Abs(sec), 2);
-		else
-			return pg_ltostr(cp, Abs(sec));
-	}
-	else
-	{
-		if (fillzeros)
-			sprintf(cp, "%0*.*f", precision + 3, precision, fabs(sec + fsec));
-		else
-			sprintf(cp, "%.*f", precision, fabs(sec + fsec));
-		return TrimTrailingZeros(cp);
-	}
-#endif   /* HAVE_INT64_TIMESTAMP */
 }
 
 
@@ -521,14 +473,6 @@ AppendSeconds(char *cp, int sec, fsec_t fsec, int precision, bool fillzeros)
 static char *
 AppendTimestampSeconds(char *cp, struct pg_tm * tm, fsec_t fsec)
 {
-	/*
-	 * In float mode, don't print fractional seconds before 1 AD, since it's
-	 * unlikely there's any precision left ...
-	 */
-#ifndef HAVE_INT64_TIMESTAMP
-	if (tm->tm_year <= 0)
-		fsec = 0;
-#endif
 	return AppendSeconds(cp, tm->tm_sec, fsec, MAX_TIMESTAMP_PRECISION, true);
 }
 
@@ -547,11 +491,7 @@ AdjustFractSeconds(double frac, struct pg_tm * tm, fsec_t *fsec, int scale)
 	sec = (int) frac;
 	tm->tm_sec += sec;
 	frac -= sec;
-#ifdef HAVE_INT64_TIMESTAMP
 	*fsec += rint(frac * 1000000);
-#else
-	*fsec += frac;
-#endif
 }
 
 /* As above, but initial scale produces days */
@@ -582,11 +522,7 @@ ParseFractionalSecond(char *cp, fsec_t *fsec)
 	/* check for parse failure */
 	if (*cp != '\0' || errno != 0)
 		return DTERR_BAD_FORMAT;
-#ifdef HAVE_INT64_TIMESTAMP
 	*fsec = rint(frac * 1000000);
-#else
-	*fsec = frac;
-#endif
 	return 0;
 }
 
@@ -1162,12 +1098,7 @@ DecodeDateTime(char **field, int *ftype, int nf,
 								time = strtod(cp, &cp);
 								if (*cp != '\0' || errno != 0)
 									return DTERR_BAD_FORMAT;
-
-#ifdef HAVE_INT64_TIMESTAMP
 								time *= USECS_PER_DAY;
-#else
-								time *= SECS_PER_DAY;
-#endif
 								dt2time(time,
 										&tm->tm_hour, &tm->tm_min,
 										&tm->tm_sec, fsec);
@@ -2070,12 +2001,7 @@ DecodeTimeOnly(char **field, int *ftype, int nf,
 								time = strtod(cp, &cp);
 								if (*cp != '\0' || errno != 0)
 									return DTERR_BAD_FORMAT;
-
-#ifdef HAVE_INT64_TIMESTAMP
 								time *= USECS_PER_DAY;
-#else
-								time *= SECS_PER_DAY;
-#endif
 								dt2time(time,
 										&tm->tm_hour, &tm->tm_min,
 										&tm->tm_sec, fsec);
@@ -2338,12 +2264,7 @@ DecodeTimeOnly(char **field, int *ftype, int nf,
 	/* test for > 24:00:00 */
 		(tm->tm_hour == HOURS_PER_DAY &&
 		 (tm->tm_min > 0 || tm->tm_sec > 0 || *fsec > 0)) ||
-#ifdef HAVE_INT64_TIMESTAMP
-		*fsec < INT64CONST(0) || *fsec > USECS_PER_SEC
-#else
-		*fsec < 0 || *fsec > 1
-#endif
-		)
+		*fsec < INT64CONST(0) || *fsec > USECS_PER_SEC)
 		return DTERR_FIELD_OVERFLOW;
 
 	if ((fmask & DTK_TIME_M) != DTK_TIME_M)
@@ -2695,18 +2616,11 @@ DecodeTime(char *str, int fmask, int range,
 		return DTERR_BAD_FORMAT;
 
 	/* do a sanity check */
-#ifdef HAVE_INT64_TIMESTAMP
 	if (tm->tm_hour < 0 || tm->tm_min < 0 || tm->tm_min > MINS_PER_HOUR - 1 ||
 		tm->tm_sec < 0 || tm->tm_sec > SECS_PER_MINUTE ||
 		*fsec < INT64CONST(0) ||
 		*fsec > USECS_PER_SEC)
 		return DTERR_FIELD_OVERFLOW;
-#else
-	if (tm->tm_hour < 0 || tm->tm_min < 0 || tm->tm_min > MINS_PER_HOUR - 1 ||
-		tm->tm_sec < 0 || tm->tm_sec > SECS_PER_MINUTE ||
-		*fsec < 0 || *fsec > 1)
-		return DTERR_FIELD_OVERFLOW;
-#endif
 
 	return 0;
 }
@@ -2923,11 +2837,7 @@ DecodeNumberField(int len, char *str, int fmask,
 		frac = strtod(cp, NULL);
 		if (errno != 0)
 			return DTERR_BAD_FORMAT;
-#ifdef HAVE_INT64_TIMESTAMP
 		*fsec = rint(frac * 1000000);
-#else
-		*fsec = frac;
-#endif
 		/* Now truncate off the fraction for further processing */
 		*cp = '\0';
 		len = strlen(str);
@@ -3336,11 +3246,7 @@ DecodeInterval(char **field, int *ftype, int nf, int range,
 				switch (type)
 				{
 					case DTK_MICROSEC:
-#ifdef HAVE_INT64_TIMESTAMP
 						*fsec += rint(val + fval);
-#else
-						*fsec += (val + fval) * 1e-6;
-#endif
 						tmask = DTK_M(MICROSECOND);
 						break;
 
@@ -3348,21 +3254,13 @@ DecodeInterval(char **field, int *ftype, int nf, int range,
 						/* avoid overflowing the fsec field */
 						tm->tm_sec += val / 1000;
 						val -= (val / 1000) * 1000;
-#ifdef HAVE_INT64_TIMESTAMP
 						*fsec += rint((val + fval) * 1000);
-#else
-						*fsec += (val + fval) * 1e-3;
-#endif
 						tmask = DTK_M(MILLISECOND);
 						break;
 
 					case DTK_SECOND:
 						tm->tm_sec += val;
-#ifdef HAVE_INT64_TIMESTAMP
 						*fsec += rint(fval * 1000000);
-#else
-						*fsec += fval;
-#endif
 
 						/*
 						 * If any subseconds were specified, consider this
@@ -3484,12 +3382,8 @@ DecodeInterval(char **field, int *ftype, int nf, int range,
 	{
 		int			sec;
 
-#ifdef HAVE_INT64_TIMESTAMP
 		sec = *fsec / USECS_PER_SEC;
 		*fsec -= sec * USECS_PER_SEC;
-#else
-		TMODULO(*fsec, sec, 1.0);
-#endif
 		tm->tm_sec += sec;
 	}
 

src/backend/utils/adt/formatting.c

@@ -2434,23 +2434,13 @@ DCH_to_char(FormatNode *node, bool is_interval, TmToChar *in, char *out, Oid col
 				s += strlen(s);
 				break;
 			case DCH_MS:		/* millisecond */
-#ifdef HAVE_INT64_TIMESTAMP
 				sprintf(s, "%03d", (int) (in->fsec / INT64CONST(1000)));
-#else
-				/* No rint() because we can't overflow and we might print US */
-				sprintf(s, "%03d", (int) (in->fsec * 1000));
-#endif
 				if (S_THth(n->suffix))
 					str_numth(s, s, S_TH_TYPE(n->suffix));
 				s += strlen(s);
 				break;
 			case DCH_US:		/* microsecond */
-#ifdef HAVE_INT64_TIMESTAMP
 				sprintf(s, "%06d", (int) in->fsec);
-#else
-				/* don't use rint() because we can't overflow 1000 */
-				sprintf(s, "%06d", (int) (in->fsec * 1000000));
-#endif
 				if (S_THth(n->suffix))
 					str_numth(s, s, S_TH_TYPE(n->suffix));
 				s += strlen(s);
@@ -3793,17 +3783,10 @@ do_to_timestamp(text *date_txt, text *fmt,
 		}
 	}
 
-#ifdef HAVE_INT64_TIMESTAMP
 	if (tmfc.ms)
 		*fsec += tmfc.ms * 1000;
 	if (tmfc.us)
 		*fsec += tmfc.us;
-#else
-	if (tmfc.ms)
-		*fsec += (double) tmfc.ms / 1000;
-	if (tmfc.us)
-		*fsec += (double) tmfc.us / 1000000;
-#endif
 
 	/* Range-check date fields according to bit mask computed above */
 	if (fmask != 0)
@@ -3826,12 +3809,7 @@ do_to_timestamp(text *date_txt, text *fmt,
 	if (tm->tm_hour < 0 || tm->tm_hour >= HOURS_PER_DAY ||
 		tm->tm_min < 0 || tm->tm_min >= MINS_PER_HOUR ||
 		tm->tm_sec < 0 || tm->tm_sec >= SECS_PER_MINUTE ||
-#ifdef HAVE_INT64_TIMESTAMP
-		*fsec < INT64CONST(0) || *fsec >= USECS_PER_SEC
-#else
-		*fsec < 0 || *fsec >= 1
-#endif
-		)
+		*fsec < INT64CONST(0) || *fsec >= USECS_PER_SEC)
 		DateTimeParseError(DTERR_FIELD_OVERFLOW, date_str, "timestamp");
 
 	DEBUG_TM(tm);

src/backend/utils/adt/misc.c

@@ -535,12 +535,7 @@ pg_sleep(PG_FUNCTION_ARGS)
 	 * less than the specified time when WaitLatch is terminated early by a
 	 * non-query-canceling signal such as SIGHUP.
 	 */
-
-#ifdef HAVE_INT64_TIMESTAMP
 #define GetNowFloat()	((float8) GetCurrentTimestamp() / 1000000.0)
-#else
-#define GetNowFloat()	GetCurrentTimestamp()
-#endif
 
 	endtime = GetNowFloat() + secs;
 

src/backend/utils/adt/nabstime.c

@@ -818,14 +818,10 @@ interval_reltime(PG_FUNCTION_ARGS)
 	month = interval->month % MONTHS_PER_YEAR;
 	day = interval->day;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	span = ((INT64CONST(365250000) * year + INT64CONST(30000000) * month +
 			 INT64CONST(1000000) * day) * INT64CONST(86400)) +
 		interval->time;
 	span /= USECS_PER_SEC;
-#else
-	span = (DAYS_PER_YEAR * year + (double) DAYS_PER_MONTH * month + day) * SECS_PER_DAY + interval->time;
-#endif
 
 	if (span < INT_MIN || span > INT_MAX)
 		time = INVALID_RELTIME;
@@ -859,7 +855,6 @@ reltime_interval(PG_FUNCTION_ARGS)
 			break;
 
 		default:
-#ifdef HAVE_INT64_TIMESTAMP
 			year = reltime / SECS_PER_YEAR;
 			reltime -= year * SECS_PER_YEAR;
 			month = reltime / (DAYS_PER_MONTH * SECS_PER_DAY);
@@ -868,13 +863,6 @@ reltime_interval(PG_FUNCTION_ARGS)
 			reltime -= day * SECS_PER_DAY;
 
 			result->time = (reltime * USECS_PER_SEC);
-#else
-			TMODULO(reltime, year, SECS_PER_YEAR);
-			TMODULO(reltime, month, DAYS_PER_MONTH * SECS_PER_DAY);
-			TMODULO(reltime, day, SECS_PER_DAY);
-
-			result->time = reltime;
-#endif
 			result->month = MONTHS_PER_YEAR * year + month;
 			result->day = day;
 			break;

src/backend/utils/adt/rangetypes.c

@@ -1443,12 +1443,7 @@ tsrange_subdiff(PG_FUNCTION_ARGS)
 	Timestamp	v2 = PG_GETARG_TIMESTAMP(1);
 	float8		result;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result = ((float8) v1 - (float8) v2) / USECS_PER_SEC;
-#else
-	result = v1 - v2;
-#endif
-
 	PG_RETURN_FLOAT8(result);
 }
 
@@ -1459,12 +1454,7 @@ tstzrange_subdiff(PG_FUNCTION_ARGS)
 	Timestamp	v2 = PG_GETARG_TIMESTAMP(1);
 	float8		result;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result = ((float8) v1 - (float8) v2) / USECS_PER_SEC;
-#else
-	result = v1 - v2;
-#endif
-
 	PG_RETURN_FLOAT8(result);
 }
 

src/backend/utils/adt/selfuncs.c

@@ -4212,31 +4212,17 @@ convert_timevalue_to_scalar(Datum value, Oid typid)
 				 * average month length of 365.25/12.0 days.  Not too
 				 * accurate, but plenty good enough for our purposes.
 				 */
-#ifdef HAVE_INT64_TIMESTAMP
 				return interval->time + interval->day * (double) 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 * ((DAYS_PER_YEAR / (double) MONTHS_PER_YEAR) * (double) SECS_PER_DAY);
-#endif
 			}
 		case RELTIMEOID:
-#ifdef HAVE_INT64_TIMESTAMP
 			return (DatumGetRelativeTime(value) * 1000000.0);
-#else
-			return DatumGetRelativeTime(value);
-#endif
 		case TINTERVALOID:
 			{
 				TimeInterval tinterval = DatumGetTimeInterval(value);
 
-#ifdef HAVE_INT64_TIMESTAMP
 				if (tinterval->status != 0)
 					return ((tinterval->data[1] - tinterval->data[0]) * 1000000.0);
-#else
-				if (tinterval->status != 0)
-					return tinterval->data[1] - tinterval->data[0];
-#endif
 				return 0;		/* for lack of a better idea */
 			}
 		case TIMEOID:
@@ -4246,11 +4232,7 @@ convert_timevalue_to_scalar(Datum value, Oid typid)
 				TimeTzADT  *timetz = DatumGetTimeTzADTP(value);
 
 				/* use GMT-equivalent time */
-#ifdef HAVE_INT64_TIMESTAMP
 				return (double) (timetz->time + (timetz->zone * 1000000.0));
-#else
-				return (double) (timetz->time + timetz->zone);
-#endif
 			}
 	}
 

src/backend/utils/misc/guc.c

@@ -1507,11 +1507,7 @@ static struct config_bool ConfigureNamesBool[] =
 			GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
 		},
 		&integer_datetimes,
-#ifdef HAVE_INT64_TIMESTAMP
 		true,
-#else
-		false,
-#endif
 		NULL, NULL, NULL
 	},
 

src/bin/pg_basebackup/streamutil.c

@@ -208,8 +208,8 @@ GetConnection(void)
 		PQconninfoFree(conn_opts);
 
 	/*
-	 * Ensure we have the same value of integer timestamps as the server we
-	 * are connecting to.
+	 * Ensure we have the same value of integer_datetimes (now always "on") as
+	 * the server we are connecting to.
 	 */
 	tmpparam = PQparameterStatus(tmpconn, "integer_datetimes");
 	if (!tmpparam)
@@ -221,11 +221,7 @@ GetConnection(void)
 		exit(1);
 	}
 
-#ifdef HAVE_INT64_TIMESTAMP
 	if (strcmp(tmpparam, "on") != 0)
-#else
-	if (strcmp(tmpparam, "off") != 0)
-#endif
 	{
 		fprintf(stderr,
 			 _("%s: integer_datetimes compile flag does not match server\n"),

src/bin/pg_waldump/compat.c

@@ -29,13 +29,8 @@ timestamptz_to_time_t(TimestampTz t)
 {
 	pg_time_t	result;
 
-#ifdef HAVE_INT64_TIMESTAMP
 	result = (pg_time_t) (t / USECS_PER_SEC +
 				 ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY));
-#else
-	result = (pg_time_t) (t +
-				 ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY));
-#endif
 	return result;
 }
 
@@ -63,11 +58,7 @@ timestamptz_to_str(TimestampTz dt)
 	strftime(ts, sizeof(ts), "%Y-%m-%d %H:%M:%S", ltime);
 	strftime(zone, sizeof(zone), "%Z", ltime);
 
-#ifdef HAVE_INT64_TIMESTAMP
 	sprintf(buf, "%s.%06d %s", ts, (int) (dt % USECS_PER_SEC), zone);
-#else
-	sprintf(buf, "%s.%.6f %s", ts, fabs(dt - floor(dt)), zone);
-#endif
 
 	return buf;
 }

src/include/datatype/timestamp.h

@@ -29,29 +29,20 @@
  * 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
  *
- * We have two implementations, one that uses int64 values with units of
- * microseconds, and one that uses double values with units of seconds.
+ * Timestamps, as well as the h/m/s fields of intervals, are stored as
+ * int64 values with units of microseconds.  (Once upon a time they were
+ * double values with units of seconds.)
  *
- * TimeOffset and fsec_t are convenience typedefs for temporary variables
- * that are of different types in the two cases.  Do not use fsec_t in values
- * stored on-disk, since it is not the same size in both implementations.
+ * TimeOffset and fsec_t are convenience typedefs for temporary variables.
+ * Do not use fsec_t in values stored on-disk.
  * Also, fsec_t is only meant for *fractional* seconds; beware of overflow
  * if the value you need to store could be many seconds.
  */
 
-#ifdef HAVE_INT64_TIMESTAMP
-
 typedef int64 Timestamp;
 typedef int64 TimestampTz;
 typedef int64 TimeOffset;
 typedef int32 fsec_t;			/* fractional seconds (in microseconds) */
-#else
-
-typedef double Timestamp;
-typedef double TimestampTz;
-typedef double TimeOffset;
-typedef double fsec_t;			/* fractional seconds (in seconds) */
-#endif
 
 typedef struct
 {
@@ -62,6 +53,7 @@ typedef struct
 } Interval;
 
 
+/* Limits on the "precision" option (typmod) for these data types */
 #define MAX_TIMESTAMP_PRECISION 6
 #define MAX_INTERVAL_PRECISION 6
 
@@ -118,18 +110,8 @@ typedef struct
 /*
  * DT_NOBEGIN represents timestamp -infinity; DT_NOEND represents +infinity
  */
-#ifdef HAVE_INT64_TIMESTAMP
 #define DT_NOBEGIN		PG_INT64_MIN
 #define DT_NOEND		PG_INT64_MAX
-#else							/* !HAVE_INT64_TIMESTAMP */
-#ifdef HUGE_VAL
-#define DT_NOBEGIN		(-HUGE_VAL)
-#define DT_NOEND		(HUGE_VAL)
-#else
-#define DT_NOBEGIN		(-DBL_MAX)
-#define DT_NOEND		(DBL_MAX)
-#endif
-#endif   /* HAVE_INT64_TIMESTAMP */
 
 #define TIMESTAMP_NOBEGIN(j)	\
 	do {(j) = DT_NOBEGIN;} while (0)
@@ -191,35 +173,22 @@ typedef struct
  * so that is the lower bound for both dates and timestamps.
  *
  * The upper limit for dates is 5874897-12-31, which is a bit less than what
- * the Julian-date code can allow.  We use that same limit for timestamps when
- * using floating-point timestamps (so that the timezone offset problem would
- * exist here too if there were no slop).  For integer timestamps, the upper
- * limit is 294276-12-31.  The int64 overflow limit would be a few days later;
- * again, leaving some slop avoids worries about corner-case overflow, and
- * provides a simpler user-visible definition.
+ * the Julian-date code can allow.  For timestamps, the upper limit is
+ * 294276-12-31.  The int64 overflow limit would be a few days later; again,
+ * leaving some slop avoids worries about corner-case overflow, and provides
+ * a simpler user-visible definition.
  */
 
 /* First allowed date, and first disallowed date, in Julian-date form */
 #define DATETIME_MIN_JULIAN (0)
 #define DATE_END_JULIAN (2147483494)	/* == date2j(JULIAN_MAXYEAR, 1, 1) */
-#ifdef HAVE_INT64_TIMESTAMP
 #define TIMESTAMP_END_JULIAN (109203528)		/* == date2j(294277, 1, 1) */
-#else
-#define TIMESTAMP_END_JULIAN DATE_END_JULIAN
-#endif
 
 /* Timestamp limits */
-#ifdef HAVE_INT64_TIMESTAMP
 #define MIN_TIMESTAMP	INT64CONST(-211813488000000000)
 /* == (DATETIME_MIN_JULIAN - POSTGRES_EPOCH_JDATE) * USECS_PER_DAY */
 #define END_TIMESTAMP	INT64CONST(9223371331200000000)
 /* == (TIMESTAMP_END_JULIAN - POSTGRES_EPOCH_JDATE) * USECS_PER_DAY */
-#else
-#define MIN_TIMESTAMP	(-211813488000.0)
-/* == (DATETIME_MIN_JULIAN - POSTGRES_EPOCH_JDATE) * SECS_PER_DAY */
-#define END_TIMESTAMP	185330760393600.0
-/* == (TIMESTAMP_END_JULIAN - POSTGRES_EPOCH_JDATE) * SECS_PER_DAY */
-#endif
 
 /* Range-check a date (given in Postgres, not Julian, numbering) */
 #define IS_VALID_DATE(d) \

src/include/utils/date.h

@@ -21,11 +21,7 @@
 
 typedef int32 DateADT;
 
-#ifdef HAVE_INT64_TIMESTAMP
 typedef int64 TimeADT;
-#else
-typedef float8 TimeADT;
-#endif
 
 typedef struct
 {
@@ -48,11 +44,9 @@ typedef struct
 /*
  * Macros for fmgr-callable functions.
  *
- * For TimeADT, we make use of the same support routines as for float8 or int64.
- * Therefore TimeADT is pass-by-reference if and only if float8 or int64 is!
+ * For TimeADT, we make use of the same support routines as for int64.
+ * Therefore TimeADT is pass-by-reference if and only if int64 is!
  */
-#ifdef HAVE_INT64_TIMESTAMP
-
 #define MAX_TIME_PRECISION 6
 
 #define DatumGetDateADT(X)	  ((DateADT) DatumGetInt32(X))
@@ -62,22 +56,6 @@ typedef struct
 #define DateADTGetDatum(X)	  Int32GetDatum(X)
 #define TimeADTGetDatum(X)	  Int64GetDatum(X)
 #define TimeTzADTPGetDatum(X) PointerGetDatum(X)
-#else							/* !HAVE_INT64_TIMESTAMP */
-
-#define MAX_TIME_PRECISION 10
-
-/* round off to MAX_TIME_PRECISION decimal places */
-#define TIME_PREC_INV 10000000000.0
-#define TIMEROUND(j) (rint(((double) (j)) * TIME_PREC_INV) / TIME_PREC_INV)
-
-#define DatumGetDateADT(X)	  ((DateADT) DatumGetInt32(X))
-#define DatumGetTimeADT(X)	  ((TimeADT) DatumGetFloat8(X))
-#define DatumGetTimeTzADTP(X) ((TimeTzADT *) DatumGetPointer(X))
-
-#define DateADTGetDatum(X)	  Int32GetDatum(X)
-#define TimeADTGetDatum(X)	  Float8GetDatum(X)
-#define TimeTzADTPGetDatum(X) PointerGetDatum(X)
-#endif   /* HAVE_INT64_TIMESTAMP */
 
 #define PG_GETARG_DATEADT(n)	 DatumGetDateADT(PG_GETARG_DATUM(n))
 #define PG_GETARG_TIMEADT(n)	 DatumGetTimeADT(PG_GETARG_DATUM(n))

src/include/utils/datetime.h

@@ -244,23 +244,15 @@ do { \
 } while(0)
 
 /* TMODULO()
- * Like FMODULO(), but work on the timestamp datatype (either int64 or float8).
+ * Like FMODULO(), but work on the timestamp datatype (now always int64).
  * We assume that int64 follows the C99 semantics for division (negative
  * quotients truncate towards zero).
  */
-#ifdef HAVE_INT64_TIMESTAMP
 #define TMODULO(t,q,u) \
 do { \
 	(q) = ((t) / (u)); \
 	if ((q) != 0) (t) -= ((q) * (u)); \
 } while(0)
-#else
-#define TMODULO(t,q,u) \
-do { \
-	(q) = (((t) < 0) ? ceil((t) / (u)) : floor((t) / (u))); \
-	if ((q) != 0) (t) -= rint((q) * (u)); \
-} while(0)
-#endif
 
 /*
  * Date/time validation

src/include/utils/timestamp.h

@@ -21,12 +21,9 @@
 /*
  * Macros for fmgr-callable functions.
  *
- * For Timestamp, we make use of the same support routines as for int64
- * or float8.  Therefore Timestamp is pass-by-reference if and only if
- * int64 or float8 is!
+ * For Timestamp, we make use of the same support routines as for int64.
+ * Therefore Timestamp is pass-by-reference if and only if int64 is!
  */
-#ifdef HAVE_INT64_TIMESTAMP
-
 #define DatumGetTimestamp(X)  ((Timestamp) DatumGetInt64(X))
 #define DatumGetTimestampTz(X)	((TimestampTz) DatumGetInt64(X))
 #define DatumGetIntervalP(X)  ((Interval *) DatumGetPointer(X))
@@ -42,24 +39,6 @@
 #define PG_RETURN_TIMESTAMP(x) return TimestampGetDatum(x)
 #define PG_RETURN_TIMESTAMPTZ(x) return TimestampTzGetDatum(x)
 #define PG_RETURN_INTERVAL_P(x) return IntervalPGetDatum(x)
-#else							/* !HAVE_INT64_TIMESTAMP */
-
-#define DatumGetTimestamp(X)  ((Timestamp) DatumGetFloat8(X))
-#define DatumGetTimestampTz(X)	((TimestampTz) DatumGetFloat8(X))
-#define DatumGetIntervalP(X)  ((Interval *) DatumGetPointer(X))
-
-#define TimestampGetDatum(X) Float8GetDatum(X)
-#define TimestampTzGetDatum(X) Float8GetDatum(X)
-#define IntervalPGetDatum(X) PointerGetDatum(X)
-
-#define PG_GETARG_TIMESTAMP(n) DatumGetTimestamp(PG_GETARG_DATUM(n))
-#define PG_GETARG_TIMESTAMPTZ(n) DatumGetTimestampTz(PG_GETARG_DATUM(n))
-#define PG_GETARG_INTERVAL_P(n) DatumGetIntervalP(PG_GETARG_DATUM(n))
-
-#define PG_RETURN_TIMESTAMP(x) return TimestampGetDatum(x)
-#define PG_RETURN_TIMESTAMPTZ(x) return TimestampTzGetDatum(x)
-#define PG_RETURN_INTERVAL_P(x) return IntervalPGetDatum(x)
-#endif   /* HAVE_INT64_TIMESTAMP */
 
 
 #define TIMESTAMP_MASK(b) (1 << (b))
@@ -74,11 +53,7 @@
 #define INTERVAL_PRECISION(t) ((t) & INTERVAL_PRECISION_MASK)
 #define INTERVAL_RANGE(t) (((t) >> 16) & INTERVAL_RANGE_MASK)
 
-#ifdef HAVE_INT64_TIMESTAMP
 #define TimestampTzPlusMilliseconds(tz,ms) ((tz) + ((ms) * (int64) 1000))
-#else
-#define TimestampTzPlusMilliseconds(tz,ms) ((tz) + ((ms) / 1000.0))
-#endif
 
 
 /* Set at postmaster start */
@@ -105,13 +80,8 @@ extern bool TimestampDifferenceExceeds(TimestampTz start_time,
  * Prototypes for functions to deal with integer timestamps, when the native
  * format is float timestamps.
  */
-#ifndef HAVE_INT64_TIMESTAMP
-extern int64 GetCurrentIntegerTimestamp(void);
-extern TimestampTz IntegerTimestampToTimestampTz(int64 timestamp);
-#else
 #define GetCurrentIntegerTimestamp()	GetCurrentTimestamp()
 #define IntegerTimestampToTimestampTz(timestamp) (timestamp)
-#endif
 
 extern TimestampTz time_t_to_timestamptz(pg_time_t tm);
 extern pg_time_t timestamptz_to_time_t(TimestampTz t);

src/interfaces/ecpg/include/pgtypes_interval.h

@@ -25,11 +25,7 @@ typedef long long int int64;
 
 typedef struct
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	int64		time;			/* all time units other than months and years */
-#else
-	double		time;			/* all time units other than months and years */
-#endif
 	long		month;			/* months and years, after time for alignment */
 }	interval;
 

src/interfaces/ecpg/include/pgtypes_timestamp.h

@@ -6,13 +6,8 @@
 /* pgtypes_interval.h includes ecpg_config.h */
 #include <pgtypes_interval.h>
 
-#ifdef HAVE_INT64_TIMESTAMP
 typedef int64 timestamp;
 typedef int64 TimestampTz;
-#else
-typedef double timestamp;
-typedef double TimestampTz;
-#endif
 
 #ifdef __cplusplus
 extern		"C"

src/interfaces/ecpg/pgtypeslib/datetime.c

@@ -37,13 +37,8 @@ PGTYPESdate_from_timestamp(timestamp dt)
 
 	if (!TIMESTAMP_NOT_FINITE(dt))
 	{
-#ifdef HAVE_INT64_TIMESTAMP
 		/* Microseconds to days */
 		dDate = (dt / USECS_PER_DAY);
-#else
-		/* Seconds to days */
-		dDate = (dt / (double) SECS_PER_DAY);
-#endif
 	}
 
 	return dDate;

src/interfaces/ecpg/pgtypeslib/dt.h

@@ -7,18 +7,7 @@
 
 #define MAXTZLEN			 10
 
-#ifdef HAVE_INT64_TIMESTAMP
-
 typedef int32 fsec_t;
-#else
-
-typedef double fsec_t;
-
-/* round off to MAX_TIMESTAMP_PRECISION decimal places */
-/* note: this is also used for rounding off intervals */
-#define TS_PREC_INV 1000000.0
-#define TSROUND(j) (rint(((double) (j)) * TS_PREC_INV) / TS_PREC_INV)
-#endif
 
 #define USE_POSTGRES_DATES				0
 #define USE_ISO_DATES					1
@@ -232,23 +221,15 @@ do { \
 } while(0)
 
 /* TMODULO()
- * Like FMODULO(), but work on the timestamp datatype (either int64 or float8).
+ * Like FMODULO(), but work on the timestamp datatype (now always int64).
  * We assume that int64 follows the C99 semantics for division (negative
  * quotients truncate towards zero).
  */
-#ifdef HAVE_INT64_TIMESTAMP
 #define TMODULO(t,q,u) \
 do { \
 	(q) = ((t) / (u)); \
 	if ((q) != 0) (t) -= ((q) * (u)); \
 } while(0)
-#else
-#define TMODULO(t,q,u) \
-do { \
-	(q) = (((t) < 0) ? ceil((t) / (u)): floor((t) / (u))); \
-	if ((q) != 0) (t) -= rint((q) * (u)); \
-} while(0)
-#endif
 
 /* in both timestamp.h and ecpg/dt.h */
 #define DAYS_PER_YEAR	365.25	/* assumes leap year every four years */
@@ -274,12 +255,10 @@ do { \
 #define SECS_PER_MINUTE 60
 #define MINS_PER_HOUR	60
 
-#ifdef HAVE_INT64_TIMESTAMP
 #define USECS_PER_DAY	INT64CONST(86400000000)
 #define USECS_PER_HOUR	INT64CONST(3600000000)
 #define USECS_PER_MINUTE INT64CONST(60000000)
 #define USECS_PER_SEC	INT64CONST(1000000)
-#endif
 
 /*
  * Date/time validation
@@ -304,13 +283,8 @@ do { \
 	 ((y) < JULIAN_MAXYEAR || \
 	  ((y) == JULIAN_MAXYEAR && ((m) < JULIAN_MAXMONTH))))
 
-#ifdef HAVE_INT64_TIMESTAMP
 #define MIN_TIMESTAMP	INT64CONST(-211813488000000000)
 #define END_TIMESTAMP	INT64CONST(9223371331200000000)
-#else
-#define MIN_TIMESTAMP	(-211813488000.0)
-#define END_TIMESTAMP	185330760393600.0
-#endif
 
 #define IS_VALID_TIMESTAMP(t)  (MIN_TIMESTAMP <= (t) && (t) < END_TIMESTAMP)
 
@@ -328,20 +302,8 @@ do { \
  || (((y) == UTIME_MAXYEAR) && (((m) < UTIME_MAXMONTH) \
   || (((m) == UTIME_MAXMONTH) && ((d) <= UTIME_MAXDAY))))))
 
-#ifdef HAVE_INT64_TIMESTAMP
-
 #define DT_NOBEGIN		(-INT64CONST(0x7fffffffffffffff) - 1)
 #define DT_NOEND		(INT64CONST(0x7fffffffffffffff))
-#else
-
-#ifdef HUGE_VAL
-#define DT_NOBEGIN		(-HUGE_VAL)
-#define DT_NOEND		(HUGE_VAL)
-#else
-#define DT_NOBEGIN		(-DBL_MAX)
-#define DT_NOEND		(DBL_MAX)
-#endif
-#endif   /* HAVE_INT64_TIMESTAMP */
 
 #define TIMESTAMP_NOBEGIN(j)	do {(j) = DT_NOBEGIN;} while (0)
 #define TIMESTAMP_NOEND(j)			do {(j) = DT_NOEND;} while (0)

src/interfaces/ecpg/pgtypeslib/dt_common.c

@@ -783,19 +783,10 @@ EncodeDateTime(struct tm * tm, fsec_t fsec, bool print_tz, int tz, const char *t
 			/*
 			 * Print fractional seconds if any.  The field widths here should
 			 * be at least equal to MAX_TIMESTAMP_PRECISION.
-			 *
-			 * In float mode, don't print fractional seconds before 1 AD,
-			 * since it's unlikely there's any precision left ...
 			 */
-#ifdef HAVE_INT64_TIMESTAMP
 			if (fsec != 0)
 			{
 				sprintf(str + strlen(str), ":%02d.%06d", tm->tm_sec, fsec);
-#else
-			if ((fsec != 0) && (tm->tm_year > 0))
-			{
-				sprintf(str + strlen(str), ":%09.6f", tm->tm_sec + fsec);
-#endif
 				TrimTrailingZeros(str);
 			}
 			else
@@ -830,19 +821,10 @@ EncodeDateTime(struct tm * tm, fsec_t fsec, bool print_tz, int tz, const char *t
 			/*
 			 * Print fractional seconds if any.  The field widths here should
 			 * be at least equal to MAX_TIMESTAMP_PRECISION.
-			 *
-			 * In float mode, don't print fractional seconds before 1 AD,
-			 * since it's unlikely there's any precision left ...
 			 */
-#ifdef HAVE_INT64_TIMESTAMP
 			if (fsec != 0)
 			{
 				sprintf(str + strlen(str), ":%02d.%06d", tm->tm_sec, fsec);
-#else
-			if (fsec != 0 && tm->tm_year > 0)
-			{
-				sprintf(str + strlen(str), ":%09.6f", tm->tm_sec + fsec);
-#endif
 				TrimTrailingZeros(str);
 			}
 			else
@@ -885,19 +867,10 @@ EncodeDateTime(struct tm * tm, fsec_t fsec, bool print_tz, int tz, const char *t
 			/*
 			 * Print fractional seconds if any.  The field widths here should
 			 * be at least equal to MAX_TIMESTAMP_PRECISION.
-			 *
-			 * In float mode, don't print fractional seconds before 1 AD,
-			 * since it's unlikely there's any precision left ...
 			 */
-#ifdef HAVE_INT64_TIMESTAMP
 			if (fsec != 0)
 			{
 				sprintf(str + strlen(str), ":%02d.%06d", tm->tm_sec, fsec);
-#else
-			if (fsec != 0 && tm->tm_year > 0)
-			{
-				sprintf(str + strlen(str), ":%09.6f", tm->tm_sec + fsec);
-#endif
 				TrimTrailingZeros(str);
 			}
 			else
@@ -942,19 +915,10 @@ EncodeDateTime(struct tm * tm, fsec_t fsec, bool print_tz, int tz, const char *t
 			/*
 			 * Print fractional seconds if any.  The field widths here should
 			 * be at least equal to MAX_TIMESTAMP_PRECISION.
-			 *
-			 * In float mode, don't print fractional seconds before 1 AD,
-			 * since it's unlikely there's any precision left ...
 			 */
-#ifdef HAVE_INT64_TIMESTAMP
 			if (fsec != 0)
 			{
 				sprintf(str + strlen(str), ":%02d.%06d", tm->tm_sec, fsec);
-#else
-			if (fsec != 0 && tm->tm_year > 0)
-			{
-				sprintf(str + strlen(str), ":%09.6f", tm->tm_sec + fsec);
-#endif
 				TrimTrailingZeros(str);
 			}
 			else
@@ -1110,28 +1074,15 @@ GetCurrentDateTime(struct tm * tm)
 void
 dt2time(double jd, int *hour, int *min, int *sec, fsec_t *fsec)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	int64		time;
-#else
-	double		time;
-#endif
 
 	time = jd;
-#ifdef HAVE_INT64_TIMESTAMP
 	*hour = time / USECS_PER_HOUR;
 	time -= (*hour) * USECS_PER_HOUR;
 	*min = time / USECS_PER_MINUTE;
 	time -= (*min) * USECS_PER_MINUTE;
 	*sec = time / USECS_PER_SEC;
 	*fsec = time - (*sec * USECS_PER_SEC);
-#else
-	*hour = time / SECS_PER_HOUR;
-	time -= (*hour) * SECS_PER_HOUR;
-	*min = time / SECS_PER_MINUTE;
-	time -= (*min) * SECS_PER_MINUTE;
-	*sec = time;
-	*fsec = time - *sec;
-#endif
 }	/* dt2time() */
 
 
@@ -1153,7 +1104,6 @@ DecodeNumberField(int len, char *str, int fmask,
 	 */
 	if ((cp = strchr(str, '.')) != NULL)
 	{
-#ifdef HAVE_INT64_TIMESTAMP
 		char		fstr[7];
 		int			i;
 
@@ -1164,16 +1114,13 @@ DecodeNumberField(int len, char *str, int fmask,
 		 * string with those digits, zero-padded on the right, and then do the
 		 * conversion to an integer.
 		 *
-		 * XXX This truncates the seventh digit, unlike rounding it as do the
-		 * backend and the !HAVE_INT64_TIMESTAMP case.
+		 * XXX This truncates the seventh digit, unlike rounding it as the
+		 * backend does.
 		 */
 		for (i = 0; i < 6; i++)
 			fstr[i] = *cp != '\0' ? *cp++ : '0';
 		fstr[i] = '\0';
 		*fsec = strtol(fstr, NULL, 10);
-#else
-		*fsec = strtod(cp, NULL);
-#endif
 		*cp = '\0';
 		len = strlen(str);
 	}
@@ -1520,7 +1467,6 @@ DecodeTime(char *str, int *tmask, struct tm * tm, fsec_t *fsec)
 			*fsec = 0;
 		else if (*cp == '.')
 		{
-#ifdef HAVE_INT64_TIMESTAMP
 			char		fstr[7];
 			int			i;
 
@@ -1531,17 +1477,13 @@ DecodeTime(char *str, int *tmask, struct tm * tm, fsec_t *fsec)
 			 * string with those digits, zero-padded on the right, and then do
 			 * the conversion to an integer.
 			 *
-			 * XXX This truncates the seventh digit, unlike rounding it as do
-			 * the backend and the !HAVE_INT64_TIMESTAMP case.
+			 * XXX This truncates the seventh digit, unlike rounding it as the
+			 * backend does.
 			 */
 			for (i = 0; i < 6; i++)
 				fstr[i] = *cp != '\0' ? *cp++ : '0';
 			fstr[i] = '\0';
 			*fsec = strtol(fstr, &cp, 10);
-#else
-			str = cp;
-			*fsec = strtod(str, &cp);
-#endif
 			if (*cp != '\0')
 				return -1;
 		}
@@ -1550,15 +1492,9 @@ DecodeTime(char *str, int *tmask, struct tm * tm, fsec_t *fsec)
 	}
 
 	/* do a sanity check */
-#ifdef HAVE_INT64_TIMESTAMP
 	if (tm->tm_hour < 0 || tm->tm_min < 0 || tm->tm_min > 59 ||
 		tm->tm_sec < 0 || tm->tm_sec > 59 || *fsec >= USECS_PER_SEC)
 		return -1;
-#else
-	if (tm->tm_hour < 0 || tm->tm_min < 0 || tm->tm_min > 59 ||
-		tm->tm_sec < 0 || tm->tm_sec > 59 || *fsec >= 1)
-		return -1;
-#endif
 
 	return 0;
 }	/* DecodeTime() */
@@ -2105,11 +2041,7 @@ DecodeDateTime(char **field, int *ftype, int nf,
 								frac = strtod(cp, &cp);
 								if (*cp != '\0')
 									return -1;
-#ifdef HAVE_INT64_TIMESTAMP
 								*fsec = frac * 1000000;
-#else
-								*fsec = frac;
-#endif
 							}
 							break;
 
@@ -2135,11 +2067,7 @@ DecodeDateTime(char **field, int *ftype, int nf,
 									return -1;
 
 								tmask |= DTK_TIME_M;
-#ifdef HAVE_INT64_TIMESTAMP
 								dt2time((time * USECS_PER_DAY), &tm->tm_hour, &tm->tm_min, &tm->tm_sec, fsec);
-#else
-								dt2time((time * SECS_PER_DAY), &tm->tm_hour, &tm->tm_min, &tm->tm_sec, fsec);
-#endif
 							}
 							break;
 

src/interfaces/ecpg/pgtypeslib/interval.c

@@ -42,11 +42,7 @@ AdjustFractSeconds(double frac, struct /* pg_ */ tm * tm, fsec_t *fsec, int scal
 	sec = (int) frac;
 	tm->tm_sec += sec;
 	frac -= sec;
-#ifdef HAVE_INT64_TIMESTAMP
 	*fsec += rint(frac * 1000000);
-#else
-	*fsec += frac;
-#endif
 }
 
 
@@ -488,30 +484,18 @@ DecodeInterval(char **field, int *ftype, int nf,		/* int range, */
 				switch (type)
 				{
 					case DTK_MICROSEC:
-#ifdef HAVE_INT64_TIMESTAMP
 						*fsec += rint(val + fval);
-#else
-						*fsec += (val + fval) * 1e-6;
-#endif
 						tmask = DTK_M(MICROSECOND);
 						break;
 
 					case DTK_MILLISEC:
-#ifdef HAVE_INT64_TIMESTAMP
 						*fsec += rint((val + fval) * 1000);
-#else
-						*fsec += (val + fval) * 1e-3;
-#endif
 						tmask = DTK_M(MILLISECOND);
 						break;
 
 					case DTK_SECOND:
 						tm->tm_sec += val;
-#ifdef HAVE_INT64_TIMESTAMP
 						*fsec += rint(fval * 1000000);
-#else
-						*fsec += fval;
-#endif
 
 						/*
 						 * If any subseconds were specified, consider this
@@ -633,12 +617,8 @@ DecodeInterval(char **field, int *ftype, int nf,		/* int range, */
 	{
 		int			sec;
 
-#ifdef HAVE_INT64_TIMESTAMP
 		sec = *fsec / USECS_PER_SEC;
 		*fsec -= sec * USECS_PER_SEC;
-#else
-		TMODULO(*fsec, sec, 1.0);
-#endif
 		tm->tm_sec += sec;
 	}
 
@@ -777,17 +757,10 @@ AppendSeconds(char *cp, int sec, fsec_t fsec, int precision, bool fillzeros)
 	}
 	else
 	{
-#ifdef HAVE_INT64_TIMESTAMP
 		if (fillzeros)
 			sprintf(cp, "%02d.%0*d", abs(sec), precision, (int) Abs(fsec));
 		else
 			sprintf(cp, "%d.%0*d", abs(sec), precision, (int) Abs(fsec));
-#else
-		if (fillzeros)
-			sprintf(cp, "%0*.*f", precision + 3, precision, fabs(sec + fsec));
-		else
-			sprintf(cp, "%.*f", precision, fabs(sec + fsec));
-#endif
 		TrimTrailingZeros(cp);
 	}
 }
@@ -985,11 +958,7 @@ EncodeInterval(struct /* pg_ */ tm * tm, fsec_t fsec, int style, char *str)
 static int
 interval2tm(interval span, struct tm * tm, fsec_t *fsec)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	int64		time;
-#else
-	double		time;
-#endif
 
 	if (span.month != 0)
 	{
@@ -1005,7 +974,6 @@ interval2tm(interval span, struct tm * tm, fsec_t *fsec)
 
 	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;
@@ -1014,21 +982,6 @@ interval2tm(interval span, struct tm * tm, fsec_t *fsec)
 	time -= tm->tm_min * USECS_PER_MINUTE;
 	tm->tm_sec = time / USECS_PER_SEC;
 	*fsec = time - (tm->tm_sec * USECS_PER_SEC);
-#else
-recalc:
-	TMODULO(time, tm->tm_mday, (double) SECS_PER_DAY);
-	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);
-	time = TSROUND(time);
-	/* roundoff may need to propagate to higher-order fields */
-	if (time >= 1.0)
-	{
-		time = ceil(span.time);
-		goto recalc;
-	}
-	*fsec = time;
-#endif
 
 	return 0;
 }	/* interval2tm() */
@@ -1040,17 +993,10 @@ tm2interval(struct tm * tm, fsec_t fsec, interval * span)
 		(double) tm->tm_year * MONTHS_PER_YEAR + tm->tm_mon < INT_MIN)
 		return -1;
 	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)) +
 				   tm->tm_sec) * USECS_PER_SEC) + fsec;
-#else
-	span->time = (((((tm->tm_mday * (double) HOURS_PER_DAY) +
-					 tm->tm_hour) * (double) MINS_PER_HOUR) +
-				   tm->tm_min) * (double) SECS_PER_MINUTE) +
-		tm->tm_sec + fsec;
-#endif
 
 	return 0;
 }	/* tm2interval() */

src/interfaces/ecpg/pgtypeslib/timestamp.c

@@ -18,28 +18,16 @@
 #include "pgtypes_date.h"
 
 
-#ifdef HAVE_INT64_TIMESTAMP
 static int64
 time2t(const int hour, const int min, const int sec, const fsec_t fsec)
 {
 	return (((((hour * MINS_PER_HOUR) + 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 * MINS_PER_HOUR) + min) * SECS_PER_MINUTE) + sec + fsec;
-}	/* time2t() */
-#endif
 
 static timestamp
 dt2local(timestamp dt, int tz)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	dt -= (tz * USECS_PER_SEC);
-#else
-	dt -= tz;
-#endif
 	return dt;
 }	/* dt2local() */
 
@@ -53,13 +41,8 @@ dt2local(timestamp dt, int tz)
 int
 tm2timestamp(struct tm * tm, fsec_t fsec, int *tzp, timestamp * result)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	int			dDate;
 	int64		time;
-#else
-	double		dDate,
-				time;
-#endif
 
 	/* Prevent overflow in Julian-day routines */
 	if (!IS_VALID_JULIAN(tm->tm_year, tm->tm_mon, tm->tm_mday))
@@ -67,7 +50,6 @@ tm2timestamp(struct tm * tm, fsec_t fsec, int *tzp, timestamp * result)
 
 	dDate = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1);
 	time = time2t(tm->tm_hour, tm->tm_min, tm->tm_sec, fsec);
-#ifdef HAVE_INT64_TIMESTAMP
 	*result = (dDate * USECS_PER_DAY) + time;
 	/* check for major overflow */
 	if ((*result - time) / USECS_PER_DAY != dDate)
@@ -77,9 +59,6 @@ tm2timestamp(struct tm * tm, fsec_t fsec, int *tzp, timestamp * result)
 	if ((*result < 0 && dDate > 0) ||
 		(*result > 0 && dDate < -1))
 		return -1;
-#else
-	*result = dDate * SECS_PER_DAY + time;
-#endif
 	if (tzp != NULL)
 		*result = dt2local(*result, -(*tzp));
 
@@ -93,11 +72,7 @@ tm2timestamp(struct tm * tm, fsec_t fsec, int *tzp, timestamp * result)
 static timestamp
 SetEpochTimestamp(void)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	int64		noresult = 0;
-#else
-	double		noresult = 0.0;
-#endif
 	timestamp	dt;
 	struct tm	tt,
 			   *tm = &tt;
@@ -123,15 +98,9 @@ SetEpochTimestamp(void)
 static int
 timestamp2tm(timestamp dt, int *tzp, struct tm * tm, fsec_t *fsec, const char **tzn)
 {
-#ifdef HAVE_INT64_TIMESTAMP
 	int64		dDate,
 				date0;
 	int64		time;
-#else
-	double		dDate,
-				date0;
-	double		time;
-#endif
 #if defined(HAVE_TM_ZONE) || defined(HAVE_INT_TIMEZONE)
 	time_t		utime;
 	struct tm  *tx;
@@ -139,7 +108,6 @@ timestamp2tm(timestamp dt, int *tzp, struct tm * tm, fsec_t *fsec, const char **
 
 	date0 = date2j(2000, 1, 1);
 
-#ifdef HAVE_INT64_TIMESTAMP
 	time = dt;
 	TMODULO(time, dDate, USECS_PER_DAY);
 
@@ -158,42 +126,6 @@ timestamp2tm(timestamp dt, int *tzp, struct tm * tm, fsec_t *fsec, const char **
 
 	j2date((int) dDate, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
 	dt2time(time, &tm->tm_hour, &tm->tm_min, &tm->tm_sec, fsec);
-#else
-	time = dt;
-	TMODULO(time, dDate, (double) SECS_PER_DAY);
-
-	if (time < 0)
-	{
-		time += SECS_PER_DAY;
-		dDate -= 1;
-	}
-
-	/* add offset to go from J2000 back to standard Julian date */
-	dDate += date0;
-
-recalc_d:
-	/* Julian day routine does not work for negative Julian days */
-	if (dDate < 0 || dDate > (timestamp) INT_MAX)
-		return -1;
-
-	j2date((int) dDate, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
-recalc_t:
-	dt2time(time, &tm->tm_hour, &tm->tm_min, &tm->tm_sec, fsec);
-
-	*fsec = TSROUND(*fsec);
-	/* roundoff may need to propagate to higher-order fields */
-	if (*fsec >= 1.0)
-	{
-		time = ceil(time);
-		if (time >= (double) SECS_PER_DAY)
-		{
-			time = 0;
-			dDate += 1;
-			goto recalc_d;
-		}
-		goto recalc_t;
-	}
-#endif
 
 	if (tzp != NULL)
 	{
@@ -205,12 +137,8 @@ recalc_t:
 		{
 #if defined(HAVE_TM_ZONE) || defined(HAVE_INT_TIMEZONE)
 
-#ifdef HAVE_INT64_TIMESTAMP
 			utime = dt / USECS_PER_SEC +
 				((date0 - date2j(1970, 1, 1)) * INT64CONST(86400));
-#else
-			utime = dt + (date0 - date2j(1970, 1, 1)) * SECS_PER_DAY;
-#endif
 
 			tx = localtime(&utime);
 			tm->tm_year = tx->tm_year + 1900;
@@ -281,12 +209,7 @@ timestamp
 PGTYPEStimestamp_from_asc(char *str, char **endptr)
 {
 	timestamp	result;
-
-#ifdef HAVE_INT64_TIMESTAMP
 	int64		noresult = 0;
-#else
-	double		noresult = 0.0;
-#endif
 	fsec_t		fsec;
 	struct tm	tt,
 			   *tm = &tt;
@@ -633,13 +556,8 @@ dttofmtasc_replace(timestamp * ts, date dDate, int dow, struct tm * tm,
 					break;
 					/* The number of seconds since the Epoch (1970-01-01) */
 				case 's':
-#ifdef HAVE_INT64_TIMESTAMP
 					replace_val.int64_val = (*ts - SetEpochTimestamp()) / 1000000.0;
 					replace_type = PGTYPES_TYPE_INT64;
-#else
-					replace_val.double_val = *ts - SetEpochTimestamp();
-					replace_type = PGTYPES_TYPE_DOUBLE_NF;
-#endif
 					break;
 					/* seconds as a decimal number with leading zeroes */
 				case 'S':