Cache the result of converting now() to a struct pg_tm.

SQL operations such as CURRENT_DATE, CURRENT_TIME, LOCALTIME, and
conversion of "now" in a datetime input string have to obtain the
transaction start timestamp ("now()") as a broken-down struct pg_tm.
This is a remarkably expensive conversion, and since now() does not
change intra-transaction, it doesn't really need to be done more than
once per transaction.  Introducing a simple cache provides visible
speedups in queries that compute these values many times, for example
insertion of many rows that use a default value of CURRENT_DATE.

Peter Smith, with a bit of kibitzing by me

Discussion: https://postgr.es/m/CAHut+Pu89TWjq530V2gY5O6SWi=OEJMQ_VHMt8bdZB_9JFna5A@mail.gmail.com

diff --git a/src/backend/utils/adt/date.c b/src/backend/utils/adt/date.c
index eaaffa7137dc7919d89983d09830752934e2ece5..057051fa85506cc66ad195515a2f2d6d510cd837 100644 (file)
--- a/src/backend/utils/adt/date.c
+++ b/src/backend/utils/adt/date.c
@@ -299,20 +299,31 @@ EncodeSpecialDate(DateADT dt, char *str)
 DateADT
 GetSQLCurrentDate(void)
 {
-       TimestampTz ts;
-       struct pg_tm tt,
-                          *tm = &tt;
-       fsec_t          fsec;
-       int                     tz;
+       struct pg_tm tm;
 
-       ts = GetCurrentTransactionStartTimestamp();
+       static int      cache_year = 0;
+       static int      cache_mon = 0;
+       static int      cache_mday = 0;
+       static DateADT cache_date;
 
-       if (timestamp2tm(ts, &tz, tm, &fsec, NULL, NULL) != 0)
-               ereport(ERROR,
-                               (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
-                                errmsg("timestamp out of range")));
+       GetCurrentDateTime(&tm);
 
-       return date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - POSTGRES_EPOCH_JDATE;
+       /*
+        * date2j involves several integer divisions; moreover, unless our session
+        * lives across local midnight, we don't really have to do it more than
+        * once.  So it seems worth having a separate cache here.
+        */
+       if (tm.tm_year != cache_year ||
+               tm.tm_mon != cache_mon ||
+               tm.tm_mday != cache_mday)
+       {
+               cache_date = date2j(tm.tm_year, tm.tm_mon, tm.tm_mday) - POSTGRES_EPOCH_JDATE;
+               cache_year = tm.tm_year;
+               cache_mon = tm.tm_mon;
+               cache_mday = tm.tm_mday;
+       }
+
+       return cache_date;
 }
 
 /*
@@ -322,18 +333,12 @@ TimeTzADT *
 GetSQLCurrentTime(int32 typmod)
 {
        TimeTzADT  *result;
-       TimestampTz ts;
        struct pg_tm tt,
                           *tm = &tt;
        fsec_t          fsec;
        int                     tz;
 
-       ts = GetCurrentTransactionStartTimestamp();
-
-       if (timestamp2tm(ts, &tz, tm, &fsec, NULL, NULL) != 0)
-               ereport(ERROR,
-                               (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
-                                errmsg("timestamp out of range")));
+       GetCurrentTimeUsec(tm, &fsec, &tz);
 
        result = (TimeTzADT *) palloc(sizeof(TimeTzADT));
        tm2timetz(tm, fsec, tz, result);
@@ -348,18 +353,12 @@ TimeADT
 GetSQLLocalTime(int32 typmod)
 {
        TimeADT         result;
-       TimestampTz ts;
        struct pg_tm tt,
                           *tm = &tt;
        fsec_t          fsec;
        int                     tz;
 
-       ts = GetCurrentTransactionStartTimestamp();
-
-       if (timestamp2tm(ts, &tz, tm, &fsec, NULL, NULL) != 0)
-               ereport(ERROR,
-                               (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
-                                errmsg("timestamp out of range")));
+       GetCurrentTimeUsec(tm, &fsec, &tz);
 
        tm2time(tm, fsec, &result);
        AdjustTimeForTypmod(&result, typmod);

diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index dec2fad82a685030f0df9c2fb8a66576ae49c000..91fab8cc9cb39257579e6d4cdd8f55fb84384216 100644 (file)
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -339,35 +339,80 @@ j2day(int date)
 /*
  * GetCurrentDateTime()
  *
- * Get the transaction start time ("now()") broken down as a struct pg_tm.
+ * Get the transaction start time ("now()") broken down as a struct pg_tm,
+ * converted according to the session timezone setting.
+ *
+ * This is just a convenience wrapper for GetCurrentTimeUsec, to cover the
+ * case where caller doesn't need either fractional seconds or tz offset.
  */
 void
 GetCurrentDateTime(struct pg_tm *tm)
 {
-       int                     tz;
        fsec_t          fsec;
 
-       timestamp2tm(GetCurrentTransactionStartTimestamp(), &tz, tm, &fsec,
-                                NULL, NULL);
-       /* Note: don't pass NULL tzp to timestamp2tm; affects behavior */
+       GetCurrentTimeUsec(tm, &fsec, NULL);
 }
 
 /*
  * GetCurrentTimeUsec()
  *
  * Get the transaction start time ("now()") broken down as a struct pg_tm,
- * including fractional seconds and timezone offset.
+ * including fractional seconds and timezone offset.  The time is converted
+ * according to the session timezone setting.
+ *
+ * Callers may pass tzp = NULL if they don't need the offset, but this does
+ * not affect the conversion behavior (unlike timestamp2tm()).
+ *
+ * Internally, we cache the result, since this could be called many times
+ * in a transaction, within which now() doesn't change.
  */
 void
 GetCurrentTimeUsec(struct pg_tm *tm, fsec_t *fsec, int *tzp)
 {
-       int                     tz;
+       TimestampTz cur_ts = GetCurrentTransactionStartTimestamp();
+
+       /*
+        * The cache key must include both current time and current timezone.  By
+        * representing the timezone by just a pointer, we're assuming that
+        * distinct timezone settings could never have the same pointer value.
+        * This is true by virtue of the hashtable used inside pg_tzset();
+        * however, it might need another look if we ever allow entries in that
+        * hash to be recycled.
+        */
+       static TimestampTz cache_ts = 0;
+       static pg_tz *cache_timezone = NULL;
+       static struct pg_tm cache_tm;
+       static fsec_t cache_fsec;
+       static int      cache_tz;
+
+       if (cur_ts != cache_ts || session_timezone != cache_timezone)
+       {
+               /*
+                * Make sure cache is marked invalid in case of error after partial
+                * update within timestamp2tm.
+                */
+               cache_timezone = NULL;
+
+               /*
+                * Perform the computation, storing results into cache.  We do not
+                * really expect any error here, since current time surely ought to be
+                * within range, but check just for sanity's sake.
+                */
+               if (timestamp2tm(cur_ts, &cache_tz, &cache_tm, &cache_fsec,
+                                                NULL, session_timezone) != 0)
+                       ereport(ERROR,
+                                       (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
+                                        errmsg("timestamp out of range")));
+
+               /* OK, so mark the cache valid. */
+               cache_ts = cur_ts;
+               cache_timezone = session_timezone;
+       }
 
-       timestamp2tm(GetCurrentTransactionStartTimestamp(), &tz, tm, fsec,
-                                NULL, NULL);
-       /* Note: don't pass NULL tzp to timestamp2tm; affects behavior */
+       *tm = cache_tm;
+       *fsec = cache_fsec;
        if (tzp != NULL)
-               *tzp = tz;
+               *tzp = cache_tz;
 }