Catcaches can now store negative entries as well as positive ones, to
speed up repetitive failed searches; per pghackers discussion in late January. inval.c logic substantially simplified, since we can now treat inserts and deletes alike as far as inval events are concerned. Some repair work needed in heap_create_with_catalog, which turns out to have been doing CommandCounterIncrement at a point where the new relation has non-self-consistent catalog entries. With the new inval code, that resulted in assert failures during a relcache entry rebuild.
This commit is contained in:
Tom Lane
parent
592caa0897
commit
26ac217173
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.130 2002/03/02 21:39:17 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.131 2002/03/03 17:47:53 tgl Exp $
|
||||
*
|
||||
*
|
||||
* INTERFACE ROUTINES
|
||||
|
|
@ -1131,12 +1131,12 @@ heap_insert(Relation relation, HeapTuple tup)
|
|||
WriteBuffer(buffer);
|
||||
|
||||
/*
|
||||
* If tuple is cachable, mark it for rollback from the caches in case
|
||||
* If tuple is cachable, mark it for invalidation from the caches in case
|
||||
* we abort. Note it is OK to do this after WriteBuffer releases the
|
||||
* buffer, because the "tup" data structure is all in local memory,
|
||||
* not in the shared buffer.
|
||||
*/
|
||||
RelationMark4RollbackHeapTuple(relation, tup);
|
||||
CacheInvalidateHeapTuple(relation, tup);
|
||||
|
||||
return tup->t_data->t_oid;
|
||||
}
|
||||
|
|
@ -1278,7 +1278,7 @@ l1:
|
|||
* look at the contents of the tuple, so we need to hold our refcount
|
||||
* on the buffer.
|
||||
*/
|
||||
RelationInvalidateHeapTuple(relation, &tp);
|
||||
CacheInvalidateHeapTuple(relation, &tp);
|
||||
|
||||
WriteBuffer(buffer);
|
||||
|
||||
|
|
@ -1585,19 +1585,19 @@ l2:
|
|||
* boundary. We have to do this before WriteBuffer because we need to
|
||||
* look at the contents of the tuple, so we need to hold our refcount.
|
||||
*/
|
||||
RelationInvalidateHeapTuple(relation, &oldtup);
|
||||
CacheInvalidateHeapTuple(relation, &oldtup);
|
||||
|
||||
if (newbuf != buffer)
|
||||
WriteBuffer(newbuf);
|
||||
WriteBuffer(buffer);
|
||||
|
||||
/*
|
||||
* If new tuple is cachable, mark it for rollback from the caches in
|
||||
* If new tuple is cachable, mark it for invalidation from the caches in
|
||||
* case we abort. Note it is OK to do this after WriteBuffer releases
|
||||
* the buffer, because the "newtup" data structure is all in local
|
||||
* memory, not in the shared buffer.
|
||||
*/
|
||||
RelationMark4RollbackHeapTuple(relation, newtup);
|
||||
CacheInvalidateHeapTuple(relation, newtup);
|
||||
|
||||
return HeapTupleMayBeUpdated;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.182 2002/02/19 20:11:11 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.183 2002/03/03 17:47:54 tgl Exp $
|
||||
*
|
||||
*
|
||||
* INTERFACE ROUTINES
|
||||
|
|
@ -57,6 +57,7 @@
|
|||
#include "storage/smgr.h"
|
||||
#include "utils/builtins.h"
|
||||
#include "utils/fmgroids.h"
|
||||
#include "utils/inval.h"
|
||||
#include "utils/lsyscache.h"
|
||||
#include "utils/relcache.h"
|
||||
#include "utils/syscache.h"
|
||||
|
|
@ -75,10 +76,10 @@ static void RelationRemoveIndexes(Relation relation);
|
|||
static void RelationRemoveInheritance(Relation relation);
|
||||
static void AddNewRelationType(char *typeName, Oid new_rel_oid,
|
||||
Oid new_type_oid);
|
||||
static void StoreAttrDefault(Relation rel, AttrNumber attnum, char *adbin,
|
||||
bool updatePgAttribute);
|
||||
static void StoreAttrDefault(Relation rel, AttrNumber attnum, char *adbin);
|
||||
static void StoreRelCheck(Relation rel, char *ccname, char *ccbin);
|
||||
static void StoreConstraints(Relation rel);
|
||||
static void StoreConstraints(Relation rel, TupleDesc tupdesc);
|
||||
static void SetRelationNumChecks(Relation rel, int numchecks);
|
||||
static void RemoveConstraints(Relation rel);
|
||||
static void RemoveStatistics(Relation rel);
|
||||
|
||||
|
|
@ -202,9 +203,6 @@ SystemAttributeByName(const char *attname, bool relhasoids)
|
|||
*
|
||||
* Remove the system relation specific code to elsewhere eventually.
|
||||
*
|
||||
* Eventually, must place information about this temporary relation
|
||||
* into the transaction context block.
|
||||
*
|
||||
* NOTE: if istemp is TRUE then heap_create will overwrite relname with
|
||||
* the unique "real" name chosen for the temp relation.
|
||||
*
|
||||
|
|
@ -799,9 +797,16 @@ heap_create_with_catalog(char *relname,
|
|||
* now add tuples to pg_attribute for the attributes in our new
|
||||
* relation.
|
||||
*/
|
||||
AddNewAttributeTuples(new_rel_oid, tupdesc, relhasoids);
|
||||
AddNewAttributeTuples(new_rel_oid, new_rel_desc->rd_att, relhasoids);
|
||||
|
||||
StoreConstraints(new_rel_desc);
|
||||
/*
|
||||
* store constraints and defaults passed in the tupdesc, if any.
|
||||
*
|
||||
* NB: this may do a CommandCounterIncrement and rebuild the relcache
|
||||
* entry, so the relation must be valid and self-consistent at this point.
|
||||
* In particular, there are not yet constraints and defaults anywhere.
|
||||
*/
|
||||
StoreConstraints(new_rel_desc, tupdesc);
|
||||
|
||||
/*
|
||||
* We create the disk file for this relation here
|
||||
|
|
@ -922,8 +927,6 @@ RelationRemoveIndexes(Relation relation)
|
|||
Oid indexoid = lfirsti(indexoidscan);
|
||||
|
||||
index_drop(indexoid);
|
||||
/* advance cmd counter to make catalog changes visible */
|
||||
CommandCounterIncrement();
|
||||
}
|
||||
|
||||
freeList(indexoidlist);
|
||||
|
|
@ -1377,12 +1380,9 @@ heap_drop_with_catalog(const char *relname,
|
|||
/*
|
||||
* Store a default expression for column attnum of relation rel.
|
||||
* The expression must be presented as a nodeToString() string.
|
||||
* If updatePgAttribute is true, update the pg_attribute entry
|
||||
* for the column to show that a default exists.
|
||||
*/
|
||||
static void
|
||||
StoreAttrDefault(Relation rel, AttrNumber attnum, char *adbin,
|
||||
bool updatePgAttribute)
|
||||
StoreAttrDefault(Relation rel, AttrNumber attnum, char *adbin)
|
||||
{
|
||||
Node *expr;
|
||||
char *adsrc;
|
||||
|
|
@ -1429,9 +1429,10 @@ StoreAttrDefault(Relation rel, AttrNumber attnum, char *adbin,
|
|||
heap_freetuple(tuple);
|
||||
pfree(adsrc);
|
||||
|
||||
if (!updatePgAttribute)
|
||||
return; /* done if pg_attribute is OK */
|
||||
|
||||
/*
|
||||
* Update the pg_attribute entry for the column to show that a default
|
||||
* exists.
|
||||
*/
|
||||
attrrel = heap_openr(AttributeRelationName, RowExclusiveLock);
|
||||
atttup = SearchSysCacheCopy(ATTNUM,
|
||||
ObjectIdGetDatum(RelationGetRelid(rel)),
|
||||
|
|
@ -1516,33 +1517,35 @@ StoreRelCheck(Relation rel, char *ccname, char *ccbin)
|
|||
* NOTE: only pre-cooked expressions will be passed this way, which is to
|
||||
* say expressions inherited from an existing relation. Newly parsed
|
||||
* expressions can be added later, by direct calls to StoreAttrDefault
|
||||
* and StoreRelCheck (see AddRelationRawConstraints()). We assume that
|
||||
* pg_attribute and pg_class entries for the relation were already set
|
||||
* to reflect the existence of these defaults/constraints.
|
||||
* and StoreRelCheck (see AddRelationRawConstraints()).
|
||||
*/
|
||||
static void
|
||||
StoreConstraints(Relation rel)
|
||||
StoreConstraints(Relation rel, TupleDesc tupdesc)
|
||||
{
|
||||
TupleConstr *constr = rel->rd_att->constr;
|
||||
TupleConstr *constr = tupdesc->constr;
|
||||
int i;
|
||||
|
||||
if (!constr)
|
||||
return;
|
||||
return; /* nothing to do */
|
||||
|
||||
/*
|
||||
* deparsing of constraint expressions will fail unless the
|
||||
* Deparsing of constraint expressions will fail unless the
|
||||
* just-created pg_attribute tuples for this relation are made
|
||||
* visible. So, bump the command counter.
|
||||
* visible. So, bump the command counter. CAUTION: this will
|
||||
* cause a relcache entry rebuild.
|
||||
*/
|
||||
CommandCounterIncrement();
|
||||
|
||||
for (i = 0; i < constr->num_defval; i++)
|
||||
StoreAttrDefault(rel, constr->defval[i].adnum,
|
||||
constr->defval[i].adbin, false);
|
||||
constr->defval[i].adbin);
|
||||
|
||||
for (i = 0; i < constr->num_check; i++)
|
||||
StoreRelCheck(rel, constr->check[i].ccname,
|
||||
constr->check[i].ccbin);
|
||||
|
||||
if (constr->num_check > 0)
|
||||
SetRelationNumChecks(rel, constr->num_check);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1580,10 +1583,6 @@ AddRelationRawConstraints(Relation rel,
|
|||
RangeTblEntry *rte;
|
||||
int numchecks;
|
||||
List *listptr;
|
||||
Relation relrel;
|
||||
Relation relidescs[Num_pg_class_indices];
|
||||
HeapTuple reltup;
|
||||
Form_pg_class relStruct;
|
||||
|
||||
/*
|
||||
* Get info about existing constraints.
|
||||
|
|
@ -1681,7 +1680,7 @@ AddRelationRawConstraints(Relation rel,
|
|||
/*
|
||||
* OK, store it.
|
||||
*/
|
||||
StoreAttrDefault(rel, colDef->attnum, nodeToString(expr), true);
|
||||
StoreAttrDefault(rel, colDef->attnum, nodeToString(expr));
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1839,9 +1838,29 @@ AddRelationRawConstraints(Relation rel,
|
|||
* We do this even if there was no change, in order to ensure that an
|
||||
* SI update message is sent out for the pg_class tuple, which will
|
||||
* force other backends to rebuild their relcache entries for the rel.
|
||||
* (Of course, for a newly created rel there is no need for an SI
|
||||
* message, but for ALTER TABLE ADD ATTRIBUTE this'd be important.)
|
||||
* (This is critical if we added defaults but not constraints.)
|
||||
*/
|
||||
SetRelationNumChecks(rel, numchecks);
|
||||
}
|
||||
|
||||
/*
|
||||
* Update the count of constraints in the relation's pg_class tuple.
|
||||
*
|
||||
* Caller had better hold exclusive lock on the relation.
|
||||
*
|
||||
* An important side effect is that a SI update message will be sent out for
|
||||
* the pg_class tuple, which will force other backends to rebuild their
|
||||
* relcache entries for the rel. Also, this backend will rebuild its
|
||||
* own relcache entry at the next CommandCounterIncrement.
|
||||
*/
|
||||
static void
|
||||
SetRelationNumChecks(Relation rel, int numchecks)
|
||||
{
|
||||
Relation relrel;
|
||||
HeapTuple reltup;
|
||||
Form_pg_class relStruct;
|
||||
Relation relidescs[Num_pg_class_indices];
|
||||
|
||||
relrel = heap_openr(RelationRelationName, RowExclusiveLock);
|
||||
reltup = SearchSysCacheCopy(RELOID,
|
||||
ObjectIdGetDatum(RelationGetRelid(rel)),
|
||||
|
|
@ -1851,22 +1870,30 @@ AddRelationRawConstraints(Relation rel,
|
|||
RelationGetRelid(rel));
|
||||
relStruct = (Form_pg_class) GETSTRUCT(reltup);
|
||||
|
||||
relStruct->relchecks = numchecks;
|
||||
if (relStruct->relchecks != numchecks)
|
||||
{
|
||||
relStruct->relchecks = numchecks;
|
||||
|
||||
simple_heap_update(relrel, &reltup->t_self, reltup);
|
||||
simple_heap_update(relrel, &reltup->t_self, reltup);
|
||||
|
||||
/* keep catalog indices current */
|
||||
CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices,
|
||||
relidescs);
|
||||
CatalogIndexInsert(relidescs, Num_pg_class_indices, relrel, reltup);
|
||||
CatalogCloseIndices(Num_pg_class_indices, relidescs);
|
||||
/* keep catalog indices current */
|
||||
CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices,
|
||||
relidescs);
|
||||
CatalogIndexInsert(relidescs, Num_pg_class_indices, relrel, reltup);
|
||||
CatalogCloseIndices(Num_pg_class_indices, relidescs);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Skip the disk update, but force relcache inval anyway */
|
||||
CacheInvalidateRelcache(RelationGetRelid(rel));
|
||||
}
|
||||
|
||||
heap_freetuple(reltup);
|
||||
heap_close(relrel, RowExclusiveLock);
|
||||
}
|
||||
|
||||
static void
|
||||
RemoveAttrDefault(Relation rel)
|
||||
RemoveAttrDefaults(Relation rel)
|
||||
{
|
||||
Relation adrel;
|
||||
HeapScanDesc adscan;
|
||||
|
|
@ -1889,7 +1916,7 @@ RemoveAttrDefault(Relation rel)
|
|||
}
|
||||
|
||||
static void
|
||||
RemoveRelCheck(Relation rel)
|
||||
RemoveRelChecks(Relation rel)
|
||||
{
|
||||
Relation rcrel;
|
||||
HeapScanDesc rcscan;
|
||||
|
|
@ -1923,9 +1950,6 @@ RemoveCheckConstraint(Relation rel, const char *constrName, bool inh)
|
|||
{
|
||||
Oid relid;
|
||||
Relation rcrel;
|
||||
Relation relrel;
|
||||
Relation inhrel;
|
||||
Relation relidescs[Num_pg_class_indices];
|
||||
TupleDesc tupleDesc;
|
||||
TupleConstr *oldconstr;
|
||||
int numoldchecks;
|
||||
|
|
@ -1933,8 +1957,6 @@ RemoveCheckConstraint(Relation rel, const char *constrName, bool inh)
|
|||
HeapScanDesc rcscan;
|
||||
ScanKeyData key[2];
|
||||
HeapTuple rctup;
|
||||
HeapTuple reltup;
|
||||
Form_pg_class relStruct;
|
||||
int rel_deleted = 0;
|
||||
int all_deleted = 0;
|
||||
|
||||
|
|
@ -1960,6 +1982,7 @@ RemoveCheckConstraint(Relation rel, const char *constrName, bool inh)
|
|||
foreach(child, children)
|
||||
{
|
||||
Oid childrelid = lfirsti(child);
|
||||
Relation inhrel;
|
||||
|
||||
if (childrelid == relid)
|
||||
continue;
|
||||
|
|
@ -1969,7 +1992,17 @@ RemoveCheckConstraint(Relation rel, const char *constrName, bool inh)
|
|||
}
|
||||
}
|
||||
|
||||
/* Grab an exclusive lock on the pg_relcheck relation */
|
||||
/*
|
||||
* Get number of existing constraints.
|
||||
*/
|
||||
tupleDesc = RelationGetDescr(rel);
|
||||
oldconstr = tupleDesc->constr;
|
||||
if (oldconstr)
|
||||
numoldchecks = oldconstr->num_check;
|
||||
else
|
||||
numoldchecks = 0;
|
||||
|
||||
/* Grab an appropriate lock on the pg_relcheck relation */
|
||||
rcrel = heap_openr(RelCheckRelationName, RowExclusiveLock);
|
||||
|
||||
/*
|
||||
|
|
@ -2002,60 +2035,21 @@ RemoveCheckConstraint(Relation rel, const char *constrName, bool inh)
|
|||
|
||||
/* Clean up after the scan */
|
||||
heap_endscan(rcscan);
|
||||
|
||||
/*
|
||||
* Update the count of constraints in the relation's pg_class tuple.
|
||||
* We do this even if there was no change, in order to ensure that an
|
||||
* SI update message is sent out for the pg_class tuple, which will
|
||||
* force other backends to rebuild their relcache entries for the rel.
|
||||
* (Of course, for a newly created rel there is no need for an SI
|
||||
* message, but for ALTER TABLE ADD ATTRIBUTE this'd be important.)
|
||||
*/
|
||||
|
||||
/*
|
||||
* Get number of existing constraints.
|
||||
*/
|
||||
|
||||
tupleDesc = RelationGetDescr(rel);
|
||||
oldconstr = tupleDesc->constr;
|
||||
if (oldconstr)
|
||||
numoldchecks = oldconstr->num_check;
|
||||
else
|
||||
numoldchecks = 0;
|
||||
|
||||
/* Calculate the new number of checks in the table, fail if negative */
|
||||
numchecks = numoldchecks - rel_deleted;
|
||||
|
||||
if (numchecks < 0)
|
||||
elog(ERROR, "check count became negative");
|
||||
|
||||
relrel = heap_openr(RelationRelationName, RowExclusiveLock);
|
||||
reltup = SearchSysCacheCopy(RELOID,
|
||||
ObjectIdGetDatum(RelationGetRelid(rel)), 0, 0, 0);
|
||||
|
||||
if (!HeapTupleIsValid(reltup))
|
||||
elog(ERROR, "cache lookup of relation %u failed",
|
||||
RelationGetRelid(rel));
|
||||
relStruct = (Form_pg_class) GETSTRUCT(reltup);
|
||||
|
||||
relStruct->relchecks = numchecks;
|
||||
|
||||
simple_heap_update(relrel, &reltup->t_self, reltup);
|
||||
|
||||
/* Keep catalog indices current */
|
||||
CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices,
|
||||
relidescs);
|
||||
CatalogIndexInsert(relidescs, Num_pg_class_indices, relrel, reltup);
|
||||
CatalogCloseIndices(Num_pg_class_indices, relidescs);
|
||||
|
||||
/* Clean up after the scan */
|
||||
heap_freetuple(reltup);
|
||||
heap_close(relrel, RowExclusiveLock);
|
||||
|
||||
/* Close the heap relation */
|
||||
heap_close(rcrel, RowExclusiveLock);
|
||||
|
||||
/* Return the number of tuples deleted */
|
||||
if (rel_deleted)
|
||||
{
|
||||
/*
|
||||
* Update the count of constraints in the relation's pg_class tuple.
|
||||
*/
|
||||
numchecks = numoldchecks - rel_deleted;
|
||||
if (numchecks < 0)
|
||||
elog(ERROR, "check count became negative");
|
||||
|
||||
SetRelationNumChecks(rel, numchecks);
|
||||
}
|
||||
|
||||
/* Return the number of tuples deleted, including all children */
|
||||
return all_deleted;
|
||||
}
|
||||
|
||||
|
|
@ -2068,10 +2062,10 @@ RemoveConstraints(Relation rel)
|
|||
return;
|
||||
|
||||
if (constr->num_defval > 0)
|
||||
RemoveAttrDefault(rel);
|
||||
RemoveAttrDefaults(rel);
|
||||
|
||||
if (constr->num_check > 0)
|
||||
RemoveRelCheck(rel);
|
||||
RemoveRelChecks(rel);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.172 2002/02/19 20:11:11 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.173 2002/03/03 17:47:54 tgl Exp $
|
||||
*
|
||||
*
|
||||
* INTERFACE ROUTINES
|
||||
|
|
@ -800,19 +800,6 @@ index_drop(Oid indexId)
|
|||
simple_heap_delete(relationRelation, &tuple->t_self);
|
||||
heap_freetuple(tuple);
|
||||
|
||||
/*
|
||||
* Update the pg_class tuple for the owning relation. We are
|
||||
* presently too lazy to attempt to compute the new correct value of
|
||||
* relhasindex (the next VACUUM will fix it if necessary). But we
|
||||
* must send out a shared-cache-inval notice on the owning relation to
|
||||
* ensure other backends update their relcache lists of indexes. So,
|
||||
* unconditionally do setRelhasindex(true).
|
||||
*
|
||||
* Possible future improvement: skip the physical tuple update and just
|
||||
* send out an invalidation message.
|
||||
*/
|
||||
setRelhasindex(heapId, true, false, InvalidOid);
|
||||
|
||||
heap_close(relationRelation, RowExclusiveLock);
|
||||
|
||||
/*
|
||||
|
|
@ -858,6 +845,15 @@ index_drop(Oid indexId)
|
|||
|
||||
smgrunlink(DEFAULT_SMGR, userIndexRelation);
|
||||
|
||||
/*
|
||||
* We are presently too lazy to attempt to compute the new correct value
|
||||
* of relhasindex (the next VACUUM will fix it if necessary). So there is
|
||||
* no need to update the pg_class tuple for the owning relation.
|
||||
* But we must send out a shared-cache-inval notice on the owning relation
|
||||
* to ensure other backends update their relcache lists of indexes.
|
||||
*/
|
||||
CacheInvalidateRelcache(heapId);
|
||||
|
||||
/*
|
||||
* Close rels, but keep locks
|
||||
*/
|
||||
|
|
@ -1076,7 +1072,7 @@ LockClassinfoForUpdate(Oid relid, HeapTuple rtup,
|
|||
}
|
||||
break;
|
||||
}
|
||||
RelationInvalidateHeapTuple(relationRelation, rtup);
|
||||
CacheInvalidateHeapTuple(relationRelation, rtup);
|
||||
if (confirmCommitted)
|
||||
{
|
||||
HeapTupleHeader th = rtup->t_data;
|
||||
|
|
@ -1137,10 +1133,8 @@ IndexesAreActive(Oid relid, bool confirmCommitted)
|
|||
*
|
||||
* NOTE: an important side-effect of this operation is that an SI invalidation
|
||||
* message is sent out to all backends --- including me --- causing relcache
|
||||
* entries to be flushed or updated with the new hasindex data.
|
||||
* Therefore, we execute the update even if relhasindex has the right value
|
||||
* already. Possible future improvement: skip the disk update and just send
|
||||
* an SI message in that case.
|
||||
* entries to be flushed or updated with the new hasindex data. This must
|
||||
* happen even if we find that no change is needed in the pg_class row.
|
||||
* ----------------
|
||||
*/
|
||||
void
|
||||
|
|
@ -1149,6 +1143,7 @@ setRelhasindex(Oid relid, bool hasindex, bool isprimary, Oid reltoastidxid)
|
|||
Relation pg_class;
|
||||
HeapTuple tuple;
|
||||
Form_pg_class classtuple;
|
||||
bool dirty = false;
|
||||
HeapScanDesc pg_class_scan = NULL;
|
||||
|
||||
/*
|
||||
|
|
@ -1192,13 +1187,28 @@ setRelhasindex(Oid relid, bool hasindex, bool isprimary, Oid reltoastidxid)
|
|||
LockBuffer(pg_class_scan->rs_cbuf, BUFFER_LOCK_EXCLUSIVE);
|
||||
|
||||
classtuple = (Form_pg_class) GETSTRUCT(tuple);
|
||||
classtuple->relhasindex = hasindex;
|
||||
|
||||
if (classtuple->relhasindex != hasindex)
|
||||
{
|
||||
classtuple->relhasindex = hasindex;
|
||||
dirty = true;
|
||||
}
|
||||
if (isprimary)
|
||||
classtuple->relhaspkey = true;
|
||||
{
|
||||
if (!classtuple->relhaspkey)
|
||||
{
|
||||
classtuple->relhaspkey = true;
|
||||
dirty = true;
|
||||
}
|
||||
}
|
||||
if (OidIsValid(reltoastidxid))
|
||||
{
|
||||
Assert(classtuple->relkind == RELKIND_TOASTVALUE);
|
||||
classtuple->reltoastidxid = reltoastidxid;
|
||||
if (classtuple->reltoastidxid != reltoastidxid)
|
||||
{
|
||||
classtuple->reltoastidxid = reltoastidxid;
|
||||
dirty = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (pg_class_scan)
|
||||
|
|
@ -1210,10 +1220,10 @@ setRelhasindex(Oid relid, bool hasindex, bool isprimary, Oid reltoastidxid)
|
|||
WriteNoReleaseBuffer(pg_class_scan->rs_cbuf);
|
||||
/* Send out shared cache inval if necessary */
|
||||
if (!IsBootstrapProcessingMode())
|
||||
RelationInvalidateHeapTuple(pg_class, tuple);
|
||||
CacheInvalidateHeapTuple(pg_class, tuple);
|
||||
BufferSync();
|
||||
}
|
||||
else
|
||||
else if (dirty)
|
||||
{
|
||||
simple_heap_update(pg_class, &tuple->t_self, tuple);
|
||||
|
||||
|
|
@ -1228,6 +1238,11 @@ setRelhasindex(Oid relid, bool hasindex, bool isprimary, Oid reltoastidxid)
|
|||
CatalogCloseIndices(Num_pg_class_indices, idescs);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* no need to change tuple, but force relcache rebuild anyway */
|
||||
CacheInvalidateRelcache(relid);
|
||||
}
|
||||
|
||||
if (!pg_class_scan)
|
||||
heap_freetuple(tuple);
|
||||
|
|
@ -1280,7 +1295,7 @@ setNewRelfilenode(Relation relation)
|
|||
classTuple = &lockTupleData;
|
||||
/* Send out shared cache inval if necessary */
|
||||
if (!IsBootstrapProcessingMode())
|
||||
RelationInvalidateHeapTuple(pg_class, classTuple);
|
||||
CacheInvalidateHeapTuple(pg_class, classTuple);
|
||||
/* Update the buffer in-place */
|
||||
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
|
||||
((Form_pg_class) GETSTRUCT(classTuple))->relfilenode = newrelfilenode;
|
||||
|
|
@ -1442,7 +1457,7 @@ UpdateStats(Oid relid, double reltuples)
|
|||
LockBuffer(pg_class_scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
|
||||
WriteNoReleaseBuffer(pg_class_scan->rs_cbuf);
|
||||
if (!IsBootstrapProcessingMode())
|
||||
RelationInvalidateHeapTuple(pg_class, tuple);
|
||||
CacheInvalidateHeapTuple(pg_class, tuple);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.215 2002/03/02 21:39:23 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.216 2002/03/03 17:47:54 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -527,7 +527,7 @@ vac_update_relstats(Oid relid, BlockNumber num_pages, double num_tuples,
|
|||
* no flush will occur, but no great harm is done since there are no
|
||||
* noncritical state updates here.)
|
||||
*/
|
||||
RelationInvalidateHeapTuple(rd, &rtup);
|
||||
CacheInvalidateHeapTuple(rd, &rtup);
|
||||
|
||||
/* Write the buffer */
|
||||
WriteBuffer(buffer);
|
||||
|
|
@ -583,7 +583,7 @@ vac_update_dbstats(Oid dbid,
|
|||
dbform->datfrozenxid = frozenXID;
|
||||
|
||||
/* invalidate the tuple in the cache and write the buffer */
|
||||
RelationInvalidateHeapTuple(relation, tuple);
|
||||
CacheInvalidateHeapTuple(relation, tuple);
|
||||
WriteNoReleaseBuffer(scan->rs_cbuf);
|
||||
|
||||
heap_endscan(scan);
|
||||
|
|
@ -1796,7 +1796,10 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
|
|||
*/
|
||||
heap_copytuple_with_tuple(&tuple, &newtup);
|
||||
|
||||
RelationInvalidateHeapTuple(onerel, &tuple);
|
||||
/*
|
||||
* register invalidation of source tuple in catcaches.
|
||||
*/
|
||||
CacheInvalidateHeapTuple(onerel, &tuple);
|
||||
|
||||
/* NO ELOG(ERROR) TILL CHANGES ARE LOGGED */
|
||||
START_CRIT_SECTION();
|
||||
|
|
@ -1953,7 +1956,15 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
|
|||
/* copy tuple */
|
||||
heap_copytuple_with_tuple(&tuple, &newtup);
|
||||
|
||||
RelationInvalidateHeapTuple(onerel, &tuple);
|
||||
/*
|
||||
* register invalidation of source tuple in catcaches.
|
||||
*
|
||||
* (Note: we do not need to register the copied tuple,
|
||||
* because we are not changing the tuple contents and
|
||||
* so there cannot be any need to flush negative
|
||||
* catcache entries.)
|
||||
*/
|
||||
CacheInvalidateHeapTuple(onerel, &tuple);
|
||||
|
||||
/* NO ELOG(ERROR) TILL CHANGES ARE LOGGED */
|
||||
START_CRIT_SECTION();
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -5,26 +5,38 @@
|
|||
*
|
||||
* This is subtle stuff, so pay attention:
|
||||
*
|
||||
* When a tuple is updated or deleted, our time qualification rules consider
|
||||
* that it is *still valid* so long as we are in the same command, ie,
|
||||
* until the next CommandCounterIncrement() or transaction commit.
|
||||
* (See utils/time/tqual.c.) At the command boundary, the old tuple stops
|
||||
* When a tuple is updated or deleted, our standard time qualification rules
|
||||
* consider that it is *still valid* so long as we are in the same command,
|
||||
* ie, until the next CommandCounterIncrement() or transaction commit.
|
||||
* (See utils/time/tqual.c, and note that system catalogs are generally
|
||||
* scanned under SnapshotNow rules by the system, or plain user snapshots
|
||||
* for user queries.) At the command boundary, the old tuple stops
|
||||
* being valid and the new version, if any, becomes valid. Therefore,
|
||||
* we cannot simply flush a tuple from the system caches during heap_update()
|
||||
* or heap_delete(). The tuple is still good at that point; what's more,
|
||||
* even if we did flush it, it might be reloaded into the caches by a later
|
||||
* request in the same command. So the correct behavior is to keep a list
|
||||
* of outdated (updated/deleted) tuples and then do the required cache
|
||||
* flushes at the next command boundary. Similarly, we need a list of
|
||||
* inserted tuples (including new versions of updated tuples), which we will
|
||||
* use to flush those tuples out of the caches if we abort the transaction.
|
||||
* Notice that the first list lives only till command boundary, whereas the
|
||||
* second lives till end of transaction. Finally, we need a third list of
|
||||
* all tuples outdated in the current transaction; if we commit, we send
|
||||
* those invalidation events to all other backends (via the SI message queue)
|
||||
* so that they can flush obsolete entries from their caches. This list
|
||||
* definitely can't be processed until after we commit, otherwise the other
|
||||
* backends won't see our updated tuples as good.
|
||||
* flushes at the next command boundary. We must also keep track of
|
||||
* inserted tuples so that we can flush "negative" cache entries that match
|
||||
* the new tuples; again, that mustn't happen until end of command.
|
||||
*
|
||||
* Once we have finished the command, we still need to remember inserted
|
||||
* tuples (including new versions of updated tuples), so that we can flush
|
||||
* them from the caches if we abort the transaction. Similarly, we'd better
|
||||
* be able to flush "negative" cache entries that may have been loaded in
|
||||
* place of deleted tuples, so we still need the deleted ones too.
|
||||
*
|
||||
* If we successfully complete the transaction, we have to broadcast all
|
||||
* these invalidation events to other backends (via the SI message queue)
|
||||
* so that they can flush obsolete entries from their caches. Note we have
|
||||
* to record the transaction commit before sending SI messages, otherwise
|
||||
* the other backends won't see our updated tuples as good.
|
||||
*
|
||||
* In short, we need to remember until xact end every insert or delete
|
||||
* of a tuple that might be in the system caches. Updates are treated as
|
||||
* two events, delete + insert, for simplicity. (There are cases where
|
||||
* it'd be possible to record just one event, but we don't currently try.)
|
||||
*
|
||||
* We do not need to register EVERY tuple operation in this way, just those
|
||||
* on tuples in relations that have associated catcaches. We do, however,
|
||||
|
|
@ -62,7 +74,7 @@
|
|||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/cache/inval.c,v 1.48 2002/02/19 20:11:17 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/cache/inval.c,v 1.49 2002/03/03 17:47:55 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -99,34 +111,27 @@ typedef struct InvalidationListHeader
|
|||
|
||||
/*
|
||||
* ----------------
|
||||
* Invalidation info is divided into three parts.
|
||||
* 1) shared invalidation to be sent to all backends at commit
|
||||
* 2) local invalidation for the transaction itself (actually, just
|
||||
* for the current command within the transaction)
|
||||
* 3) rollback information for the transaction itself (in case we abort)
|
||||
* Invalidation info is divided into two lists:
|
||||
* 1) events so far in current command, not yet reflected to caches.
|
||||
* 2) events in previous commands of current transaction; these have
|
||||
* been reflected to local caches, and must be either broadcast to
|
||||
* other backends or rolled back from local cache when we commit
|
||||
* or abort the transaction.
|
||||
*
|
||||
* The relcache-file-invalidated flag can just be a simple boolean,
|
||||
* since we only act on it at transaction commit; we don't care which
|
||||
* command of the transaction set it.
|
||||
* ----------------
|
||||
*/
|
||||
|
||||
/*
|
||||
* head of invalidation message list for all backends
|
||||
* eaten by AtCommit_Cache() in CommitTransaction()
|
||||
*/
|
||||
static InvalidationListHeader GlobalInvalidMsgs;
|
||||
/* head of current-command event list */
|
||||
static InvalidationListHeader CurrentCmdInvalidMsgs;
|
||||
|
||||
/* head of previous-commands event list */
|
||||
static InvalidationListHeader PriorCmdInvalidMsgs;
|
||||
|
||||
static bool RelcacheInitFileInval; /* init file must be invalidated? */
|
||||
|
||||
/*
|
||||
* head of invalidation message list for the current command
|
||||
* eaten by AtCommit_LocalCache() in CommandCounterIncrement()
|
||||
*/
|
||||
static InvalidationListHeader LocalInvalidMsgs;
|
||||
|
||||
/*
|
||||
* head of rollback message list for abort-time processing
|
||||
* eaten by AtAbort_Cache() in AbortTransaction()
|
||||
*/
|
||||
static InvalidationListHeader RollbackMsgs;
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* Invalidation list support functions
|
||||
|
|
@ -204,6 +209,29 @@ FreeInvalidationMessageList(InvalidationChunk **listHdr)
|
|||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Append one list of invalidation message chunks to another, resetting
|
||||
* the source chunk-list pointer to NULL.
|
||||
*/
|
||||
static void
|
||||
AppendInvalidationMessageList(InvalidationChunk **destHdr,
|
||||
InvalidationChunk **srcHdr)
|
||||
{
|
||||
InvalidationChunk *chunk = *srcHdr;
|
||||
|
||||
if (chunk == NULL)
|
||||
return; /* nothing to do */
|
||||
|
||||
while (chunk->next != NULL)
|
||||
chunk = chunk->next;
|
||||
|
||||
chunk->next = *destHdr;
|
||||
|
||||
*destHdr = *srcHdr;
|
||||
|
||||
*srcHdr = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Process a list of invalidation messages.
|
||||
*
|
||||
|
|
@ -238,15 +266,15 @@ FreeInvalidationMessageList(InvalidationChunk **listHdr)
|
|||
*/
|
||||
static void
|
||||
AddCatcacheInvalidationMessage(InvalidationListHeader *hdr,
|
||||
int id, Index hashIndex,
|
||||
int id, uint32 hashValue,
|
||||
ItemPointer tuplePtr, Oid dbId)
|
||||
{
|
||||
SharedInvalidationMessage msg;
|
||||
|
||||
msg.cc.id = (int16) id;
|
||||
msg.cc.hashIndex = (uint16) hashIndex;
|
||||
msg.cc.dbId = dbId;
|
||||
msg.cc.tuplePtr = *tuplePtr;
|
||||
msg.cc.dbId = dbId;
|
||||
msg.cc.hashValue = hashValue;
|
||||
AddInvalidationMessage(&hdr->cclist, &msg);
|
||||
}
|
||||
|
||||
|
|
@ -271,6 +299,18 @@ AddRelcacheInvalidationMessage(InvalidationListHeader *hdr,
|
|||
AddInvalidationMessage(&hdr->rclist, &msg);
|
||||
}
|
||||
|
||||
/*
|
||||
* Append one list of invalidation messages to another, resetting
|
||||
* the source list to empty.
|
||||
*/
|
||||
static void
|
||||
AppendInvalidationMessages(InvalidationListHeader *dest,
|
||||
InvalidationListHeader *src)
|
||||
{
|
||||
AppendInvalidationMessageList(&dest->cclist, &src->cclist);
|
||||
AppendInvalidationMessageList(&dest->rclist, &src->rclist);
|
||||
}
|
||||
|
||||
/*
|
||||
* Reset an invalidation list to empty
|
||||
*
|
||||
|
|
@ -318,21 +358,16 @@ ProcessInvalidationMessages(InvalidationListHeader *hdr,
|
|||
/*
|
||||
* RegisterCatcacheInvalidation
|
||||
*
|
||||
* Register an invalidation event for an updated/deleted catcache entry.
|
||||
* We insert the event into both GlobalInvalidMsgs (for transmission
|
||||
* to other backends at transaction commit) and LocalInvalidMsgs (for
|
||||
* my local invalidation at end of command within xact).
|
||||
* Register an invalidation event for a catcache tuple entry.
|
||||
*/
|
||||
static void
|
||||
RegisterCatcacheInvalidation(int cacheId,
|
||||
Index hashIndex,
|
||||
uint32 hashValue,
|
||||
ItemPointer tuplePtr,
|
||||
Oid dbId)
|
||||
{
|
||||
AddCatcacheInvalidationMessage(&GlobalInvalidMsgs,
|
||||
cacheId, hashIndex, tuplePtr, dbId);
|
||||
AddCatcacheInvalidationMessage(&LocalInvalidMsgs,
|
||||
cacheId, hashIndex, tuplePtr, dbId);
|
||||
AddCatcacheInvalidationMessage(&CurrentCmdInvalidMsgs,
|
||||
cacheId, hashValue, tuplePtr, dbId);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -343,11 +378,8 @@ RegisterCatcacheInvalidation(int cacheId,
|
|||
static void
|
||||
RegisterRelcacheInvalidation(Oid dbId, Oid relId)
|
||||
{
|
||||
AddRelcacheInvalidationMessage(&GlobalInvalidMsgs,
|
||||
AddRelcacheInvalidationMessage(&CurrentCmdInvalidMsgs,
|
||||
dbId, relId);
|
||||
AddRelcacheInvalidationMessage(&LocalInvalidMsgs,
|
||||
dbId, relId);
|
||||
|
||||
/*
|
||||
* If the relation being invalidated is one of those cached in the
|
||||
* relcache init file, mark that we need to zap that file at commit.
|
||||
|
|
@ -356,34 +388,6 @@ RegisterRelcacheInvalidation(Oid dbId, Oid relId)
|
|||
RelcacheInitFileInval = true;
|
||||
}
|
||||
|
||||
/*
|
||||
* RegisterCatcacheRollback
|
||||
*
|
||||
* Register an invalidation event for an inserted catcache entry.
|
||||
* This only needs to be flushed out of my local catcache, if I abort.
|
||||
*/
|
||||
static void
|
||||
RegisterCatcacheRollback(int cacheId,
|
||||
Index hashIndex,
|
||||
ItemPointer tuplePtr,
|
||||
Oid dbId)
|
||||
{
|
||||
AddCatcacheInvalidationMessage(&RollbackMsgs,
|
||||
cacheId, hashIndex, tuplePtr, dbId);
|
||||
}
|
||||
|
||||
/*
|
||||
* RegisterRelcacheRollback
|
||||
*
|
||||
* As above, but register a relcache invalidation event.
|
||||
*/
|
||||
static void
|
||||
RegisterRelcacheRollback(Oid dbId, Oid relId)
|
||||
{
|
||||
AddRelcacheInvalidationMessage(&RollbackMsgs,
|
||||
dbId, relId);
|
||||
}
|
||||
|
||||
/*
|
||||
* LocalExecuteInvalidationMessage
|
||||
*
|
||||
|
|
@ -398,7 +402,7 @@ LocalExecuteInvalidationMessage(SharedInvalidationMessage *msg)
|
|||
{
|
||||
if (msg->cc.dbId == MyDatabaseId || msg->cc.dbId == 0)
|
||||
CatalogCacheIdInvalidate(msg->cc.id,
|
||||
msg->cc.hashIndex,
|
||||
msg->cc.hashValue,
|
||||
&msg->cc.tuplePtr);
|
||||
}
|
||||
else if (msg->id == SHAREDINVALRELCACHE_ID)
|
||||
|
|
@ -438,7 +442,7 @@ InvalidateSystemCaches(void)
|
|||
*/
|
||||
static void
|
||||
PrepareForTupleInvalidation(Relation relation, HeapTuple tuple,
|
||||
void (*CacheIdRegisterFunc) (int, Index,
|
||||
void (*CacheIdRegisterFunc) (int, uint32,
|
||||
ItemPointer, Oid),
|
||||
void (*RelationIdRegisterFunc) (Oid, Oid))
|
||||
{
|
||||
|
|
@ -517,16 +521,18 @@ AcceptInvalidationMessages(void)
|
|||
* AtEOXactInvalidationMessages
|
||||
* Process queued-up invalidation messages at end of transaction.
|
||||
*
|
||||
* If isCommit, we must send out the messages in our GlobalInvalidMsgs list
|
||||
* If isCommit, we must send out the messages in our PriorCmdInvalidMsgs list
|
||||
* to the shared invalidation message queue. Note that these will be read
|
||||
* not only by other backends, but also by our own backend at the next
|
||||
* transaction start (via AcceptInvalidationMessages). Therefore, it's okay
|
||||
* to discard any pending LocalInvalidMsgs, since these will be redundant
|
||||
* with the global list.
|
||||
* transaction start (via AcceptInvalidationMessages). This means that
|
||||
* we can skip immediate local processing of anything that's still in
|
||||
* CurrentCmdInvalidMsgs, and just send that list out too.
|
||||
*
|
||||
* If not isCommit, we are aborting, and must locally process the messages
|
||||
* in our RollbackMsgs list. No messages need be sent to other backends,
|
||||
* since they'll not have seen our changed tuples anyway.
|
||||
* in PriorCmdInvalidMsgs. No messages need be sent to other backends,
|
||||
* since they'll not have seen our changed tuples anyway. We can forget
|
||||
* about CurrentCmdInvalidMsgs too, since those changes haven't touched
|
||||
* the caches yet.
|
||||
*
|
||||
* In any case, reset the various lists to empty. We need not physically
|
||||
* free memory here, since TopTransactionContext is about to be emptied
|
||||
|
|
@ -548,7 +554,10 @@ AtEOXactInvalidationMessages(bool isCommit)
|
|||
if (RelcacheInitFileInval)
|
||||
RelationCacheInitFileInvalidate(true);
|
||||
|
||||
ProcessInvalidationMessages(&GlobalInvalidMsgs,
|
||||
AppendInvalidationMessages(&PriorCmdInvalidMsgs,
|
||||
&CurrentCmdInvalidMsgs);
|
||||
|
||||
ProcessInvalidationMessages(&PriorCmdInvalidMsgs,
|
||||
SendSharedInvalidMessage);
|
||||
|
||||
if (RelcacheInitFileInval)
|
||||
|
|
@ -556,15 +565,14 @@ AtEOXactInvalidationMessages(bool isCommit)
|
|||
}
|
||||
else
|
||||
{
|
||||
ProcessInvalidationMessages(&RollbackMsgs,
|
||||
ProcessInvalidationMessages(&PriorCmdInvalidMsgs,
|
||||
LocalExecuteInvalidationMessage);
|
||||
}
|
||||
|
||||
RelcacheInitFileInval = false;
|
||||
|
||||
DiscardInvalidationMessages(&GlobalInvalidMsgs, false);
|
||||
DiscardInvalidationMessages(&LocalInvalidMsgs, false);
|
||||
DiscardInvalidationMessages(&RollbackMsgs, false);
|
||||
DiscardInvalidationMessages(&PriorCmdInvalidMsgs, false);
|
||||
DiscardInvalidationMessages(&CurrentCmdInvalidMsgs, false);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -573,13 +581,13 @@ AtEOXactInvalidationMessages(bool isCommit)
|
|||
* in a transaction.
|
||||
*
|
||||
* Here, we send no messages to the shared queue, since we don't know yet if
|
||||
* we will commit. But we do need to locally process the LocalInvalidMsgs
|
||||
* list, so as to flush our caches of any tuples we have outdated in the
|
||||
* current command.
|
||||
* we will commit. We do need to locally process the CurrentCmdInvalidMsgs
|
||||
* list, so as to flush our caches of any entries we have outdated in the
|
||||
* current command. We then move the current-cmd list over to become part
|
||||
* of the prior-cmds list.
|
||||
*
|
||||
* The isCommit = false case is not currently used, but may someday be
|
||||
* needed to support rollback to a savepoint within a transaction.
|
||||
* (I suspect it needs more work first --- tgl.)
|
||||
*
|
||||
* Note:
|
||||
* This should be called during CommandCounterIncrement(),
|
||||
|
|
@ -590,29 +598,24 @@ CommandEndInvalidationMessages(bool isCommit)
|
|||
{
|
||||
if (isCommit)
|
||||
{
|
||||
ProcessInvalidationMessages(&LocalInvalidMsgs,
|
||||
ProcessInvalidationMessages(&CurrentCmdInvalidMsgs,
|
||||
LocalExecuteInvalidationMessage);
|
||||
AppendInvalidationMessages(&PriorCmdInvalidMsgs,
|
||||
&CurrentCmdInvalidMsgs);
|
||||
}
|
||||
else
|
||||
{
|
||||
ProcessInvalidationMessages(&RollbackMsgs,
|
||||
LocalExecuteInvalidationMessage);
|
||||
/* XXX what needs to be done here? */
|
||||
}
|
||||
|
||||
/*
|
||||
* LocalInvalidMsgs list is not interesting anymore, so flush it (for
|
||||
* real). Do *not* clear GlobalInvalidMsgs or RollbackMsgs.
|
||||
*/
|
||||
DiscardInvalidationMessages(&LocalInvalidMsgs, true);
|
||||
}
|
||||
|
||||
/*
|
||||
* RelationInvalidateHeapTuple
|
||||
* CacheInvalidateHeapTuple
|
||||
* Register the given tuple for invalidation at end of command
|
||||
* (ie, current command is outdating this tuple).
|
||||
*/
|
||||
void
|
||||
RelationInvalidateHeapTuple(Relation relation, HeapTuple tuple)
|
||||
CacheInvalidateHeapTuple(Relation relation, HeapTuple tuple)
|
||||
{
|
||||
PrepareForTupleInvalidation(relation, tuple,
|
||||
RegisterCatcacheInvalidation,
|
||||
|
|
@ -620,14 +623,17 @@ RelationInvalidateHeapTuple(Relation relation, HeapTuple tuple)
|
|||
}
|
||||
|
||||
/*
|
||||
* RelationMark4RollbackHeapTuple
|
||||
* Register the given tuple for invalidation in case of abort
|
||||
* (ie, current command is creating this tuple).
|
||||
* CacheInvalidateRelcache
|
||||
* Register invalidation of the specified relation's relcache entry
|
||||
* at end of command.
|
||||
*
|
||||
* This is used in places that need to force relcache rebuild but aren't
|
||||
* changing any of the tuples recognized as contributors to the relcache
|
||||
* entry by PrepareForTupleInvalidation. (An example is dropping an index.)
|
||||
*/
|
||||
void
|
||||
RelationMark4RollbackHeapTuple(Relation relation, HeapTuple tuple)
|
||||
CacheInvalidateRelcache(Oid relationId)
|
||||
{
|
||||
PrepareForTupleInvalidation(relation, tuple,
|
||||
RegisterCatcacheRollback,
|
||||
RegisterRelcacheRollback);
|
||||
/* See KLUGE ALERT in PrepareForTupleInvalidation */
|
||||
RegisterRelcacheInvalidation(MyDatabaseId, relationId);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.152 2002/02/19 20:11:17 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.153 2002/03/03 17:47:55 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -2065,10 +2065,16 @@ RelationBuildLocalRelation(const char *relname,
|
|||
rel->rd_isnailed = true;
|
||||
|
||||
/*
|
||||
* create a new tuple descriptor from the one passed in (we do this to
|
||||
* copy it into the cache context)
|
||||
* create a new tuple descriptor from the one passed in. We do this
|
||||
* partly to copy it into the cache context, and partly because the
|
||||
* new relation can't have any defaults or constraints yet; they
|
||||
* have to be added in later steps, because they require additions
|
||||
* to multiple system catalogs. We can copy attnotnull constraints
|
||||
* here, however.
|
||||
*/
|
||||
rel->rd_att = CreateTupleDescCopyConstr(tupDesc);
|
||||
rel->rd_att = CreateTupleDescCopy(tupDesc);
|
||||
for (i = 0; i < natts; i++)
|
||||
rel->rd_att->attrs[i]->attnotnull = tupDesc->attrs[i]->attnotnull;
|
||||
|
||||
/*
|
||||
* initialize relation tuple form (caller may add/override data later)
|
||||
|
|
@ -2082,8 +2088,6 @@ RelationBuildLocalRelation(const char *relname,
|
|||
rel->rd_rel->relhasoids = true;
|
||||
rel->rd_rel->relnatts = natts;
|
||||
rel->rd_rel->reltype = InvalidOid;
|
||||
if (tupDesc->constr)
|
||||
rel->rd_rel->relchecks = tupDesc->constr->num_check;
|
||||
|
||||
/*
|
||||
* Insert relation OID and database/tablespace ID into the right
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: sinval.h,v 1.25 2001/11/05 17:46:35 momjian Exp $
|
||||
* $Id: sinval.h,v 1.26 2002/03/03 17:47:56 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -28,22 +28,32 @@
|
|||
* are available to identify other inval message types.
|
||||
*
|
||||
* Shared-inval events are initially driven by detecting tuple inserts,
|
||||
* updates and deletions in system catalogs (see RelationInvalidateHeapTuple
|
||||
* and RelationMark4RollbackHeapTuple). Note that some system catalogs have
|
||||
* multiple caches on them (with different indexes). On detecting a tuple
|
||||
* invalidation in such a catalog, a separate catcache inval message must be
|
||||
* generated for each of its caches. The catcache inval message carries the
|
||||
* hash index for the target tuple, so that the catcache only needs to search
|
||||
* one hash chain not all its chains. Of course this assumes that all the
|
||||
* backends are using identical hashing code, but that should be OK.
|
||||
* updates and deletions in system catalogs (see CacheInvalidateHeapTuple).
|
||||
* An update generates two inval events, one for the old tuple and one for
|
||||
* the new --- this is needed to get rid of both positive entries for the
|
||||
* old tuple, and negative cache entries associated with the new tuple's
|
||||
* cache key. (This could perhaps be optimized down to one event when the
|
||||
* cache key is not changing, but for now we don't bother to try.) Note that
|
||||
* the inval events themselves don't actually say whether the tuple is being
|
||||
* inserted or deleted.
|
||||
*
|
||||
* Note that some system catalogs have multiple caches on them (with different
|
||||
* indexes). On detecting a tuple invalidation in such a catalog, separate
|
||||
* catcache inval messages must be generated for each of its caches. The
|
||||
* catcache inval messages carry the hash value for the target tuple, so
|
||||
* that the catcache only needs to search one hash chain not all its chains,
|
||||
* and so that negative cache entries can be recognized with good accuracy.
|
||||
* (Of course this assumes that all the backends are using identical hashing
|
||||
* code, but that should be OK.)
|
||||
*/
|
||||
|
||||
typedef struct
|
||||
{
|
||||
/* note: field layout chosen with an eye to alignment concerns */
|
||||
int16 id; /* cache ID --- must be first */
|
||||
uint16 hashIndex; /* hashchain index within this catcache */
|
||||
Oid dbId; /* database ID, or 0 if a shared relation */
|
||||
ItemPointerData tuplePtr; /* tuple identifier in cached relation */
|
||||
Oid dbId; /* database ID, or 0 if a shared relation */
|
||||
uint32 hashValue; /* hash value of key for this catcache */
|
||||
} SharedInvalCatcacheMsg;
|
||||
|
||||
#define SHAREDINVALRELCACHE_ID (-1)
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: catcache.h,v 1.38 2002/02/19 20:11:19 tgl Exp $
|
||||
* $Id: catcache.h,v 1.39 2002/03/03 17:47:56 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -35,20 +35,28 @@ typedef struct catcache
|
|||
struct catcache *cc_next; /* link to next catcache */
|
||||
char *cc_relname; /* name of relation the tuples come from */
|
||||
char *cc_indname; /* name of index matching cache keys */
|
||||
int cc_reloidattr; /* AttrNumber of relation OID, or 0 */
|
||||
Oid cc_reloid; /* OID of relation the tuples come from */
|
||||
bool cc_relisshared; /* is relation shared? */
|
||||
TupleDesc cc_tupdesc; /* tuple descriptor (copied from reldesc) */
|
||||
int cc_reloidattr; /* AttrNumber of relation OID attr, or 0 */
|
||||
int cc_ntup; /* # of tuples currently in this cache */
|
||||
int cc_size; /* # of hash buckets in this cache */
|
||||
int cc_nkeys; /* number of keys (1..4) */
|
||||
int cc_key[4]; /* AttrNumber of each key */
|
||||
PGFunction cc_hashfunc[4]; /* hash function to use for each key */
|
||||
ScanKeyData cc_skey[4]; /* precomputed key info for heap scans */
|
||||
bool cc_isname[4]; /* flag key columns that are NAMEs */
|
||||
#ifdef CATCACHE_STATS
|
||||
long cc_searches; /* total # searches against this cache */
|
||||
long cc_hits; /* # of matches against existing entry */
|
||||
long cc_neg_hits; /* # of matches against negative entry */
|
||||
long cc_newloads; /* # of successful loads of new entry */
|
||||
/* cc_searches - (cc_hits + cc_newloads) is # of failed searches */
|
||||
/*
|
||||
* cc_searches - (cc_hits + cc_neg_hits + cc_newloads) is number of
|
||||
* failed searches, each of which will result in loading a negative entry
|
||||
*/
|
||||
long cc_invals; /* # of entries invalidated from cache */
|
||||
long cc_discards; /* # of entries discarded due to overflow */
|
||||
#endif
|
||||
Dllist cc_bucket[1]; /* hash buckets --- VARIABLE LENGTH ARRAY */
|
||||
} CatCache; /* VARIABLE LENGTH STRUCT */
|
||||
|
|
@ -68,11 +76,18 @@ typedef struct catctup
|
|||
* A tuple marked "dead" must not be returned by subsequent searches.
|
||||
* However, it won't be physically deleted from the cache until its
|
||||
* refcount goes to zero.
|
||||
*
|
||||
* A negative cache entry is an assertion that there is no tuple
|
||||
* matching a particular key. This is just as useful as a normal entry
|
||||
* so far as avoiding catalog searches is concerned. Management of
|
||||
* positive and negative entries is identical.
|
||||
*/
|
||||
Dlelem lrulist_elem; /* list member of global LRU list */
|
||||
Dlelem cache_elem; /* list member of per-bucket list */
|
||||
int refcount; /* number of active references */
|
||||
bool dead; /* dead but not yet removed? */
|
||||
bool negative; /* negative cache entry? */
|
||||
uint32 hash_value; /* hash value for this tuple's keys */
|
||||
HeapTupleData tuple; /* tuple management header */
|
||||
} CatCTup;
|
||||
|
||||
|
|
@ -104,10 +119,10 @@ extern void ReleaseCatCache(HeapTuple tuple);
|
|||
|
||||
extern void ResetCatalogCaches(void);
|
||||
extern void CatalogCacheFlushRelation(Oid relId);
|
||||
extern void CatalogCacheIdInvalidate(int cacheId, Index hashIndex,
|
||||
extern void CatalogCacheIdInvalidate(int cacheId, uint32 hashValue,
|
||||
ItemPointer pointer);
|
||||
extern void PrepareToInvalidateCacheTuple(Relation relation,
|
||||
HeapTuple tuple,
|
||||
void (*function) (int, Index, ItemPointer, Oid));
|
||||
void (*function) (int, uint32, ItemPointer, Oid));
|
||||
|
||||
#endif /* CATCACHE_H */
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: inval.h,v 1.23 2001/11/05 17:46:36 momjian Exp $
|
||||
* $Id: inval.h,v 1.24 2002/03/03 17:47:56 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -23,8 +23,8 @@ extern void AtEOXactInvalidationMessages(bool isCommit);
|
|||
|
||||
extern void CommandEndInvalidationMessages(bool isCommit);
|
||||
|
||||
extern void RelationInvalidateHeapTuple(Relation relation, HeapTuple tuple);
|
||||
extern void CacheInvalidateHeapTuple(Relation relation, HeapTuple tuple);
|
||||
|
||||
extern void RelationMark4RollbackHeapTuple(Relation relation, HeapTuple tuple);
|
||||
extern void CacheInvalidateRelcache(Oid relationId);
|
||||
|
||||
#endif /* INVAL_H */
|
||||
|
|
|
|||
Loading…
Reference in New Issue