Use heap_inplace_update() to unset pg_database.dathasloginevt

Doing this instead of regular updates serves two purposes. First, that avoids
possible waiting on the row-level lock.  Second, that avoids dealing with
TOAST.

It's known that changes made by heap_inplace_update() may be lost due to
concurrent normal updates.  However, we are OK with that.  The subsequent
connections will still have a chance to set "dathasloginevt" to false.

Reported-by: Alexander Lakhin
Discussion: https://postgr.es/m/e2a0248e-5f32-af0c-9832-a90d303c2c61%40gmail.com

diff --git a/src/backend/commands/event_trigger.c b/src/backend/commands/event_trigger.c
index f193c7ddf60ea7b6988bd6e16b5e2823f2fd9054..c8b662131c3a82f0257fcfbc7ea5e450775271ae 100644 (file)
--- a/src/backend/commands/event_trigger.c
+++ b/src/backend/commands/event_trigger.c
@@ -13,6 +13,7 @@
  */
 #include "postgres.h"
 
+#include "access/heapam.h"
 #include "access/htup_details.h"
 #include "access/table.h"
 #include "access/xact.h"
@@ -943,18 +944,45 @@ EventTriggerOnLogin(void)
            Relation    pg_db = table_open(DatabaseRelationId, RowExclusiveLock);
            HeapTuple   tuple;
            Form_pg_database db;
+           ScanKeyData key[1];
+           SysScanDesc scan;
 
-           tuple = SearchSysCacheCopy1(DATABASEOID,
-                                       ObjectIdGetDatum(MyDatabaseId));
+           /*
+            * Get the pg_database tuple to scribble on.  Note that this does
+            * not directly rely on the syscache to avoid issues with
+            * flattened toast values for the in-place update.
+            */
+           ScanKeyInit(&key[0],
+                       Anum_pg_database_oid,
+                       BTEqualStrategyNumber, F_OIDEQ,
+                       ObjectIdGetDatum(MyDatabaseId));
+
+           scan = systable_beginscan(pg_db, DatabaseOidIndexId, true,
+                                     NULL, 1, key);
+           tuple = systable_getnext(scan);
+           tuple = heap_copytuple(tuple);
+           systable_endscan(scan);
 
            if (!HeapTupleIsValid(tuple))
-               elog(ERROR, "cache lookup failed for database %u", MyDatabaseId);
+               elog(ERROR, "could not find tuple for database %u", MyDatabaseId);
 
            db = (Form_pg_database) GETSTRUCT(tuple);
            if (db->dathasloginevt)
            {
                db->dathasloginevt = false;
-               CatalogTupleUpdate(pg_db, &tuple->t_self, tuple);
+
+               /*
+                * Do an "in place" update of the pg_database tuple.  Doing
+                * this instead of regular updates serves two purposes. First,
+                * that avoids possible waiting on the row-level lock. Second,
+                * that avoids dealing with TOAST.
+                *
+                * It's known that changes made by heap_inplace_update() may
+                * be lost due to concurrent normal updates.  However, we are
+                * OK with that.  The subsequent connections will still have a
+                * chance to set "dathasloginevt" to false.
+                */
+               heap_inplace_update(pg_db, tuple);
            }
            table_close(pg_db, RowExclusiveLock);
            heap_freetuple(tuple);