*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.61 2000/07/12 02:36:46 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.62 2000/07/14 22:17:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
Relation heap = (Relation) PG_GETARG_POINTER(0);
Relation index = (Relation) PG_GETARG_POINTER(1);
- int32 natts = PG_GETARG_INT32(2);
- AttrNumber *attnum = (AttrNumber *) PG_GETARG_POINTER(3);
- FuncIndexInfo *finfo = (FuncIndexInfo *) PG_GETARG_POINTER(4);
- PredInfo *predInfo = (PredInfo *) PG_GETARG_POINTER(5);
+ IndexInfo *indexInfo = (IndexInfo *) PG_GETARG_POINTER(2);
+ Node *oldPred = (Node *) PG_GETARG_POINTER(3);
#ifdef NOT_USED
- bool unique = PG_GETARG_BOOL(6);
- IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(7);
+ IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(4);
#endif
- HeapScanDesc scan;
- AttrNumber i;
+ HeapScanDesc hscan;
HeapTuple htup;
IndexTuple itup;
- TupleDesc hd,
- id;
- InsertIndexResult res;
- Datum *d;
- bool *nulls;
- int nb,
- nh,
- ni;
+ TupleDesc htupdesc,
+ itupdesc;
+ Datum attdata[INDEX_MAX_KEYS];
+ char nulls[INDEX_MAX_KEYS];
+ int nhtups,
+ nitups;
+ Node *pred = indexInfo->ii_Predicate;
#ifndef OMIT_PARTIAL_INDEX
- ExprContext *econtext;
TupleTable tupleTable;
TupleTableSlot *slot;
#endif
- Node *pred,
- *oldPred;
+ ExprContext *econtext;
+ InsertIndexResult res = NULL;
GISTSTATE giststate;
GISTENTRY tmpcentry;
Buffer buffer = InvalidBuffer;
bool *compvec;
+ int i;
/* no locking is needed */
- CommandCounterIncrement(); /* so we can see the new pg_index tuple */
-
initGISTstate(&giststate, index);
- pred = predInfo->pred;
- oldPred = predInfo->oldPred;
-
/*
* We expect to be called exactly once for any index relation. If
* that's not the case, big trouble's what we have.
*/
-
- if (oldPred == NULL && (nb = RelationGetNumberOfBlocks(index)) != 0)
+ if (oldPred == NULL && RelationGetNumberOfBlocks(index) != 0)
elog(ERROR, "%s already contains data", RelationGetRelationName(index));
/* initialize the root page (if this is a new index) */
WriteBuffer(buffer);
}
- /* init the tuple descriptors and get set for a heap scan */
- hd = RelationGetDescr(heap);
- id = RelationGetDescr(index);
- d = (Datum *) palloc(natts * sizeof(*d));
- nulls = (bool *) palloc(natts * sizeof(*nulls));
+ /* get tuple descriptors for heap and index relations */
+ htupdesc = RelationGetDescr(heap);
+ itupdesc = RelationGetDescr(index);
/*
* If this is a predicate (partial) index, we will need to evaluate
* the predicate using ExecQual, which requires the current tuple to
* be in a slot of a TupleTable. In addition, ExecQual must have an
* ExprContext referring to that slot. Here, we initialize dummy
- * TupleTable and ExprContext objects for this purpose. --Nels, Feb
- * '92
+ * TupleTable and ExprContext objects for this purpose. --Nels, Feb 92
+ *
+ * We construct the ExprContext anyway since we need a per-tuple
+ * temporary memory context for function evaluation -- tgl July 00
*/
#ifndef OMIT_PARTIAL_INDEX
if (pred != NULL || oldPred != NULL)
{
tupleTable = ExecCreateTupleTable(1);
slot = ExecAllocTableSlot(tupleTable);
- ExecSetSlotDescriptor(slot, hd);
- econtext = MakeExprContext(slot, TransactionCommandContext);
+ ExecSetSlotDescriptor(slot, htupdesc);
}
else
{
tupleTable = NULL;
slot = NULL;
- econtext = NULL;
}
+ econtext = MakeExprContext(slot, TransactionCommandContext);
+#else
+ econtext = MakeExprContext(NULL, TransactionCommandContext);
#endif /* OMIT_PARTIAL_INDEX */
- /* int the tuples as we insert them */
- nh = ni = 0;
- scan = heap_beginscan(heap, 0, SnapshotNow, 0, (ScanKey) NULL);
+ /* build the index */
+ nhtups = nitups = 0;
+
+ compvec = (bool *) palloc(sizeof(bool) * indexInfo->ii_NumIndexAttrs);
- while (HeapTupleIsValid(htup = heap_getnext(scan, 0)))
+ /* start a heap scan */
+ hscan = heap_beginscan(heap, 0, SnapshotNow, 0, (ScanKey) NULL);
+
+ while (HeapTupleIsValid(htup = heap_getnext(hscan, 0)))
{
- nh++;
+ MemoryContextReset(econtext->ecxt_per_tuple_memory);
+
+ nhtups++;
#ifndef OMIT_PARTIAL_INDEX
/*
*/
if (oldPred != NULL)
{
- /* SetSlotContents(slot, htup); */
slot->val = htup;
if (ExecQual((List *) oldPred, econtext, false))
{
- ni++;
+ nitups++;
continue;
}
}
*/
if (pred != NULL)
{
- /* SetSlotContents(slot, htup); */
slot->val = htup;
if (!ExecQual((List *) pred, econtext, false))
continue;
}
#endif /* OMIT_PARTIAL_INDEX */
- ni++;
+ nitups++;
/*
* For the current heap tuple, extract all the attributes we use
* in this index, and note which are null.
*/
-
- for (i = 1; i <= natts; i++)
- {
- int attoff;
- bool attnull;
-
- /*
- * Offsets are from the start of the tuple, and are
- * zero-based; indices are one-based. The next call returns i
- * - 1. That's data hiding for you.
- */
-
- attoff = AttrNumberGetAttrOffset(i);
-
- /*
- * d[attoff] = HeapTupleGetAttributeValue(htup, buffer,
- */
- d[attoff] = GetIndexValue(htup,
- hd,
- attoff,
- attnum,
- finfo,
- &attnull);
- nulls[attoff] = (attnull ? 'n' : ' ');
- }
+ FormIndexDatum(indexInfo,
+ htup,
+ htupdesc,
+ econtext->ecxt_per_tuple_memory,
+ attdata,
+ nulls);
/* immediately compress keys to normalize */
- compvec = (bool *) palloc(sizeof(bool) * natts);
- for (i = 0; i < natts; i++)
+ for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
{
- gistcentryinit(&giststate, &tmpcentry, (char *) d[i],
+ gistcentryinit(&giststate, &tmpcentry, (char *) attdata[i],
(Relation) NULL, (Page) NULL, (OffsetNumber) 0,
-1 /* size is currently bogus */ , TRUE);
- if (d[i] != (Datum) tmpcentry.pred && !(giststate.keytypbyval))
+ if (attdata[i] != (Datum) tmpcentry.pred &&
+ !(giststate.keytypbyval))
compvec[i] = TRUE;
else
compvec[i] = FALSE;
- d[i] = (Datum) tmpcentry.pred;
+ attdata[i] = (Datum) tmpcentry.pred;
}
/* form an index tuple and point it at the heap tuple */
- itup = index_formtuple(id, &d[0], nulls);
+ itup = index_formtuple(itupdesc, attdata, nulls);
itup->t_tid = htup->t_self;
/*
*/
res = gistdoinsert(index, itup, &giststate);
- for (i = 0; i < natts; i++)
- if (compvec[i] == TRUE)
- pfree((char *) d[i]);
+
+ for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
+ if (compvec[i])
+ pfree(DatumGetPointer(attdata[i]));
+
pfree(itup);
pfree(res);
- pfree(compvec);
}
/* okay, all heap tuples are indexed */
- heap_endscan(scan);
+ heap_endscan(hscan);
+
+ pfree(compvec);
#ifndef OMIT_PARTIAL_INDEX
if (pred != NULL || oldPred != NULL)
{
ExecDropTupleTable(tupleTable, true);
- FreeExprContext(econtext);
}
#endif /* OMIT_PARTIAL_INDEX */
+ FreeExprContext(econtext);
/*
* Since we just counted the tuples in the heap, we update its stats
heap_close(heap, NoLock);
index_close(index);
- UpdateStats(hrelid, nh, inplace);
- UpdateStats(irelid, ni, inplace);
+ UpdateStats(hrelid, nhtups, inplace);
+ UpdateStats(irelid, nitups, inplace);
if (oldPred != NULL && !inplace)
{
- if (ni == nh)
+ if (nitups == nhtups)
pred = NULL;
UpdateIndexPredicate(irelid, oldPred, pred);
}
}
- /* be tidy */
- pfree(nulls);
- pfree(d);
-
PG_RETURN_VOID();
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.41 2000/07/12 02:36:46 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.42 2000/07/14 22:17:28 tgl Exp $
*
* NOTES
* This file contains only the public interface routines.
{
Relation heap = (Relation) PG_GETARG_POINTER(0);
Relation index = (Relation) PG_GETARG_POINTER(1);
- int32 natts = PG_GETARG_INT32(2);
- AttrNumber *attnum = (AttrNumber *) PG_GETARG_POINTER(3);
- FuncIndexInfo *finfo = (FuncIndexInfo *) PG_GETARG_POINTER(4);
- PredInfo *predInfo = (PredInfo *) PG_GETARG_POINTER(5);
+ IndexInfo *indexInfo = (IndexInfo *) PG_GETARG_POINTER(2);
+ Node *oldPred = (Node *) PG_GETARG_POINTER(3);
#ifdef NOT_USED
- bool unique = PG_GETARG_BOOL(6);
- IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(7);
+ IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(4);
#endif
HeapScanDesc hscan;
HeapTuple htup;
IndexTuple itup;
TupleDesc htupdesc,
itupdesc;
- Datum *attdata;
- bool *nulls;
- InsertIndexResult res;
+ Datum attdata[INDEX_MAX_KEYS];
+ char nulls[INDEX_MAX_KEYS];
int nhtups,
nitups;
- int i;
HashItem hitem;
-
+ Node *pred = indexInfo->ii_Predicate;
#ifndef OMIT_PARTIAL_INDEX
- ExprContext *econtext;
TupleTable tupleTable;
TupleTableSlot *slot;
-
#endif
- Node *pred,
- *oldPred;
+ ExprContext *econtext;
+ InsertIndexResult res = NULL;
- /* note that this is a new btree */
+ /* note that this is a new hash */
BuildingHash = true;
- pred = predInfo->pred;
- oldPred = predInfo->oldPred;
-
/* initialize the hash index metadata page (if this is a new index) */
if (oldPred == NULL)
_hash_metapinit(index);
htupdesc = RelationGetDescr(heap);
itupdesc = RelationGetDescr(index);
- /* get space for data items that'll appear in the index tuple */
- attdata = (Datum *) palloc(natts * sizeof(Datum));
- nulls = (bool *) palloc(natts * sizeof(bool));
-
/*
* If this is a predicate (partial) index, we will need to evaluate
* the predicate using ExecQual, which requires the current tuple to
* be in a slot of a TupleTable. In addition, ExecQual must have an
* ExprContext referring to that slot. Here, we initialize dummy
- * TupleTable and ExprContext objects for this purpose. --Nels, Feb
- * '92
+ * TupleTable and ExprContext objects for this purpose. --Nels, Feb 92
+ *
+ * We construct the ExprContext anyway since we need a per-tuple
+ * temporary memory context for function evaluation -- tgl July 00
*/
#ifndef OMIT_PARTIAL_INDEX
if (pred != NULL || oldPred != NULL)
tupleTable = ExecCreateTupleTable(1);
slot = ExecAllocTableSlot(tupleTable);
ExecSetSlotDescriptor(slot, htupdesc);
- econtext = MakeExprContext(slot, TransactionCommandContext);
}
else
{
tupleTable = NULL;
slot = NULL;
- econtext = NULL;
}
+ econtext = MakeExprContext(slot, TransactionCommandContext);
+#else
+ econtext = MakeExprContext(NULL, TransactionCommandContext);
#endif /* OMIT_PARTIAL_INDEX */
/* build the index */
while (HeapTupleIsValid(htup = heap_getnext(hscan, 0)))
{
+ MemoryContextReset(econtext->ecxt_per_tuple_memory);
+
nhtups++;
#ifndef OMIT_PARTIAL_INDEX
*/
if (oldPred != NULL)
{
- /* SetSlotContents(slot, htup); */
slot->val = htup;
if (ExecQual((List *) oldPred, econtext, false))
{
*/
if (pred != NULL)
{
- /* SetSlotContents(slot, htup); */
slot->val = htup;
if (!ExecQual((List *) pred, econtext, false))
continue;
* For the current heap tuple, extract all the attributes we use
* in this index, and note which are null.
*/
- for (i = 1; i <= natts; i++)
- {
- int attoff;
- bool attnull;
-
- /*
- * Offsets are from the start of the tuple, and are
- * zero-based; indices are one-based. The next call returns i
- * - 1. That's data hiding for you.
- */
-
- /* attoff = i - 1 */
- attoff = AttrNumberGetAttrOffset(i);
-
- /*
- * below, attdata[attoff] set to equal some datum & attnull is
- * changed to indicate whether or not the attribute is null
- * for this tuple
- */
- attdata[attoff] = GetIndexValue(htup,
- htupdesc,
- attoff,
- attnum,
- finfo,
- &attnull);
- nulls[attoff] = (attnull ? 'n' : ' ');
- }
+ FormIndexDatum(indexInfo,
+ htup,
+ htupdesc,
+ econtext->ecxt_per_tuple_memory,
+ attdata,
+ nulls);
/* form an index tuple and point it at the heap tuple */
itup = index_formtuple(itupdesc, attdata, nulls);
itup->t_tid = htup->t_self;
hitem = _hash_formitem(itup);
+
res = _hash_doinsert(index, hitem);
+
pfree(hitem);
pfree(itup);
pfree(res);
if (pred != NULL || oldPred != NULL)
{
ExecDropTupleTable(tupleTable, true);
- FreeExprContext(econtext);
}
#endif /* OMIT_PARTIAL_INDEX */
+ FreeExprContext(econtext);
/*
* Since we just counted the tuples in the heap, we update its stats
}
}
- /* be tidy */
- pfree(nulls);
- pfree(attdata);
-
/* all done */
BuildingHash = false;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.45 2000/06/13 07:34:35 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.46 2000/07/14 22:17:30 tgl Exp $
*
* INTERFACE ROUTINES
* index_open - open an index relation by relationId
return loc[(natts * (procnum - 1)) + (attnum - 1)];
}
-
-Datum
-GetIndexValue(HeapTuple tuple,
- TupleDesc hTupDesc,
- int attOff,
- AttrNumber *attrNums,
- FuncIndexInfo *fInfo,
- bool *attNull)
-{
- Datum returnVal;
-
- if (PointerIsValid(fInfo) && FIgetProcOid(fInfo) != InvalidOid)
- {
- FmgrInfo flinfo;
- FunctionCallInfoData fcinfo;
- int i;
- bool anynull = false;
-
- /*
- * XXX ought to store lookup info in FuncIndexInfo so it need not
- * be repeated on each call?
- */
- fmgr_info(FIgetProcOid(fInfo), &flinfo);
-
- MemSet(&fcinfo, 0, sizeof(fcinfo));
- fcinfo.flinfo = &flinfo;
- fcinfo.nargs = FIgetnArgs(fInfo);
-
- for (i = 0; i < FIgetnArgs(fInfo); i++)
- {
- fcinfo.arg[i] = heap_getattr(tuple,
- attrNums[i],
- hTupDesc,
- &fcinfo.argnull[i]);
- anynull |= fcinfo.argnull[i];
- }
- if (flinfo.fn_strict && anynull)
- {
- /* force a null result for strict function */
- returnVal = (Datum) 0;
- *attNull = true;
- }
- else
- {
- returnVal = FunctionCallInvoke(&fcinfo);
- *attNull = fcinfo.isnull;
- }
- }
- else
- returnVal = heap_getattr(tuple, attrNums[attOff], hTupDesc, attNull);
-
- return returnVal;
-}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.45 2000/06/08 22:36:51 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.46 2000/07/14 22:17:30 tgl Exp $
*
*-------------------------------------------------------------------------
*/
void
IndexSupportInitialize(IndexStrategy indexStrategy,
RegProcedure *indexSupport,
+ bool *isUnique,
Oid indexObjectId,
Oid accessMethodObjectId,
StrategyNumber maxStrategyNumber,
ScanKeyData entry[2];
Relation operatorRelation;
HeapTuple tuple;
+ Form_pg_index iform;
StrategyMap map;
AttrNumber attributeNumber;
int attributeIndex;
}
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "IndexSupportInitialize: corrupted catalogs");
+ elog(ERROR, "IndexSupportInitialize: no pg_index entry for index %u",
+ indexObjectId);
+
+ iform = (Form_pg_index) GETSTRUCT(tuple);
+
+ *isUnique = iform->indisunique;
maxStrategyNumber = AMStrategies(maxStrategyNumber);
*/
for (attributeIndex = 0; attributeIndex < maxAttributeNumber; attributeIndex++)
{
- Form_pg_index iform;
-
- iform = (Form_pg_index) GETSTRUCT(tuple);
-
if (!OidIsValid(iform->indkey[attributeIndex]))
{
if (attributeIndex == InvalidAttrNumber)
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.60 2000/07/12 02:36:48 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.61 2000/07/14 22:17:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
Relation heap = (Relation) PG_GETARG_POINTER(0);
Relation index = (Relation) PG_GETARG_POINTER(1);
- int32 natts = PG_GETARG_INT32(2);
- AttrNumber *attnum = (AttrNumber *) PG_GETARG_POINTER(3);
- FuncIndexInfo *finfo = (FuncIndexInfo *) PG_GETARG_POINTER(4);
- PredInfo *predInfo = (PredInfo *) PG_GETARG_POINTER(5);
- bool unique = PG_GETARG_BOOL(6);
+ IndexInfo *indexInfo = (IndexInfo *) PG_GETARG_POINTER(2);
+ Node *oldPred = (Node *) PG_GETARG_POINTER(3);
#ifdef NOT_USED
- IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(7);
+ IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(4);
#endif
HeapScanDesc hscan;
HeapTuple htup;
IndexTuple itup;
TupleDesc htupdesc,
itupdesc;
- Datum *attdata;
- bool *nulls;
- InsertIndexResult res = 0;
+ Datum attdata[INDEX_MAX_KEYS];
+ char nulls[INDEX_MAX_KEYS];
int nhtups,
nitups;
- int i;
- BTItem btitem;
-
+ Node *pred = indexInfo->ii_Predicate;
#ifndef OMIT_PARTIAL_INDEX
- ExprContext *econtext = (ExprContext *) NULL;
- TupleTable tupleTable = (TupleTable) NULL;
- TupleTableSlot *slot = (TupleTableSlot *) NULL;
-
+ TupleTable tupleTable;
+ TupleTableSlot *slot;
#endif
- Node *pred,
- *oldPred;
+ ExprContext *econtext;
+ InsertIndexResult res = NULL;
BTSpool *spool = NULL;
+ BTItem btitem;
bool usefast;
/* note that this is a new btree */
BuildingBtree = true;
- pred = predInfo->pred;
- oldPred = predInfo->oldPred;
-
/*
* bootstrap processing does something strange, so don't use
* sort/build for initial catalog indices. at some point i need to
htupdesc = RelationGetDescr(heap);
itupdesc = RelationGetDescr(index);
- /* get space for data items that'll appear in the index tuple */
- attdata = (Datum *) palloc(natts * sizeof(Datum));
- nulls = (bool *) palloc(natts * sizeof(bool));
-
/*
* If this is a predicate (partial) index, we will need to evaluate
* the predicate using ExecQual, which requires the current tuple to
* be in a slot of a TupleTable. In addition, ExecQual must have an
* ExprContext referring to that slot. Here, we initialize dummy
- * TupleTable and ExprContext objects for this purpose. --Nels, Feb
- * '92
+ * TupleTable and ExprContext objects for this purpose. --Nels, Feb 92
+ *
+ * We construct the ExprContext anyway since we need a per-tuple
+ * temporary memory context for function evaluation -- tgl July 00
*/
#ifndef OMIT_PARTIAL_INDEX
if (pred != NULL || oldPred != NULL)
tupleTable = ExecCreateTupleTable(1);
slot = ExecAllocTableSlot(tupleTable);
ExecSetSlotDescriptor(slot, htupdesc);
- econtext = MakeExprContext(slot, TransactionCommandContext);
/*
* we never want to use sort/build if we are extending an existing
*/
usefast = false;
}
+ else
+ {
+ tupleTable = NULL;
+ slot = NULL;
+ }
+ econtext = MakeExprContext(slot, TransactionCommandContext);
+#else
+ econtext = MakeExprContext(NULL, TransactionCommandContext);
#endif /* OMIT_PARTIAL_INDEX */
- /* start a heap scan */
/* build the index */
nhtups = nitups = 0;
if (usefast)
- {
- spool = _bt_spoolinit(index, unique);
- res = (InsertIndexResult) NULL;
- }
+ spool = _bt_spoolinit(index, indexInfo->ii_Unique);
+ /* start a heap scan */
hscan = heap_beginscan(heap, 0, SnapshotNow, 0, (ScanKey) NULL);
while (HeapTupleIsValid(htup = heap_getnext(hscan, 0)))
{
+ MemoryContextReset(econtext->ecxt_per_tuple_memory);
+
nhtups++;
#ifndef OMIT_PARTIAL_INDEX
*/
if (oldPred != NULL)
{
- /* SetSlotContents(slot, htup); */
slot->val = htup;
if (ExecQual((List *) oldPred, econtext, false))
{
*/
if (pred != NULL)
{
- /* SetSlotContents(slot, htup); */
slot->val = htup;
if (!ExecQual((List *) pred, econtext, false))
continue;
* For the current heap tuple, extract all the attributes we use
* in this index, and note which are null.
*/
-
- for (i = 1; i <= natts; i++)
- {
- int attoff;
- bool attnull;
-
- /*
- * Offsets are from the start of the tuple, and are
- * zero-based; indices are one-based. The next call returns i
- * - 1. That's data hiding for you.
- */
-
- attoff = AttrNumberGetAttrOffset(i);
- attdata[attoff] = GetIndexValue(htup,
- htupdesc,
- attoff,
- attnum,
- finfo,
- &attnull);
- nulls[attoff] = (attnull ? 'n' : ' ');
- }
+ FormIndexDatum(indexInfo,
+ htup,
+ htupdesc,
+ econtext->ecxt_per_tuple_memory,
+ attdata,
+ nulls);
/* form an index tuple and point it at the heap tuple */
itup = index_formtuple(itupdesc, attdata, nulls);
if (usefast)
_bt_spool(btitem, spool);
else
- res = _bt_doinsert(index, btitem, unique, heap);
+ res = _bt_doinsert(index, btitem, indexInfo->ii_Unique, heap);
pfree(btitem);
pfree(itup);
if (pred != NULL || oldPred != NULL)
{
ExecDropTupleTable(tupleTable, true);
- FreeExprContext(econtext);
}
#endif /* OMIT_PARTIAL_INDEX */
+ FreeExprContext(econtext);
/*
* if we are doing bottom-up btree build, finish the build by (1)
heap_close(heap, NoLock);
index_close(index);
- /*
- * UpdateStats(hrelid, nhtups, true); UpdateStats(irelid, nitups,
- * false);
- */
UpdateStats(hrelid, nhtups, inplace);
UpdateStats(irelid, nitups, inplace);
if (oldPred != NULL)
}
}
- pfree(nulls);
- pfree(attdata);
-
/* all done */
BuildingBtree = false;
btitem = _bt_formitem(itup);
- res = _bt_doinsert(rel, btitem,
- IndexIsUnique(RelationGetRelid(rel)), heapRel);
+ res = _bt_doinsert(rel, btitem, rel->rd_uniqueindex, heapRel);
pfree(btitem);
pfree(itup);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.51 2000/07/12 02:36:52 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.52 2000/07/14 22:17:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
Relation heap = (Relation) PG_GETARG_POINTER(0);
Relation index = (Relation) PG_GETARG_POINTER(1);
- int32 natts = PG_GETARG_INT32(2);
- AttrNumber *attnum = (AttrNumber *) PG_GETARG_POINTER(3);
- FuncIndexInfo *finfo = (FuncIndexInfo *) PG_GETARG_POINTER(4);
- PredInfo *predInfo = (PredInfo *) PG_GETARG_POINTER(5);
+ IndexInfo *indexInfo = (IndexInfo *) PG_GETARG_POINTER(2);
+ Node *oldPred = (Node *) PG_GETARG_POINTER(3);
#ifdef NOT_USED
- bool unique = PG_GETARG_BOOL(6);
- IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(7);
+ IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(4);
#endif
- HeapScanDesc scan;
- AttrNumber i;
+ HeapScanDesc hscan;
HeapTuple htup;
IndexTuple itup;
- TupleDesc hd,
- id;
- InsertIndexResult res;
- Datum *d;
- bool *nulls;
- Buffer buffer = InvalidBuffer;
- int nb,
- nh,
- ni;
-
+ TupleDesc htupdesc,
+ itupdesc;
+ Datum attdata[INDEX_MAX_KEYS];
+ char nulls[INDEX_MAX_KEYS];
+ int nhtups,
+ nitups;
+ Node *pred = indexInfo->ii_Predicate;
#ifndef OMIT_PARTIAL_INDEX
- ExprContext *econtext;
TupleTable tupleTable;
TupleTableSlot *slot;
-
#endif
- Node *pred,
- *oldPred;
+ ExprContext *econtext;
+ InsertIndexResult res = NULL;
+ Buffer buffer = InvalidBuffer;
RTSTATE rtState;
initRtstate(&rtState, index);
- pred = predInfo->pred;
- oldPred = predInfo->oldPred;
-
/*
* We expect to be called exactly once for any index relation. If
* that's not the case, big trouble's what we have.
*/
-
- if (oldPred == NULL && (nb = RelationGetNumberOfBlocks(index)) != 0)
+ if (oldPred == NULL && RelationGetNumberOfBlocks(index) != 0)
elog(ERROR, "%s already contains data", RelationGetRelationName(index));
/* initialize the root page (if this is a new index) */
WriteBuffer(buffer);
}
- /* init the tuple descriptors and get set for a heap scan */
- hd = RelationGetDescr(heap);
- id = RelationGetDescr(index);
- d = (Datum *) palloc(natts * sizeof(*d));
- nulls = (bool *) palloc(natts * sizeof(*nulls));
+ /* get tuple descriptors for heap and index relations */
+ htupdesc = RelationGetDescr(heap);
+ itupdesc = RelationGetDescr(index);
/*
* If this is a predicate (partial) index, we will need to evaluate
* the predicate using ExecQual, which requires the current tuple to
* be in a slot of a TupleTable. In addition, ExecQual must have an
* ExprContext referring to that slot. Here, we initialize dummy
- * TupleTable and ExprContext objects for this purpose. --Nels, Feb
- * '92
+ * TupleTable and ExprContext objects for this purpose. --Nels, Feb 92
+ *
+ * We construct the ExprContext anyway since we need a per-tuple
+ * temporary memory context for function evaluation -- tgl July 00
*/
#ifndef OMIT_PARTIAL_INDEX
if (pred != NULL || oldPred != NULL)
{
tupleTable = ExecCreateTupleTable(1);
slot = ExecAllocTableSlot(tupleTable);
- ExecSetSlotDescriptor(slot, hd);
- econtext = MakeExprContext(slot, TransactionCommandContext);
+ ExecSetSlotDescriptor(slot, htupdesc);
}
else
{
tupleTable = NULL;
slot = NULL;
- econtext = NULL;
}
+ econtext = MakeExprContext(slot, TransactionCommandContext);
+#else
+ econtext = MakeExprContext(NULL, TransactionCommandContext);
#endif /* OMIT_PARTIAL_INDEX */
/* count the tuples as we insert them */
- nh = ni = 0;
+ nhtups = nitups = 0;
- scan = heap_beginscan(heap, 0, SnapshotNow, 0, (ScanKey) NULL);
+ /* start a heap scan */
+ hscan = heap_beginscan(heap, 0, SnapshotNow, 0, (ScanKey) NULL);
- while (HeapTupleIsValid(htup = heap_getnext(scan, 0)))
+ while (HeapTupleIsValid(htup = heap_getnext(hscan, 0)))
{
- nh++;
+ MemoryContextReset(econtext->ecxt_per_tuple_memory);
+
+ nhtups++;
#ifndef OMIT_PARTIAL_INDEX
/*
*/
if (oldPred != NULL)
{
- /* SetSlotContents(slot, htup); */
slot->val = htup;
if (ExecQual((List *) oldPred, econtext, false))
{
- ni++;
+ nitups++;
continue;
}
}
*/
if (pred != NULL)
{
- /* SetSlotContents(slot, htup); */
slot->val = htup;
if (!ExecQual((List *) pred, econtext, false))
continue;
}
#endif /* OMIT_PARTIAL_INDEX */
- ni++;
+ nitups++;
/*
* For the current heap tuple, extract all the attributes we use
* in this index, and note which are null.
*/
-
- for (i = 1; i <= natts; i++)
- {
- int attoff;
- bool attnull;
-
- /*
- * Offsets are from the start of the tuple, and are
- * zero-based; indices are one-based. The next call returns i
- * - 1. That's data hiding for you.
- */
-
- attoff = AttrNumberGetAttrOffset(i);
-
- /*
- * d[attoff] = HeapTupleGetAttributeValue(htup, buffer,
- */
- d[attoff] = GetIndexValue(htup,
- hd,
- attoff,
- attnum,
- finfo,
- &attnull);
- nulls[attoff] = (attnull ? 'n' : ' ');
- }
+ FormIndexDatum(indexInfo,
+ htup,
+ htupdesc,
+ econtext->ecxt_per_tuple_memory,
+ attdata,
+ nulls);
/* form an index tuple and point it at the heap tuple */
- itup = index_formtuple(id, &d[0], nulls);
+ itup = index_formtuple(itupdesc, attdata, nulls);
itup->t_tid = htup->t_self;
/*
}
/* okay, all heap tuples are indexed */
- heap_endscan(scan);
+ heap_endscan(hscan);
#ifndef OMIT_PARTIAL_INDEX
if (pred != NULL || oldPred != NULL)
{
ExecDropTupleTable(tupleTable, true);
- FreeExprContext(econtext);
}
#endif /* OMIT_PARTIAL_INDEX */
+ FreeExprContext(econtext);
/*
* Since we just counted the tuples in the heap, we update its stats
heap_close(heap, NoLock);
index_close(index);
- UpdateStats(hrelid, nh, inplace);
- UpdateStats(irelid, ni, inplace);
+ UpdateStats(hrelid, nhtups, inplace);
+ UpdateStats(irelid, nitups, inplace);
if (oldPred != NULL && !inplace)
{
- if (ni == nh)
+ if (nitups == nhtups)
pred = NULL;
UpdateIndexPredicate(irelid, oldPred, pred);
}
}
- /* be tidy */
- pfree(nulls);
- pfree(d);
-
PG_RETURN_VOID();
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v 1.31 2000/07/04 06:11:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v 1.32 2000/07/14 22:17:38 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/attnum.h"
-#include "access/funcindex.h"
#include "access/htup.h"
#include "access/itup.h"
#include "access/skey.h"
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootscanner.l,v 1.17 2000/01/26 05:56:07 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootscanner.l,v 1.18 2000/07/14 22:17:38 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/attnum.h"
-#include "access/funcindex.h"
#include "access/htup.h"
#include "access/itup.h"
#include "access/skey.h"
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.90 2000/07/03 23:09:23 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.91 2000/07/14 22:17:38 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
char *il_heap;
char *il_ind;
- int il_natts;
- AttrNumber *il_attnos;
- FuncIndexInfo *il_finfo;
- PredInfo *il_predInfo;
- bool il_unique;
+ IndexInfo *il_info;
struct _IndexList *il_next;
} IndexList;
static IndexList *ILHead = (IndexList *) NULL;
-typedef void (*sig_func) ();
-
-
-
/* ----------------------------------------------------------------
* misc functions
if (!IsUnderPostmaster)
{
- pqsignal(SIGINT, (sig_func) die);
- pqsignal(SIGHUP, (sig_func) die);
- pqsignal(SIGTERM, (sig_func) die);
+ pqsignal(SIGINT, (pqsigfunc) die);
+ pqsignal(SIGHUP, (pqsigfunc) die);
+ pqsignal(SIGTERM, (pqsigfunc) die);
}
/*
void
index_register(char *heap,
char *ind,
- int natts,
- AttrNumber *attnos,
- FuncIndexInfo *finfo,
- PredInfo *predInfo,
- bool unique)
+ IndexInfo *indexInfo)
{
IndexList *newind;
- int len;
MemoryContext oldcxt;
/*
newind = (IndexList *) palloc(sizeof(IndexList));
newind->il_heap = pstrdup(heap);
newind->il_ind = pstrdup(ind);
- newind->il_natts = natts;
-
- if (PointerIsValid(finfo))
- len = FIgetnArgs(finfo) * sizeof(AttrNumber);
- else
- len = natts * sizeof(AttrNumber);
-
- newind->il_attnos = (AttrNumber *) palloc(len);
- memcpy(newind->il_attnos, attnos, len);
-
- if (PointerIsValid(finfo))
- {
- newind->il_finfo = (FuncIndexInfo *) palloc(sizeof(FuncIndexInfo));
- memcpy(newind->il_finfo, finfo, sizeof(FuncIndexInfo));
- }
- else
- newind->il_finfo = (FuncIndexInfo *) NULL;
+ newind->il_info = (IndexInfo *) palloc(sizeof(IndexInfo));
- if (predInfo != NULL)
- {
- newind->il_predInfo = (PredInfo *) palloc(sizeof(PredInfo));
- newind->il_predInfo->pred = predInfo->pred;
- newind->il_predInfo->oldPred = predInfo->oldPred;
- }
- else
- newind->il_predInfo = NULL;
-
- newind->il_unique = unique;
+ memcpy(newind->il_info, indexInfo, sizeof(IndexInfo));
+ /* predicate will likely be null anyway, but may as well copy it */
+ newind->il_info->ii_Predicate = copyObject(indexInfo->ii_Predicate);
newind->il_next = ILHead;
-
ILHead = newind;
MemoryContextSwitchTo(oldcxt);
void
build_indices()
{
- Relation heap;
- Relation ind;
-
for (; ILHead != (IndexList *) NULL; ILHead = ILHead->il_next)
{
+ Relation heap;
+ Relation ind;
+
heap = heap_openr(ILHead->il_heap, NoLock);
Assert(heap);
ind = index_openr(ILHead->il_ind);
Assert(ind);
- index_build(heap, ind, ILHead->il_natts, ILHead->il_attnos,
- ILHead->il_finfo, ILHead->il_predInfo,
- ILHead->il_unique);
+ index_build(heap, ind, ILHead->il_info, NULL);
/*
* In normal processing mode, index_build would close the heap and
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.139 2000/07/05 23:11:06 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.140 2000/07/14 22:17:40 tgl Exp $
*
*
* INTERFACE ROUTINES
ScanKeyData entry;
HeapScanDesc scan;
HeapTuple indexTuple,
- procTuple,
classTuple;
- Form_pg_index index;
+ IndexInfo *indexInfo;
Oid heapId,
indexId,
- procId,
accessMethodId;
- Node *oldPred = NULL;
- PredInfo *predInfo;
- List *cnfPred = NULL;
- AttrNumber *attributeNumberA;
- FuncIndexInfo fInfo,
- *funcInfo = NULL;
- bool unique;
- int i,
- numberOfAttributes;
- char *predString;
heapId = RelationGetRelid(heapRelation);
/* Scan pg_index to find indexes on heapRelation */
-
indexRelation = heap_openr(IndexRelationName, AccessShareLock);
ScanKeyEntryInitialize(&entry, 0, Anum_pg_index_indrelid, F_OIDEQ,
ObjectIdGetDatum(heapId));
scan = heap_beginscan(indexRelation, false, SnapshotNow, 1, &entry);
while (HeapTupleIsValid(indexTuple = heap_getnext(scan, 0)))
{
-
/*
- * For each index, fetch index attributes so we can apply
- * index_build
+ * For each index, fetch info needed for index_build
*/
- index = (Form_pg_index) GETSTRUCT(indexTuple);
- indexId = index->indexrelid;
- procId = index->indproc;
- unique = index->indisunique;
-
- for (i = 0; i < INDEX_MAX_KEYS; i++)
- {
- if (index->indkey[i] == InvalidAttrNumber)
- break;
- }
- numberOfAttributes = i;
-
- /* If a valid where predicate, compute predicate Node */
- if (VARSIZE(&index->indpred) != 0)
- {
- predString = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(&index->indpred)));
- oldPred = stringToNode(predString);
- pfree(predString);
- }
- predInfo = (PredInfo *) palloc(sizeof(PredInfo));
- predInfo->pred = (Node *) cnfPred;
- predInfo->oldPred = oldPred;
-
- /* Assign Index keys to attributes array */
- attributeNumberA = (AttrNumber *) palloc(numberOfAttributes *
- sizeof(AttrNumber));
- for (i = 0; i < numberOfAttributes; i++)
- attributeNumberA[i] = index->indkey[i];
-
- /* If this is a procedural index, initialize our FuncIndexInfo */
- if (procId != InvalidOid)
- {
- funcInfo = &fInfo;
- FIsetnArgs(funcInfo, numberOfAttributes);
- procTuple = SearchSysCacheTuple(PROCOID, ObjectIdGetDatum(procId),
- 0, 0, 0);
- if (!HeapTupleIsValid(procTuple))
- elog(ERROR, "RelationTruncateIndexes: index procedure not found");
- namecpy(&(funcInfo->funcName),
- &(((Form_pg_proc) GETSTRUCT(procTuple))->proname));
- FIsetProcOid(funcInfo, procTuple->t_data->t_oid);
- }
+ indexId = ((Form_pg_index) GETSTRUCT(indexTuple))->indexrelid;
+ indexInfo = BuildIndexInfo(indexTuple);
- /* Fetch the classTuple associated with this index */
- classTuple = SearchSysCacheTupleCopy(RELOID, ObjectIdGetDatum(indexId),
+ /* Fetch the pg_class tuple associated with this index */
+ classTuple = SearchSysCacheTupleCopy(RELOID,
+ ObjectIdGetDatum(indexId),
0, 0, 0);
if (!HeapTupleIsValid(classTuple))
- elog(ERROR, "RelationTruncateIndexes: index access method not found");
+ elog(ERROR, "RelationTruncateIndexes: index %u not found in pg_class",
+ indexId);
accessMethodId = ((Form_pg_class) GETSTRUCT(classTuple))->relam;
- /* Open our index relation */
+ /* Open the index relation */
currentIndex = index_open(indexId);
if (currentIndex == NULL)
elog(ERROR, "RelationTruncateIndexes: can't open index relation");
currentIndex->rd_nblocks = 0;
/* Initialize the index and rebuild */
- InitIndexStrategy(numberOfAttributes, currentIndex, accessMethodId);
- index_build(heapRelation, currentIndex, numberOfAttributes,
- attributeNumberA, funcInfo, predInfo, unique);
+ InitIndexStrategy(indexInfo->ii_NumIndexAttrs,
+ currentIndex, accessMethodId);
+ index_build(heapRelation, currentIndex, indexInfo, NULL);
/*
* index_build will close both the heap and index relations (but
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.125 2000/07/12 02:36:55 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.126 2000/07/14 22:17:41 tgl Exp $
*
*
* INTERFACE ROUTINES
* index_create() - Create a cataloged index relation
* index_drop() - Removes index relation from catalogs
- *
+ * BuildIndexInfo() - Prepare to insert index tuples
+ * FormIndexDatum() - Construct datum vector for one index tuple
*
*-------------------------------------------------------------------------
*/
/* non-export function prototypes */
static Oid GetHeapRelationOid(char *heapRelationName, char *indexRelationName,
bool istemp);
-static TupleDesc BuildFuncTupleDesc(FuncIndexInfo *funcInfo);
+static TupleDesc BuildFuncTupleDesc(Oid funcOid);
static TupleDesc ConstructTupleDescriptor(Oid heapoid, Relation heapRelation,
- List *attributeList, int numatts, AttrNumber *attNums);
-
+ int numatts, AttrNumber *attNums);
static void ConstructIndexReldesc(Relation indexRelation, Oid amoid);
static Oid UpdateRelationRelation(Relation indexRelation, char *temp_relname);
static void InitializeAttributeOids(Relation indexRelation,
int numatts, Oid indexoid);
static void AppendAttributeTuples(Relation indexRelation, int numatts);
static void UpdateIndexRelation(Oid indexoid, Oid heapoid,
- FuncIndexInfo *funcInfo, int natts,
- AttrNumber *attNums, Oid *classOids, Node *predicate,
- List *attributeList, bool islossy, bool unique, bool primary);
+ IndexInfo *indexInfo,
+ Oid *classOids,
+ bool islossy, bool primary);
static void DefaultBuild(Relation heapRelation, Relation indexRelation,
- int numberOfAttributes, AttrNumber *attributeNumber,
- FuncIndexInfoPtr funcInfo, PredInfo *predInfo,
- bool unique, IndexStrategy indexStrategy);
+ IndexInfo *indexInfo, Node *oldPred,
+ IndexStrategy indexStrategy);
static Oid IndexGetRelation(Oid indexId);
static bool activate_index(Oid indexId, bool activate);
+
static bool reindexing = false;
-extern bool
+
+
+bool
SetReindexProcessing(bool reindexmode)
{
bool old = reindexing;
reindexing = reindexmode;
return old;
}
-extern bool
+
+bool
IsReindexProcessing(void)
{
return reindexing;
}
static TupleDesc
-BuildFuncTupleDesc(FuncIndexInfo *funcInfo)
+BuildFuncTupleDesc(Oid funcOid)
{
- HeapTuple tuple;
TupleDesc funcTupDesc;
+ HeapTuple tuple;
Oid retType;
- char *funcname;
- int4 nargs;
- Oid *argtypes;
/*
* Allocate and zero a tuple descriptor.
MemSet(funcTupDesc->attrs[0], 0, ATTRIBUTE_TUPLE_SIZE);
/*
- * Lookup the function for the return type.
+ * Lookup the function to get its name and return type.
*/
- funcname = FIgetname(funcInfo);
- nargs = FIgetnArgs(funcInfo);
- argtypes = FIgetArglist(funcInfo);
- tuple = SearchSysCacheTuple(PROCNAME,
- PointerGetDatum(funcname),
- Int32GetDatum(nargs),
- PointerGetDatum(argtypes),
- 0);
-
+ tuple = SearchSysCacheTuple(PROCOID,
+ ObjectIdGetDatum(funcOid),
+ 0, 0, 0);
if (!HeapTupleIsValid(tuple))
- func_error("BuildFuncTupleDesc", funcname, nargs, argtypes, NULL);
-
+ elog(ERROR, "Function %u does not exist", funcOid);
retType = ((Form_pg_proc) GETSTRUCT(tuple))->prorettype;
/*
- * Look up the return type in pg_type for the type length.
+ * make the attributes name the same as the functions
+ */
+ namestrcpy(&funcTupDesc->attrs[0]->attname,
+ NameStr(((Form_pg_proc) GETSTRUCT(tuple))->proname));
+
+ /*
+ * Lookup the return type in pg_type for the type length etc.
*/
tuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(retType),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "Function %s return type does not exist", FIgetname(funcInfo));
+ elog(ERROR, "Type %u does not exist", retType);
/*
* Assign some of the attributes values. Leave the rest as 0.
funcTupDesc->attrs[0]->attstorage = 'p';
funcTupDesc->attrs[0]->attalign = ((Form_pg_type) GETSTRUCT(tuple))->typalign;
- /*
- * make the attributes name the same as the functions
- */
- namestrcpy(&funcTupDesc->attrs[0]->attname, funcname);
-
return funcTupDesc;
}
/* ----------------------------------------------------------------
* ConstructTupleDescriptor
+ *
+ * Build an index tuple descriptor for a new index (plain not functional)
* ----------------------------------------------------------------
*/
static TupleDesc
ConstructTupleDescriptor(Oid heapoid,
Relation heapRelation,
- List *attributeList,
int numatts,
AttrNumber *attNums)
{
TupleDesc heapTupDesc;
TupleDesc indexTupDesc;
- IndexElem *IndexKey;
- TypeName *IndexKeyType;
- AttrNumber atnum; /* attributeNumber[attributeOffset] */
- AttrNumber atind;
- int natts; /* Form_pg_class->relnatts */
- char *from; /* used to simplify memcpy below */
- char *to; /* used to simplify memcpy below */
+ int natts; /* #atts in heap rel --- for error checks */
int i;
+ heapTupDesc = RelationGetDescr(heapRelation);
+ natts = RelationGetForm(heapRelation)->relnatts;
+
/* ----------------
* allocate the new tuple descriptor
* ----------------
*/
- natts = RelationGetForm(heapRelation)->relnatts;
indexTupDesc = CreateTemplateTupleDesc(numatts);
- /* ----------------
- *
- * ----------------
- */
-
/* ----------------
* for each attribute we are indexing, obtain its attribute
* tuple form from either the static table of system attribute
* tuple forms or the relation tuple descriptor
* ----------------
*/
- for (i = 0; i < numatts; i += 1)
+ for (i = 0; i < numatts; i++)
{
+ AttrNumber atnum; /* attributeNumber[attributeOffset] */
+ AttrNumber atind;
+ char *from; /* used to simplify memcpy below */
+ char *to; /* used to simplify memcpy below */
/* ----------------
* get the attribute number and make sure it's valid
if (atnum > natts)
elog(ERROR, "Cannot create index: attribute %d does not exist",
atnum);
- if (attributeList)
- {
- IndexKey = (IndexElem *) lfirst(attributeList);
- IndexKeyType = IndexKey->typename;
- attributeList = lnext(attributeList);
- }
- else
- IndexKeyType = NULL;
- indexTupDesc->attrs[i] = (Form_pg_attribute) palloc(ATTRIBUTE_TUPLE_SIZE);
+ indexTupDesc->attrs[i] =
+ (Form_pg_attribute) palloc(ATTRIBUTE_TUPLE_SIZE);
/* ----------------
* determine which tuple descriptor to copy
*/
if (!AttrNumberIsForUserDefinedAttr(atnum))
{
-
/* ----------------
- * here we are indexing on a system attribute (-1...-12)
- * so we convert atnum into a usable index 0...11 so we can
+ * here we are indexing on a system attribute (-1...-n)
+ * so we convert atnum into a usable index 0...n-1 so we can
* use it to dereference the array sysatts[] which stores
* tuple descriptor information for system attributes.
* ----------------
atind = (-atnum) - 1;
from = (char *) (&sysatts[atind]);
-
}
else
{
* here we are indexing on a normal attribute (1...n)
* ----------------
*/
- heapTupDesc = RelationGetDescr(heapRelation);
atind = AttrNumberGetAttrOffset(atnum);
from = (char *) (heapTupDesc->attrs[atind]);
* the tuple desc data...
* ----------------
*/
-
to = (char *) (indexTupDesc->attrs[i]);
memcpy(to, from, ATTRIBUTE_TUPLE_SIZE);
+ /*
+ * Fix the stuff that should not be the same as the underlying attr
+ */
((Form_pg_attribute) to)->attnum = i + 1;
+ ((Form_pg_attribute) to)->attdisbursion = 0.0;
((Form_pg_attribute) to)->attnotnull = false;
((Form_pg_attribute) to)->atthasdef = false;
((Form_pg_attribute) to)->attcacheoff = -1;
- ((Form_pg_attribute) to)->atttypmod = -1;
- ((Form_pg_attribute) to)->attalign = 'i';
-
- /*
- * if the keytype is defined, we need to change the tuple form's
- * atttypid & attlen field to match that of the key's type
- */
- if (IndexKeyType != NULL)
- {
- HeapTuple tup;
-
- tup = SearchSysCacheTuple(TYPENAME,
- PointerGetDatum(IndexKeyType->name),
- 0, 0, 0);
- if (!HeapTupleIsValid(tup))
- elog(ERROR, "create index: type '%s' undefined",
- IndexKeyType->name);
- ((Form_pg_attribute) to)->atttypid = tup->t_data->t_oid;
- ((Form_pg_attribute) to)->attbyval =
- ((Form_pg_type) GETSTRUCT(tup))->typbyval;
- ((Form_pg_attribute) to)->attlen =
- ((Form_pg_type) GETSTRUCT(tup))->typlen;
- ((Form_pg_attribute) to)->attstorage = 'p';
- ((Form_pg_attribute) to)->attalign =
- ((Form_pg_type) GETSTRUCT(tup))->typalign;
- ((Form_pg_attribute) to)->atttypmod = IndexKeyType->typmod;
- }
-
/* ----------------
* now we have to drop in the proper relation descriptor
new_tuple;
bool hasind;
Relation idescs[Num_pg_attr_indices];
-
Datum value[Natts_pg_attribute];
char nullv[Natts_pg_attribute];
char replace[Natts_pg_attribute];
-
TupleDesc indexTupDesc;
int i;
/* ----------------
* open the attribute relation
- * XXX ADD INDEXING
* ----------------
*/
pg_attribute = heap_openr(AttributeRelationName, RowExclusiveLock);
heap_close(pg_attribute, RowExclusiveLock);
if (hasind)
CatalogCloseIndices(Num_pg_attr_indices, idescs);
-
}
/* ----------------------------------------------------------------
static void
UpdateIndexRelation(Oid indexoid,
Oid heapoid,
- FuncIndexInfo *funcInfo,
- int natts,
- AttrNumber *attNums,
+ IndexInfo *indexInfo,
Oid *classOids,
- Node *predicate,
- List *attributeList,
bool islossy,
- bool unique,
bool primary)
{
Form_pg_index indexForm;
- IndexElem *IndexKey;
char *predString;
text *predText;
int predLen,
Relation idescs[Num_pg_index_indices];
/* ----------------
- * allocate an Form_pg_index big enough to hold the
+ * allocate a Form_pg_index big enough to hold the
* index-predicate (if any) in string form
* ----------------
*/
- if (predicate != NULL)
+ if (indexInfo->ii_Predicate != NULL)
{
- predString = nodeToString(predicate);
+ predString = nodeToString(indexInfo->ii_Predicate);
predText = DatumGetTextP(DirectFunctionCall1(textin,
CStringGetDatum(predString)));
pfree(predString);
predLen = VARSIZE(predText);
itupLen = predLen + sizeof(FormData_pg_index);
indexForm = (Form_pg_index) palloc(itupLen);
- memset(indexForm, 0, sizeof(FormData_pg_index));
-
- memmove((char *) &indexForm->indpred, (char *) predText, predLen);
+ MemSet(indexForm, 0, sizeof(FormData_pg_index));
/* ----------------
- * store the oid information into the index tuple form
+ * store information into the index tuple form
* ----------------
*/
- indexForm->indrelid = heapoid;
indexForm->indexrelid = indexoid;
- indexForm->indproc = (PointerIsValid(funcInfo)) ?
- FIgetProcOid(funcInfo) : InvalidOid;
+ indexForm->indrelid = heapoid;
+ indexForm->indproc = indexInfo->ii_FuncOid;
+ indexForm->indisclustered = false;
indexForm->indislossy = islossy;
+ indexForm->indhaskeytype = true; /* not actually used anymore */
+ indexForm->indisunique = indexInfo->ii_Unique;
indexForm->indisprimary = primary;
- indexForm->indisunique = unique;
-
- indexForm->indhaskeytype = 0;
- while (attributeList != NIL)
- {
- IndexKey = (IndexElem *) lfirst(attributeList);
- if (IndexKey->typename != NULL)
- {
- indexForm->indhaskeytype = 1;
- break;
- }
- attributeList = lnext(attributeList);
- }
-
- MemSet((char *) &indexForm->indkey[0], 0, sizeof indexForm->indkey);
- MemSet((char *) &indexForm->indclass[0], 0, sizeof indexForm->indclass);
+ memcpy((char *) &indexForm->indpred, (char *) predText, predLen);
/* ----------------
* copy index key and op class information
+ *
+ * We zeroed the extra slots (if any) above --- that's essential.
* ----------------
*/
- for (i = 0; i < natts; i += 1)
- {
- indexForm->indkey[i] = attNums[i];
- indexForm->indclass[i] = classOids[i];
- }
-
- /*
- * If we have a functional index, add all attribute arguments
- */
- if (PointerIsValid(funcInfo))
- {
- for (i = 1; i < FIgetnArgs(funcInfo); i++)
- indexForm->indkey[i] = attNums[i];
- }
+ for (i = 0; i < indexInfo->ii_NumKeyAttrs; i++)
+ indexForm->indkey[i] = indexInfo->ii_KeyAttrNumbers[i];
- indexForm->indisclustered = '\0'; /* XXX constant */
+ for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
+ indexForm->indclass[i] = classOids[i];
/* ----------------
* open the system catalog index relation
/* ----------------
* insert the tuple into the pg_index
- * XXX ADD INDEX TUPLES TOO
* ----------------
*/
heap_insert(pg_index, tuple);
/* ----------------
- * insert the index tuple into the pg_index
+ * add index tuples for it
* ----------------
*/
if (!IsIgnoringSystemIndexes())
CatalogIndexInsert(idescs, Num_pg_index_indices, pg_index, tuple);
CatalogCloseIndices(Num_pg_index_indices, idescs);
}
+
/* ----------------
* close the relation and free the tuple
* ----------------
CommandCounterIncrement();
IndexSupportInitialize(strategy, support,
+ &indexRelation->rd_uniqueindex,
attrelid, accessMethodObjectId,
amstrategies, amsupport, numatts);
void
index_create(char *heapRelationName,
char *indexRelationName,
- FuncIndexInfo *funcInfo,
- List *attributeList,
+ IndexInfo *indexInfo,
Oid accessMethodObjectId,
- int numatts,
- AttrNumber *attNums,
Oid *classObjectId,
- Node *predicate,
bool islossy,
- bool unique,
bool primary,
bool allow_system_table_mods)
{
TupleDesc indexTupDesc;
Oid heapoid;
Oid indexoid;
- PredInfo *predInfo;
bool istemp = (get_temp_rel_by_username(heapRelationName) != NULL);
char *temp_relname = NULL;
+ SetReindexProcessing(false);
+
/* ----------------
* check parameters
* ----------------
*/
- SetReindexProcessing(false);
- if (numatts < 1)
+ if (indexInfo->ii_NumIndexAttrs < 1 ||
+ indexInfo->ii_NumKeyAttrs < 1)
elog(ERROR, "must index at least one attribute");
/* ----------------
* construct new tuple descriptor
* ----------------
*/
- if (PointerIsValid(funcInfo))
- indexTupDesc = BuildFuncTupleDesc(funcInfo);
+ if (OidIsValid(indexInfo->ii_FuncOid))
+ indexTupDesc = BuildFuncTupleDesc(indexInfo->ii_FuncOid);
else
indexTupDesc = ConstructTupleDescriptor(heapoid,
heapRelation,
- attributeList,
- numatts,
- attNums);
+ indexInfo->ii_NumKeyAttrs,
+ indexInfo->ii_KeyAttrNumbers);
if (istemp)
{
* tuple forms in the index relation's tuple descriptor
* ----------------
*/
- InitializeAttributeOids(indexRelation, numatts, indexoid);
+ InitializeAttributeOids(indexRelation,
+ indexInfo->ii_NumIndexAttrs,
+ indexoid);
/* ----------------
- * append ATTRIBUTE tuples
+ * append ATTRIBUTE tuples for the index
* ----------------
*/
- AppendAttributeTuples(indexRelation, numatts);
+ AppendAttributeTuples(indexRelation, indexInfo->ii_NumIndexAttrs);
/* ----------------
* update pg_index
* (Or, could define a rule to maintain the predicate) --Nels, Feb '92
* ----------------
*/
- UpdateIndexRelation(indexoid, heapoid, funcInfo,
- numatts, attNums, classObjectId, predicate,
- attributeList, islossy, unique, primary);
-
- predInfo = (PredInfo *) palloc(sizeof(PredInfo));
- predInfo->pred = predicate;
- predInfo->oldPred = NULL;
+ UpdateIndexRelation(indexoid, heapoid, indexInfo,
+ classObjectId, islossy, primary);
/* ----------------
* initialize the index strategy
* ----------------
*/
- InitIndexStrategy(numatts, indexRelation, accessMethodObjectId);
+ InitIndexStrategy(indexInfo->ii_NumIndexAttrs,
+ indexRelation,
+ accessMethodObjectId);
/*
* If this is bootstrap (initdb) time, then we don't actually fill in
*/
if (IsBootstrapProcessingMode())
{
- index_register(heapRelationName, indexRelationName, numatts, attNums,
- funcInfo, predInfo, unique);
+ index_register(heapRelationName, indexRelationName, indexInfo);
/* XXX shouldn't we close the heap and index rels here? */
}
else
{
- index_build(heapRelation, indexRelation, numatts, attNums,
- funcInfo, predInfo, unique);
+ index_build(heapRelation, indexRelation, indexInfo, NULL);
}
}
* index_build support
* ----------------------------------------------------------------
*/
+
+/* ----------------
+ * BuildIndexInfo
+ * Construct an IndexInfo record given the index's pg_index tuple
+ *
+ * IndexInfo stores the information about the index that's needed by
+ * FormIndexDatum, which is used for both index_build() and later insertion
+ * of individual index tuples. Normally we build an IndexInfo for an index
+ * just once per command, and then use it for (potentially) many tuples.
+ * ----------------
+ */
+IndexInfo *
+BuildIndexInfo(HeapTuple indexTuple)
+{
+ Form_pg_index indexStruct = (Form_pg_index) GETSTRUCT(indexTuple);
+ IndexInfo *ii = makeNode(IndexInfo);
+ int i;
+ int numKeys;
+
+ /* ----------------
+ * count the number of keys, and copy them into the IndexInfo
+ * ----------------
+ */
+ numKeys = 0;
+ for (i = 0; i < INDEX_MAX_KEYS &&
+ indexStruct->indkey[i] != InvalidAttrNumber; i++)
+ {
+ ii->ii_KeyAttrNumbers[i] = indexStruct->indkey[i];
+ numKeys++;
+ }
+ ii->ii_NumKeyAttrs = numKeys;
+
+ /* ----------------
+ * Handle functional index.
+ *
+ * If we have a functional index then the number of
+ * attributes defined in the index must be 1 (the function's
+ * single return value). Otherwise it's same as number of keys.
+ * ----------------
+ */
+ ii->ii_FuncOid = indexStruct->indproc;
+
+ if (OidIsValid(indexStruct->indproc))
+ {
+ ii->ii_NumIndexAttrs = 1;
+ /* Do a lookup on the function, too */
+ fmgr_info(indexStruct->indproc, & ii->ii_FuncInfo);
+ }
+ else
+ ii->ii_NumIndexAttrs = numKeys;
+
+ /* ----------------
+ * If partial index, convert predicate into expression nodetree
+ * ----------------
+ */
+ if (VARSIZE(&indexStruct->indpred) != 0)
+ {
+ char *predString;
+
+ predString = DatumGetCString(DirectFunctionCall1(textout,
+ PointerGetDatum(&indexStruct->indpred)));
+ ii->ii_Predicate = stringToNode(predString);
+ pfree(predString);
+ }
+ else
+ ii->ii_Predicate = NULL;
+
+ /* Other info */
+ ii->ii_Unique = indexStruct->indisunique;
+
+ return ii;
+}
+
/* ----------------
* FormIndexDatum
+ * Construct Datum[] and nullv[] arrays for a new index tuple.
+ *
+ * indexInfo Info about the index
+ * heapTuple Heap tuple for which we must prepare an index entry
+ * heapDescriptor tupledesc for heap tuple
+ * resultCxt Temporary memory context for any palloc'd datums created
+ * datum Array of index Datums (output area)
+ * nullv Array of is-null indicators (output area)
+ *
+ * For largely historical reasons, we don't actually call index_formtuple()
+ * here, we just prepare its input arrays datum[] and nullv[].
* ----------------
*/
void
-FormIndexDatum(int numberOfAttributes,
- AttrNumber *attributeNumber,
+FormIndexDatum(IndexInfo *indexInfo,
HeapTuple heapTuple,
TupleDesc heapDescriptor,
+ MemoryContext resultCxt,
Datum *datum,
- char *nullv,
- FuncIndexInfoPtr fInfo)
+ char *nullv)
{
- AttrNumber i;
- int offset;
+ MemoryContext oldContext;
+ int i;
+ Datum iDatum;
bool isNull;
- /* ----------------
- * for each attribute we need from the heap tuple,
- * get the attribute and stick it into the datum and
- * null arrays.
- * ----------------
- */
+ oldContext = MemoryContextSwitchTo(resultCxt);
- for (i = 1; i <= numberOfAttributes; i++)
+ if (OidIsValid(indexInfo->ii_FuncOid))
{
- offset = AttrNumberGetAttrOffset(i);
+ /* ----------------
+ * Functional index --- compute the single index attribute
+ * ----------------
+ */
+ FunctionCallInfoData fcinfo;
+ bool anynull = false;
- datum[offset] = PointerGetDatum(GetIndexValue(heapTuple,
- heapDescriptor,
- offset,
- attributeNumber,
- fInfo,
- &isNull));
+ MemSet(&fcinfo, 0, sizeof(fcinfo));
+ fcinfo.flinfo = &indexInfo->ii_FuncInfo;
+ fcinfo.nargs = indexInfo->ii_NumKeyAttrs;
- nullv[offset] = (isNull) ? 'n' : ' ';
+ for (i = 0; i < indexInfo->ii_NumKeyAttrs; i++)
+ {
+ fcinfo.arg[i] = heap_getattr(heapTuple,
+ indexInfo->ii_KeyAttrNumbers[i],
+ heapDescriptor,
+ &fcinfo.argnull[i]);
+ anynull |= fcinfo.argnull[i];
+ }
+ if (indexInfo->ii_FuncInfo.fn_strict && anynull)
+ {
+ /* force a null result for strict function */
+ iDatum = (Datum) 0;
+ isNull = true;
+ }
+ else
+ {
+ iDatum = FunctionCallInvoke(&fcinfo);
+ isNull = fcinfo.isnull;
+ }
+ datum[0] = iDatum;
+ nullv[0] = (isNull) ? 'n' : ' ';
+ }
+ else
+ {
+ /* ----------------
+ * Plain index --- for each attribute we need from the heap tuple,
+ * get the attribute and stick it into the datum and nullv arrays.
+ * ----------------
+ */
+ for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
+ {
+ iDatum = heap_getattr(heapTuple,
+ indexInfo->ii_KeyAttrNumbers[i],
+ heapDescriptor,
+ &isNull);
+ datum[i] = iDatum;
+ nullv[i] = (isNull) ? 'n' : ' ';
+ }
}
+
+ MemoryContextSwitchTo(oldContext);
}
* Lock class info for update
* --------------------------------------------
*/
-static
-bool
-LockClassinfoForUpdate(Oid relid, HeapTuple rtup, Buffer *buffer, bool confirmCommitted)
+static bool
+LockClassinfoForUpdate(Oid relid, HeapTuple rtup,
+ Buffer *buffer, bool confirmCommitted)
{
HeapTuple classTuple;
Form_pg_class pgcform;
/*
* Confirm that target tuple is locked by this transaction in case of
- * immedaite updation.
+ * immediate updation.
*/
if (immediate)
{
static void
DefaultBuild(Relation heapRelation,
Relation indexRelation,
- int numberOfAttributes,
- AttrNumber *attributeNumber,
- FuncIndexInfoPtr funcInfo,
- PredInfo *predInfo,
- bool unique, /* not used */
+ IndexInfo *indexInfo,
+ Node *oldPred,
IndexStrategy indexStrategy) /* not used */
{
HeapScanDesc scan;
HeapTuple heapTuple;
- IndexTuple indexTuple;
TupleDesc heapDescriptor;
- TupleDesc indexDescriptor;
- Datum *datum;
- char *nullv;
+ Datum datum[INDEX_MAX_KEYS];
+ char nullv[INDEX_MAX_KEYS];
long reltuples,
indtuples;
-
+ Node *predicate = indexInfo->ii_Predicate;
#ifndef OMIT_PARTIAL_INDEX
- ExprContext *econtext;
TupleTable tupleTable;
TupleTableSlot *slot;
-
#endif
- Node *predicate;
- Node *oldPred;
-
+ ExprContext *econtext;
InsertIndexResult insertResult;
/* ----------------
*/
Assert(OidIsValid(indexRelation->rd_rel->relam)); /* XXX */
- /* ----------------
- * get the tuple descriptors from the relations so we know
- * how to form the index tuples..
- * ----------------
- */
heapDescriptor = RelationGetDescr(heapRelation);
- indexDescriptor = RelationGetDescr(indexRelation);
-
- /* ----------------
- * datum and null are arrays in which we collect the index attributes
- * when forming a new index tuple.
- * ----------------
- */
- datum = (Datum *) palloc(numberOfAttributes * sizeof *datum);
- nullv = (char *) palloc(numberOfAttributes * sizeof *nullv);
/*
* If this is a predicate (partial) index, we will need to evaluate
* the predicate using ExecQual, which requires the current tuple to
* be in a slot of a TupleTable. In addition, ExecQual must have an
* ExprContext referring to that slot. Here, we initialize dummy
- * TupleTable and ExprContext objects for this purpose. --Nels, Feb
- * '92
+ * TupleTable and ExprContext objects for this purpose. --Nels, Feb 92
+ *
+ * We construct the ExprContext anyway since we need a per-tuple
+ * temporary memory context for function evaluation -- tgl July 00
*/
-
- predicate = predInfo->pred;
- oldPred = predInfo->oldPred;
-
#ifndef OMIT_PARTIAL_INDEX
if (predicate != NULL || oldPred != NULL)
{
tupleTable = ExecCreateTupleTable(1);
slot = ExecAllocTableSlot(tupleTable);
ExecSetSlotDescriptor(slot, heapDescriptor);
- econtext = MakeExprContext(slot, TransactionCommandContext);
}
else
{
tupleTable = NULL;
slot = NULL;
- econtext = NULL;
}
+ econtext = MakeExprContext(slot, TransactionCommandContext);
+#else
+ econtext = MakeExprContext(NULL, TransactionCommandContext);
#endif /* OMIT_PARTIAL_INDEX */
/* ----------------
*/
while (HeapTupleIsValid(heapTuple = heap_getnext(scan, 0)))
{
+ MemoryContextReset(econtext->ecxt_per_tuple_memory);
+
reltuples++;
#ifndef OMIT_PARTIAL_INDEX
*/
if (oldPred != NULL)
{
- /* SetSlotContents(slot, heapTuple); */
slot->val = heapTuple;
if (ExecQual((List *) oldPred, econtext, false))
{
*/
if (predicate != NULL)
{
- /* SetSlotContents(slot, heapTuple); */
slot->val = heapTuple;
if (!ExecQual((List *) predicate, econtext, false))
continue;
* with attribute information taken from the given heap tuple.
* ----------------
*/
- FormIndexDatum(numberOfAttributes, /* num attributes */
- attributeNumber, /* array of att nums to extract */
- heapTuple, /* tuple from base relation */
- heapDescriptor, /* heap tuple's descriptor */
- datum, /* return: array of attributes */
- nullv, /* return: array of char's */
- funcInfo);
-
- indexTuple = index_formtuple(indexDescriptor,
- datum,
- nullv);
-
- indexTuple->t_tid = heapTuple->t_self;
+ FormIndexDatum(indexInfo,
+ heapTuple,
+ heapDescriptor,
+ econtext->ecxt_per_tuple_memory,
+ datum,
+ nullv);
insertResult = index_insert(indexRelation, datum, nullv,
&(heapTuple->t_self), heapRelation);
if (insertResult)
pfree(insertResult);
- pfree(indexTuple);
}
heap_endscan(scan);
#ifndef OMIT_PARTIAL_INDEX
if (predicate != NULL || oldPred != NULL)
{
- /* parameter was 'false', almost certainly wrong --- tgl 9/21/99 */
ExecDropTupleTable(tupleTable, true);
- FreeExprContext(econtext);
}
#endif /* OMIT_PARTIAL_INDEX */
-
- pfree(nullv);
- pfree(datum);
+ FreeExprContext(econtext);
/*
* Since we just counted the tuples in the heap, we update its stats
void
index_build(Relation heapRelation,
Relation indexRelation,
- int numberOfAttributes,
- AttrNumber *attributeNumber,
- FuncIndexInfo *funcInfo,
- PredInfo *predInfo,
- bool unique)
+ IndexInfo *indexInfo,
+ Node *oldPred)
{
RegProcedure procedure;
* ----------------
*/
if (RegProcedureIsValid(procedure))
- OidFunctionCall8(procedure,
+ OidFunctionCall5(procedure,
PointerGetDatum(heapRelation),
PointerGetDatum(indexRelation),
- Int32GetDatum(numberOfAttributes),
- PointerGetDatum(attributeNumber),
- PointerGetDatum(funcInfo),
- PointerGetDatum(predInfo),
- BoolGetDatum(unique),
+ PointerGetDatum(indexInfo),
+ PointerGetDatum(oldPred),
PointerGetDatum(RelationGetIndexStrategy(indexRelation)));
else
DefaultBuild(heapRelation,
indexRelation,
- numberOfAttributes,
- attributeNumber,
- funcInfo,
- predInfo,
- unique,
+ indexInfo,
+ oldPred,
RelationGetIndexStrategy(indexRelation));
}
return index->indrelid;
}
-/*
- * IndexIsUnique: given an index's relation OID, see if it
- * is unique using the system cache.
- */
-bool
-IndexIsUnique(Oid indexId)
-{
- HeapTuple tuple;
- Form_pg_index index;
-
- tuple = SearchSysCacheTuple(INDEXRELID,
- ObjectIdGetDatum(indexId),
- 0, 0, 0);
- if (!HeapTupleIsValid(tuple))
- {
- elog(ERROR, "IndexIsUnique: can't find index id %u",
- indexId);
- }
- index = (Form_pg_index) GETSTRUCT(tuple);
- Assert(index->indexrelid == indexId);
-
- return index->indisunique;
-}
-
-
/* ---------------------------------
* activate_index -- activate/deactivate the specified index.
- * Note that currelntly PostgreSQL doesn't hold the
+ * Note that currently PostgreSQL doesn't hold the
* status per index
* ---------------------------------
*/
ScanKeyData entry;
HeapScanDesc scan;
HeapTuple indexTuple,
- procTuple,
classTuple;
- Form_pg_index index;
+ IndexInfo *indexInfo;
Oid heapId,
- procId,
accessMethodId;
- Node *oldPred = NULL;
- PredInfo *predInfo;
- AttrNumber *attributeNumberA;
- FuncIndexInfo fInfo,
- *funcInfo = NULL;
- int i,
- numberOfAttributes;
- bool unique;
- char *predString;
bool old;
old = SetReindexProcessing(true);
- /* Scan pg_index to find indexes on heapRelation */
+
+ /* Scan pg_index to find the index's pg_index entry */
indexRelation = heap_openr(IndexRelationName, AccessShareLock);
ScanKeyEntryInitialize(&entry, 0, Anum_pg_index_indexrelid, F_OIDEQ,
ObjectIdGetDatum(indexId));
scan = heap_beginscan(indexRelation, false, SnapshotNow, 1, &entry);
indexTuple = heap_getnext(scan, 0);
if (!HeapTupleIsValid(indexTuple))
- elog(ERROR, "reindex_index index %d tuple is invalid", indexId);
-
- /*
- * For the index, fetch index attributes so we can apply index_build
- */
- index = (Form_pg_index) GETSTRUCT(indexTuple);
- heapId = index->indrelid;
- procId = index->indproc;
- unique = index->indisunique;
-
- for (i = 0; i < INDEX_MAX_KEYS; i++)
- {
- if (index->indkey[i] == InvalidAttrNumber)
- break;
- }
- numberOfAttributes = i;
+ elog(ERROR, "reindex_index: index %u not found in pg_index", indexId);
- /* If a valid where predicate, compute predicate Node */
- if (VARSIZE(&index->indpred) != 0)
- {
- predString = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(&index->indpred)));
- oldPred = stringToNode(predString);
- pfree(predString);
- }
- predInfo = (PredInfo *) palloc(sizeof(PredInfo));
- predInfo->pred = (Node *) oldPred;
- predInfo->oldPred = NULL;
+ /* Get OID of index's parent table */
+ heapId = ((Form_pg_index) GETSTRUCT(indexTuple))->indrelid;
+ /* Fetch info needed for index_build */
+ indexInfo = BuildIndexInfo(indexTuple);
- /* Assign Index keys to attributes array */
- attributeNumberA = (AttrNumber *) palloc(numberOfAttributes * sizeof(AttrNumber));
- for (i = 0; i < numberOfAttributes; i++)
- attributeNumberA[i] = index->indkey[i];
-
- /* If this is a procedural index, initialize our FuncIndexInfo */
- if (procId != InvalidOid)
- {
- funcInfo = &fInfo;
- FIsetnArgs(funcInfo, numberOfAttributes);
- procTuple = SearchSysCacheTuple(PROCOID, ObjectIdGetDatum(procId),
- 0, 0, 0);
- if (!HeapTupleIsValid(procTuple))
- elog(ERROR, "RelationTruncateIndexes: index procedure not found");
- namecpy(&(funcInfo->funcName),
- &(((Form_pg_proc) GETSTRUCT(procTuple))->proname));
- FIsetProcOid(funcInfo, procTuple->t_data->t_oid);
- }
+ /* Complete the scan and close pg_index */
+ heap_endscan(scan);
+ heap_close(indexRelation, AccessShareLock);
/* Fetch the classTuple associated with this index */
- classTuple = SearchSysCacheTupleCopy(RELOID, ObjectIdGetDatum(indexId), 0, 0, 0);
+ classTuple = SearchSysCacheTuple(RELOID,
+ ObjectIdGetDatum(indexId),
+ 0, 0, 0);
if (!HeapTupleIsValid(classTuple))
- elog(ERROR, "RelationTruncateIndexes: index access method not found");
+ elog(ERROR, "reindex_index: index %u not found in pg_class", indexId);
accessMethodId = ((Form_pg_class) GETSTRUCT(classTuple))->relam;
/* Open our index relation */
- iRel = index_open(indexId);
- if (iRel == NULL)
- elog(ERROR, "reindex_index: can't open index relation");
heapRelation = heap_open(heapId, ExclusiveLock);
if (heapRelation == NULL)
elog(ERROR, "reindex_index: can't open heap relation");
+ iRel = index_open(indexId);
+ if (iRel == NULL)
+ elog(ERROR, "reindex_index: can't open index relation");
/* Obtain exclusive lock on it, just to be sure */
LockRelation(iRel, AccessExclusiveLock);
iRel->rd_nblocks = 0;
/* Initialize the index and rebuild */
- InitIndexStrategy(numberOfAttributes, iRel, accessMethodId);
- index_build(heapRelation, iRel, numberOfAttributes,
- attributeNumberA, funcInfo, predInfo, unique);
+ InitIndexStrategy(indexInfo->ii_NumIndexAttrs, iRel, accessMethodId);
+ index_build(heapRelation, iRel, indexInfo, NULL);
/*
* index_build will close both the heap and index relations (but not
- * give up the locks we hold on them). That's fine for the index, but
- * we need to open the heap again. We need no new lock, since this
- * backend still has the exclusive lock grabbed by heap_truncate.
+ * give up the locks we hold on them). So we're done.
*/
- iRel = index_open(indexId);
- Assert(iRel != NULL);
- /* Complete the scan and close pg_index */
- heap_endscan(scan);
- heap_close(indexRelation, AccessShareLock);
SetReindexProcessing(old);
+
return true;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.66 2000/06/17 04:56:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.67 2000/07/14 22:17:41 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
- * Changes (appends) to catalogs can (and does) happen at various places
+ * Changes (appends) to catalogs can and do happen at various places
* throughout the code. We need a generic routine that will open all of
- * the indices defined on a given catalog a return the relation descriptors
+ * the indices defined on a given catalog and return the relation descriptors
* associated with them.
*/
void
/*
- * For the same reasons outlined above CatalogOpenIndices() we need a routine
- * that takes a new catalog tuple and inserts an associated index tuple into
- * each catalog index.
+ * For the same reasons outlined above for CatalogOpenIndices(), we need a
+ * routine that takes a new catalog tuple and inserts an associated index
+ * tuple into each catalog index.
+ *
+ * NOTE: since this routine looks up all the pg_index data on each call,
+ * it's relatively inefficient for inserting a large number of tuples into
+ * the same catalog. We use it only for inserting one or a few tuples
+ * in a given command. See ExecOpenIndices() and related routines if you
+ * are inserting tuples in bulk.
+ *
+ * NOTE: we do not bother to handle partial indices. Nor do we try to
+ * be efficient for functional indices (the code should work for them,
+ * but may leak memory intraquery). This should be OK for system catalogs,
+ * but don't use this routine for user tables!
*/
void
CatalogIndexInsert(Relation *idescs,
Relation heapRelation,
HeapTuple heapTuple)
{
- HeapTuple index_tup;
TupleDesc heapDescriptor;
- Form_pg_index index_form;
Datum datum[INDEX_MAX_KEYS];
- char nulls[INDEX_MAX_KEYS];
- int natts;
- AttrNumber *attnumP;
- FuncIndexInfo finfo,
- *finfoP;
+ char nullv[INDEX_MAX_KEYS];
int i;
if (IsIgnoringSystemIndexes())
for (i = 0; i < nIndices; i++)
{
+ HeapTuple index_tup;
+ IndexInfo *indexInfo;
InsertIndexResult indexRes;
- index_tup = SearchSysCacheTupleCopy(INDEXRELID,
- ObjectIdGetDatum(idescs[i]->rd_id),
- 0, 0, 0);
- Assert(index_tup);
- index_form = (Form_pg_index) GETSTRUCT(index_tup);
-
- if (index_form->indproc != InvalidOid)
- {
- int fatts;
-
- /*
- * Compute the number of attributes we are indexing upon.
- */
- for (attnumP = index_form->indkey, fatts = 0;
- fatts < INDEX_MAX_KEYS && *attnumP != InvalidAttrNumber;
- attnumP++, fatts++)
- ;
- FIgetnArgs(&finfo) = fatts;
- natts = 1;
- FIgetProcOid(&finfo) = index_form->indproc;
- *(FIgetname(&finfo)) = '\0';
- finfoP = &finfo;
- }
- else
- {
- natts = RelationGetDescr(idescs[i])->natts;
- finfoP = (FuncIndexInfo *) NULL;
- }
+ index_tup = SearchSysCacheTuple(INDEXRELID,
+ ObjectIdGetDatum(idescs[i]->rd_id),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(index_tup))
+ elog(ERROR, "CatalogIndexInsert: index %u not found",
+ idescs[i]->rd_id);
+ indexInfo = BuildIndexInfo(index_tup);
- FormIndexDatum(natts,
- (AttrNumber *) index_form->indkey,
+ FormIndexDatum(indexInfo,
heapTuple,
heapDescriptor,
+ CurrentMemoryContext,
datum,
- nulls,
- finfoP);
+ nullv);
- indexRes = index_insert(idescs[i], datum, nulls,
+ indexRes = index_insert(idescs[i], datum, nullv,
&heapTuple->t_self, heapRelation);
if (indexRes)
pfree(indexRes);
-
- heap_freetuple(index_tup);
+ pfree(indexInfo);
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.57 2000/07/04 06:11:27 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.58 2000/07/14 22:17:42 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Relation OldIndex,
NewHeap;
HeapTuple Old_pg_index_Tuple,
- Old_pg_index_relation_Tuple,
- pg_proc_Tuple;
+ Old_pg_index_relation_Tuple;
Form_pg_index Old_pg_index_Form;
Form_pg_class Old_pg_index_relation_Form;
- Form_pg_proc pg_proc_Form;
+ IndexInfo *indexInfo;
char *NewIndexName;
- AttrNumber *attnumP;
- int natts;
- FuncIndexInfo *finfo;
NewHeap = heap_open(OIDNewHeap, AccessExclusiveLock);
OldIndex = index_open(OIDOldIndex);
/*
* OK. Create a new (temporary) index for the one that's already here.
- * To do this I get the info from pg_index, re-build the FunctInfo if
- * I have to, and add a new index with a temporary name.
+ * To do this I get the info from pg_index, and add a new index with
+ * a temporary name.
*/
- Old_pg_index_Tuple = SearchSysCacheTuple(INDEXRELID,
+ Old_pg_index_Tuple = SearchSysCacheTupleCopy(INDEXRELID,
ObjectIdGetDatum(RelationGetRelid(OldIndex)),
- 0, 0, 0);
-
+ 0, 0, 0);
Assert(Old_pg_index_Tuple);
Old_pg_index_Form = (Form_pg_index) GETSTRUCT(Old_pg_index_Tuple);
- Old_pg_index_relation_Tuple = SearchSysCacheTuple(RELOID,
- ObjectIdGetDatum(RelationGetRelid(OldIndex)),
- 0, 0, 0);
+ indexInfo = BuildIndexInfo(Old_pg_index_Tuple);
+ Old_pg_index_relation_Tuple = SearchSysCacheTupleCopy(RELOID,
+ ObjectIdGetDatum(RelationGetRelid(OldIndex)),
+ 0, 0, 0);
Assert(Old_pg_index_relation_Tuple);
Old_pg_index_relation_Form = (Form_pg_class) GETSTRUCT(Old_pg_index_relation_Tuple);
NewIndexName = palloc(NAMEDATALEN); /* XXX */
snprintf(NewIndexName, NAMEDATALEN, "temp_%x", OIDOldIndex);
- /*
- * Ugly as it is, the only way I have of working out the number of
- * attribues is to count them. Mostly there'll be just one but I've
- * got to be sure.
- */
- for (attnumP = &(Old_pg_index_Form->indkey[0]), natts = 0;
- natts < INDEX_MAX_KEYS && *attnumP != InvalidAttrNumber;
- attnumP++, natts++);
-
- /*
- * If this is a functional index, I need to rebuild the functional
- * component to pass it to the defining procedure.
- */
- if (Old_pg_index_Form->indproc != InvalidOid)
- {
- finfo = (FuncIndexInfo *) palloc(sizeof(FuncIndexInfo));
- FIgetnArgs(finfo) = natts;
- FIgetProcOid(finfo) = Old_pg_index_Form->indproc;
-
- pg_proc_Tuple = SearchSysCacheTuple(PROCOID,
- ObjectIdGetDatum(Old_pg_index_Form->indproc),
- 0, 0, 0);
-
- Assert(pg_proc_Tuple);
- pg_proc_Form = (Form_pg_proc) GETSTRUCT(pg_proc_Tuple);
- namecpy(&(finfo->funcName), &(pg_proc_Form->proname));
- natts = 1; /* function result is a single column */
- }
- else
- {
- finfo = (FuncIndexInfo *) NULL;
- }
-
index_create(RelationGetRelationName(NewHeap),
NewIndexName,
- finfo,
- NULL, /* type info is in the old index */
+ indexInfo,
Old_pg_index_relation_Form->relam,
- natts,
- Old_pg_index_Form->indkey,
Old_pg_index_Form->indclass,
- (Node *) NULL, /* XXX where's the predicate? */
Old_pg_index_Form->indislossy,
- Old_pg_index_Form->indisunique,
Old_pg_index_Form->indisprimary,
allowSystemTableMods);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.88 2000/07/05 23:11:09 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.89 2000/07/14 22:17:42 tgl Exp $
*
* NOTES
* The PerformAddAttribute() code, like most of the relation
char toast_relname[NAMEDATALEN + 1];
char toast_idxname[NAMEDATALEN + 1];
Relation toast_rel;
- AttrNumber attNums[1];
+ IndexInfo *indexInfo;
Oid classObjectId[1];
/*
CommandCounterIncrement();
/* create index on chunk_id */
- attNums[0] = 1;
+
+ indexInfo = makeNode(IndexInfo);
+ indexInfo->ii_NumIndexAttrs = 1;
+ indexInfo->ii_NumKeyAttrs = 1;
+ indexInfo->ii_KeyAttrNumbers[0] = 1;
+ indexInfo->ii_Predicate = NULL;
+ indexInfo->ii_FuncOid = InvalidOid;
+ indexInfo->ii_Unique = false;
+
classObjectId[0] = OID_OPS_OID;
- index_create(toast_relname, toast_idxname, NULL, NULL, BTREE_AM_OID,
- 1, attNums, classObjectId,
- (Node *) NULL, false, false, false, true);
+
+ index_create(toast_relname, toast_idxname, indexInfo,
+ BTREE_AM_OID, classObjectId,
+ false, false, true);
/* make the index visible in this transaction */
CommandCounterIncrement();
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.118 2000/07/12 02:36:58 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.119 2000/07/14 22:17:42 tgl Exp $
*
*-------------------------------------------------------------------------
*/
static Oid GetTypeElement(Oid type);
static Oid GetInputFunction(Oid type);
static Oid IsTypeByVal(Oid type);
-static void GetIndexRelations(Oid main_relation_oid,
- int *n_indices,
- Relation **index_rels);
-
static void CopyReadNewline(FILE *fp, int *newline);
static char *CopyReadAttribute(FILE *fp, bool *isnull, char *delim, int *newline, char *null_print);
}
static void
-CopyFrom(Relation rel, bool binary, bool oids, FILE *fp, char *delim, char *null_print)
+CopyFrom(Relation rel, bool binary, bool oids, FILE *fp,
+ char *delim, char *null_print)
{
HeapTuple tuple;
- AttrNumber attr_count;
+ TupleDesc tupDesc;
Form_pg_attribute *attr;
+ AttrNumber attr_count;
FmgrInfo *in_functions;
+ Oid *elements;
+ int32 *typmod;
int i;
Oid in_func_oid;
Datum *values;
- char *nulls,
- *index_nulls;
+ char *nulls;
bool *byval;
bool isnull;
- bool has_index;
int done = 0;
char *string = NULL,
*ptr;
- Relation *index_rels;
int32 len,
null_ct,
null_id;
int32 ntuples,
tuples_read = 0;
bool reading_to_eof = true;
- Oid *elements;
- int32 *typmod;
- FuncIndexInfo *finfo,
- **finfoP = NULL;
- TupleDesc *itupdescArr;
- HeapTuple pgIndexTup;
- Form_pg_index *pgIndexP = NULL;
- int *indexNatts = NULL;
- char *predString;
- Node **indexPred = NULL;
- TupleDesc rtupdesc;
+ RelationInfo *relationInfo;
EState *estate = makeNode(EState); /* for ExecConstraints() */
-#ifndef OMIT_PARTIAL_INDEX
- ExprContext *econtext = NULL;
TupleTable tupleTable;
- TupleTableSlot *slot = NULL;
-#endif
- int natts;
- AttrNumber *attnumP;
- Datum *idatum;
- int n_indices;
- InsertIndexResult indexRes;
- TupleDesc tupDesc;
+ TupleTableSlot *slot;
Oid loaded_oid = InvalidOid;
bool skip_tuple = false;
attr = tupDesc->attrs;
attr_count = tupDesc->natts;
- has_index = false;
-
/*
- * This may be a scalar or a functional index. We initialize all
- * kinds of arrays here to avoid doing extra work at every tuple copy.
+ * We need a RelationInfo so we can use the regular executor's
+ * index-entry-making machinery. (There used to be a huge amount
+ * of code here that basically duplicated execUtils.c ...)
*/
+ relationInfo = makeNode(RelationInfo);
+ relationInfo->ri_RangeTableIndex = 1; /* dummy */
+ relationInfo->ri_RelationDesc = rel;
+ relationInfo->ri_NumIndices = 0;
+ relationInfo->ri_IndexRelationDescs = NULL;
+ relationInfo->ri_IndexRelationInfo = NULL;
- if (rel->rd_rel->relhasindex)
- {
- GetIndexRelations(RelationGetRelid(rel), &n_indices, &index_rels);
- if (n_indices > 0)
- {
- has_index = true;
- itupdescArr = (TupleDesc *) palloc(n_indices * sizeof(TupleDesc));
- pgIndexP = (Form_pg_index *) palloc(n_indices * sizeof(Form_pg_index));
- indexNatts = (int *) palloc(n_indices * sizeof(int));
- finfo = (FuncIndexInfo *) palloc(n_indices * sizeof(FuncIndexInfo));
- finfoP = (FuncIndexInfo **) palloc(n_indices * sizeof(FuncIndexInfo *));
- indexPred = (Node **) palloc(n_indices * sizeof(Node *));
- for (i = 0; i < n_indices; i++)
- {
- itupdescArr[i] = RelationGetDescr(index_rels[i]);
- pgIndexTup = SearchSysCacheTuple(INDEXRELID,
- ObjectIdGetDatum(RelationGetRelid(index_rels[i])),
- 0, 0, 0);
- Assert(pgIndexTup);
- pgIndexP[i] = (Form_pg_index) GETSTRUCT(pgIndexTup);
- for (attnumP = &(pgIndexP[i]->indkey[0]), natts = 0;
- natts < INDEX_MAX_KEYS && *attnumP != InvalidAttrNumber;
- attnumP++, natts++);
- if (pgIndexP[i]->indproc != InvalidOid)
- {
- FIgetnArgs(&finfo[i]) = natts;
- natts = 1;
- FIgetProcOid(&finfo[i]) = pgIndexP[i]->indproc;
- *(FIgetname(&finfo[i])) = '\0';
- finfoP[i] = &finfo[i];
- }
- else
- finfoP[i] = (FuncIndexInfo *) NULL;
- indexNatts[i] = natts;
- if (VARSIZE(&pgIndexP[i]->indpred) != 0)
- {
- predString = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(&pgIndexP[i]->indpred)));
- indexPred[i] = stringToNode(predString);
- pfree(predString);
-#ifndef OMIT_PARTIAL_INDEX
- /* make dummy ExprContext for use by ExecQual */
- if (econtext == NULL)
- {
- tupleTable = ExecCreateTupleTable(1);
- slot = ExecAllocTableSlot(tupleTable);
- rtupdesc = RelationGetDescr(rel);
- ExecSetSlotDescriptor(slot, rtupdesc);
- econtext = MakeExprContext(slot,
- TransactionCommandContext);
- }
-#endif /* OMIT_PARTIAL_INDEX */
- }
- else
- indexPred[i] = NULL;
- }
- }
- }
+ ExecOpenIndices(relationInfo);
+
+ estate->es_result_relation_info = relationInfo;
+
+ /* Set up a dummy tuple table too */
+ tupleTable = ExecCreateTupleTable(1);
+ slot = ExecAllocTableSlot(tupleTable);
+ ExecSetSlotDescriptor(slot, tupDesc);
if (!binary)
{
reading_to_eof = false;
}
- values = (Datum *) palloc(sizeof(Datum) * attr_count);
- nulls = (char *) palloc(attr_count);
- index_nulls = (char *) palloc(attr_count);
- idatum = (Datum *) palloc(sizeof(Datum) * attr_count);
+ values = (Datum *) palloc(attr_count * sizeof(Datum));
+ nulls = (char *) palloc(attr_count * sizeof(char));
byval = (bool *) palloc(attr_count * sizeof(bool));
for (i = 0; i < attr_count; i++)
{
nulls[i] = ' ';
- index_nulls[i] = ' ';
#ifdef _DROP_COLUMN_HACK__
if (COLUMN_IS_DROPPED(attr[i]))
{
tuple->t_data->t_oid = loaded_oid;
skip_tuple = false;
+
/* BEFORE ROW INSERT Triggers */
if (rel->trigdesc &&
rel->trigdesc->n_before_row[TRIGGER_EVENT_INSERT] > 0)
if (!skip_tuple)
{
/* ----------------
- * Check the constraints of a tuple
+ * Check the constraints of the tuple
* ----------------
*/
if (rel->rd_att->constr)
ExecConstraints("CopyFrom", rel, tuple, estate);
+ /* ----------------
+ * OK, store the tuple and create index entries for it
+ * ----------------
+ */
heap_insert(rel, tuple);
- if (has_index)
+ if (relationInfo->ri_NumIndices > 0)
{
- for (i = 0; i < n_indices; i++)
- {
-#ifndef OMIT_PARTIAL_INDEX
- if (indexPred[i] != NULL)
- {
- /*
- * if tuple doesn't satisfy predicate, don't
- * update index
- */
- slot->val = tuple;
- /* SetSlotContents(slot, tuple); */
- if (!ExecQual((List *) indexPred[i], econtext, false))
- continue;
- }
-#endif /* OMIT_PARTIAL_INDEX */
- FormIndexDatum(indexNatts[i],
- (AttrNumber *) &(pgIndexP[i]->indkey[0]),
- tuple,
- tupDesc,
- idatum,
- index_nulls,
- finfoP[i]);
- indexRes = index_insert(index_rels[i], idatum, index_nulls,
- &(tuple->t_self), rel);
- if (indexRes)
- pfree(indexRes);
- }
+ ExecStoreTuple(tuple, slot, InvalidBuffer, false);
+ ExecInsertIndexTuples(slot, &(tuple->t_self), estate, false);
}
+
/* AFTER ROW INSERT Triggers */
if (rel->trigdesc &&
rel->trigdesc->n_after_row[TRIGGER_EVENT_INSERT] > 0)
if (!binary)
pfree((void *) values[i]);
}
- else if (nulls[i] == 'n')
- nulls[i] = ' ';
+ /* reset nulls[] array for next time */
+ nulls[i] = ' ';
}
heap_freetuple(tuple);
if (!reading_to_eof && ntuples == tuples_read)
done = true;
}
+
+ /*
+ * Done, clean up
+ */
lineno = 0;
+
pfree(values);
pfree(nulls);
- pfree(index_nulls);
- pfree(idatum);
pfree(byval);
if (!binary)
pfree(typmod);
}
- if (has_index)
- {
- for (i = 0; i < n_indices; i++)
- {
- if (index_rels[i] == NULL)
- continue;
- /* see comments in ExecOpenIndices() in execUtils.c */
- if ((index_rels[i])->rd_rel->relam != BTREE_AM_OID &&
- (index_rels[i])->rd_rel->relam != HASH_AM_OID)
- UnlockRelation(index_rels[i], AccessExclusiveLock);
- index_close(index_rels[i]);
- }
- }
-}
+ ExecDropTupleTable(tupleTable, true);
+ ExecCloseIndices(relationInfo);
+}
static Oid
return InvalidOid;
}
-/*
- * Given the OID of a relation, return an array of index relation descriptors
- * and the number of index relations. These relation descriptors are open
- * using index_open().
- *
- * Space for the array itself is palloc'ed.
- */
-
-static void
-GetIndexRelations(Oid main_relation_oid,
- int *n_indices,
- Relation **index_rels)
-{
- Relation relation;
- List *indexoidlist,
- *indexoidscan;
- int i;
-
- relation = heap_open(main_relation_oid, AccessShareLock);
- indexoidlist = RelationGetIndexList(relation);
-
- *n_indices = length(indexoidlist);
-
- if (*n_indices > 0)
- *index_rels = (Relation *) palloc(*n_indices * sizeof(Relation));
- else
- *index_rels = NULL;
-
- i = 0;
- foreach(indexoidscan, indexoidlist)
- {
- Oid indexoid = lfirsti(indexoidscan);
- Relation index = index_open(indexoid);
-
- /* see comments in ExecOpenIndices() in execUtils.c */
- if (index != NULL &&
- index->rd_rel->relam != BTREE_AM_OID &&
- index->rd_rel->relam != HASH_AM_OID)
- LockRelation(index, AccessExclusiveLock);
- (*index_rels)[i] = index;
- i++;
- }
-
- freeList(indexoidlist);
- heap_close(relation, AccessShareLock);
-}
/*
* Reads input from fp until an end of line is seen.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.34 2000/07/05 23:11:11 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.35 2000/07/14 22:17:42 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/catname.h"
#include "catalog/heap.h"
#include "catalog/index.h"
+#include "catalog/pg_am.h"
#include "catalog/pg_amop.h"
#include "catalog/pg_database.h"
#include "catalog/pg_index.h"
static void CheckPredicate(List *predList, List *rangeTable, Oid baseRelOid);
static void CheckPredExpr(Node *predicate, List *rangeTable, Oid baseRelOid);
static void CheckPredClause(Expr *predicate, List *rangeTable, Oid baseRelOid);
-static void FuncIndexArgs(IndexElem *funcIndex, FuncIndexInfo *funcInfo,
- AttrNumber *attNumP, Oid *opOidP, Oid relId,
+static void FuncIndexArgs(IndexInfo *indexInfo, Oid *classOidP,
+ IndexElem *funcIndex,
+ Oid relId,
char *accessMethodName, Oid accessMethodId);
-static void NormIndexAttrs(List *attList, AttrNumber *attNumP,
- Oid *opOidP, Oid relId,
+static void NormIndexAttrs(IndexInfo *indexInfo, Oid *classOidP,
+ List *attList,
+ Oid relId,
char *accessMethodName, Oid accessMethodId);
-static void ProcessAttrTypename(IndexElem *attribute,
- Oid defType, int32 defTypmod);
static Oid GetAttrOpClass(IndexElem *attribute, Oid attrType,
char *accessMethodName, Oid accessMethodId);
static char *GetDefaultOpClass(Oid atttypid);
* index or a list of attributes to index on.
* 'parameterList' is a list of DefElem specified in the with clause.
* 'predicate' is the qual specified in the where clause.
- * 'rangetable' is for the predicate
- *
- * Exceptions:
- * XXX
+ * 'rangetable' is needed to interpret the predicate
*/
void
DefineIndex(char *heapRelationName,
Oid *classObjectId;
Oid accessMethodId;
Oid relationId;
+ IndexInfo *indexInfo;
int numberOfAttributes;
- AttrNumber *attributeNumberA;
HeapTuple tuple;
- FuncIndexInfo fInfo;
- List *cnfPred = NULL;
+ List *cnfPred = NIL;
bool lossy = false;
List *pl;
/*
- * count attributes
+ * count attributes in index
*/
numberOfAttributes = length(attributeList);
if (numberOfAttributes <= 0)
* compute heap relation id
*/
if ((relationId = RelnameFindRelid(heapRelationName)) == InvalidOid)
- {
elog(ERROR, "DefineIndex: relation \"%s\" not found",
heapRelationName);
- }
-
- /*
- * XXX Hardwired hacks to check for limitations on supported index types.
- * We really ought to be learning this info from entries in the pg_am
- * table, instead of having it wired in here!
- */
- if (unique && strcmp(accessMethodName, "btree") != 0)
- elog(ERROR, "DefineIndex: unique indices are only available with the btree access method");
-
- if (numberOfAttributes > 1 && strcmp(accessMethodName, "btree") != 0)
- elog(ERROR, "DefineIndex: multi-column indices are only available with the btree access method");
/*
* compute access method id
PointerGetDatum(accessMethodName),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
- {
elog(ERROR, "DefineIndex: access method \"%s\" not found",
accessMethodName);
- }
accessMethodId = tuple->t_data->t_oid;
+ /*
+ * XXX Hardwired hacks to check for limitations on supported index types.
+ * We really ought to be learning this info from entries in the pg_am
+ * table, instead of having it wired in here!
+ */
+ if (unique && accessMethodId != BTREE_AM_OID)
+ elog(ERROR, "DefineIndex: unique indices are only available with the btree access method");
+
+ if (numberOfAttributes > 1 && accessMethodId != BTREE_AM_OID)
+ elog(ERROR, "DefineIndex: multi-column indices are only available with the btree access method");
+
/*
* WITH clause reinstated to handle lossy indices. -- JMH, 7/22/96
*/
DefElem *param = (DefElem *) lfirst(pl);
if (!strcasecmp(param->defname, "islossy"))
- lossy = TRUE;
+ lossy = true;
else
elog(NOTICE, "Unrecognized index attribute \"%s\" ignored",
param->defname);
if (!IsBootstrapProcessingMode() && !IndexesAreActive(relationId, false))
elog(ERROR, "Existing indexes are inactive. REINDEX first");
+ /*
+ * Prepare arguments for index_create, primarily an IndexInfo structure
+ */
+ indexInfo = makeNode(IndexInfo);
+ indexInfo->ii_Predicate = (Node *) cnfPred;
+ indexInfo->ii_FuncOid = InvalidOid;
+ indexInfo->ii_Unique = unique;
+
if (IsFuncIndex(attributeList))
{
- IndexElem *funcIndex = lfirst(attributeList);
+ IndexElem *funcIndex = (IndexElem *) lfirst(attributeList);
int nargs;
+ /* Parser should have given us only one list item, but check */
+ if (numberOfAttributes != 1)
+ elog(ERROR, "Functional index can only have one attribute");
+
nargs = length(funcIndex->args);
if (nargs > INDEX_MAX_KEYS)
elog(ERROR, "Index function can take at most %d arguments",
INDEX_MAX_KEYS);
- FIsetnArgs(&fInfo, nargs);
-
- namestrcpy(&fInfo.funcName, funcIndex->name);
-
- attributeNumberA = (AttrNumber *) palloc(nargs *
- sizeof attributeNumberA[0]);
+ indexInfo->ii_NumIndexAttrs = 1;
+ indexInfo->ii_NumKeyAttrs = nargs;
classObjectId = (Oid *) palloc(sizeof(Oid));
- FuncIndexArgs(funcIndex, &fInfo, attributeNumberA,
- classObjectId, relationId,
- accessMethodName, accessMethodId);
-
- index_create(heapRelationName, indexRelationName,
- &fInfo, NULL,
- accessMethodId, numberOfAttributes, attributeNumberA,
- classObjectId,
- (Node *) cnfPred,
- lossy, unique, primary, allowSystemTableMods);
+ FuncIndexArgs(indexInfo, classObjectId, funcIndex,
+ relationId, accessMethodName, accessMethodId);
}
else
{
- attributeNumberA = (AttrNumber *) palloc(numberOfAttributes *
- sizeof attributeNumberA[0]);
+ indexInfo->ii_NumIndexAttrs = numberOfAttributes;
+ indexInfo->ii_NumKeyAttrs = numberOfAttributes;
classObjectId = (Oid *) palloc(numberOfAttributes * sizeof(Oid));
- NormIndexAttrs(attributeList, attributeNumberA,
- classObjectId, relationId,
- accessMethodName, accessMethodId);
-
- index_create(heapRelationName, indexRelationName,
- NULL, attributeList,
- accessMethodId, numberOfAttributes, attributeNumberA,
- classObjectId,
- (Node *) cnfPred,
- lossy, unique, primary, allowSystemTableMods);
+ NormIndexAttrs(indexInfo, classObjectId, attributeList,
+ relationId, accessMethodName, accessMethodId);
}
+ index_create(heapRelationName, indexRelationName,
+ indexInfo, accessMethodId, classObjectId,
+ lossy, primary, allowSystemTableMods);
+
/*
* We update the relation's pg_class tuple even if it already has
* relhasindex = true. This is needed to cause a shared-cache-inval
/*
* ExtendIndex
* Extends a partial index.
- *
- * Exceptions:
- * XXX
*/
void
ExtendIndex(char *indexRelationName, Expr *predicate, List *rangetable)
{
- Oid *classObjectId;
- Oid accessMethodId;
- Oid indexId,
+ Relation heapRelation;
+ Relation indexRelation;
+ Oid accessMethodId,
+ indexId,
relationId;
- Oid indproc;
- int numberOfAttributes;
- AttrNumber *attributeNumberA;
HeapTuple tuple;
- FuncIndexInfo fInfo;
- FuncIndexInfo *funcInfo = NULL;
- bool unique;
Form_pg_index index;
- Node *oldPred = NULL;
- List *cnfPred = NULL;
- PredInfo *predInfo;
- Relation heapRelation;
- Relation indexRelation;
- int i;
+ List *cnfPred = NIL;
+ IndexInfo *indexInfo;
+ Node *oldPred;
/*
- * compute index relation id and access method id
+ * Get index's relation id and access method id from pg_class
*/
tuple = SearchSysCacheTuple(RELNAME,
PointerGetDatum(indexRelationName),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
- {
elog(ERROR, "ExtendIndex: index \"%s\" not found",
indexRelationName);
- }
indexId = tuple->t_data->t_oid;
accessMethodId = ((Form_pg_class) GETSTRUCT(tuple))->relam;
/*
- * find pg_index tuple
+ * Extract info from the pg_index tuple for the index
*/
tuple = SearchSysCacheTuple(INDEXRELID,
ObjectIdGetDatum(indexId),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
- {
elog(ERROR, "ExtendIndex: relation \"%s\" is not an index",
indexRelationName);
- }
-
- /*
- * Extract info from the pg_index tuple
- */
index = (Form_pg_index) GETSTRUCT(tuple);
Assert(index->indexrelid == indexId);
relationId = index->indrelid;
- indproc = index->indproc;
- unique = index->indisunique;
-
- for (i = 0; i < INDEX_MAX_KEYS; i++)
- {
- if (index->indkey[i] == InvalidAttrNumber)
- break;
- }
- numberOfAttributes = i;
+ indexInfo = BuildIndexInfo(tuple);
+ oldPred = indexInfo->ii_Predicate;
- if (VARSIZE(&index->indpred) != 0)
- {
- char *predString;
-
- predString = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(&index->indpred)));
- oldPred = stringToNode(predString);
- pfree(predString);
- }
if (oldPred == NULL)
elog(ERROR, "ExtendIndex: \"%s\" is not a partial index",
indexRelationName);
/*
* Convert the extension predicate from parsetree form to plan form,
* so it can be readily evaluated during index creation. Note:
- * "predicate" comes in as a list containing (1) the predicate itself
- * (a where_clause), and (2) a corresponding range table.
+ * "predicate" comes in two parts (1) the predicate expression itself,
+ * and (2) a corresponding range table.
+ *
+ * XXX I think this code is broken --- index_build expects a single
+ * expression not a list --- tgl Jul 00
*/
if (rangetable != NIL)
{
CheckPredicate(cnfPred, rangetable, relationId);
}
- /* make predInfo list to pass to index_build */
- predInfo = (PredInfo *) palloc(sizeof(PredInfo));
- predInfo->pred = (Node *) cnfPred;
- predInfo->oldPred = oldPred;
-
- attributeNumberA = (AttrNumber *) palloc(numberOfAttributes *
- sizeof attributeNumberA[0]);
- classObjectId = (Oid *) palloc(numberOfAttributes * sizeof classObjectId[0]);
-
-
- for (i = 0; i < numberOfAttributes; i++)
- {
- attributeNumberA[i] = index->indkey[i];
- classObjectId[i] = index->indclass[i];
- }
-
- if (indproc != InvalidOid)
- {
- funcInfo = &fInfo;
- FIsetnArgs(funcInfo, numberOfAttributes);
-
- tuple = SearchSysCacheTuple(PROCOID,
- ObjectIdGetDatum(indproc),
- 0, 0, 0);
- if (!HeapTupleIsValid(tuple))
- elog(ERROR, "ExtendIndex: index procedure %u not found",
- indproc);
-
- namecpy(&(funcInfo->funcName),
- &(((Form_pg_proc) GETSTRUCT(tuple))->proname));
-
- FIsetProcOid(funcInfo, tuple->t_data->t_oid);
- }
+ /* pass new predicate to index_build */
+ indexInfo->ii_Predicate = (Node *) cnfPred;
+ /* Open heap and index rels, and get suitable locks */
heapRelation = heap_open(relationId, ShareLock);
indexRelation = index_open(indexId);
- InitIndexStrategy(numberOfAttributes, indexRelation, accessMethodId);
+ /* Obtain exclusive lock on it, just to be sure */
+ LockRelation(indexRelation, AccessExclusiveLock);
+
+ InitIndexStrategy(indexInfo->ii_NumIndexAttrs,
+ indexRelation, accessMethodId);
- index_build(heapRelation, indexRelation, numberOfAttributes,
- attributeNumberA, funcInfo, predInfo, unique);
+ index_build(heapRelation, indexRelation, indexInfo, oldPred);
/* heap and index rels are closed as a side-effect of index_build */
}
static void
-FuncIndexArgs(IndexElem *funcIndex,
- FuncIndexInfo *funcInfo,
- AttrNumber *attNumP,
- Oid *opOidP,
+FuncIndexArgs(IndexInfo *indexInfo,
+ Oid *classOidP,
+ IndexElem *funcIndex,
Oid relId,
char *accessMethodName,
Oid accessMethodId)
{
- List *rest;
+ Oid argTypes[FUNC_MAX_ARGS];
+ List *arglist;
HeapTuple tuple;
Oid retType;
int argn = 0;
/*
* process the function arguments, which are a list of T_String
* (someday ought to allow more general expressions?)
+ *
+ * Note caller already checked that list is not too long.
*/
- MemSet(funcInfo->arglist, 0, FUNC_MAX_ARGS * sizeof(Oid));
+ MemSet(argTypes, 0, sizeof(argTypes));
- foreach(rest, funcIndex->args)
+ foreach(arglist, funcIndex->args)
{
- char *arg = strVal(lfirst(rest));
+ char *arg = strVal(lfirst(arglist));
Form_pg_attribute att;
tuple = SearchSysCacheTuple(ATTNAME,
ObjectIdGetDatum(relId),
- PointerGetDatum(arg), 0, 0);
-
+ PointerGetDatum(arg),
+ 0, 0);
if (!HeapTupleIsValid(tuple))
elog(ERROR, "DefineIndex: attribute \"%s\" not found", arg);
att = (Form_pg_attribute) GETSTRUCT(tuple);
- *attNumP++ = att->attnum;
- funcInfo->arglist[argn++] = att->atttypid;
+
+ indexInfo->ii_KeyAttrNumbers[argn] = att->attnum;
+ argTypes[argn] = att->atttypid;
+ argn++;
}
/* ----------------
* Lookup the function procedure to get its OID and result type.
+ *
+ * XXX need to accept binary-compatible functions here, not just
+ * an exact match.
* ----------------
*/
tuple = SearchSysCacheTuple(PROCNAME,
- PointerGetDatum(FIgetname(funcInfo)),
- Int32GetDatum(FIgetnArgs(funcInfo)),
- PointerGetDatum(FIgetArglist(funcInfo)),
+ PointerGetDatum(funcIndex->name),
+ Int32GetDatum(indexInfo->ii_NumKeyAttrs),
+ PointerGetDatum(argTypes),
0);
-
if (!HeapTupleIsValid(tuple))
{
- func_error("DefineIndex", FIgetname(funcInfo),
- FIgetnArgs(funcInfo), FIgetArglist(funcInfo), NULL);
+ func_error("DefineIndex", funcIndex->name,
+ indexInfo->ii_NumKeyAttrs, argTypes, NULL);
}
- FIsetProcOid(funcInfo, tuple->t_data->t_oid);
+ indexInfo->ii_FuncOid = tuple->t_data->t_oid;
retType = ((Form_pg_proc) GETSTRUCT(tuple))->prorettype;
- /* Process type and opclass, using func return type as default */
+ /* Process opclass, using func return type as default type */
- ProcessAttrTypename(funcIndex, retType, -1);
+ classOidP[0] = GetAttrOpClass(funcIndex, retType,
+ accessMethodName, accessMethodId);
- *opOidP = GetAttrOpClass(funcIndex, retType,
- accessMethodName, accessMethodId);
+ /* Need to do the fmgr function lookup now, too */
+
+ fmgr_info(indexInfo->ii_FuncOid, & indexInfo->ii_FuncInfo);
}
static void
-NormIndexAttrs(List *attList, /* list of IndexElem's */
- AttrNumber *attNumP,
+NormIndexAttrs(IndexInfo *indexInfo,
Oid *classOidP,
+ List *attList, /* list of IndexElem's */
Oid relId,
char *accessMethodName,
Oid accessMethodId)
{
List *rest;
+ int attn = 0;
/*
* process attributeList
*/
foreach(rest, attList)
{
- IndexElem *attribute = lfirst(rest);
+ IndexElem *attribute = (IndexElem *) lfirst(rest);
HeapTuple atttuple;
Form_pg_attribute attform;
attribute->name);
attform = (Form_pg_attribute) GETSTRUCT(atttuple);
- *attNumP++ = attform->attnum;
-
- ProcessAttrTypename(attribute, attform->atttypid, attform->atttypmod);
+ indexInfo->ii_KeyAttrNumbers[attn] = attform->attnum;
- *classOidP++ = GetAttrOpClass(attribute, attform->atttypid,
- accessMethodName, accessMethodId);
+ classOidP[attn] = GetAttrOpClass(attribute, attform->atttypid,
+ accessMethodName, accessMethodId);
heap_freetuple(atttuple);
- }
-}
-
-static void
-ProcessAttrTypename(IndexElem *attribute,
- Oid defType, int32 defTypmod)
-{
- HeapTuple tuple;
-
- /* build a type node so we can set the proper alignment, etc. */
- if (attribute->typename == NULL)
- {
- tuple = SearchSysCacheTuple(TYPEOID,
- ObjectIdGetDatum(defType),
- 0, 0, 0);
- if (!HeapTupleIsValid(tuple))
- elog(ERROR, "DefineIndex: type for attribute \"%s\" undefined",
- attribute->name);
-
- attribute->typename = makeNode(TypeName);
- attribute->typename->name = nameout(&((Form_pg_type) GETSTRUCT(tuple))->typname);
- attribute->typename->typmod = defTypmod;
+ attn++;
}
}
*
* If the opclass was the default for the datatype, assume we can skip
* this check --- that saves a few cycles in the most common case.
- * If pg_opclass is messed up then we're probably screwed anyway...
+ * If pg_opclass is wrong then we're probably screwed anyway...
*/
if (doTypeCheck)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.162 2000/07/05 16:17:38 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.163 2000/07/14 22:17:42 tgl Exp $
*
*-------------------------------------------------------------------------
#include "catalog/index.h"
#include "commands/vacuum.h"
#include "miscadmin.h"
+#include "nodes/execnodes.h"
#include "storage/sinval.h"
#include "storage/smgr.h"
#include "tcop/tcopprot.h"
static void vpage_insert(VacPageList vacpagelist, VacPage vpnew);
static void get_indices(Relation relation, int *nindices, Relation **Irel);
static void close_indices(int nindices, Relation *Irel);
-static void get_index_desc(Relation onerel, int nindices, Relation *Irel, IndDesc **Idesc);
+static IndexInfo **get_index_desc(Relation onerel, int nindices,
+ Relation *Irel);
static void *vac_find_eq(void *bot, int nelem, int size, void *elm,
int (*compar) (const void *, const void *));
static int vac_cmp_blk(const void *left, const void *right);
newitemid;
HeapTupleData tuple,
newtup;
- TupleDesc tupdesc = NULL;
- Datum *idatum = NULL;
- char *inulls = NULL;
+ TupleDesc tupdesc;
+ IndexInfo **indexInfo = NULL;
+ Datum idatum[INDEX_MAX_KEYS];
+ char inulls[INDEX_MAX_KEYS];
InsertIndexResult iresult;
VacPageListData Nvacpagelist;
VacPage cur_page = NULL,
vacpage,
*curpage;
int cur_item = 0;
- IndDesc *Idesc,
- *idcur;
int last_move_dest_block = -1,
last_vacuum_block,
i = 0;
myXID = GetCurrentTransactionId();
myCID = GetCurrentCommandId();
+ tupdesc = RelationGetDescr(onerel);
+
if (Irel != (Relation *) NULL) /* preparation for index' inserts */
- {
- get_index_desc(onerel, nindices, Irel, &Idesc);
- tupdesc = RelationGetDescr(onerel);
- idatum = (Datum *) palloc(INDEX_MAX_KEYS * sizeof(*idatum));
- inulls = (char *) palloc(INDEX_MAX_KEYS * sizeof(*inulls));
- }
+ indexInfo = get_index_desc(onerel, nindices, Irel);
Nvacpagelist.num_pages = 0;
num_fraged_pages = fraged_pages->num_pages;
if (Irel != (Relation *) NULL)
{
- for (i = 0, idcur = Idesc; i < nindices; i++, idcur++)
+ /*
+ * XXX using CurrentMemoryContext here means
+ * intra-vacuum memory leak for functional indexes.
+ * Should fix someday.
+ *
+ * XXX This code fails to handle partial indexes!
+ * Probably should change it to use ExecOpenIndices.
+ */
+ for (i = 0; i < nindices; i++)
{
- FormIndexDatum(idcur->natts,
- (AttrNumber *) &(idcur->tform->indkey[0]),
+ FormIndexDatum(indexInfo[i],
&newtup,
tupdesc,
+ CurrentMemoryContext,
idatum,
- inulls,
- idcur->finfoP);
+ inulls);
iresult = index_insert(Irel[i],
idatum,
inulls,
/* insert index' tuples if needed */
if (Irel != (Relation *) NULL)
{
- for (i = 0, idcur = Idesc; i < nindices; i++, idcur++)
+ /*
+ * XXX using CurrentMemoryContext here means
+ * intra-vacuum memory leak for functional indexes.
+ * Should fix someday.
+ *
+ * XXX This code fails to handle partial indexes!
+ * Probably should change it to use ExecOpenIndices.
+ */
+ for (i = 0; i < nindices; i++)
{
- FormIndexDatum(idcur->natts,
- (AttrNumber *) &(idcur->tform->indkey[0]),
+ FormIndexDatum(indexInfo[i],
&newtup,
tupdesc,
+ CurrentMemoryContext,
idatum,
- inulls,
- idcur->finfoP);
+ inulls);
iresult = index_insert(Irel[i],
idatum,
inulls,
if (Irel != (Relation *) NULL) /* pfree index' allocations */
{
- pfree(Idesc);
- pfree(idatum);
- pfree(inulls);
close_indices(nindices, Irel);
+ pfree(indexInfo);
}
pfree(vacpage);
}
-static void
-get_index_desc(Relation onerel, int nindices, Relation *Irel, IndDesc **Idesc)
+/*
+ * Obtain IndexInfo data for each index on the rel
+ */
+static IndexInfo **
+get_index_desc(Relation onerel, int nindices, Relation *Irel)
{
- IndDesc *idcur;
- HeapTuple cachetuple;
- AttrNumber *attnumP;
- int natts;
+ IndexInfo **indexInfo;
int i;
+ HeapTuple cachetuple;
- *Idesc = (IndDesc *) palloc(nindices * sizeof(IndDesc));
+ indexInfo = (IndexInfo **) palloc(nindices * sizeof(IndexInfo *));
- for (i = 0, idcur = *Idesc; i < nindices; i++, idcur++)
+ for (i = 0; i < nindices; i++)
{
- cachetuple = SearchSysCacheTupleCopy(INDEXRELID,
+ cachetuple = SearchSysCacheTuple(INDEXRELID,
ObjectIdGetDatum(RelationGetRelid(Irel[i])),
- 0, 0, 0);
- Assert(cachetuple);
-
- /*
- * we never free the copy we make, because Idesc needs it for
- * later
- */
- idcur->tform = (Form_pg_index) GETSTRUCT(cachetuple);
- for (attnumP = &(idcur->tform->indkey[0]), natts = 0;
- natts < INDEX_MAX_KEYS && *attnumP != InvalidAttrNumber;
- attnumP++, natts++);
- if (idcur->tform->indproc != InvalidOid)
- {
- idcur->finfoP = &(idcur->finfo);
- FIgetnArgs(idcur->finfoP) = natts;
- natts = 1;
- FIgetProcOid(idcur->finfoP) = idcur->tform->indproc;
- *(FIgetname(idcur->finfoP)) = '\0';
- }
- else
- idcur->finfoP = (FuncIndexInfo *) NULL;
-
- idcur->natts = natts;
+ 0, 0, 0);
+ if (!HeapTupleIsValid(cachetuple))
+ elog(ERROR, "get_index_desc: index %u not found",
+ RelationGetRelid(Irel[i]));
+ indexInfo[i] = BuildIndexInfo(cachetuple);
}
+ return indexInfo;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.63 2000/07/12 02:37:03 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.64 2000/07/14 22:17:45 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* QueryDescGetTypeInfo - moved here from main.c
* am not sure what uses it -cim 10/12/89
*
- * ExecGetIndexKeyInfo \
- * ExecOpenIndices | referenced by InitPlan, EndPlan,
- * ExecCloseIndices | ExecAppend, ExecReplace
- * ExecFormIndexTuple |
- * ExecInsertIndexTuple /
+ * ExecOpenIndices \
+ * ExecCloseIndices | referenced by InitPlan, EndPlan,
+ * ExecInsertIndexTuples / ExecAppend, ExecReplace
*
* NOTES
* This file has traditionally been the place to stick misc.
#include "utils/relcache.h"
#include "utils/syscache.h"
-static void ExecGetIndexKeyInfo(Form_pg_index indexTuple, int *numAttsOutP,
- AttrNumber **attsOutP, FuncIndexInfoPtr fInfoP);
/* ----------------------------------------------------------------
* global counters for number of tuples processed, retrieved,
* ExecInsertIndexTuples support
* ----------------------------------------------------------------
*/
-/* ----------------------------------------------------------------
- * ExecGetIndexKeyInfo
- *
- * Extracts the index key attribute numbers from
- * an index tuple form (i.e. a tuple from the pg_index relation)
- * into an array of attribute numbers. The array and the
- * size of the array are returned to the caller via return
- * parameters.
- * ----------------------------------------------------------------
- */
-static void
-ExecGetIndexKeyInfo(Form_pg_index indexTuple,
- int *numAttsOutP,
- AttrNumber **attsOutP,
- FuncIndexInfoPtr fInfoP)
-{
- int i;
- int numKeys;
- AttrNumber *attKeys;
-
- /* ----------------
- * check parameters
- * ----------------
- */
- if (numAttsOutP == NULL || attsOutP == NULL)
- {
- elog(DEBUG, "ExecGetIndexKeyInfo: %s",
- "invalid parameters: numAttsOutP and attsOutP must be non-NULL");
- }
-
- /* ----------------
- * set the procid for a possible functional index.
- * ----------------
- */
- FIsetProcOid(fInfoP, indexTuple->indproc);
-
- /* ----------------
- * count the number of keys..
- * ----------------
- */
- numKeys = 0;
- for (i = 0; i < INDEX_MAX_KEYS &&
- indexTuple->indkey[i] != InvalidAttrNumber; i++)
- numKeys++;
-
- /* ----------------
- * place number keys in callers return area
- * or the number of arguments for a functional index.
- *
- * If we have a functional index then the number of
- * attributes defined in the index must 1 (the function's
- * single return value).
- * ----------------
- */
- if (FIgetProcOid(fInfoP) != InvalidOid)
- {
- FIsetnArgs(fInfoP, numKeys);
- (*numAttsOutP) = 1;
- }
- else
- (*numAttsOutP) = numKeys;
-
- if (numKeys < 1)
- {
- elog(DEBUG, "ExecGetIndexKeyInfo: %s",
- "all index key attribute numbers are zero!");
- (*attsOutP) = NULL;
- return;
- }
-
- /* ----------------
- * allocate and fill in array of key attribute numbers
- * ----------------
- */
- CXT1_printf("ExecGetIndexKeyInfo: context is %d\n", CurrentMemoryContext);
-
- attKeys = (AttrNumber *) palloc(numKeys * sizeof(AttrNumber));
-
- for (i = 0; i < numKeys; i++)
- attKeys[i] = indexTuple->indkey[i];
-
- /* ----------------
- * return array to caller.
- * ----------------
- */
- (*attsOutP) = attKeys;
-}
/* ----------------------------------------------------------------
* ExecOpenIndices
Oid indexOid = lfirsti(indexoidscan);
Relation indexDesc;
HeapTuple indexTuple;
- Form_pg_index indexStruct;
- int numKeyAtts;
- AttrNumber *indexKeyAtts;
- FuncIndexInfoPtr fInfoP;
- PredInfo *predicate;
IndexInfo *ii;
/* ----------------
* Get the pg_index tuple for the index
* ----------------
*/
- indexTuple = SearchSysCacheTupleCopy(INDEXRELID,
- ObjectIdGetDatum(indexOid),
- 0, 0, 0);
+ indexTuple = SearchSysCacheTuple(INDEXRELID,
+ ObjectIdGetDatum(indexOid),
+ 0, 0, 0);
if (!HeapTupleIsValid(indexTuple))
elog(ERROR, "ExecOpenIndices: index %u not found", indexOid);
- indexStruct = (Form_pg_index) GETSTRUCT(indexTuple);
/* ----------------
* extract the index key information from the tuple
* ----------------
*/
- fInfoP = (FuncIndexInfoPtr) palloc(sizeof(*fInfoP));
- ExecGetIndexKeyInfo(indexStruct,
- &numKeyAtts,
- &indexKeyAtts,
- fInfoP);
-
- /* ----------------
- * next get the index predicate from the tuple
- * ----------------
- */
- if (VARSIZE(&indexStruct->indpred) != 0)
- {
- char *predString;
-
- predString = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(&indexStruct->indpred)));
- predicate = (PredInfo *) stringToNode(predString);
- pfree(predString);
- }
- else
- predicate = NULL;
-
- /* Save the index info */
- ii = makeNode(IndexInfo);
- ii->ii_NumKeyAttributes = numKeyAtts;
- ii->ii_KeyAttributeNumbers = indexKeyAtts;
- ii->ii_FuncIndexInfo = fInfoP;
- ii->ii_Predicate = (Node *) predicate;
-
- heap_freetuple(indexTuple);
+ ii = BuildIndexInfo(indexTuple);
relationDescs[i] = indexDesc;
indexInfoArray[i] = ii;
int numIndices;
RelationPtr relationDescs;
Relation heapRelation;
+ TupleDesc heapDescriptor;
IndexInfo **indexInfoArray;
- IndexInfo *indexInfo;
- Node *predicate;
ExprContext *econtext;
- InsertIndexResult result;
- int numberOfAttributes;
- AttrNumber *keyAttributeNumbers;
- FuncIndexInfoPtr fInfoP;
- TupleDesc heapDescriptor;
- Datum *datum;
- char *nulls;
+ Datum datum[INDEX_MAX_KEYS];
+ char nullv[INDEX_MAX_KEYS];
heapTuple = slot->val;
relationDescs = resultRelationInfo->ri_IndexRelationDescs;
indexInfoArray = resultRelationInfo->ri_IndexRelationInfo;
heapRelation = resultRelationInfo->ri_RelationDesc;
+ heapDescriptor = RelationGetDescr(heapRelation);
+
+ /* ----------------
+ * Make a temporary expr/memory context for evaluating predicates
+ * and functional-index functions.
+ * XXX should do this once per command not once per tuple, and
+ * just reset it once per tuple.
+ * ----------------
+ */
+ econtext = MakeExprContext(slot, TransactionCommandContext);
/* ----------------
* for each index, form and insert the index tuple
* ----------------
*/
- econtext = NULL;
for (i = 0; i < numIndices; i++)
{
+ IndexInfo *indexInfo;
+ Node *predicate;
+ InsertIndexResult result;
+
if (relationDescs[i] == NULL)
continue;
predicate = indexInfo->ii_Predicate;
if (predicate != NULL)
{
- if (econtext == NULL)
- econtext = MakeExprContext(slot,
- TransactionCommandContext);
-
/* Skip this index-update if the predicate isn't satisfied */
if (!ExecQual((List *) predicate, econtext, false))
continue;
}
/* ----------------
- * get information from index info structure
+ * FormIndexDatum fills in its datum and null parameters
+ * with attribute information taken from the given heap tuple.
* ----------------
*/
- numberOfAttributes = indexInfo->ii_NumKeyAttributes;
- keyAttributeNumbers = indexInfo->ii_KeyAttributeNumbers;
- fInfoP = indexInfo->ii_FuncIndexInfo;
- datum = (Datum *) palloc(numberOfAttributes * sizeof *datum);
- nulls = (char *) palloc(numberOfAttributes * sizeof *nulls);
- heapDescriptor = (TupleDesc) RelationGetDescr(heapRelation);
-
- FormIndexDatum(numberOfAttributes, /* num attributes */
- keyAttributeNumbers, /* array of att nums to
- * extract */
- heapTuple, /* tuple from base relation */
- heapDescriptor, /* heap tuple's descriptor */
- datum, /* return: array of attributes */
- nulls, /* return: array of char's */
- fInfoP); /* functional index information */
-
+ FormIndexDatum(indexInfo,
+ heapTuple,
+ heapDescriptor,
+ econtext->ecxt_per_tuple_memory,
+ datum,
+ nullv);
result = index_insert(relationDescs[i], /* index relation */
datum, /* array of heaptuple Datums */
- nulls, /* info on nulls */
+ nullv, /* info on nulls */
&(heapTuple->t_self), /* tid of heap tuple */
heapRelation);
*/
IncrIndexInserted();
- /* ----------------
- * free index tuple after insertion
- * ----------------
- */
if (result)
pfree(result);
}
- if (econtext != NULL)
- FreeExprContext(econtext);
+
+ FreeExprContext(econtext);
}
void
/* else - add this param to the list */
node->chgParam = lappendi(node->chgParam, paramId);
}
-
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.73 2000/07/04 06:11:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.74 2000/07/14 22:17:48 tgl Exp $
*
*-------------------------------------------------------------------------
*/
LargeObjectDesc *
inv_create(int flags)
{
- int file_oid;
LargeObjectDesc *retval;
+ Oid file_oid;
Relation r;
Relation indr;
TupleDesc tupdesc;
- AttrNumber attNums[1];
+ IndexInfo *indexInfo;
Oid classObjectId[1];
char objname[NAMEDATALEN];
char indname[NAMEDATALEN];
sprintf(indname, "xinx%u", file_oid);
if (RelnameFindRelid(objname) != InvalidOid)
- {
elog(ERROR,
"internal error: %s already exists -- cannot create large obj",
objname);
- }
if (RelnameFindRelid(indname) != InvalidOid)
- {
elog(ERROR,
"internal error: %s already exists -- cannot create large obj",
indname);
- }
/* this is pretty painful... want a tuple descriptor */
tupdesc = CreateTemplateTupleDesc(2);
/*
* Now create a btree index on the relation's olastbyte attribute to
- * make seeks go faster. The hardwired constants are embarassing to
- * me, and are symptomatic of the pressure under which this code was
- * written.
- *
- * ok, mao, let's put in some symbolic constants - jolly
+ * make seeks go faster.
*/
+ indexInfo = makeNode(IndexInfo);
+ indexInfo->ii_NumIndexAttrs = 1;
+ indexInfo->ii_NumKeyAttrs = 1;
+ indexInfo->ii_KeyAttrNumbers[0] = 1;
+ indexInfo->ii_Predicate = NULL;
+ indexInfo->ii_FuncOid = InvalidOid;
+ indexInfo->ii_Unique = false;
- attNums[0] = 1;
classObjectId[0] = INT4_OPS_OID;
- index_create(objname, indname, NULL, NULL, BTREE_AM_OID,
- 1, &attNums[0], &classObjectId[0],
- (Node *) NULL, false, false, false, false);
+
+ index_create(objname, indname, indexInfo,
+ BTREE_AM_OID, classObjectId,
+ false, false, false);
/* make the index visible in this transaction */
CommandCounterIncrement();
+
indr = index_openr(indname);
if (!RelationIsValid(indr))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.106 2000/07/05 23:11:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.107 2000/07/14 22:17:50 tgl Exp $
*
*-------------------------------------------------------------------------
*/
support = (RegProcedure *) NULL;
IndexSupportInitialize(strategy, support,
+ &relation->rd_uniqueindex,
relation->rd_att->attrs[0]->attrelid,
relation->rd_rel->relam,
relamstrategies, relamsupport, natts);
+++ /dev/null
-/*-------------------------------------------------------------------------
- *
- * funcindex.h
- *
- *
- *
- * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * $Id: funcindex.h,v 1.9 2000/01/26 05:57:50 momjian Exp $
- *
- *-------------------------------------------------------------------------
- */
-#ifndef _FUNC_INDEX_INCLUDED_
-#define _FUNC_INDEX_INCLUDED_
-
-typedef struct
-{
- int nargs;
- Oid arglist[FUNC_MAX_ARGS];
- Oid procOid;
- NameData funcName;
-} FuncIndexInfo;
-
-typedef FuncIndexInfo *FuncIndexInfoPtr;
-
-/*
- * some marginally useful macro definitions
- */
-/* #define FIgetname(FINFO) (&((FINFO)->funcName.data[0]))*/
-#define FIgetname(FINFO) (FINFO)->funcName.data
-#define FIgetnArgs(FINFO) (FINFO)->nargs
-#define FIgetProcOid(FINFO) (FINFO)->procOid
-#define FIgetArg(FINFO, argnum) (FINFO)->arglist[argnum]
-#define FIgetArglist(FINFO) (FINFO)->arglist
-
-#define FIsetnArgs(FINFO, numargs) ((FINFO)->nargs = numargs)
-#define FIsetProcOid(FINFO, id) ((FINFO)->procOid = id)
-#define FIsetArg(FINFO, argnum, argtype) ((FINFO)->arglist[argnum] = argtype)
-
-#define FIisFunctionalIndex(FINFO) (FINFO->procOid != InvalidOid)
-
-#endif /* FUNCINDEX_H */
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: genam.h,v 1.23 2000/01/26 05:57:50 momjian Exp $
+ * $Id: genam.h,v 1.24 2000/07/14 22:17:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef GENAM_H
#define GENAM_H
-#include "access/funcindex.h"
#include "access/itup.h"
#include "access/relscan.h"
#include "access/sdir.h"
extern RegProcedure index_cost_estimator(Relation relation);
extern RegProcedure index_getprocid(Relation irel, AttrNumber attnum,
uint16 procnum);
-extern Datum GetIndexValue(HeapTuple tuple, TupleDesc hTupDesc,
- int attOff, AttrNumber *attrNums, FuncIndexInfo *fInfo,
- bool *attNull);
/* in genam.c */
extern IndexScanDesc RelationGetIndexScan(Relation relation, bool scanFromEnd,
#ifndef GIST_H
#define GIST_H
-#include "access/funcindex.h"
#include "access/itup.h"
#include "access/relscan.h"
#include "access/sdir.h"
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: hash.h,v 1.34 2000/06/19 03:54:35 tgl Exp $
+ * $Id: hash.h,v 1.35 2000/07/14 22:17:53 tgl Exp $
*
* NOTES
* modeled after Margo Seltzer's hash implementation for unix.
#ifndef HASH_H
#define HASH_H
-#include "access/funcindex.h"
#include "access/itup.h"
#include "access/relscan.h"
#include "access/sdir.h"
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: istrat.h,v 1.17 2000/06/08 22:37:36 momjian Exp $
+ * $Id: istrat.h,v 1.18 2000/07/14 22:17:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
AttrNumber attributeNumber, StrategyEvaluation evaluation,
RegProcedure procedure);
extern void IndexSupportInitialize(IndexStrategy indexStrategy,
- RegProcedure *indexSupport, Oid indexObjectId,
- Oid accessMethodObjectId, StrategyNumber maxStrategyNumber,
- StrategyNumber maxSupportNumber, AttrNumber maxAttributeNumber);
-
+ RegProcedure *indexSupport,
+ bool *isUnique,
+ Oid indexObjectId,
+ Oid accessMethodObjectId,
+ StrategyNumber maxStrategyNumber,
+ StrategyNumber maxSupportNumber,
+ AttrNumber maxAttributeNumber);
#endif /* ISTRAT_H */
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: itup.h,v 1.24 2000/03/17 02:36:37 tgl Exp $
+ * $Id: itup.h,v 1.25 2000/07/14 22:17:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
typedef RetrieveIndexResultData *RetrieveIndexResult;
-/*-----------------
- * PredInfo -
- * used for partial indices
- *-----------------
- */
-typedef struct PredInfo
-{
- Node *pred;
- Node *oldPred;
-} PredInfo;
-
-
/* ----------------
* externs
* ----------------
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: bootstrap.h,v 1.18 2000/06/17 23:41:49 tgl Exp $
+ * $Id: bootstrap.h,v 1.19 2000/07/14 22:17:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef BOOTSTRAP_H
#define BOOTSTRAP_H
-#include "access/funcindex.h"
#include "access/itup.h"
+#include "nodes/execnodes.h"
#include "utils/rel.h"
-#define MAXATTR 40 /* max. number of attributes in a relation */
+/* MAXATTR is the maximum number of attributes in a relation supported
+ * at bootstrap time (ie, the max possible in a system table).
+ */
+#define MAXATTR 40
typedef struct hashnode
{
extern int BootstrapMain(int ac, char *av[]);
-extern void index_register(char *heap, char *ind,
- int natts, AttrNumber *attnos,
- FuncIndexInfo *finfo, PredInfo *predInfo,
- bool unique);
+extern void index_register(char *heap, char *ind, IndexInfo *indexInfo);
extern void err_out(void);
extern void InsertOneTuple(Oid objectid);
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: index.h,v 1.28 2000/07/12 02:37:27 tgl Exp $
+ * $Id: index.h,v 1.29 2000/07/14 22:17:56 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Oid accessMethodObjectId);
extern void index_create(char *heapRelationName,
- char *indexRelationName,
- FuncIndexInfo *funcInfo,
- List *attributeList,
- Oid accessMethodObjectId,
- int numatts,
- AttrNumber *attNums,
- Oid *classObjectId,
- Node *predicate,
- bool islossy,
- bool unique,
- bool primary,
- bool allow_system_table_mods);
+ char *indexRelationName,
+ IndexInfo *indexInfo,
+ Oid accessMethodObjectId,
+ Oid *classObjectId,
+ bool islossy,
+ bool primary,
+ bool allow_system_table_mods);
extern void index_drop(Oid indexId);
-extern void FormIndexDatum(int numberOfAttributes,
- AttrNumber *attributeNumber, HeapTuple heapTuple,
- TupleDesc heapDescriptor, Datum *datum,
- char *nullv, FuncIndexInfoPtr fInfo);
+extern IndexInfo *BuildIndexInfo(HeapTuple indexTuple);
+
+extern void FormIndexDatum(IndexInfo *indexInfo,
+ HeapTuple heapTuple,
+ TupleDesc heapDescriptor,
+ MemoryContext resultCxt,
+ Datum *datum,
+ char *nullv);
extern void UpdateStats(Oid relid, long reltuples, bool inplace);
extern bool IndexesAreActive(Oid relid, bool comfirmCommitted);
extern bool IsReindexProcessing(void);
extern void index_build(Relation heapRelation, Relation indexRelation,
- int numberOfAttributes, AttrNumber *attributeNumber,
- FuncIndexInfo *funcInfo, PredInfo *predInfo,
- bool unique);
-
-extern bool IndexIsUnique(Oid indexId);
+ IndexInfo *indexInfo, Node *oldPred);
extern bool reindex_index(Oid indexId, bool force);
extern bool activate_indexes_of_a_table(Oid relid, bool activate);
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_proc.h,v 1.146 2000/07/08 03:04:21 tgl Exp $
+ * $Id: pg_proc.h,v 1.147 2000/07/14 22:17:56 tgl Exp $
*
* NOTES
* The script catalog/genbki.sh reads this file and generates .bki
DESCR("r-tree(internal)");
DATA(insert OID = 322 ( rtgettuple PGUID 12 f t f t 2 f 23 "0 0" 100 0 0 100 rtgettuple - ));
DESCR("r-tree(internal)");
-DATA(insert OID = 323 ( rtbuild PGUID 12 f t f t 8 f 23 "0 0 0 0 0 0 0 0" 100 0 0 100 rtbuild - ));
+DATA(insert OID = 323 ( rtbuild PGUID 12 f t f t 5 f 23 "0 0 0 0 0" 100 0 0 100 rtbuild - ));
DESCR("r-tree(internal)");
DATA(insert OID = 324 ( rtbeginscan PGUID 12 f t f t 4 f 23 "0 0 0 0" 100 0 0 100 rtbeginscan - ));
DESCR("r-tree(internal)");
DESCR("btree(internal)");
DATA(insert OID = 337 ( btrestrpos PGUID 12 f t f t 1 f 23 "0" 100 0 0 100 btrestrpos - ));
DESCR("btree(internal)");
-DATA(insert OID = 338 ( btbuild PGUID 12 f t f t 8 f 23 "0 0 0 0 0 0 0 0" 100 0 0 100 btbuild - ));
+DATA(insert OID = 338 ( btbuild PGUID 12 f t f t 5 f 23 "0 0 0 0 0" 100 0 0 100 btbuild - ));
DESCR("btree(internal)");
DATA(insert OID = 339 ( poly_same PGUID 11 f t t t 2 f 16 "604 604" 100 0 1 0 poly_same - ));
DESCR("hash(internal)");
DATA(insert OID = 447 ( hashrestrpos PGUID 12 f t f t 1 f 23 "0" 100 0 0 100 hashrestrpos - ));
DESCR("hash(internal)");
-DATA(insert OID = 448 ( hashbuild PGUID 12 f t f t 8 f 23 "0 0 0 0 0 0 0 0" 100 0 0 100 hashbuild - ));
+DATA(insert OID = 448 ( hashbuild PGUID 12 f t f t 5 f 23 "0 0 0 0 0" 100 0 0 100 hashbuild - ));
DESCR("hash(internal)");
DATA(insert OID = 449 ( hashint2 PGUID 12 f t t t 1 f 23 "21" 100 0 0 100 hashint2 - ));
DESCR("hash");
DESCR("gist(internal)");
DATA(insert OID = 781 ( gistrestrpos PGUID 12 f t f t 1 f 23 "0" 100 0 0 100 gistrestrpos - ));
DESCR("gist(internal)");
-DATA(insert OID = 782 ( gistbuild PGUID 12 f t f t 8 f 23 "0 0 0 0 0 0 0 0" 100 0 0 100 gistbuild - ));
+DATA(insert OID = 782 ( gistbuild PGUID 12 f t f t 5 f 23 "0 0 0 0 0" 100 0 0 100 gistbuild - ));
DESCR("gist(internal)");
DATA(insert OID = 784 ( tintervaleq PGUID 12 f t f t 2 f 16 "704 704" 100 0 0 100 tintervaleq - ));
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: vacuum.h,v 1.31 2000/05/29 17:40:44 momjian Exp $
+ * $Id: vacuum.h,v 1.32 2000/07/14 22:17:57 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef VACUUM_H
#define VACUUM_H
-#include "fmgr.h"
-#include "access/funcindex.h"
-#include "catalog/pg_index.h"
#include "catalog/pg_attribute.h"
+#include "catalog/pg_index.h"
+#include "fmgr.h"
#include "nodes/pg_list.h"
#include "storage/itemptr.h"
typedef VacPageListData *VacPageList;
-typedef struct
-{
- FuncIndexInfo finfo;
- FuncIndexInfo *finfoP;
- Form_pg_index tform;
- int natts;
-} IndDesc;
-
typedef struct
{
Form_pg_attribute attr;
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: execnodes.h,v 1.43 2000/07/12 02:37:32 tgl Exp $
+ * $Id: execnodes.h,v 1.44 2000/07/14 22:17:58 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef EXECNODES_H
#define EXECNODES_H
-#include "access/funcindex.h"
#include "access/relscan.h"
#include "access/sdir.h"
#include "executor/hashjoin.h"
#include "executor/tuptable.h"
+#include "fmgr.h"
#include "nodes/params.h"
#include "nodes/primnodes.h"
/* ----------------
* IndexInfo information
*
- * this class holds the information saying what attributes
- * are the key attributes for this index. -cim 10/15/89
- *
- * NumKeyAttributes number of key attributes for this index
- * KeyAttributeNumbers array of attribute numbers used as keys
- * Predicate partial-index predicate for this index
+ * this class holds the information needed to construct new index
+ * entries for a particular index. Used for both index_build and
+ * retail creation of index entries.
+ *
+ * NumIndexAttrs number of columns in this index
+ * (1 if a func. index, else same as NumKeyAttrs)
+ * NumKeyAttrs number of key attributes for this index
+ * (ie, number of attrs from underlying relation)
+ * KeyAttrNumbers underlying-rel attribute numbers used as keys
+ * Predicate partial-index predicate, or NULL if none
+ * FuncOid OID of function, or InvalidOid if not f. index
+ * FuncInfo fmgr lookup data for function, if FuncOid valid
+ * Unique is it a unique index?
* ----------------
*/
typedef struct IndexInfo
{
NodeTag type;
- int ii_NumKeyAttributes;
- AttrNumber *ii_KeyAttributeNumbers;
- FuncIndexInfoPtr ii_FuncIndexInfo;
+ int ii_NumIndexAttrs;
+ int ii_NumKeyAttrs;
+ AttrNumber ii_KeyAttrNumbers[INDEX_MAX_KEYS];
Node *ii_Predicate;
+ Oid ii_FuncOid;
+ FmgrInfo ii_FuncInfo;
+ bool ii_Unique;
} IndexInfo;
/* ----------------
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: rel.h,v 1.39 2000/06/30 07:04:03 tgl Exp $
+ * $Id: rel.h,v 1.40 2000/07/14 22:18:02 tgl Exp $
*
*-------------------------------------------------------------------------
*/
bool rd_isnailed; /* rel is nailed in cache */
bool rd_unlinked; /* rel already unlinked or not created yet */
bool rd_indexfound; /* true if rd_indexlist is valid */
+ bool rd_uniqueindex; /* true if rel is a UNIQUE index */
Form_pg_am rd_am; /* AM tuple */
Form_pg_class rd_rel; /* RELATION tuple */
Oid rd_id; /* relation's object id */
projects / postgresql.git / commitdiff