Use a hash table to store current sequence values.

This speeds up nextval() and currval(), when you touch a lot of different
sequences in the same backend.

David Rowley

diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
index f3344c6207d513f1d795fdc5cf3169df05d9d5f4..5e0be13a2196a0d80dcedff53739c8958d53cef0 100644 (file)
--- a/src/backend/commands/sequence.c
+++ b/src/backend/commands/sequence.c
@@ -60,15 +60,10 @@ typedef struct sequence_magic
  * session.  This is needed to hold onto nextval/currval state.  (We can't
  * rely on the relcache, since it's only, well, a cache, and may decide to
  * discard entries.)
- *
- * XXX We use linear search to find pre-existing SeqTable entries. This is
- * good when only a small number of sequences are touched in a session, but
- * would suck with many different sequences.  Perhaps use a hashtable someday.
  */
 typedef struct SeqTableData
 {
-   struct SeqTableData *next;  /* link to next SeqTable object */
-   Oid         relid;          /* pg_class OID of this sequence */
+   Oid         relid;          /* pg_class OID of this sequence (hash key) */
    Oid         filenode;       /* last seen relfilenode of this sequence */
    LocalTransactionId lxid;    /* xact in which we last did a seq op */
    bool        last_valid;     /* do we have a valid "last" value? */
@@ -81,7 +76,7 @@ typedef struct SeqTableData
 
 typedef SeqTableData *SeqTable;
 
-static SeqTable seqtab = NULL; /* Head of list of SeqTable items */
+static HTAB *seqhashtab = NULL;        /* hash table for SeqTable items */
 
 /*
  * last_used_seq is updated by nextval() to point to the last used
@@ -92,6 +87,7 @@ static SeqTableData *last_used_seq = NULL;
 static void fill_seq_with_data(Relation rel, HeapTuple tuple);
 static int64 nextval_internal(Oid relid);
 static Relation open_share_lock(SeqTable seq);
+static void create_seq_hashtable(void);
 static void init_sequence(Oid relid, SeqTable *p_elm, Relation *p_rel);
 static Form_pg_sequence read_seq_tuple(SeqTable elm, Relation rel,
               Buffer *buf, HeapTuple seqtuple);
@@ -998,6 +994,23 @@ open_share_lock(SeqTable seq)
    return relation_open(seq->relid, NoLock);
 }
 
+/*
+ * Creates the hash table for storing sequence data
+ */
+static void
+create_seq_hashtable(void)
+{
+   HASHCTL     ctl;
+
+   memset(&ctl, 0, sizeof(ctl));
+   ctl.keysize = sizeof(Oid);
+   ctl.entrysize = sizeof(SeqTableData);
+   ctl.hash = oid_hash;
+
+   seqhashtab = hash_create("Sequence values", 16, &ctl,
+       HASH_ELEM | HASH_FUNCTION | HASH_CONTEXT);
+}
+
 /*
  * Given a relation OID, open and lock the sequence.  p_elm and p_rel are
  * output parameters.
@@ -1007,39 +1020,28 @@ init_sequence(Oid relid, SeqTable *p_elm, Relation *p_rel)
 {
    SeqTable    elm;
    Relation    seqrel;
+   bool        found;
 
-   /* Look to see if we already have a seqtable entry for relation */
-   for (elm = seqtab; elm != NULL; elm = elm->next)
-   {
-       if (elm->relid == relid)
-           break;
-   }
+   if (seqhashtab == NULL)
+       create_seq_hashtable();
+
+   elm = (SeqTable) hash_search(seqhashtab, &relid, HASH_ENTER, &found);
 
    /*
-    * Allocate new seqtable entry if we didn't find one.
+    * Initalize the new hash table entry if it did not exist already.
     *
-    * NOTE: seqtable entries remain in the list for the life of a backend. If
-    * the sequence itself is deleted then the entry becomes wasted memory,
-    * but it's small enough that this should not matter.
+    * NOTE: seqtable entries are stored for the life of a backend (unless
+    * explictly discarded with DISCARD). If the sequence itself is deleted
+    * then the entry becomes wasted memory, but it's small enough that this
+    * should not matter.
     */
-   if (elm == NULL)
+   if (!found)
    {
-       /*
-        * Time to make a new seqtable entry.  These entries live as long as
-        * the backend does, so we use plain malloc for them.
-        */
-       elm = (SeqTable) malloc(sizeof(SeqTableData));
-       if (elm == NULL)
-           ereport(ERROR,
-                   (errcode(ERRCODE_OUT_OF_MEMORY),
-                    errmsg("out of memory")));
-       elm->relid = relid;
+       /* relid already filled in */
        elm->filenode = InvalidOid;
        elm->lxid = InvalidLocalTransactionId;
        elm->last_valid = false;
        elm->last = elm->cached = elm->increment = 0;
-       elm->next = seqtab;
-       seqtab = elm;
    }
 
    /*
@@ -1609,13 +1611,10 @@ seq_redo(XLogRecPtr lsn, XLogRecord *record)
 void
 ResetSequenceCaches(void)
 {
-   SeqTableData *next;
-
-   while (seqtab != NULL)
+   if (seqhashtab)
    {
-       next = seqtab->next;
-       free(seqtab);
-       seqtab = next;
+       hash_destroy(seqhashtab);
+       seqhashtab = NULL;
    }
 
    last_used_seq = NULL;