open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Combine index_info and find_secondary_indexes into a single routine that

Browse Source 
returns a list of RelOptInfos, eliminating the need for static state
in index_info.  That static state was a direct cause of coredumps; if
anything decided to elog(ERROR) partway through an index_info search of
pg_index, the next query would try to close a scan pointer that was
pointing at no-longer-valid memory.  Another example of the reasons to
avoid static state variables...
REL7_0_PATCHES
Tom Lane 26 years ago
parent 40d3e92541
commit 610dfa6d55
3 changed files with 115 additions and 214 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 58
      src/backend/optimizer/util/indexnode.c
  2. 238
      src/backend/optimizer/util/plancat.c
  3. 33
      src/include/optimizer/plancat.h

58
src/backend/optimizer/util/indexnode.c
Unescape View File

@ -7,21 +7,16 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/indexnode.c,v 1.20 1999/08/16 02:17:57 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/indexnode.c,v 1.21 1999/11/21 23:25:47 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include <sys/types.h>
#include "postgres.h"
#include "optimizer/pathnode.h"
#include "optimizer/plancat.h"
static List *find_secondary_index(Query *root, Oid relid);
/*
* find_relation_indices
* Returns a list of index nodes containing appropriate information for
@ -32,56 +27,7 @@ List *
find_relation_indices(Query *root, RelOptInfo *rel)
{
if (rel->indexed)
return find_secondary_index(root, lfirsti(rel->relids));
return find_secondary_indexes(root, lfirsti(rel->relids));
else
return NIL;
}
/*
* find_secondary_index
* Creates a list of RelOptInfo nodes containing information for each
* secondary index defined on a relation by searching through the index
* catalog.
*
* 'relid' is the OID of the relation for which indices are being located
*
* Returns a list of new index RelOptInfo nodes.
*/
static List *
find_secondary_index(Query *root, Oid relid)
{
IdxInfoRetval indexinfo;
List *indexes = NIL;
bool first = true;
while (index_info(root, first, relid, &indexinfo))
{
RelOptInfo *indexnode = makeNode(RelOptInfo);
indexnode->relids = lconsi(indexinfo.relid, NIL);
indexnode->relam = indexinfo.relam;
indexnode->pages = indexinfo.pages;
indexnode->tuples = indexinfo.tuples;
indexnode->classlist = indexinfo.classlist;
indexnode->indexkeys = indexinfo.indexkeys;
indexnode->ordering = indexinfo.orderOprs;
indexnode->indproc = indexinfo.indproc;
indexnode->indpred = (List *) indexinfo.indpred;
indexnode->indexed = false; /* not indexed itself */
indexnode->size = 0;
indexnode->width = 0;
indexnode->targetlist = NIL;
indexnode->pathlist = NIL;
indexnode->cheapestpath = NULL;
indexnode->pruneable = true;
indexnode->restrictinfo = NIL;
indexnode->joininfo = NIL;
indexnode->innerjoin = NIL;
indexes = lcons(indexnode, indexes);
first = false;
}
return indexes;
}

238
src/backend/optimizer/util/plancat.c
Unescape View File

@ -8,13 +8,14 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.38 1999/09/18 19:07:06 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.39 1999/11/21 23:25:47 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include <math.h>
#include "postgres.h"
#include "access/genam.h"
#include "access/heapam.h"
#include "catalog/catname.h"
@ -38,8 +39,8 @@ static void IndexSelectivity(Oid indexrelid, Oid baserelid, int nIndexKeys,
/*
* relation_info -
* Retrieves catalog information for a given relation. Given the oid of
* the relation, return the following information:
* Retrieves catalog information for a given relation.
* Given the rangetable index of the relation, return the following info:
* whether the relation has secondary indices
* number of pages
* number of tuples
@ -54,166 +55,141 @@ relation_info(Query *root, Index relid,
relationObjectId = getrelid(relid, root->rtable);
relationTuple = SearchSysCacheTuple(RELOID,
ObjectIdGetDatum(relationObjectId),
ObjectIdGetDatum(relationObjectId),
0, 0, 0);
if (HeapTupleIsValid(relationTuple))
{
relation = (Form_pg_class) GETSTRUCT(relationTuple);
*hasindex = (relation->relhasindex) ? TRUE : FALSE;
*hasindex = (relation->relhasindex) ? true : false;
*pages = relation->relpages;
*tuples = relation->reltuples;
}
else
{
elog(ERROR, "RelationCatalogInformation: Relation %u not found",
elog(ERROR, "relation_info: Relation %u not found",
relationObjectId);
}
return;
}
/*
* index_info
* Retrieves catalog information on an index on a given relation.
* find_secondary_indexes
* Creates a list of RelOptInfo nodes containing information for each
* secondary index defined on the given relation.
*
* The index relation is opened on the first invocation. The current
* retrieves the next index relation within the catalog that has not
* already been retrieved by a previous call. The index catalog
* is closed when no more indices for 'relid' can be found.
*
* 'first' is 1 if this is the first call
*
* Returns true if successful and false otherwise. Index info is returned
* via the transient data structure 'info'.
* 'relid' is the RT index of the relation for which indices are being located
*
* Returns a list of new index RelOptInfo nodes.
*/
bool
index_info(Query *root, bool first, int relid, IdxInfoRetval *info)
List *
find_secondary_indexes(Query *root, Index relid)
{
int i;
HeapTuple indexTuple,
amopTuple;
Form_pg_index index;
Relation indexRelation;
uint16 amstrategy;
Oid relam;
Oid indrelid;
static Relation relation = (Relation) NULL;
static HeapScanDesc scan = (HeapScanDesc) NULL;
static ScanKeyData indexKey;
List *indexes = NIL;
Oid indrelid = getrelid(relid, root->rtable);
Relation relation;
HeapScanDesc scan;
ScanKeyData indexKey;
HeapTuple indexTuple;
/* Scan pg_index for tuples describing indexes of this rel */
relation = heap_openr(IndexRelationName, AccessShareLock);
/* find the oid of the indexed relation */
indrelid = getrelid(relid, root->rtable);
ScanKeyEntryInitialize(&indexKey, 0,
Anum_pg_index_indrelid,
F_OIDEQ,
ObjectIdGetDatum(indrelid));
MemSet(info, 0, sizeof(IdxInfoRetval));
scan = heap_beginscan(relation, 0, SnapshotNow,
1, &indexKey);
/*
* the maximum number of elements in each of the following arrays is
* 8. We allocate one more for a terminating 0 to indicate the end of
* the array.
*/
info->indexkeys = (int *) palloc(sizeof(int) * 9);
MemSet(info->indexkeys, 0, sizeof(int) * 9);
info->orderOprs = (Oid *) palloc(sizeof(Oid) * 9);
MemSet(info->orderOprs, 0, sizeof(Oid) * 9);
info->classlist = (Oid *) palloc(sizeof(Oid) * 9);
MemSet(info->classlist, 0, sizeof(Oid) * 9);
/* Find an index on the given relation */
if (first)
{
if (HeapScanIsValid(scan))
heap_endscan(scan);
scan = (HeapScanDesc) NULL;
if (RelationIsValid(relation))
heap_close(relation, AccessShareLock);
relation = (Relation) NULL;
ScanKeyEntryInitialize(&indexKey, 0,
Anum_pg_index_indrelid,
F_OIDEQ,
ObjectIdGetDatum(indrelid));
relation = heap_openr(IndexRelationName, AccessShareLock);
scan = heap_beginscan(relation, 0, SnapshotNow,
1, &indexKey);
}
if (!HeapScanIsValid(scan))
elog(ERROR, "index_info: scan not started");
indexTuple = heap_getnext(scan, 0);
if (!HeapTupleIsValid(indexTuple))
{
heap_endscan(scan);
heap_close(relation, AccessShareLock);
scan = (HeapScanDesc) NULL;
relation = (Relation) NULL;
return 0;
}
/* Extract info from the index tuple */
index = (Form_pg_index) GETSTRUCT(indexTuple);
info->relid = index->indexrelid; /* index relation */
for (i = 0; i < INDEX_MAX_KEYS; i++)
info->indexkeys[i] = index->indkey[i];
for (i = 0; i < INDEX_MAX_KEYS; i++)
info->classlist[i] = index->indclass[i];
info->indproc = index->indproc; /* functional index ?? */
/* partial index ?? */
if (VARSIZE(&index->indpred) != 0)
while (HeapTupleIsValid(indexTuple = heap_getnext(scan, 0)))
{
Form_pg_index index = (Form_pg_index) GETSTRUCT(indexTuple);
RelOptInfo *info = makeNode(RelOptInfo);
int i;
Relation indexRelation;
uint16 amstrategy;
Oid relam;
/*
* The memory allocated here for the predicate (in lispReadString)
* only needs to stay around until it's used in find_index_paths,
* which is all within a command, so the automatic pfree at end of
* transaction should be ok.
* Need to make these arrays large enough to be sure there is a
* terminating 0 at the end of each one.
*/
char *predString;
info->classlist = (Oid *) palloc(sizeof(Oid) * (INDEX_MAX_KEYS+1));
info->indexkeys = (int *) palloc(sizeof(int) * (INDEX_MAX_KEYS+1));
info->ordering = (Oid *) palloc(sizeof(Oid) * (INDEX_MAX_KEYS+1));
/* Extract info from the pg_index tuple */
info->relids = lconsi(index->indexrelid, NIL);
info->indproc = index->indproc; /* functional index ?? */
if (VARSIZE(&index->indpred) != 0) /* partial index ?? */
{
char *predString = fmgr(F_TEXTOUT, &index->indpred);
info->indpred = (List *) stringToNode(predString);
pfree(predString);
}
else
info->indpred = NIL;
predString = fmgr(F_TEXTOUT, &index->indpred);
info->indpred = (Node *) stringToNode(predString);
pfree(predString);
}
for (i = 0; i < INDEX_MAX_KEYS; i++)
info->indexkeys[i] = index->indkey[i];
info->indexkeys[INDEX_MAX_KEYS] = 0;
for (i = 0; i < INDEX_MAX_KEYS; i++)
info->classlist[i] = index->indclass[i];
info->classlist[INDEX_MAX_KEYS] = (Oid) 0;
/* Extract info from the relation descriptor for the index */
indexRelation = index_open(index->indexrelid);
/* Extract info from the relation descriptor for the index */
indexRelation = index_open(index->indexrelid);
#ifdef notdef
/* XXX should iterate through strategies -- but how? use #1 for now */
amstrategy = indexRelation->rd_am->amstrategies;
/* XXX should iterate through strategies -- but how? use #1 for now */
amstrategy = indexRelation->rd_am->amstrategies;
#endif /* notdef */
amstrategy = 1;
relam = indexRelation->rd_rel->relam;
info->relam = relam;
info->pages = indexRelation->rd_rel->relpages;
info->tuples = indexRelation->rd_rel->reltuples;
index_close(indexRelation);
amstrategy = 1;
relam = indexRelation->rd_rel->relam;
info->relam = relam;
info->pages = indexRelation->rd_rel->relpages;
info->tuples = indexRelation->rd_rel->reltuples;
index_close(indexRelation);
/*
* Find the index ordering keys
*
* Must use indclass to know when to stop looking since with functional
* indices there could be several keys (args) for one opclass. -mer 27
* Sept 1991
*/
for (i = 0; i < 8 && index->indclass[i]; ++i)
{
amopTuple = SearchSysCacheTuple(AMOPSTRATEGY,
/*
* Fetch the ordering operators associated with the index.
*
* XXX what if it's a hash or other unordered index?
*/
MemSet(info->ordering, 0, sizeof(Oid) * (INDEX_MAX_KEYS+1));
for (i = 0; i < INDEX_MAX_KEYS && index->indclass[i]; i++)
{
HeapTuple amopTuple;
amopTuple = SearchSysCacheTuple(AMOPSTRATEGY,
ObjectIdGetDatum(relam),
ObjectIdGetDatum(index->indclass[i]),
ObjectIdGetDatum(index->indclass[i]),
UInt16GetDatum(amstrategy),
0);
if (!HeapTupleIsValid(amopTuple))
elog(ERROR, "index_info: no amop %u %u %d",
relam, index->indclass[i], amstrategy);
info->orderOprs[i] = ((Form_pg_amop) GETSTRUCT(amopTuple))->amopopr;
if (!HeapTupleIsValid(amopTuple))
elog(ERROR, "find_secondary_indexes: no amop %u %u %d",
relam, index->indclass[i], amstrategy);
info->ordering[i] = ((Form_pg_amop) GETSTRUCT(amopTuple))->amopopr;
}
info->indexed = false; /* not indexed itself */
info->size = 0;
info->width = 0;
info->targetlist = NIL;
info->pathlist = NIL;
info->cheapestpath = NULL;
info->pruneable = true;
info->restrictinfo = NIL;
info->joininfo = NIL;
info->innerjoin = NIL;
indexes = lcons(info, indexes);
}
return TRUE;
heap_endscan(scan);
heap_close(relation, AccessShareLock);
return indexes;
}
/*
@ -370,10 +346,10 @@ join_selectivity(Oid functionObjectId,
}
/*
* find_all_inheritors
* find_inheritance_children
*
* Returns a LISP list containing the OIDs of all relations which
* inherits from the relation with OID 'inhparent'.
* Returns an integer list containing the OIDs of all relations which
* inherit *directly* from the relation with OID 'inhparent'.
*/
List *
find_inheritance_children(Oid inhparent)
@ -390,8 +366,8 @@ find_inheritance_children(Oid inhparent)
fmgr_info(F_OIDEQ, &key[0].sk_func);
key[0].sk_nargs = key[0].sk_func.fn_nargs;
key[0].sk_argument = ObjectIdGetDatum(inhparent);
key[0].sk_argument = ObjectIdGetDatum((Oid) inhparent);
relation = heap_openr(InheritsRelationName, AccessShareLock);
scan = heap_beginscan(relation, 0, SnapshotNow, 1, key);
while (HeapTupleIsValid(inheritsTuple = heap_getnext(scan, 0)))

33
src/include/optimizer/plancat.h
Unescape View File

@ -6,7 +6,7 @@
*
* Copyright (c) 1994, Regents of the University of California
*
* $Id: plancat.h,v 1.13 1999/07/25 23:07:23 tgl Exp $
* $Id: plancat.h,v 1.14 1999/11/21 23:25:42 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -15,32 +15,11 @@
#include "nodes/parsenodes.h"
/*
* transient data structure to hold return value of index_info. Note that
* indexkeys, orderOprs and classlist is "null-terminated".
*/
typedef struct IdxInfoRetval
{
Oid relid; /* OID of the index relation (not the OID
* of the relation being indexed) */
Oid relam; /* OID of the pg_am of this index */
int pages; /* number of pages in the index relation */
int tuples; /* number of tuples in the index relation */
int *indexkeys; /* keys over which we're indexing */
Oid *orderOprs; /* operators used for ordering purposes */
Oid *classlist; /* classes of AM operators */
Oid indproc;
Node *indpred;
} IdxInfoRetval;
extern void relation_info(Query *root,
Oid relid,
bool *hashindex, int *pages,
int *tuples);
extern bool index_info(Query *root,
bool first, int relid, IdxInfoRetval *info);
extern void relation_info(Query *root, Index relid,
bool *hasindex, int *pages, int *tuples);
extern List *find_secondary_indexes(Query *root, Index relid);
extern Cost restriction_selectivity(Oid functionObjectId,
Oid operatorObjectId,

Write Preview
Loading…
Cancel
Save