Fix spccache.c to not suppose that a cache entry will live across database

access, per testing with CLOBBER_CACHE_ALWAYS.  Minor other editorialization.

diff --git a/src/backend/utils/cache/spccache.c b/src/backend/utils/cache/spccache.c
index 7de65b31b712d75d66cf8bd4ae1760d2e569c38b..16526159bc80113523414fdc69f52b708e114a1f 100644 (file)
--- a/src/backend/utils/cache/spccache.c
+++ b/src/backend/utils/cache/spccache.c
@@ -12,12 +12,12 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/utils/cache/spccache.c,v 1.2 2010/01/06 22:27:09 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/utils/cache/spccache.c,v 1.3 2010/01/06 23:00:02 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
-
 #include "postgres.h"
+
 #include "access/reloptions.h"
 #include "catalog/pg_tablespace.h"
 #include "commands/tablespace.h"
@@ -29,12 +29,16 @@
 #include "utils/spccache.h"
 #include "utils/syscache.h"
 
+
+/* Hash table for information about each tablespace */
 static HTAB *TableSpaceCacheHash = NULL;
 
-typedef struct {
-       Oid                     oid;
-       TableSpaceOpts *opts;
-} TableSpace;
+typedef struct
+{
+       Oid                     oid;                    /* lookup key - must be first */
+       TableSpaceOpts *opts;           /* options, or NULL if none */
+} TableSpaceCacheEntry;
+
 
 /*
  * InvalidateTableSpaceCacheCallback
@@ -49,10 +53,10 @@ static void
 InvalidateTableSpaceCacheCallback(Datum arg, int cacheid, ItemPointer tuplePtr)
 {
        HASH_SEQ_STATUS status;
-       TableSpace *spc;
+       TableSpaceCacheEntry *spc;
 
        hash_seq_init(&status, TableSpaceCacheHash);
-       while ((spc = (TableSpace *) hash_seq_search(&status)) != NULL)
+       while ((spc = (TableSpaceCacheEntry *) hash_seq_search(&status)) != NULL)
        {
                if (spc->opts)
                        pfree(spc->opts);
@@ -66,7 +70,7 @@ InvalidateTableSpaceCacheCallback(Datum arg, int cacheid, ItemPointer tuplePtr)
 
 /*
  * InitializeTableSpaceCache
- *             Initiate the tablespace cache.
+ *             Initialize the tablespace cache.
  */
 static void
 InitializeTableSpaceCache(void)
@@ -76,8 +80,8 @@ InitializeTableSpaceCache(void)
        /* Initialize the hash table. */
        MemSet(&ctl, 0, sizeof(ctl));
        ctl.keysize = sizeof(Oid);
-       ctl.entrysize = sizeof(TableSpace);
-       ctl.hash = tag_hash;
+       ctl.entrysize = sizeof(TableSpaceCacheEntry);
+       ctl.hash = oid_hash;
        TableSpaceCacheHash =
                hash_create("TableSpace cache", 16, &ctl,
                                    HASH_ELEM | HASH_FUNCTION);
@@ -94,17 +98,17 @@ InitializeTableSpaceCache(void)
 
 /*
  * get_tablespace
- *             Fetch TableSpace structure for a specified table OID.
+ *             Fetch TableSpaceCacheEntry structure for a specified table OID.
  *
  * Pointers returned by this function should not be stored, since a cache
  * flush will invalidate them.
  */
-static TableSpace *
+static TableSpaceCacheEntry *
 get_tablespace(Oid spcid)
 {
+       TableSpaceCacheEntry *spc;
        HeapTuple       tp;
-       TableSpace *spc;
-       bool            found;
+       TableSpaceOpts *opts;
 
        /*
         * Since spcid is always from a pg_class tuple, InvalidOid implies the
@@ -113,12 +117,14 @@ get_tablespace(Oid spcid)
        if (spcid == InvalidOid)
                spcid = MyDatabaseTableSpace;
 
-       /* Find existing cache entry, or create a new one. */
+       /* Find existing cache entry, if any. */
        if (!TableSpaceCacheHash)
                InitializeTableSpaceCache();
-       spc = (TableSpace *) hash_search(TableSpaceCacheHash, (void *) &spcid,
-                                                                        HASH_ENTER, &found);
-       if (found)
+       spc = (TableSpaceCacheEntry *) hash_search(TableSpaceCacheHash,
+                                                                                          (void *) &spcid,
+                                                                                          HASH_FIND,
+                                                                                          NULL);
+       if (spc)
                return spc;
 
        /*
@@ -127,9 +133,11 @@ get_tablespace(Oid spcid)
         * details for a non-existent tablespace.  We'll just treat that case as if
         * no options were specified.
         */
-       tp = SearchSysCache(TABLESPACEOID, ObjectIdGetDatum(spcid), 0, 0, 0);
+       tp = SearchSysCache(TABLESPACEOID,
+                                               ObjectIdGetDatum(spcid),
+                                               0, 0, 0);
        if (!HeapTupleIsValid(tp))
-               spc->opts = NULL;
+               opts = NULL;
        else
        {
                Datum   datum;
@@ -141,29 +149,40 @@ get_tablespace(Oid spcid)
                                                                Anum_pg_tablespace_spcoptions,
                                                                &isNull);
                if (isNull)
-                       spc->opts = NULL;
+                       opts = NULL;
                else
                {
+                       /* XXX should NOT do the parsing work in CacheMemoryContext */
                        octx = MemoryContextSwitchTo(CacheMemoryContext);
-                       spc->opts = (TableSpaceOpts *) tablespace_reloptions(datum, false);
+                       opts = (TableSpaceOpts *) tablespace_reloptions(datum, false);
                        MemoryContextSwitchTo(octx);
                }
                ReleaseSysCache(tp);
        }
 
-       /* Update new TableSpace cache entry with results of option parsing. */
+       /*
+        * Now create the cache entry.  It's important to do this only after
+        * reading the pg_tablespace entry, since doing so could cause a cache
+        * flush.
+        */
+       spc = (TableSpaceCacheEntry *) hash_search(TableSpaceCacheHash,
+                                                                                          (void *) &spcid,
+                                                                                          HASH_ENTER,
+                                                                                          NULL);
+       spc->opts = opts;
        return spc;
 }
 
 /*
  * get_tablespace_page_costs
- *             Return random and sequential page costs for a given tablespace.
+ *             Return random and/or sequential page costs for a given tablespace.
  */
 void
-get_tablespace_page_costs(Oid spcid, double *spc_random_page_cost,
-                                                          double *spc_seq_page_cost)
+get_tablespace_page_costs(Oid spcid,
+                                                 double *spc_random_page_cost,
+                                                 double *spc_seq_page_cost)
 {
-       TableSpace *spc = get_tablespace(spcid);
+       TableSpaceCacheEntry *spc = get_tablespace(spcid);
 
        Assert(spc != NULL);