Use common parser and encoder for timestamp data type.

Remove older date and time code (retain NEW_DATE_CODE and NEW_TIME_CODE).
Use common encoder for date and time.
Fix datetime +/- timespan math bug.

3 files changed, 625 insertions, 33 deletions

diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 9690dd7fe76..2cf7324275b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *    $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.9 1997/06/23 14:47:26 thomas Exp $
+ *    $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.10 1997/07/01 00:22:40 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -114,15 +114,24 @@ char *
 date_out(DateADT date)
 {
     char *result;
+    struct tm tt, *tm = &tt;
     char buf[MAXDATELEN+1];
+
+#if FALSE
     int year, month, day;
+#endif
 
-    j2date( (date + date2j(2000,1,1)), &year, &month, &day);
+    j2date( (date + date2j(2000,1,1)),
+      &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
 
+    EncodeDateOnly( tm, DateStyle, buf);
+
+#if FALSE
     if (EuroDates == 1) /* Output European-format dates */
         sprintf(buf, "%02d-%02d-%04d", day, month, year);
     else
         sprintf(buf, "%02d-%02d-%04d", month, day, year);
+#endif
 
     result = PALLOC(strlen(buf)+1);
 
@@ -445,19 +454,25 @@ char *
 time_out(TimeADT *time)
 {
     char *result;
+    struct tm tt, *tm = &tt;
+#if FALSE
     int hour, min, sec;
+#endif
     double fsec;
-    char buf[32];
+    char buf[MAXDATELEN+1];
 
     if (!PointerIsValid(time))
 	return NULL;
 
-    hour = (*time / (60*60));
-    min = (((int) (*time / 60)) % 60);
-    sec = (((int) *time) % 60);
+    tm->tm_hour = (*time / (60*60));
+    tm->tm_min = (((int) (*time / 60)) % 60);
+    tm->tm_sec = (((int) *time) % 60);
 
     fsec = 0;
 
+    EncodeTimeOnly( tm, fsec, DateStyle, buf);
+
+#if FALSE
     if (sec == 0.0) {
 	sprintf(buf, "%02d:%02d", hour, min);
 
@@ -468,6 +483,7 @@ time_out(TimeADT *time)
 	    sprintf(buf, "%02d:%02d:%05.2f", hour, min, (sec+fsec));
 	};
     };
+#endif
 
     result = PALLOC(strlen(buf)+1);
 
diff --git a/src/backend/utils/adt/dt.c b/src/backend/utils/adt/dt.c
index 68051df2162..809e39c749a 100644
--- a/src/backend/utils/adt/dt.c
+++ b/src/backend/utils/adt/dt.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *    $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/dt.c,v 1.26 1997/06/23 14:50:56 thomas Exp $
+ *    $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/dt.c,v 1.27 1997/07/01 00:22:43 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -722,6 +722,7 @@ printf( "datetime_add_span- date was %04d-%02d-%02d %02d:%02d:%02d\n",
 			tm->tm_mday = mdays[ tm->tm_mon-1];
 		    };
 		};
+
 #ifdef DATEDEBUG
 printf( "datetime_add_span- date becomes %04d-%02d-%02d %02d:%02d:%02d\n",
  tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
@@ -897,6 +898,125 @@ timespan_sub(TimeSpan *span1, TimeSpan *span2)
 } /* timespan_sub() */
 
 
+/* datetime_age()
+ * Calculate time difference while retaining year/month fields.
+ * Note that this does not result in an accurate absolute time span
+ *  since year and month are out of context once the arithmetic
+ *  is done.
+ */
+TimeSpan *
+datetime_age(DateTime *datetime1, DateTime *datetime2)
+{
+    TimeSpan *result;
+
+    DateTime dt1, dt2;
+    double fsec, fsec1, fsec2;
+    struct tm tt, *tm = &tt;
+    struct tm tt1, *tm1 = &tt1;
+    struct tm tt2, *tm2 = &tt2;
+
+    if (!PointerIsValid(datetime1) || !PointerIsValid(datetime2))
+	return NULL;
+
+    result = PALLOCTYPE(TimeSpan);
+
+    dt1 = *datetime1;
+    dt2 = *datetime2;
+
+    if (DATETIME_IS_RELATIVE(dt1)) dt1 = SetDateTime(dt1);
+    if (DATETIME_IS_RELATIVE(dt2)) dt2 = SetDateTime(dt2);
+
+    if (DATETIME_IS_INVALID(dt1)
+     || DATETIME_IS_INVALID(dt2)) {
+	DATETIME_INVALID( result->time);
+
+    } else if ((datetime2tm( dt1, NULL, tm1, &fsec1, NULL) == 0)
+     &&(datetime2tm( dt2, NULL, tm2, &fsec2, NULL) == 0)) {
+	fsec = (fsec1 - fsec2);
+	tm->tm_sec = (tm1->tm_sec - tm2->tm_sec);
+	tm->tm_min = (tm1->tm_min - tm2->tm_min);
+	tm->tm_hour = (tm1->tm_hour - tm2->tm_hour);
+	tm->tm_mday = (tm1->tm_mday - tm2->tm_mday);
+	tm->tm_mon = (tm1->tm_mon - tm2->tm_mon);
+	tm->tm_year = (tm1->tm_year - tm2->tm_year);
+
+	/* flip sign if necessary... */
+	if (dt1 < dt2) {
+	    fsec = -fsec;
+	    tm->tm_sec = -tm->tm_sec;
+	    tm->tm_min = -tm->tm_min;
+	    tm->tm_hour = -tm->tm_hour;
+	    tm->tm_mday = -tm->tm_mday;
+	    tm->tm_mon = -tm->tm_mon;
+	    tm->tm_year = -tm->tm_year;
+	};
+
+	if (tm->tm_sec < 0) {
+	    tm->tm_sec += 60;
+	    tm->tm_min--;
+	};
+
+	if (tm->tm_min < 0) {
+	    tm->tm_min += 60;
+	    tm->tm_hour--;
+	};
+
+	if (tm->tm_hour < 0) {
+	    tm->tm_hour += 24;
+	    tm->tm_mday--;
+	};
+
+	if (tm->tm_mday < 0) {
+	    if (dt1 < dt2) {
+		tm->tm_mday += mdays[tm1->tm_mon-1];
+		if (isleap(tm1->tm_year) && (tm1->tm_mon == 2)) tm->tm_mday++;
+		tm->tm_mon--;
+	    } else {
+		tm->tm_mday += mdays[tm2->tm_mon-1];
+		if (isleap(tm2->tm_year) && (tm2->tm_mon == 2)) tm->tm_mday++;
+		tm->tm_mon--;
+	    };
+	};
+
+	if (tm->tm_mon < 0) {
+	    tm->tm_mon += 12;
+	    tm->tm_year--;
+	};
+
+	/* recover sign if necessary... */
+	if (dt1 < dt2) {
+	    fsec = -fsec;
+	    tm->tm_sec = -tm->tm_sec;
+	    tm->tm_min = -tm->tm_min;
+	    tm->tm_hour = -tm->tm_hour;
+	    tm->tm_mday = -tm->tm_mday;
+	    tm->tm_mon = -tm->tm_mon;
+	    tm->tm_year = -tm->tm_year;
+	};
+
+	if (tm2timespan(tm, fsec, result) != 0) {
+	    elog(WARN,"Unable to decode datetime",NULL);
+	};
+
+#if FALSE
+	result->time = (fsec2 - fsec1);
+	result->time += (tm2->tm_sec - tm1->tm_sec);
+	result->time += 60*(tm2->tm_min - tm1->tm_min);
+	result->time += 3600*(tm2->tm_hour - tm1->tm_hour);
+	result->time += 86400*(tm2->tm_mday - tm1->tm_mday);
+
+	result->month = 12*(tm2->tm_year - tm1->tm_year);
+	result->month += (tm2->tm_mon - tm1->tm_mon);
+#endif
+
+    } else {
+	elog(WARN,"Unable to decode datetime",NULL);
+    };
+
+    return(result);
+} /* datetime_age() */
+
+
 /*----------------------------------------------------------
  *  Conversion operators.
  *---------------------------------------------------------*/
@@ -1016,6 +1136,242 @@ text_timespan(text *str)
 } /* text_timespan() */
 
 
+/* datetime_trunc()
+ * Extract specified field from datetime.
+ */
+DateTime *
+datetime_trunc(text *units, DateTime *datetime)
+{
+    DateTime *result;
+
+    DateTime dt;
+    int tz;
+    int type, val;
+    int i;
+    char *up, *lp, lowunits[MAXDATELEN+1];
+    double fsec;
+    char *tzn;
+    struct tm tt, *tm = &tt;
+
+    if ((!PointerIsValid(units)) || (!PointerIsValid(datetime)))
+	return NULL;
+
+    result = PALLOCTYPE(DateTime);
+
+    up = VARDATA(units);
+    lp = lowunits;
+    for (i = 0; i < (VARSIZE(units)-VARHDRSZ); i++) *lp++ = tolower( *up++);
+    *lp = '\0';
+
+    type = DecodeUnits( 0, lowunits, &val);
+#if FALSE
+    if (type == IGNORE) {
+	type = DecodeSpecial( 0, lowunits, &val);
+    };
+#endif
+
+#ifdef DATEDEBUG
+if (type == IGNORE) strcpy(lowunits, "(unknown)");
+printf( "datetime_trunc- units %s type=%d value=%d\n", lowunits, type, val); 
+#endif
+
+    if (DATETIME_NOT_FINITE(*datetime)) {
+#if FALSE
+/* should return null but Postgres doesn't like that currently. - tgl 97/06/12 */
+	elog(WARN,"Datetime is not finite",NULL);
+#endif
+	*result = 0;
+
+    } else {
+	dt = (DATETIME_IS_RELATIVE(*datetime)? SetDateTime(*datetime): *datetime); 
+
+	if ((type == UNITS) && (datetime2tm( dt, &tz, tm, &fsec, &tzn) == 0)) {
+	    switch (val) {
+	    case DTK_MILLENIUM:
+		tm->tm_year = (tm->tm_year/1000)*1000;
+	    case DTK_CENTURY:
+		tm->tm_year = (tm->tm_year/100)*100;
+	    case DTK_DECADE:
+		tm->tm_year = (tm->tm_year/10)*10;
+	    case DTK_YEAR:
+		tm->tm_mon = 1;
+	    case DTK_QUARTER:
+		tm->tm_mon = (3*(tm->tm_mon/4))+1;
+	    case DTK_MONTH:
+		tm->tm_mday = 1;
+	    case DTK_DAY:
+		tm->tm_hour = 0;
+	    case DTK_HOUR:
+		tm->tm_min = 0;
+	    case DTK_MINUTE:
+		tm->tm_sec = 0;
+	    case DTK_SECOND:
+		fsec = 0;
+		break;
+
+	    case DTK_MILLISEC:
+		fsec = rint(fsec*1000)/1000;
+		break;
+
+	    case DTK_MICROSEC:
+		fsec = rint(fsec*1000)/1000;
+		break;
+
+	    default:
+		elog(WARN,"Datetime units %s not supported",lowunits);
+		result = NULL;
+	    };
+
+	    if (IS_VALID_UTIME( tm->tm_year, tm->tm_mon, tm->tm_mday)) {
+#ifdef USE_POSIX_TIME
+		tm->tm_isdst = -1;
+		tm->tm_year -= 1900;
+		tm->tm_mon -= 1;
+		tm->tm_isdst = -1;
+		mktime(tm);
+		tm->tm_year += 1900;
+		tm->tm_mon += 1;
+
+#ifdef HAVE_INT_TIMEZONE
+		tz = ((tm->tm_isdst > 0)? (timezone - 3600): timezone);
+
+#else /* !HAVE_INT_TIMEZONE */
+		tz = -(tm->tm_gmtoff); /* tm_gmtoff is Sun/DEC-ism */
+#endif
+
+#else /* !USE_POSIX_TIME */
+		tz = CTimeZone;
+#endif
+	    } else {
+		tm->tm_isdst = 0;
+		tz = 0;
+	    };
+
+	    if (tm2datetime( tm, fsec, &tz, result) != 0)
+		elog(WARN,"Unable to truncate datetime to %s",lowunits);
+
+#if FALSE
+	} else if ((type == RESERV) && (val == DTK_EPOCH)) {
+	    DATETIME_EPOCH(*result);
+	    *result = dt - SetDateTime(*result);
+#endif
+
+	} else {
+	    elog(WARN,"Datetime units %s not recognized",lowunits);
+	    result = NULL;
+	};
+    };
+
+    return(result);
+} /* datetime_trunc() */
+
+/* timespan_trunc()
+ * Extract specified field from timespan.
+ */
+TimeSpan *
+timespan_trunc(text *units, TimeSpan *timespan)
+{
+    TimeSpan *result;
+
+    int type, val;
+    int i;
+    char *up, *lp, lowunits[MAXDATELEN+1];
+    double fsec;
+    struct tm tt, *tm = &tt;
+
+    if ((!PointerIsValid(units)) || (!PointerIsValid(timespan)))
+	return NULL;
+
+    result = PALLOCTYPE(TimeSpan);
+
+    up = VARDATA(units);
+    lp = lowunits;
+    for (i = 0; i < (VARSIZE(units)-VARHDRSZ); i++) *lp++ = tolower( *up++);
+    *lp = '\0';
+
+    type = DecodeUnits( 0, lowunits, &val);
+#if FALSE
+    if (type == IGNORE) {
+	type = DecodeSpecial( 0, lowunits, &val);
+    };
+#endif
+
+#ifdef DATEDEBUG
+if (type == IGNORE) strcpy(lowunits, "(unknown)");
+printf( "timespan_trunc- units %s type=%d value=%d\n", lowunits, type, val); 
+#endif
+
+    if (TIMESPAN_IS_INVALID(*timespan)) {
+#if FALSE
+	elog(WARN,"Timespan is not finite",NULL);
+#endif
+	result = NULL;
+
+    } else if (type == UNITS) {
+
+	if (timespan2tm(*timespan, tm, &fsec) == 0) {
+	    switch (val) {
+	    case DTK_MILLENIUM:
+		tm->tm_year = (tm->tm_year/1000)*1000;
+	    case DTK_CENTURY:
+		tm->tm_year = (tm->tm_year/100)*100;
+	    case DTK_DECADE:
+		tm->tm_year = (tm->tm_year/10)*10;
+	    case DTK_YEAR:
+		tm->tm_mon = 0;
+	    case DTK_QUARTER:
+		tm->tm_mon = (3*(tm->tm_mon/4));
+	    case DTK_MONTH:
+		tm->tm_mday = 0;
+	    case DTK_DAY:
+		tm->tm_hour = 0;
+	    case DTK_HOUR:
+		tm->tm_min = 0;
+	    case DTK_MINUTE:
+		tm->tm_sec = 0;
+	    case DTK_SECOND:
+		fsec = 0;
+		break;
+
+	    case DTK_MILLISEC:
+		fsec = rint(fsec*1000)/1000;
+		break;
+
+	    case DTK_MICROSEC:
+		fsec = rint(fsec*1000)/1000;
+		break;
+
+	    default:
+		elog(WARN,"Timespan units %s not supported",lowunits);
+		result = NULL;
+	    };
+
+	    if (tm2timespan(tm, fsec, result) != 0)
+		elog(WARN,"Unable to truncate timespan to %s",lowunits);
+
+	} else {
+	    elog(NOTICE,"Timespan out of range",NULL);
+	    result = NULL;
+	};
+
+#if FALSE
+    } else if ((type == RESERV) && (val == DTK_EPOCH)) {
+	*result = timespan->time;
+	if (timespan->month != 0) {
+	    *result += ((365.25*86400)*(timespan->month / 12));
+	    *result += ((30*86400)*(timespan->month % 12));
+	};
+#endif
+
+    } else {
+	elog(WARN,"Timespan units %s not recognized",units);
+	result = NULL;
+    };
+
+    return(result);
+} /* timespan_trunc() */
+
+
 /* datetime_part()
  * Extract specified field from datetime.
  */
@@ -1122,9 +1478,24 @@ printf( "datetime_part- units %s type=%d value=%d\n", lowunits, type, val);
 		*result = 0;
 	    };
 
-	} else if ((type == RESERV) && (val == DTK_EPOCH)) {
-	    DATETIME_EPOCH(*result);
-	    *result = dt - SetDateTime(*result);
+	} else if (type == RESERV) {
+	    switch (val) {
+	    case DTK_EPOCH:
+		DATETIME_EPOCH(*result);
+		*result = dt - SetDateTime(*result);
+		break;
+
+	    case DTK_DOW:
+		if (datetime2tm( dt, &tz, tm, &fsec, &tzn) != 0)
+		    elog(WARN,"Unable to encode datetime",NULL);
+
+		*result = j2day( date2j( tm->tm_year, tm->tm_mon, tm->tm_mday));
+		break;
+
+	    default:
+		elog(WARN,"Datetime units %s not supported",lowunits);
+		*result = 0;
+	    };
 
 	} else {
 	    elog(WARN,"Datetime units %s not recognized",lowunits);
@@ -1254,6 +1625,79 @@ printf( "timespan_part- units %s type=%d value=%d\n", lowunits, type, val);
 } /* timespan_part() */
 
 
+/* datetime_zone()
+ * Encode datetime type with specified time zone.
+ */
+text *
+datetime_zone(text *zone, DateTime *datetime)
+{
+    text *result;
+
+    DateTime dt;
+    int tz;
+    int type, val;
+    int i;
+    char *up, *lp, lowzone[MAXDATELEN+1];
+    char *tzn, upzone[MAXDATELEN+1];
+    double fsec;
+    struct tm tt, *tm = &tt;
+    char buf[MAXDATELEN+1];
+    int len;
+
+    if ((!PointerIsValid(zone)) || (!PointerIsValid(datetime)))
+	return NULL;
+
+    up = VARDATA(zone);
+    lp = lowzone;
+    for (i = 0; i < (VARSIZE(zone)-VARHDRSZ); i++) *lp++ = tolower( *up++);
+    *lp = '\0';
+
+    type = DecodeSpecial( 0, lowzone, &val);
+
+#ifdef DATEDEBUG
+if (type == IGNORE) strcpy(lowzone, "(unknown)");
+printf( "datetime_zone- zone %s type=%d value=%d\n", lowzone, type, val); 
+#endif
+
+    if (DATETIME_NOT_FINITE(*datetime)) {
+	/* could return null but Postgres doesn't like that currently. - tgl 97/06/12 */
+	elog(WARN,"Datetime is not finite",NULL);
+	result = NULL;
+
+    } else if ((type == TZ) || (type == DTZ)) {
+	tm->tm_isdst = ((type == DTZ)? 1: 0);
+	tz = val * 60;
+
+	dt = (DATETIME_IS_RELATIVE(*datetime)? SetDateTime(*datetime): *datetime); 
+	dt = dt2local( dt, tz);
+
+	if (datetime2tm( dt, NULL, tm, &fsec, NULL) != 0)
+	    elog(WARN,"Datetime not legal",NULL);
+
+	up = upzone;
+	lp = lowzone;
+	for (i = 0; *lp != '\0'; i++) *up++ = toupper( *lp++);
+	*up = '\0';
+
+	tzn = upzone;
+	EncodeDateTime(tm, fsec, &tz, &tzn, DateStyle, buf);
+
+	len = (strlen(buf)+VARHDRSZ);
+
+	result = PALLOC(len);
+
+	VARSIZE(result) = len;
+	memmove(VARDATA(result), buf, (len-VARHDRSZ));
+
+    } else {
+	elog(WARN,"Time zone %s not recognized",lowzone);
+	result = NULL;
+    };
+
+    return(result);
+} /* datetime_zone() */
+
+
 /***************************************************************************** 
  *   PRIVATE ROUTINES                                                        *
  *****************************************************************************/
@@ -1307,6 +1751,7 @@ static datetkn datetktbl[] = {
 {	"dec",		MONTH,	12},
 {	"december",	MONTH,	12},
 {	"dnt",		TZ,	6},		/* Dansk Normal Tid */
+{	"dow",		RESERV,	DTK_DOW},	/* day of week */
 {	"dst",		DTZMOD,	6},
 {	"east",		TZ,	NEG(60)},	/* East Australian Std Time */
 {	"edt",		DTZ,	NEG(24)},	/* Eastern Daylight Time */
@@ -2156,6 +2601,9 @@ printf( " %02d:%02d:%02d\n", tm->tm_hour, tm->tm_min, tm->tm_sec);
     if ((*dtype == DTK_DATE) && ((fmask & DTK_DATE_M) == DTK_DATE_M)
       && (tzp != NULL) && (! (fmask & DTK_M(TZ)))) {
 
+	/* daylight savings time modifier but no standard timezone? then error */
+	if (fmask & DTK_M(DTZMOD)) return -1;
+
 	if (IS_VALID_UTIME( tm->tm_year, tm->tm_mon, tm->tm_mday)) {
 #ifdef USE_POSIX_TIME
 	    tm->tm_year -= 1900;
@@ -2669,10 +3117,16 @@ DecodeSpecial(int field, char *lowtoken, int *val)
 	*val = 0;
     } else {
 	type = tp->type;
-	if ((type == TZ) || (type == DTZ) || (type == DTZMOD)) {
+	switch (type) {
+	case TZ:
+	case DTZ:
+	case DTZMOD:
 	    *val = FROMVAL(tp);
-	} else {
+	    break;
+
+	default:
 	    *val = tp->value;
+	    break;
 	};
     };
 
@@ -2990,15 +3444,125 @@ printf( "EncodeSpecialDateTime- unrecognized date\n");
 } /* EncodeSpecialDateTime() */
 
 
+/* EncodeDateOnly()
+ * Encode date as local time.
+ */
+int EncodeDateOnly(struct tm *tm, int style, char *str)
+{
+#if FALSE
+    int day;
+#endif
+
+    if ((tm->tm_mon < 1) || (tm->tm_mon > 12))
+	return -1;
+
+    /* compatible with ISO date formats */
+    if (style == USE_ISO_DATES) {
+	if (tm->tm_year > 0) {
+	    sprintf( str, "%04d-%02d-%02d",
+	      tm->tm_year, tm->tm_mon, tm->tm_mday);
+
+	} else {
+	    sprintf( str, "%04d-%02d-%02d %s",
+	      -(tm->tm_year-1), tm->tm_mon, tm->tm_mday, "BC");
+	};
+
+    /* compatible with Oracle/Ingres date formats */
+    } else if (style == USE_SQL_DATES) {
+	if (EuroDates) {
+	    sprintf( str, "%02d/%02d", tm->tm_mday, tm->tm_mon);
+	} else {
+	    sprintf( str, "%02d/%02d", tm->tm_mon, tm->tm_mday);
+	};
+	if (tm->tm_year > 0) {
+	    sprintf( (str+5), "/%04d", tm->tm_year);
+
+	} else {
+	    sprintf( (str+5), "/%04d %s", -(tm->tm_year-1), "BC");
+	};
+
+    /* backward-compatible with traditional Postgres abstime dates */
+    } else { /* if (style == USE_POSTGRES_DATES) */
+
+#if FALSE
+	day = date2j( tm->tm_year, tm->tm_mon, tm->tm_mday);
+#ifdef DATEDEBUG
+printf( "EncodeDateOnly- day is %d\n", day);
+#endif
+	tm->tm_wday = j2day( day);
+
+	strncpy( str, days[tm->tm_wday], 3);
+	strcpy( (str+3), " ");
+
+	if (EuroDates) {
+	    sprintf( (str+4), "%02d %3s", tm->tm_mday, months[tm->tm_mon-1]);
+	} else {
+	    sprintf( (str+4), "%3s %02d", months[tm->tm_mon-1], tm->tm_mday);
+	};
+	if (tm->tm_year > 0) {
+	    sprintf( (str+10), " %04d", tm->tm_year);
+
+	} else {
+	    sprintf( (str+10), " %04d %s", -(tm->tm_year-1), "BC");
+	};
+#endif
+
+	/* traditional date-only style for Postgres */
+	if (EuroDates) {
+	    sprintf( str, "%02d-%02d", tm->tm_mday, tm->tm_mon);
+	} else {
+	    sprintf( str, "%02d-%02d", tm->tm_mon, tm->tm_mday);
+	};
+	if (tm->tm_year > 0) {
+	    sprintf( (str+5), "-%04d", tm->tm_year);
+
+	} else {
+	    sprintf( (str+5), "-%04d %s", -(tm->tm_year-1), "BC");
+	};
+    };
+
+#ifdef DATEDEBUG
+printf( "EncodeDateOnly- date result is %s\n", str);
+#endif
+
+    return(TRUE);
+} /* EncodeDateOnly() */
+
+
+/* EncodeTimeOnly()
+ * Encode time fields only.
+ */
+int EncodeTimeOnly(struct tm *tm, double fsec, int style, char *str)
+{
+    double sec;
+
+    if ((tm->tm_hour < 0) || (tm->tm_hour > 24))
+	return -1;
+
+    sec = (tm->tm_sec + fsec);
+
+    sprintf( str, "%02d:%02d:", tm->tm_hour, tm->tm_min);
+    sprintf( (str+6), ((fsec != 0)? "%05.2f": "%02.0f"), sec);
+
+#ifdef DATEDEBUG
+printf( "EncodeTimeOnly- time result is %s\n", str);
+#endif
+
+    return(TRUE);
+} /* EncodeTimeOnly() */
+
+
 /* EncodeDateTime()
  * Encode date and time interpreted as local time.
  */
 int EncodeDateTime(struct tm *tm, double fsec, int *tzp, char **tzn, int style, char *str)
 {
-    char mabbrev[4], dabbrev[4];
     int day, hour, min;
     double sec;
 
+    if ((tm->tm_mon < 1) || (tm->tm_mon > 12))
+	return -1;
+
     sec = (tm->tm_sec + fsec);
 
 #ifdef DATEDEBUG
@@ -3016,20 +3580,6 @@ printf( "EncodeDateTime- timezone is %s (%s); offset is %d; daylight is %d\n",
 #endif
 #endif
 
-    day = date2j( tm->tm_year, tm->tm_mon, tm->tm_mday);
-#ifdef DATEDEBUG
-printf( "EncodeDateTime- day is %d\n", day);
-#endif
-    tm->tm_wday = j2day( day);
-
-    strncpy( dabbrev, days[tm->tm_wday], 3);
-    dabbrev[3] = '\0';
-
-    if ((tm->tm_mon < 1) || (tm->tm_mon > 12))
-	return -1;
-
-    strcpy( mabbrev, months[tm->tm_mon-1]);
-
     /* compatible with ISO date formats */
     if (style == USE_ISO_DATES) {
 	if (tm->tm_year > 0) {
@@ -3081,11 +3631,19 @@ printf( "EncodeDateTime- day is %d\n", day);
 
     /* backward-compatible with traditional Postgres abstime dates */
     } else { /* if (style == USE_POSTGRES_DATES) */
-	sprintf( str, "%3s ", dabbrev);
+	day = date2j( tm->tm_year, tm->tm_mon, tm->tm_mday);
+#ifdef DATEDEBUG
+printf( "EncodeDateTime- day is %d\n", day);
+#endif
+	tm->tm_wday = j2day( day);
+
+	strncpy( str, days[tm->tm_wday], 3);
+	strcpy( (str+3), " ");
+
 	if (EuroDates) {
-	    sprintf( (str+4), "%02d %3s", tm->tm_mday, mabbrev);
+	    sprintf( (str+4), "%02d %3s", tm->tm_mday, months[tm->tm_mon-1]);
 	} else {
-	    sprintf( (str+4), "%3s %02d", mabbrev, tm->tm_mday);
+	    sprintf( (str+4), "%3s %02d", months[tm->tm_mon-1], tm->tm_mday);
 	};
 	if (tm->tm_year > 0) {
 	    sprintf( (str+10), " %02d:%02d", tm->tm_hour, tm->tm_min);
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index e884f7eb08c..58113955e5a 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -3,8 +3,10 @@
 #include <time.h>
 #include <ctype.h>
 #include "postgres.h"
+#include "miscadmin.h"
 #include "utils/builtins.h"
 
+#if FALSE
 /* copy the next part of the string into a buffer */
 static const char *
 cpstr(const char *s, char *buf)
@@ -29,13 +31,16 @@ cpstr(const char *s, char *buf)
 	buf[in] = 0;
 	return s;
 }
+#endif
 
 /* assumes dd/mm/yyyy unless first item is month in word form */
 time_t
 timestamp_in(const char *timestamp_str)
 {
-    struct tm input_time;
     int4 result;
+
+#if FALSE
+    struct tm input_time;
 	char buf[18];
 	const char *p;
 	static const char *mstr[] = {
@@ -105,6 +110,9 @@ timestamp_in(const char *timestamp_str)
 
     /* use mktime(), but make this GMT, not local time */
     result = mktime(&input_time);
+#endif
+
+    result = nabstimein( (char *) timestamp_str);
 
     return result;
 }
@@ -113,14 +121,24 @@ char *
 timestamp_out(time_t timestamp)
 {
     char *result;
-    struct tm *time;
+    int tz;
+    double fsec = 0;
+    struct tm tt, *tm = &tt;
+    char buf[MAXDATELEN+1];
+    char zone[MAXDATELEN+1], *tzn = zone;
 
+#if FALSE
     time = localtime(&timestamp);
-    result = palloc(20);
+
     sprintf(result, "%04d-%02d-%02d %02d:%02d:%02d",
 	    time->tm_year+1900, time->tm_mon+1, time->tm_mday,
 	    time->tm_hour, time->tm_min, time->tm_sec);
+#endif
+    abstime2tm( timestamp, &tz, tm, tzn);
+    EncodeDateTime( tm, fsec, &tz, &tzn, USE_ISO_DATES, buf);
 
+    result = palloc(strlen(buf)+1);
+    strcpy( result, buf);
     return result;
 }