Improve cache invalidation handling. Eespecially

this would fix TODO
* elog() flushes cache, try invalidating just entries from
  current xact, perhaps using invalidation cache

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 9ff1525b88cf9da390476ff721102e60e2f684fe..4b7c4096222974b251b99e05bd154748609d0cdc 100644 (file)
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.62 1999/12/21 00:06:40 wieck Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.63 2000/01/10 06:30:50 inoue Exp $
  *
  *
  * INTERFACE ROUTINES
@@ -1262,7 +1262,7 @@ heap_insert(Relation relation, HeapTuple tup)
        RelationPutHeapTupleAtEnd(relation, tup);
 
        if (IsSystemRelationName(RelationGetRelationName(relation)))
-               RelationInvalidateHeapTuple(relation, tup);
+               RelationMark4RollbackHeapTuple(relation, tup);
 
        return tup->t_data->t_oid;
 }
@@ -1473,6 +1473,8 @@ l2:
                RelationPutHeapTupleAtEnd(relation, newtup);
                LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
        }
+       /* mark for rollback caches */
+       RelationMark4RollbackHeapTuple(relation, newtup);
 
        /*
         * New item in place, now record address of new tuple in t_ctid of old

diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
index d3a81e647bf9e4b9bb7ed0c2079719eee362a056..483a52d441ec8325b2f3d790c34006accba89f84 100644 (file)
--- a/src/backend/access/transam/xact.c
+++ b/src/backend/access/transam/xact.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.57 2000/01/05 18:23:44 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.58 2000/01/10 06:30:50 inoue Exp $
  *
  * NOTES
  *             Transaction aborts can now occur two ways:
@@ -165,6 +165,7 @@ static void AtAbort_Cache(void);
 static void AtAbort_Locks(void);
 static void AtAbort_Memory(void);
 static void AtCommit_Cache(void);
+static void AtCommit_LocalCache(void);
 static void AtCommit_Locks(void);
 static void AtCommit_Memory(void);
 static void AtStart_Cache(void);
@@ -512,8 +513,11 @@ CommandCounterIncrement()
 
        CurrentTransactionStateData.scanCommandId = CurrentTransactionStateData.commandId;
 
-       /* make cache changes visible to me */
-       AtCommit_Cache();
+       /*
+        * make cache changes visible to me.  AtCommit_LocalCache()
+        * instead of AtCommit_Cache() is called here.
+        */
+       AtCommit_LocalCache();
        AtStart_Cache();
 
 }
@@ -663,15 +667,26 @@ static void
 AtCommit_Cache()
 {
        /* ----------------
-        * Make catalog changes visible to me for the next command.
-        * Other backends will not process my invalidation messages until
-        * after I commit and free my locks--though they will do
-        * unnecessary work if I abort.
+        * Make catalog changes visible to all backend.
         * ----------------
         */
        RegisterInvalid(true);
 }
 
+/* --------------------------------
+ *             AtCommit_LocalCache
+ * --------------------------------
+ */
+static void
+AtCommit_LocalCache()
+{
+       /* ----------------
+        * Make catalog changes visible to me for the next command.
+        * ----------------
+        */
+       ImmediateLocalInvalidation(true);
+}
+
 /* --------------------------------
  *             AtCommit_Locks
  * --------------------------------

diff --git a/src/backend/storage/smgr/md.c b/src/backend/storage/smgr/md.c
index 0cf2893d79c4aad5d73616c242bf2f22ca4ace9b..af887c95ca7aaee3b0598ba74cb37df8d5b47780 100644 (file)
--- a/src/backend/storage/smgr/md.c
+++ b/src/backend/storage/smgr/md.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.60 1999/11/16 04:13:56 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.61 2000/01/10 06:30:51 inoue Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -20,6 +20,7 @@
 #include "catalog/catalog.h"
 #include "miscadmin.h"
 #include "storage/smgr.h"
+#include "utils/inval.h"       /* ImmediateSharedRelationCacheInvalidate() */
 
 #undef DIAGNOSTIC
 
@@ -203,6 +204,15 @@ mdunlink(Relation reln)
         */
        if (reln->rd_unlinked && reln->rd_fd < 0)
                return SM_SUCCESS;
+       /*
+        * This call isn't good for independency of md stuff,but 
+        * mdunlink() unlinks the base file immediately and couldn't
+        * be rollbacked in case of abort. We must guarantee all
+        * backends' relation cache invalidation here.
+        * This would be unnecessary if unlinking is postponed
+        * till end of transaction.
+        */
+       ImmediateSharedRelationCacheInvalidate(reln);
        /*
         * Force all segments of the relation to be opened, so that we
         * won't miss deleting any of them.
@@ -779,6 +789,7 @@ mdtruncate(Relation reln, int nblocks)
 #ifndef LET_OS_MANAGE_FILESIZE
        MemoryContext oldcxt;
        int                     priorblocks;
+       bool    invalregistered = false;
 #endif
 
        /* NOTE: mdnblocks makes sure we have opened all existing segments,
@@ -810,6 +821,20 @@ mdtruncate(Relation reln, int nblocks)
                         * a big file...
                         */
                        FileTruncate(v->mdfd_vfd, 0);
+                       /*
+                        * To call ImmediateSharedRelationCacheInvalidate() here
+                        * isn't good for independency of md stuff,but smgrunlink()
+                        * removes the base file immediately and couldn't be
+                        * rollbacked in case of abort. We must guarantee
+                        * all backends' relation cache invalidation here.
+                        * This would be unnecessary if the truncation is postponed
+                        * till end of transaction.
+                        */
+                       if (!invalregistered)
+                       {
+                               ImmediateSharedRelationCacheInvalidate(reln);
+                               invalregistered = true;
+                       }
                        FileUnlink(v->mdfd_vfd);
                        v = v->mdfd_chain;
                        Assert(ov != &Md_fdvec[fd]); /* we never drop the 1st segment */

diff --git a/src/backend/utils/cache/inval.c b/src/backend/utils/cache/inval.c
index d89a1f678a48afcfea20b6ca5769f16736ce4fb6..a0224f516782cb4d84c244957e17710c3661365e 100644 (file)
--- a/src/backend/utils/cache/inval.c
+++ b/src/backend/utils/cache/inval.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/utils/cache/inval.c,v 1.30 1999/11/21 01:58:22 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/utils/cache/inval.c,v 1.31 2000/01/10 06:30:53 inoue Exp $
  *
  * Note - this code is real crufty...
  *
@@ -79,13 +79,39 @@ typedef InvalidationMessageData *InvalidationMessage;
  *             variables and macros
  * ----------------
  */
-static LocalInvalid Invalid = EmptyLocalInvalid;       /* head of linked list */
+
+/*
+ * ----------------
+ *     Invalidation info was devided into three parts.
+ *     1) shared invalidation to be registerd for all backends
+ *     2) local invalidation for the transaction itself
+ *     3) rollback information for the transaction itself
+ * ----------------
+ */
+
+/*
+ * head of invalidation linked list for all backends
+ * eaten by AtCommit_Cache() in CommitTransaction()
+ */
+static LocalInvalid InvalidForall = EmptyLocalInvalid;
+/*
+ * head of invalidation linked list for the backend itself
+ * eaten by AtCommit_LocalCache() in CommandCounterIncrement()
+ */
+static LocalInvalid InvalidLocal = EmptyLocalInvalid;
+/*
+ * head of rollback linked list for the backend itself
+ * eaten by AtAbort_Cache() in AbortTransaction()
+ */
+static LocalInvalid RollbackStack = EmptyLocalInvalid;
 
 
 static InvalidationEntry InvalidationEntryAllocate(uint16 size);
-static void LocalInvalidInvalidate(LocalInvalid invalid, void (*function) ());
+static void LocalInvalidInvalidate(LocalInvalid invalid, void (*function) (), bool freemember);
 static LocalInvalid LocalInvalidRegister(LocalInvalid invalid,
                                                                                 InvalidationEntry entry);
+static void DiscardInvalidStack(LocalInvalid *invalid);
+static void InvalidationMessageRegisterSharedInvalid(InvalidationMessage message);
 
 
 /* ----------------------------------------------------------------
@@ -130,11 +156,11 @@ LocalInvalidRegister(LocalInvalid invalid,
 /* --------------------------------
  *             LocalInvalidInvalidate
  *                             Processes, then frees all entries in a local cache
- *                             invalidation list.
+ *                             invalidation list unless freemember parameter is false.
  * --------------------------------
  */
 static void
-LocalInvalidInvalidate(LocalInvalid invalid, void (*function) ())
+LocalInvalidInvalidate(LocalInvalid invalid, void (*function) (), bool freemember)
 {
        InvalidationEntryData *entryDataP;
 
@@ -148,6 +174,8 @@ LocalInvalidInvalidate(LocalInvalid invalid, void (*function) ())
 
                invalid = (Pointer) entryDataP->nextP;
 
+               if (!freemember)
+                       continue;
                /* help catch errors */
                entryDataP->nextP = (InvalidationUserData *) NULL;
 
@@ -155,27 +183,147 @@ LocalInvalidInvalidate(LocalInvalid invalid, void (*function) ())
        }
 }
 
+static void
+DiscardInvalidStack(LocalInvalid *invalid)
+{
+       LocalInvalid    locinv;
+
+       locinv = *invalid;
+       *invalid = EmptyLocalInvalid;
+       if (locinv)
+               LocalInvalidInvalidate(locinv, (void (*)()) NULL, true);
+}
+
 /* ----------------------------------------------------------------
  *                                       private support functions
  * ----------------------------------------------------------------
  */
 /* --------------------------------
- *             CacheIdRegisterLocalInvalid
+ *             CacheIdRegister.......
+ *             RelationIdRegister....
  * --------------------------------
  */
 #ifdef INVALIDDEBUG
+#define CacheIdRegisterSpecifiedLocalInvalid_DEBUG1 \
+elog(DEBUG, "CacheIdRegisterSpecifiedLocalInvalid(%d, %d, [%d, %d])", \
+        cacheId, hashIndex, ItemPointerGetBlockNumber(pointer), \
+        ItemPointerGetOffsetNumber(pointer))
 #define CacheIdRegisterLocalInvalid_DEBUG1 \
 elog(DEBUG, "CacheIdRegisterLocalInvalid(%d, %d, [%d, %d])", \
         cacheId, hashIndex, ItemPointerGetBlockNumber(pointer), \
         ItemPointerGetOffsetNumber(pointer))
+#define CacheIdRegisterLocalRollback_DEBUG1 \
+elog(DEBUG, "CacheIdRegisterLocalRollback(%d, %d, [%d, %d])", \
+        cacheId, hashIndex, ItemPointerGetBlockNumber(pointer), \
+        ItemPointerGetOffsetNumber(pointer))
+#define CacheIdImmediateRegisterSharedInvalid_DEBUG1 \
+elog(DEBUG, "CacheIdImmediateRegisterSharedInvalid(%d, %d, [%d, %d])", \
+        cacheId, hashIndex, ItemPointerGetBlockNumber(pointer), \
+        ItemPointerGetOffsetNumber(pointer))
 #else
+#define CacheIdRegisterSpecifiedLocalInvalid_DEBUG1
 #define CacheIdRegisterLocalInvalid_DEBUG1
+#define CacheIdRegisterLocalRollback_DEBUG1
+#define CacheIdImmediateRegisterSharedInvalid_DEBUG1
 #endif  /* INVALIDDEBUG */
 
+/* --------------------------------
+ *             CacheIdRegisterSpecifiedLocalInvalid
+ * --------------------------------
+ */
+static LocalInvalid
+CacheIdRegisterSpecifiedLocalInvalid(LocalInvalid invalid,
+               Index cacheId, Index hashIndex, ItemPointer pointer)
+{
+       InvalidationMessage message;
+
+       /* ----------------
+        *      debugging stuff
+        * ----------------
+        */
+       CacheIdRegisterSpecifiedLocalInvalid_DEBUG1;
+
+       /* ----------------
+        *      create a message describing the system catalog tuple
+        *      we wish to invalidate.
+        * ----------------
+        */
+       message = (InvalidationMessage)
+               InvalidationEntryAllocate(sizeof(InvalidationMessageData));
+
+       message->kind = 'c';
+       message->any.catalog.cacheId = cacheId;
+       message->any.catalog.hashIndex = hashIndex;
+
+       ItemPointerCopy(pointer, &message->any.catalog.pointerData);
+
+       /* ----------------
+        *      Add message to linked list of unprocessed messages.
+        * ----------------
+        */
+       invalid = LocalInvalidRegister(invalid, (InvalidationEntry) message);
+       return invalid;
+}
+
+/* --------------------------------
+ *             CacheIdRegisterLocalInvalid
+ * --------------------------------
+ */
 static void
 CacheIdRegisterLocalInvalid(Index cacheId,
                                                        Index hashIndex,
                                                        ItemPointer pointer)
+{
+       /* ----------------
+        *      debugging stuff
+        * ----------------
+        */
+       CacheIdRegisterLocalInvalid_DEBUG1;
+
+       /* ----------------
+        *      Add message to InvalidForall linked list.
+        * ----------------
+        */
+       InvalidForall = CacheIdRegisterSpecifiedLocalInvalid(InvalidForall,
+                               cacheId, hashIndex, pointer);
+       /* ----------------
+        *      Add message to InvalidLocal linked list.
+        * ----------------
+        */
+       InvalidLocal = CacheIdRegisterSpecifiedLocalInvalid(InvalidLocal,
+                               cacheId, hashIndex, pointer);
+}
+
+/* --------------------------------
+ *             CacheIdRegisterLocalRollback
+ * --------------------------------
+ */
+static void
+CacheIdRegisterLocalRollback(Index cacheId, Index hashIndex,
+                                       ItemPointer pointer)
+{
+
+       /* ----------------
+        *      debugging stuff
+        * ----------------
+        */
+       CacheIdRegisterLocalRollback_DEBUG1;
+
+       /* ----------------
+        *      Add message to RollbackStack linked list.
+        * ----------------
+        */
+       RollbackStack = CacheIdRegisterSpecifiedLocalInvalid(
+               RollbackStack, cacheId, hashIndex, pointer);
+}
+
+/* --------------------------------
+ *             CacheIdImmediateRegisterSharedInvalid
+ * --------------------------------
+ */
+static void
+CacheIdImmediateRegisterSharedInvalid(Index cacheId, Index hashIndex,
+                                       ItemPointer pointer)
 {
        InvalidationMessage message;
 
@@ -183,7 +331,7 @@ CacheIdRegisterLocalInvalid(Index cacheId,
         *      debugging stuff
         * ----------------
         */
-       CacheIdRegisterLocalInvalid_DEBUG1;
+       CacheIdImmediateRegisterSharedInvalid_DEBUG1;
 
        /* ----------------
         *      create a message describing the system catalog tuple
@@ -198,12 +346,51 @@ CacheIdRegisterLocalInvalid(Index cacheId,
        message->any.catalog.hashIndex = hashIndex;
 
        ItemPointerCopy(pointer, &message->any.catalog.pointerData);
+       /* ----------------
+        *      Register a shared catalog cache invalidation.
+        * ----------------
+        */
+       InvalidationMessageRegisterSharedInvalid(message);
+       free((Pointer) &((InvalidationUserData *) message)->dataP[-1]);
+}
+
+/* --------------------------------
+ *             RelationIdRegisterSpecifiedLocalInvalid
+ * --------------------------------
+ */
+static LocalInvalid
+RelationIdRegisterSpecifiedLocalInvalid(LocalInvalid invalid,
+                       Oid relationId, Oid objectId)
+{
+       InvalidationMessage message;
+
+       /* ----------------
+        *      debugging stuff
+        * ----------------
+        */
+#ifdef INVALIDDEBUG
+       elog(DEBUG, "RelationRegisterSpecifiedLocalInvalid(%u, %u)", relationId,
+                objectId);
+#endif  /* defined(INVALIDDEBUG) */
+
+       /* ----------------
+        *      create a message describing the relation descriptor
+        *      we wish to invalidate.
+        * ----------------
+        */
+       message = (InvalidationMessage)
+               InvalidationEntryAllocate(sizeof(InvalidationMessageData));
+
+       message->kind = 'r';
+       message->any.relation.relationId = relationId;
+       message->any.relation.objectId = objectId;
 
        /* ----------------
         *      Add message to linked list of unprocessed messages.
         * ----------------
         */
-       Invalid = LocalInvalidRegister(Invalid, (InvalidationEntry) message);
+       invalid = LocalInvalidRegister(invalid, (InvalidationEntry) message);
+       return invalid;
 }
 
 /* --------------------------------
@@ -212,6 +399,61 @@ CacheIdRegisterLocalInvalid(Index cacheId,
  */
 static void
 RelationIdRegisterLocalInvalid(Oid relationId, Oid objectId)
+{
+       /* ----------------
+        *      debugging stuff
+        * ----------------
+        */
+#ifdef INVALIDDEBUG
+       elog(DEBUG, "RelationRegisterLocalInvalid(%u, %u)", relationId,
+                objectId);
+#endif  /* defined(INVALIDDEBUG) */
+
+       /* ----------------
+        *      Add message to InvalidForall linked list.
+        * ----------------
+        */
+       InvalidForall = RelationIdRegisterSpecifiedLocalInvalid(InvalidForall,
+                               relationId, objectId);
+       /* ----------------
+        *      Add message to InvalidLocal linked list.
+        * ----------------
+        */
+       InvalidLocal = RelationIdRegisterSpecifiedLocalInvalid(InvalidLocal,
+                               relationId, objectId);
+}
+
+/* --------------------------------
+ *             RelationIdRegisterLocalRollback
+ * --------------------------------
+ */
+static void
+RelationIdRegisterLocalRollback(Oid relationId, Oid objectId)
+{
+
+       /* ----------------
+        *      debugging stuff
+        * ----------------
+        */
+#ifdef INVALIDDEBUG
+       elog(DEBUG, "RelationRegisterLocalRollback(%u, %u)", relationId,
+                objectId);
+#endif  /* defined(INVALIDDEBUG) */
+
+       /* ----------------
+        *      Add message to RollbackStack linked list.
+        * ----------------
+        */
+       RollbackStack = RelationIdRegisterSpecifiedLocalInvalid(
+                       RollbackStack, relationId, objectId);
+}
+
+/* --------------------------------
+ *             RelationIdImmediateRegisterSharedInvalid
+ * --------------------------------
+ */
+static void
+RelationIdImmediateRegisterSharedInvalid(Oid relationId, Oid objectId)
 {
        InvalidationMessage message;
 
@@ -220,7 +462,7 @@ RelationIdRegisterLocalInvalid(Oid relationId, Oid objectId)
         * ----------------
         */
 #ifdef INVALIDDEBUG
-       elog(DEBUG, "RelationRegisterLocalInvalid(%u, %u)", relationId,
+       elog(DEBUG, "RelationImmediateRegisterSharedInvalid(%u, %u)", relationId,
                 objectId);
 #endif  /* defined(INVALIDDEBUG) */
 
@@ -237,10 +479,11 @@ RelationIdRegisterLocalInvalid(Oid relationId, Oid objectId)
        message->any.relation.objectId = objectId;
 
        /* ----------------
-        *      Add message to linked list of unprocessed messages.
+        *      Register a shared catalog cache invalidation.
         * ----------------
         */
-       Invalid = LocalInvalidRegister(Invalid, (InvalidationEntry) message);
+       InvalidationMessageRegisterSharedInvalid(message);
+       free((Pointer) &((InvalidationUserData *) message)->dataP[-1]);
 }
 
 /* --------------------------------
@@ -397,7 +640,7 @@ InvalidationMessageCacheInvalidate(InvalidationMessage message)
                case 'c':                               /* cached system catalog tuple */
                        InvalidationMessageCacheInvalidate_DEBUG1;
 
-                       CatalogCacheIdInvalidate(message->any.catalog.cacheId,
+                       CacheIdInvalidate(message->any.catalog.cacheId,
                                                                         message->any.catalog.hashIndex,
                                                                         &message->any.catalog.pointerData);
                        break;
@@ -405,7 +648,9 @@ InvalidationMessageCacheInvalidate(InvalidationMessage message)
                case 'r':                               /* cached relation descriptor */
                        InvalidationMessageCacheInvalidate_DEBUG2;
 
-                       /* XXX ignore this--is this correct ??? */
+                       CacheIdInvalidate(message->any.relation.relationId,
+                                               message->any.relation.objectId,
+                                               (ItemPointer) NULL);
                        break;
 
                default:
@@ -500,38 +745,93 @@ RegisterInvalid(bool send)
         *      Process and free the current list of inval messages.
         * ----------------
         */
-       invalid = Invalid;
-       Invalid = EmptyLocalInvalid; /* anything added now is part of a new list */
 
+       DiscardInvalidStack(&InvalidLocal);
        if (send)
-               LocalInvalidInvalidate(invalid,
-                                                          InvalidationMessageRegisterSharedInvalid);
+       {
+               DiscardInvalidStack(&RollbackStack);
+               invalid = InvalidForall;
+               InvalidForall = EmptyLocalInvalid; /* clear InvalidForall */
+               LocalInvalidInvalidate(invalid, InvalidationMessageRegisterSharedInvalid, true);
+       }
        else
-               LocalInvalidInvalidate(invalid,
-                                                          InvalidationMessageCacheInvalidate);
+       {
+               DiscardInvalidStack(&InvalidForall);
+               invalid = RollbackStack;
+               RollbackStack = EmptyLocalInvalid; /* clear RollbackStack */
+               LocalInvalidInvalidate(invalid, InvalidationMessageCacheInvalidate, true);
+       }
 
 }
 
 /*
- * RelationIdInvalidateHeapTuple
- *             Causes the given tuple in a relation to be invalidated.
+ * ImmediateLocalInvalidation
+ *             Causes invalidation immediately for the next command of the transaction.
  *
  * Note:
+ *             This should be called in time of CommandCounterIncrement().
+ */
+void
+ImmediateLocalInvalidation(bool send)
+{
+       LocalInvalid invalid;
+
+       /* ----------------
+        *      debugging stuff
+        * ----------------
+        */
+#ifdef INVALIDDEBUG
+       elog(DEBUG, "ImmediateLocalInvalidation(%d) called", send);
+#endif  /* defined(INVALIDDEBUG) */
+
+       /* ----------------
+        *      Process and free the local list of inval messages.
+        * ----------------
+        */
+
+       if (send)
+       {
+               invalid = InvalidLocal;
+               InvalidLocal = EmptyLocalInvalid; /* clear InvalidLocal */
+               LocalInvalidInvalidate(invalid, InvalidationMessageCacheInvalidate, true);
+       }
+       else
+       {
+               /*
+                * This may be used for rollback to a savepoint.
+                * Don't clear InvalidForall and RollbackStack here.
+                */
+               DiscardInvalidStack(&InvalidLocal);
+               invalid = RollbackStack;
+               LocalInvalidInvalidate(invalid, InvalidationMessageCacheInvalidate, false);
+       }
+
+}
+
+/*
+ * InvokeHeapTupleInvalidation
+ *             Invoke functions for the tuple which register invalidation
+ *             of catalog/relation cache.  
+ *  Note:
  *             Assumes object id is valid.
  *             Assumes tuple is valid.
  */
 #ifdef INVALIDDEBUG
-#define RelationInvalidateHeapTuple_DEBUG1 \
-elog(DEBUG, "RelationInvalidateHeapTuple(%s, [%d,%d])", \
+#define InvokeHeapTupleInvalidation_DEBUG1 \
+elog(DEBUG, "%s(%s, [%d,%d])", \
+        funcname,\
         RelationGetPhysicalRelationName(relation), \
-        ItemPointerGetBlockNumber(&tuple->t_ctid), \
-        ItemPointerGetOffsetNumber(&tuple->t_ctid))
+        ItemPointerGetBlockNumber(&tuple->t_self), \
+        ItemPointerGetOffsetNumber(&tuple->t_self))
 #else
-#define RelationInvalidateHeapTuple_DEBUG1
+#define InvokeHeapTupleInvalidation_DEBUG1
 #endif  /* defined(INVALIDDEBUG) */
 
-void
-RelationInvalidateHeapTuple(Relation relation, HeapTuple tuple)
+static void
+InvokeHeapTupleInvalidation(Relation relation, HeapTuple tuple,
+               void (*CacheIdRegisterFunc)(),
+               void (*RelationIdRegisterFunc)(),
+               const char *funcname)
 {
        /* ----------------
         *      sanity checks
@@ -553,13 +853,88 @@ RelationInvalidateHeapTuple(Relation relation, HeapTuple tuple)
         *      debugging stuff
         * ----------------
         */
-       RelationInvalidateHeapTuple_DEBUG1;
+       InvokeHeapTupleInvalidation_DEBUG1;
+
+       RelationInvalidateCatalogCacheTuple(relation, tuple, 
+               CacheIdRegisterFunc);
 
-       RelationInvalidateCatalogCacheTuple(relation,
-                                                                               tuple,
-                                                                               CacheIdRegisterLocalInvalid);
+       RelationInvalidateRelationCache(relation, tuple,
+               RelationIdRegisterFunc);
+}
+ 
+/*
+ * RelationInvalidateHeapTuple
+ *             Causes the given tuple in a relation to be invalidated.
+ */
+void
+RelationInvalidateHeapTuple(Relation relation, HeapTuple tuple)
+{
+       InvokeHeapTupleInvalidation(relation, tuple, 
+               CacheIdRegisterLocalInvalid,
+               RelationIdRegisterLocalInvalid,
+               "RelationInvalidateHeapTuple");
+}
+
+/*
+ * RelationMark4RollbackHeapTuple
+ *             keep the given tuple in a relation to be invalidated
+ *             in case of abort.
+ */
+void
+RelationMark4RollbackHeapTuple(Relation relation, HeapTuple tuple)
+{
+       InvokeHeapTupleInvalidation(relation, tuple,
+               CacheIdRegisterLocalRollback,
+               RelationIdRegisterLocalRollback,
+               "RelationMark4RollbackHeapTuple");
+}
+
+/*
+ * ImmediateInvalidateSharedHeapTuple
+ *             Different from RelationInvalidateHeapTuple()
+ *             this function queues shared invalidation info immediately.
+ */
+void
+ImmediateInvalidateSharedHeapTuple(Relation relation, HeapTuple tuple)
+{
+       InvokeHeapTupleInvalidation(relation, tuple,
+               CacheIdImmediateRegisterSharedInvalid,
+               RelationIdImmediateRegisterSharedInvalid,
+               "ImmediateInvalidateSharedHeapTuple");
+}
+
+/*
+ * ImmediateSharedRelationCacheInvalidate
+ *     Register shared relation cache invalidation immediately
+ *
+ *     This is needed for smgrunlink()/smgrtruncate().
+ *     Those functions unlink/truncate the base file immediately
+ *     and couldn't be rollbacked in case of abort/crash.
+ *     So relation cache invalidation must be registerd immediately. 
+ *  Note:
+ *             Assumes Relation is valid.
+ */
+void
+ImmediateSharedRelationCacheInvalidate(Relation relation)
+{
+       /* ----------------
+        *      sanity checks
+        * ----------------
+        */
+       Assert(RelationIsValid(relation));
+
+       if (IsBootstrapProcessingMode())
+               return;
+
+       /* ----------------
+        *      debugging stuff
+        * ----------------
+        */
+#ifdef INVALIDDEBUG
+elog(DEBUG, "ImmediateSharedRelationCacheInvalidate(%s)", \
+        RelationGetPhysicalRelationName(relation));
+#endif  /* defined(INVALIDDEBUG) */
 
-       RelationInvalidateRelationCache(relation,
-                                                                       tuple,
-                                                                       RelationIdRegisterLocalInvalid);
+       RelationIdImmediateRegisterSharedInvalid(
+               RelOid_pg_class, RelationGetRelid(relation));
 }

diff --git a/src/include/utils/inval.h b/src/include/utils/inval.h
index a559c4374dc0be63515bc2d946c700e535cd2698..fb1adbc0c974ea47fbb5ff4a2309840d20fcfce8 100644 (file)
--- a/src/include/utils/inval.h
+++ b/src/include/utils/inval.h
@@ -6,7 +6,7 @@
  *
  * Copyright (c) 1994, Regents of the University of California
  *
- * $Id: inval.h,v 1.14 1999/11/21 01:58:20 tgl Exp $
+ * $Id: inval.h,v 1.15 2000/01/10 06:30:56 inoue Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -19,6 +19,14 @@ extern void DiscardInvalid(void);
 
 extern void RegisterInvalid(bool send);
 
+extern void ImmediateLocalInvalidation(bool send);
+
 extern void RelationInvalidateHeapTuple(Relation relation, HeapTuple tuple);
 
+extern void RelationMark4RollbackHeapTuple(Relation relation, HeapTuple tuple);
+
+extern void ImmediateInvalidateSharedHeapTuple(Relation relation, HeapTuple tuple);
+
+extern void ImmediateSharedRelationCacheInvalidate(Relation relation);
+
 #endif  /* INVAL_H */