REINDEX under WAL.
This commit is contained in:
Hiroshi Inoue
parent
8d7c0851a3
commit
d7892e0263
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.130 2000/11/16 22:30:17 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.131 2000/12/08 06:17:57 inoue Exp $
|
||||
*
|
||||
*
|
||||
* INTERFACE ROUTINES
|
||||
|
|
@ -76,7 +76,7 @@ static void DefaultBuild(Relation heapRelation, Relation indexRelation,
|
|||
IndexInfo *indexInfo, Node *oldPred,
|
||||
IndexStrategy indexStrategy);
|
||||
static Oid IndexGetRelation(Oid indexId);
|
||||
static bool activate_index(Oid indexId, bool activate);
|
||||
static bool activate_index(Oid indexId, bool activate, bool inplace);
|
||||
|
||||
|
||||
static bool reindexing = false;
|
||||
|
|
@ -1430,7 +1430,11 @@ setRelhasindex(Oid relid, bool hasindex)
|
|||
*/
|
||||
pg_class = heap_openr(RelationRelationName, RowExclusiveLock);
|
||||
|
||||
#ifdef OLD_FILE_NAMING
|
||||
if (!IsIgnoringSystemIndexes())
|
||||
#else
|
||||
if (!IsIgnoringSystemIndexes() && (!IsReindexProcessing() || pg_class->rd_rel->relhasindex))
|
||||
#endif /* OLD_FILE_NAMING */
|
||||
{
|
||||
tuple = SearchSysCacheCopy(RELOID,
|
||||
ObjectIdGetDatum(relid),
|
||||
|
|
@ -1462,7 +1466,11 @@ setRelhasindex(Oid relid, bool hasindex)
|
|||
* Update hasindex in pg_class.
|
||||
* ----------------
|
||||
*/
|
||||
if (pg_class_scan)
|
||||
LockBuffer(pg_class_scan->rs_cbuf, BUFFER_LOCK_EXCLUSIVE);
|
||||
((Form_pg_class) GETSTRUCT(tuple))->relhasindex = hasindex;
|
||||
if (pg_class_scan)
|
||||
LockBuffer(pg_class_scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
|
||||
|
||||
if (pg_class_scan)
|
||||
{
|
||||
|
|
@ -1471,6 +1479,7 @@ setRelhasindex(Oid relid, bool hasindex)
|
|||
/* Send out shared cache inval if necessary */
|
||||
if (!IsBootstrapProcessingMode())
|
||||
RelationInvalidateHeapTuple(pg_class, tuple);
|
||||
BufferSync();
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -1496,6 +1505,75 @@ setRelhasindex(Oid relid, bool hasindex)
|
|||
heap_close(pg_class, RowExclusiveLock);
|
||||
}
|
||||
|
||||
#ifndef OLD_FILE_NAMING
|
||||
void
|
||||
setNewRelfilenode(Relation relation)
|
||||
{
|
||||
Relation pg_class, idescs[Num_pg_class_indices];
|
||||
Oid newrelfilenode;
|
||||
bool in_place_update = false;
|
||||
HeapTupleData lockTupleData;
|
||||
HeapTuple classTuple;
|
||||
Buffer buffer;
|
||||
RelationData workrel;
|
||||
|
||||
Assert(!IsSystemRelationName(NameStr(relation->rd_rel->relname)) || relation->rd_rel->relkind == RELKIND_INDEX);
|
||||
|
||||
pg_class = heap_openr(RelationRelationName, RowExclusiveLock);
|
||||
/* Fetch and lock the classTuple associated with this relation */
|
||||
if (!LockClassinfoForUpdate(relation->rd_id, &lockTupleData, &buffer, true))
|
||||
elog(ERROR, "setNewRelfilenode impossible to lock class tuple");
|
||||
if (IsIgnoringSystemIndexes())
|
||||
in_place_update = true;
|
||||
/* Allocate a new relfilenode */
|
||||
newrelfilenode = newoid();
|
||||
/* update pg_class tuple with new relfilenode */
|
||||
if (!in_place_update)
|
||||
{
|
||||
classTuple = heap_copytuple(&lockTupleData);
|
||||
ReleaseBuffer(buffer);
|
||||
((Form_pg_class) GETSTRUCT(classTuple))->relfilenode = newrelfilenode;
|
||||
heap_update(pg_class, &classTuple->t_self, classTuple, NULL);
|
||||
}
|
||||
/* unlink old relfilenode */
|
||||
DropRelationBuffers(relation);
|
||||
smgrunlink(DEFAULT_SMGR, relation);
|
||||
/* cleanup pg_internal.init if necessary */
|
||||
if (relation->rd_isnailed)
|
||||
unlink(RELCACHE_INIT_FILENAME);
|
||||
/* create another storage file. Is it a little ugly ? */
|
||||
memcpy((char *) &workrel, relation, sizeof(RelationData));
|
||||
workrel.rd_node.relNode = newrelfilenode;
|
||||
heap_storage_create(&workrel);
|
||||
/* update pg_class tuple with new relfilenode in place */
|
||||
if (in_place_update)
|
||||
{
|
||||
classTuple = &lockTupleData;
|
||||
/* Send out shared cache inval if necessary */
|
||||
if (!IsBootstrapProcessingMode())
|
||||
RelationInvalidateHeapTuple(pg_class, classTuple);
|
||||
/* Update the buffer in-place */
|
||||
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
|
||||
((Form_pg_class) GETSTRUCT(classTuple))->relfilenode = newrelfilenode;
|
||||
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
|
||||
WriteBuffer(buffer);
|
||||
BufferSync();
|
||||
}
|
||||
/* Keep the catalog indices up to date */
|
||||
if (!in_place_update && pg_class->rd_rel->relhasindex)
|
||||
{
|
||||
CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices,
|
||||
idescs);
|
||||
CatalogIndexInsert(idescs, Num_pg_class_indices, pg_class, classTuple);
|
||||
CatalogCloseIndices(Num_pg_class_indices, idescs);
|
||||
heap_freetuple(classTuple);
|
||||
}
|
||||
heap_close(pg_class, NoLock);
|
||||
/* Make sure the relfilenode change */
|
||||
CommandCounterIncrement();
|
||||
}
|
||||
#endif /* OLD_FILE_NAMING */
|
||||
|
||||
/* ----------------
|
||||
* UpdateStats
|
||||
* ----------------
|
||||
|
|
@ -1552,7 +1630,12 @@ UpdateStats(Oid relid, long reltuples)
|
|||
*/
|
||||
pg_class = heap_openr(RelationRelationName, RowExclusiveLock);
|
||||
|
||||
#ifdef OLD_FILE_NAMING
|
||||
in_place_upd = (IsReindexProcessing() || IsBootstrapProcessingMode());
|
||||
#else
|
||||
in_place_upd = (IsIgnoringSystemIndexes() || (IsReindexProcessing() &&
|
||||
relid == RelOid_pg_class));
|
||||
#endif /* OLD_FILE_NAMING */
|
||||
|
||||
if (!in_place_upd)
|
||||
{
|
||||
|
|
@ -1631,8 +1714,10 @@ UpdateStats(Oid relid, long reltuples)
|
|||
* visibility of changes, so we cheat. Also cheat if REINDEX.
|
||||
*/
|
||||
rd_rel = (Form_pg_class) GETSTRUCT(tuple);
|
||||
LockBuffer(pg_class_scan->rs_cbuf, BUFFER_LOCK_EXCLUSIVE);
|
||||
rd_rel->relpages = relpages;
|
||||
rd_rel->reltuples = reltuples;
|
||||
LockBuffer(pg_class_scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
|
||||
WriteNoReleaseBuffer(pg_class_scan->rs_cbuf);
|
||||
if (!IsBootstrapProcessingMode())
|
||||
RelationInvalidateHeapTuple(pg_class, tuple);
|
||||
|
|
@ -1924,11 +2009,11 @@ IndexGetRelation(Oid indexId)
|
|||
* ---------------------------------
|
||||
*/
|
||||
static bool
|
||||
activate_index(Oid indexId, bool activate)
|
||||
activate_index(Oid indexId, bool activate, bool inplace)
|
||||
{
|
||||
if (!activate) /* Currently does nothing */
|
||||
return true;
|
||||
return reindex_index(indexId, false);
|
||||
return reindex_index(indexId, false, inplace);
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
|
|
@ -1936,7 +2021,7 @@ activate_index(Oid indexId, bool activate)
|
|||
* --------------------------------
|
||||
*/
|
||||
bool
|
||||
reindex_index(Oid indexId, bool force)
|
||||
reindex_index(Oid indexId, bool force, bool inplace)
|
||||
{
|
||||
Relation iRel,
|
||||
indexRelation,
|
||||
|
|
@ -1996,18 +2081,25 @@ reindex_index(Oid indexId, bool force)
|
|||
if (iRel == NULL)
|
||||
elog(ERROR, "reindex_index: can't open index relation");
|
||||
|
||||
#ifndef OLD_FILE_NAMING
|
||||
if (!inplace)
|
||||
setNewRelfilenode(iRel);
|
||||
#endif /* OLD_FILE_NAMING */
|
||||
/* Obtain exclusive lock on it, just to be sure */
|
||||
LockRelation(iRel, AccessExclusiveLock);
|
||||
|
||||
/*
|
||||
* Release any buffers associated with this index. If they're dirty,
|
||||
* they're just dropped without bothering to flush to disk.
|
||||
*/
|
||||
DropRelationBuffers(iRel);
|
||||
if (inplace)
|
||||
{
|
||||
/*
|
||||
* Release any buffers associated with this index. If they're dirty,
|
||||
* they're just dropped without bothering to flush to disk.
|
||||
*/
|
||||
DropRelationBuffers(iRel);
|
||||
|
||||
/* Now truncate the actual data and set blocks to zero */
|
||||
smgrtruncate(DEFAULT_SMGR, iRel, 0);
|
||||
iRel->rd_nblocks = 0;
|
||||
/* Now truncate the actual data and set blocks to zero */
|
||||
smgrtruncate(DEFAULT_SMGR, iRel, 0);
|
||||
iRel->rd_nblocks = 0;
|
||||
}
|
||||
|
||||
/* Initialize the index and rebuild */
|
||||
InitIndexStrategy(indexInfo->ii_NumIndexAttrs, iRel, accessMethodId);
|
||||
|
|
@ -2064,15 +2156,57 @@ reindex_relation(Oid relid, bool force)
|
|||
bool old,
|
||||
reindexed;
|
||||
|
||||
old = SetReindexProcessing(true);
|
||||
if (IndexesAreActive(relid, true))
|
||||
bool deactivate_needed, overwrite, upd_pg_class_inplace;
|
||||
#ifdef OLD_FILE_NAMING
|
||||
overwrite = upd_pg_class_inplace = deactivate_needed = true;
|
||||
#else
|
||||
Relation rel;
|
||||
overwrite = upd_pg_class_inplace = deactivate_needed = false;
|
||||
/*
|
||||
* avoid heap_update() pg_class tuples while processing
|
||||
* reindex for pg_class.
|
||||
*/
|
||||
if (IsIgnoringSystemIndexes())
|
||||
upd_pg_class_inplace = true;
|
||||
/*
|
||||
* ignore the indexes of the target system relation while processing
|
||||
* reindex.
|
||||
*/
|
||||
rel = RelationIdGetRelation(relid);
|
||||
if (!IsIgnoringSystemIndexes() && IsSystemRelationName(NameStr(rel->rd_rel->relname)))
|
||||
deactivate_needed = true;
|
||||
#ifndef ENABLE_REINDEX_NAILED_RELATIONS
|
||||
/*
|
||||
* nailed relations are never updated.
|
||||
* We couldn't keep the consistency between the relation
|
||||
* descriptors and pg_class tuples.
|
||||
*/
|
||||
if (rel->rd_isnailed)
|
||||
{
|
||||
if (!force)
|
||||
if (IsIgnoringSystemIndexes())
|
||||
{
|
||||
SetReindexProcessing(old);
|
||||
return false;
|
||||
overwrite = true;
|
||||
deactivate_needed = true;
|
||||
}
|
||||
else
|
||||
elog(ERROR, "the target relation %u is nailed", relid);
|
||||
}
|
||||
#endif /* ENABLE_REINDEX_NAILED_RELATIONS */
|
||||
RelationClose(rel);
|
||||
#endif /* OLD_FILE_NAMING */
|
||||
old = SetReindexProcessing(true);
|
||||
if (deactivate_needed)
|
||||
{
|
||||
if (IndexesAreActive(relid, upd_pg_class_inplace))
|
||||
{
|
||||
if (!force)
|
||||
{
|
||||
SetReindexProcessing(old);
|
||||
return false;
|
||||
}
|
||||
activate_indexes_of_a_table(relid, false);
|
||||
CommandCounterIncrement();
|
||||
}
|
||||
activate_indexes_of_a_table(relid, false);
|
||||
}
|
||||
|
||||
indexRelation = heap_openr(IndexRelationName, AccessShareLock);
|
||||
|
|
@ -2085,7 +2219,7 @@ reindex_relation(Oid relid, bool force)
|
|||
{
|
||||
Form_pg_index index = (Form_pg_index) GETSTRUCT(indexTuple);
|
||||
|
||||
if (activate_index(index->indexrelid, true))
|
||||
if (activate_index(index->indexrelid, true, overwrite))
|
||||
reindexed = true;
|
||||
else
|
||||
{
|
||||
|
|
@ -2096,7 +2230,30 @@ reindex_relation(Oid relid, bool force)
|
|||
heap_endscan(scan);
|
||||
heap_close(indexRelation, AccessShareLock);
|
||||
if (reindexed)
|
||||
setRelhasindex(relid, true);
|
||||
/*
|
||||
* Ok,we could use the reindexed indexes of the target
|
||||
* system relation now.
|
||||
*/
|
||||
{
|
||||
if (deactivate_needed)
|
||||
{
|
||||
if (!overwrite && relid == RelOid_pg_class)
|
||||
{
|
||||
/*
|
||||
* For pg_class, relhasindex should be set
|
||||
* to true here in place.
|
||||
*/
|
||||
setRelhasindex(relid, true);
|
||||
CommandCounterIncrement();
|
||||
/*
|
||||
* However the following setRelhasindex()
|
||||
* is needed to keep consistency with WAL.
|
||||
*/
|
||||
}
|
||||
setRelhasindex(relid, true);
|
||||
}
|
||||
}
|
||||
SetReindexProcessing(old);
|
||||
|
||||
return reindexed;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.41 2000/11/16 22:30:18 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.42 2000/12/08 06:17:58 inoue Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -653,7 +653,11 @@ ReindexIndex(const char *name, bool force /* currently unused */ )
|
|||
elog(ERROR, "relation \"%s\" is of type \"%c\"",
|
||||
name, ((Form_pg_class) GETSTRUCT(tuple))->relkind);
|
||||
|
||||
if (!reindex_index(tuple->t_data->t_oid, force))
|
||||
#ifdef OLD_FILE_NAMING
|
||||
if (!reindex_index(tuple->t_data->t_oid, force, false))
|
||||
#else
|
||||
if (!reindex_index(tuple->t_data->t_oid, force, false))
|
||||
#endif /* OLD_FILE_NAMING */
|
||||
elog(NOTICE, "index \"%s\" wasn't reindexed", name);
|
||||
|
||||
ReleaseSysCache(tuple);
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.103 2000/11/16 22:30:30 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.104 2000/12/08 06:17:58 inoue Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -866,6 +866,7 @@ ProcessUtility(Node *parsetree,
|
|||
relname = (char *) stmt->name;
|
||||
if (IsSystemRelationName(relname))
|
||||
{
|
||||
#ifdef OLD_FILE_NAMING
|
||||
if (!allowSystemTableMods && IsSystemRelationName(relname))
|
||||
elog(ERROR, "\"%s\" is a system table. call REINDEX under standalone postgres with -O -P options",
|
||||
relname);
|
||||
|
|
@ -873,6 +874,7 @@ ProcessUtility(Node *parsetree,
|
|||
elog(ERROR, "\"%s\" is a system table. call REINDEX under standalone postgres with -P -O options",
|
||||
|
||||
relname);
|
||||
#endif /* OLD_FILE_NAMING */
|
||||
}
|
||||
if (!pg_ownercheck(GetUserId(), relname, RELNAME))
|
||||
elog(ERROR, "%s: %s", relname, aclcheck_error_strings[ACLCHECK_NOT_OWNER]);
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.118 2000/11/30 18:38:46 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.119 2000/12/08 06:17:56 inoue Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -250,6 +250,10 @@ do { \
|
|||
/* non-export function prototypes */
|
||||
|
||||
static void RelationClearRelation(Relation relation, bool rebuildIt);
|
||||
#ifdef ENABLE_REINDEX_NAILED_RELATIONS
|
||||
static void RelationReloadClassinfo(Relation relation);
|
||||
#endif /* ENABLE_REINDEX_NAILED_RELATIONS */
|
||||
static void RelationResetRelation(Relation relation, bool rebuildIt);
|
||||
static void RelationFlushRelation(Relation *relationPtr,
|
||||
int skipLocalRelations);
|
||||
static Relation RelationNameCacheGetRelation(const char *relationName);
|
||||
|
|
@ -387,6 +391,15 @@ scan_pg_rel_ind(RelationBuildDescInfo buildinfo)
|
|||
HeapTuple return_tuple;
|
||||
|
||||
pg_class_desc = heap_openr(RelationRelationName, AccessShareLock);
|
||||
/*
|
||||
* If the indexes of pg_class are deactivated
|
||||
* we have to call scan_pg_rel_seq() instead.
|
||||
*/
|
||||
if (!pg_class_desc->rd_rel->relhasindex)
|
||||
{
|
||||
heap_close(pg_class_desc, AccessShareLock);
|
||||
return scan_pg_rel_seq(buildinfo);
|
||||
}
|
||||
|
||||
switch (buildinfo.infotype)
|
||||
{
|
||||
|
|
@ -1555,6 +1568,45 @@ RelationClose(Relation relation)
|
|||
RelationDecrementReferenceCount(relation);
|
||||
}
|
||||
|
||||
#ifdef ENABLE_REINDEX_NAILED_RELATIONS
|
||||
/* --------------------------------
|
||||
* RelationReloadClassinfo
|
||||
*
|
||||
* This function is especially for nailed relations.
|
||||
* relhasindex/relfilenode could be changed even for
|
||||
* nailed relations.
|
||||
* --------------------------------
|
||||
*/
|
||||
static void
|
||||
RelationReloadClassinfo(Relation relation)
|
||||
{
|
||||
RelationBuildDescInfo buildinfo;
|
||||
HeapTuple pg_class_tuple;
|
||||
Form_pg_class relp;
|
||||
|
||||
if (!relation->rd_rel)
|
||||
return;
|
||||
buildinfo.infotype = INFO_RELID;
|
||||
buildinfo.i.info_id = relation->rd_id;
|
||||
pg_class_tuple = ScanPgRelation(buildinfo);
|
||||
if (!HeapTupleIsValid(pg_class_tuple))
|
||||
{
|
||||
elog(ERROR, "RelationReloadClassinfo system relation id=%d doesn't exist", relation->rd_id);
|
||||
return;
|
||||
}
|
||||
RelationCacheDelete(relation);
|
||||
relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
|
||||
memcpy((char *) relation->rd_rel, (char *) relp, CLASS_TUPLE_SIZE);
|
||||
relation->rd_node.relNode = relp->relfilenode;
|
||||
RelationCacheInsert(relation);
|
||||
heap_freetuple(pg_class_tuple);
|
||||
fprintf(stderr, "RelationClearRelation nailed %s hasindex=%d relfilenode=%d,%d\n",
|
||||
RelationGetRelationName(relation), relation->rd_rel->relhasindex,
|
||||
relation->rd_rel->relfilenode, relation->rd_node.relNode);
|
||||
|
||||
return;
|
||||
}
|
||||
#endif /* ENABLE_REINDEX_NAILED_RELATIONS */
|
||||
/* --------------------------------
|
||||
* RelationClearRelation
|
||||
*
|
||||
|
|
@ -1588,7 +1640,14 @@ RelationClearRelation(Relation relation, bool rebuildIt)
|
|||
* we'd be unable to recover.
|
||||
*/
|
||||
if (relation->rd_isnailed)
|
||||
#ifdef ENABLE_REINDEX_NAILED_RELATIONS
|
||||
{
|
||||
RelationReloadClassinfo(relation);
|
||||
#endif /* ENABLE_REINDEX_NAILED_RELATIONS */
|
||||
return;
|
||||
#ifdef ENABLE_REINDEX_NAILED_RELATIONS
|
||||
}
|
||||
#endif /* ENABLE_REINDEX_NAILED_RELATIONS */
|
||||
|
||||
/*
|
||||
* Remove relation from hash tables
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: index.h,v 1.30 2000/11/08 22:10:01 tgl Exp $
|
||||
* $Id: index.h,v 1.31 2000/12/08 06:17:56 inoue Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -49,13 +49,16 @@ extern void FormIndexDatum(IndexInfo *indexInfo,
|
|||
extern void UpdateStats(Oid relid, long reltuples);
|
||||
extern bool IndexesAreActive(Oid relid, bool comfirmCommitted);
|
||||
extern void setRelhasindex(Oid relid, bool hasindex);
|
||||
#ifndef OLD_FILE_NAMING
|
||||
extern void setNewRelfilenode(Relation relation);
|
||||
#endif /* OLD_FILE_NAMING */
|
||||
extern bool SetReindexProcessing(bool processing);
|
||||
extern bool IsReindexProcessing(void);
|
||||
|
||||
extern void index_build(Relation heapRelation, Relation indexRelation,
|
||||
IndexInfo *indexInfo, Node *oldPred);
|
||||
|
||||
extern bool reindex_index(Oid indexId, bool force);
|
||||
extern bool reindex_index(Oid indexId, bool force, bool inplace);
|
||||
extern bool activate_indexes_of_a_table(Oid relid, bool activate);
|
||||
extern bool reindex_relation(Oid relid, bool force);
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue