Avoid O(N^2) overhead in repeated nocachegetattr calls when columns of
a tuple are being accessed via ExecEvalVar and the attcacheoff shortcut isn't usable (due to nulls and/or varlena columns). To do this, cache Datums extracted from a tuple in the associated TupleTableSlot. Also some code cleanup in and around the TupleTable handling. Atsushi Ogawa with some kibitzing by Tom Lane.
This commit is contained in:
Tom Lane
parent
d1022ce3a1
commit
a9b05bdc83
|
|
@ -9,7 +9,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/access/common/heaptuple.c,v 1.96 2005/01/27 23:23:49 neilc Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/common/heaptuple.c,v 1.97 2005/03/14 04:41:12 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* The old interface functions have been converted to macros
|
||||
|
|
@ -23,6 +23,7 @@
|
|||
#include "access/heapam.h"
|
||||
#include "access/tuptoaster.h"
|
||||
#include "catalog/pg_type.h"
|
||||
#include "executor/tuptable.h"
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
|
|
@ -751,6 +752,7 @@ heap_deformtuple(HeapTuple tuple,
|
|||
char *nulls)
|
||||
{
|
||||
HeapTupleHeader tup = tuple->t_data;
|
||||
bool hasnulls = HeapTupleHasNulls(tuple);
|
||||
Form_pg_attribute *att = tupleDesc->attrs;
|
||||
int tdesc_natts = tupleDesc->natts;
|
||||
int natts; /* number of atts to extract */
|
||||
|
|
@ -775,7 +777,9 @@ heap_deformtuple(HeapTuple tuple,
|
|||
|
||||
for (attnum = 0; attnum < natts; attnum++)
|
||||
{
|
||||
if (HeapTupleHasNulls(tuple) && att_isnull(attnum, bp))
|
||||
Form_pg_attribute thisatt = att[attnum];
|
||||
|
||||
if (hasnulls && att_isnull(attnum, bp))
|
||||
{
|
||||
values[attnum] = (Datum) 0;
|
||||
nulls[attnum] = 'n';
|
||||
|
|
@ -785,21 +789,21 @@ heap_deformtuple(HeapTuple tuple,
|
|||
|
||||
nulls[attnum] = ' ';
|
||||
|
||||
if (!slow && att[attnum]->attcacheoff >= 0)
|
||||
off = att[attnum]->attcacheoff;
|
||||
if (!slow && thisatt->attcacheoff >= 0)
|
||||
off = thisatt->attcacheoff;
|
||||
else
|
||||
{
|
||||
off = att_align(off, att[attnum]->attalign);
|
||||
off = att_align(off, thisatt->attalign);
|
||||
|
||||
if (!slow)
|
||||
att[attnum]->attcacheoff = off;
|
||||
thisatt->attcacheoff = off;
|
||||
}
|
||||
|
||||
values[attnum] = fetchatt(att[attnum], tp + off);
|
||||
values[attnum] = fetchatt(thisatt, tp + off);
|
||||
|
||||
off = att_addlength(off, att[attnum]->attlen, tp + off);
|
||||
off = att_addlength(off, thisatt->attlen, tp + off);
|
||||
|
||||
if (att[attnum]->attlen <= 0)
|
||||
if (thisatt->attlen <= 0)
|
||||
slow = true; /* can't use attcacheoff anymore */
|
||||
}
|
||||
|
||||
|
|
@ -814,6 +818,177 @@ heap_deformtuple(HeapTuple tuple,
|
|||
}
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
* slot_deformtuple
|
||||
*
|
||||
* Given a TupleTableSlot, extract data into cache_values array
|
||||
* from the slot's tuple.
|
||||
*
|
||||
* This is essentially an incremental version of heap_deformtuple:
|
||||
* on each call we extract attributes up to the one needed, without
|
||||
* re-computing information about previously extracted attributes.
|
||||
* slot->cache_natts is the number of attributes already extracted.
|
||||
*
|
||||
* This only gets called from slot_getattr. Note that slot_getattr
|
||||
* must check for a null attribute since we don't create an array
|
||||
* of null indicators.
|
||||
* ----------------
|
||||
*/
|
||||
static void
|
||||
slot_deformtuple(TupleTableSlot *slot, int natts)
|
||||
{
|
||||
HeapTuple tuple = slot->val;
|
||||
TupleDesc tupleDesc = slot->ttc_tupleDescriptor;
|
||||
Datum *values = slot->cache_values;
|
||||
HeapTupleHeader tup = tuple->t_data;
|
||||
bool hasnulls = HeapTupleHasNulls(tuple);
|
||||
Form_pg_attribute *att = tupleDesc->attrs;
|
||||
int attnum;
|
||||
char *tp; /* ptr to tuple data */
|
||||
long off; /* offset in tuple data */
|
||||
bits8 *bp = tup->t_bits; /* ptr to null bitmask in tuple */
|
||||
bool slow; /* can we use/set attcacheoff? */
|
||||
|
||||
/*
|
||||
* Check whether the first call for this tuple, and initialize or
|
||||
* restore loop state.
|
||||
*/
|
||||
attnum = slot->cache_natts;
|
||||
if (attnum == 0)
|
||||
{
|
||||
/* Start from the first attribute */
|
||||
off = 0;
|
||||
slow = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Restore state from previous execution */
|
||||
off = slot->cache_off;
|
||||
slow = slot->cache_slow;
|
||||
}
|
||||
|
||||
tp = (char *) tup + tup->t_hoff;
|
||||
|
||||
for (; attnum < natts; attnum++)
|
||||
{
|
||||
Form_pg_attribute thisatt = att[attnum];
|
||||
|
||||
if (hasnulls && att_isnull(attnum, bp))
|
||||
{
|
||||
values[attnum] = (Datum) 0;
|
||||
slow = true; /* can't use attcacheoff anymore */
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!slow && thisatt->attcacheoff >= 0)
|
||||
off = thisatt->attcacheoff;
|
||||
else
|
||||
{
|
||||
off = att_align(off, thisatt->attalign);
|
||||
|
||||
if (!slow)
|
||||
thisatt->attcacheoff = off;
|
||||
}
|
||||
|
||||
values[attnum] = fetchatt(thisatt, tp + off);
|
||||
|
||||
off = att_addlength(off, thisatt->attlen, tp + off);
|
||||
|
||||
if (thisatt->attlen <= 0)
|
||||
slow = true; /* can't use attcacheoff anymore */
|
||||
}
|
||||
|
||||
/*
|
||||
* Save state for next execution
|
||||
*/
|
||||
slot->cache_natts = attnum;
|
||||
slot->cache_off = off;
|
||||
slot->cache_slow = slow;
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
* slot_getattr
|
||||
*
|
||||
* This function fetches an attribute of the slot's current tuple.
|
||||
* It is functionally equivalent to heap_getattr, but fetches of
|
||||
* multiple attributes of the same tuple will be optimized better,
|
||||
* because we avoid O(N^2) behavior from multiple calls of
|
||||
* nocachegetattr(), even when attcacheoff isn't usable.
|
||||
* --------------------------------
|
||||
*/
|
||||
Datum
|
||||
slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)
|
||||
{
|
||||
HeapTuple tuple = slot->val;
|
||||
TupleDesc tupleDesc = slot->ttc_tupleDescriptor;
|
||||
HeapTupleHeader tup;
|
||||
|
||||
/*
|
||||
* system attributes are handled by heap_getsysattr
|
||||
*/
|
||||
if (attnum <= 0)
|
||||
return heap_getsysattr(tuple, attnum, tupleDesc, isnull);
|
||||
|
||||
/*
|
||||
* check if attnum is out of range according to either the tupdesc
|
||||
* or the tuple itself; if so return NULL
|
||||
*/
|
||||
tup = tuple->t_data;
|
||||
|
||||
if (attnum > tup->t_natts || attnum > tupleDesc->natts)
|
||||
{
|
||||
*isnull = true;
|
||||
return (Datum) 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* check if target attribute is null
|
||||
*/
|
||||
if (HeapTupleHasNulls(tuple) && att_isnull(attnum - 1, tup->t_bits))
|
||||
{
|
||||
*isnull = true;
|
||||
return (Datum) 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* If the attribute's column has been dropped, we force a NULL
|
||||
* result. This case should not happen in normal use, but it could
|
||||
* happen if we are executing a plan cached before the column was
|
||||
* dropped.
|
||||
*/
|
||||
if (tupleDesc->attrs[attnum - 1]->attisdropped)
|
||||
{
|
||||
*isnull = true;
|
||||
return (Datum) 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* If attribute wasn't already extracted, extract it and preceding
|
||||
* attributes.
|
||||
*/
|
||||
if (attnum > slot->cache_natts)
|
||||
{
|
||||
/*
|
||||
* If first time for this TupleTableSlot, allocate the cache
|
||||
* workspace. It must have the same lifetime as the slot, so allocate
|
||||
* it in the slot's own context. We size the array according to what
|
||||
* the tupdesc says, NOT the tuple.
|
||||
*/
|
||||
if (slot->cache_values == NULL)
|
||||
slot->cache_values = (Datum *)
|
||||
MemoryContextAlloc(slot->ttc_mcxt,
|
||||
tupleDesc->natts * sizeof(Datum));
|
||||
|
||||
slot_deformtuple(slot, attnum);
|
||||
}
|
||||
|
||||
/*
|
||||
* The result is acquired from cache_values array.
|
||||
*/
|
||||
*isnull = false;
|
||||
return slot->cache_values[attnum - 1];
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
* heap_freetuple
|
||||
* ----------------
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/access/heap/tuptoaster.c,v 1.47 2005/01/01 05:43:06 momjian Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/heap/tuptoaster.c,v 1.48 2005/03/14 04:41:12 tgl Exp $
|
||||
*
|
||||
*
|
||||
* INTERFACE ROUTINES
|
||||
|
|
@ -1197,9 +1197,9 @@ toast_fetch_datum(varattrib *attr)
|
|||
/*
|
||||
* Have a chunk, extract the sequence number and the data
|
||||
*/
|
||||
residx = DatumGetInt32(heap_getattr(ttup, 2, toasttupDesc, &isnull));
|
||||
residx = DatumGetInt32(fastgetattr(ttup, 2, toasttupDesc, &isnull));
|
||||
Assert(!isnull);
|
||||
chunk = DatumGetPointer(heap_getattr(ttup, 3, toasttupDesc, &isnull));
|
||||
chunk = DatumGetPointer(fastgetattr(ttup, 3, toasttupDesc, &isnull));
|
||||
Assert(!isnull);
|
||||
chunksize = VARATT_SIZE(chunk) - VARHDRSZ;
|
||||
|
||||
|
|
@ -1372,9 +1372,9 @@ toast_fetch_datum_slice(varattrib *attr, int32 sliceoffset, int32 length)
|
|||
/*
|
||||
* Have a chunk, extract the sequence number and the data
|
||||
*/
|
||||
residx = DatumGetInt32(heap_getattr(ttup, 2, toasttupDesc, &isnull));
|
||||
residx = DatumGetInt32(fastgetattr(ttup, 2, toasttupDesc, &isnull));
|
||||
Assert(!isnull);
|
||||
chunk = DatumGetPointer(heap_getattr(ttup, 3, toasttupDesc, &isnull));
|
||||
chunk = DatumGetPointer(fastgetattr(ttup, 3, toasttupDesc, &isnull));
|
||||
Assert(!isnull);
|
||||
chunksize = VARATT_SIZE(chunk) - VARHDRSZ;
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/executor/execJunk.c,v 1.46 2004/12/31 21:59:45 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/executor/execJunk.c,v 1.47 2005/03/14 04:41:12 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -209,20 +209,13 @@ ExecGetJunkAttribute(JunkFilter *junkfilter,
|
|||
Datum *value,
|
||||
bool *isNull)
|
||||
{
|
||||
List *targetList;
|
||||
ListCell *t;
|
||||
AttrNumber resno;
|
||||
TupleDesc tupType;
|
||||
HeapTuple tuple;
|
||||
|
||||
/*
|
||||
* first look in the junkfilter's target list for an attribute with
|
||||
* Look in the junkfilter's target list for an attribute with
|
||||
* the given name
|
||||
*/
|
||||
resno = InvalidAttrNumber;
|
||||
targetList = junkfilter->jf_targetList;
|
||||
|
||||
foreach(t, targetList)
|
||||
foreach(t, junkfilter->jf_targetList)
|
||||
{
|
||||
TargetEntry *tle = lfirst(t);
|
||||
Resdom *resdom = tle->resdom;
|
||||
|
|
@ -231,26 +224,13 @@ ExecGetJunkAttribute(JunkFilter *junkfilter,
|
|||
(strcmp(resdom->resname, attrName) == 0))
|
||||
{
|
||||
/* We found it ! */
|
||||
resno = resdom->resno;
|
||||
break;
|
||||
*value = slot_getattr(slot, resdom->resno, isNull);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (resno == InvalidAttrNumber)
|
||||
{
|
||||
/* Ooops! We couldn't find this attribute... */
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Now extract the attribute value from the tuple.
|
||||
*/
|
||||
tuple = slot->val;
|
||||
tupType = slot->ttc_tupleDescriptor;
|
||||
|
||||
*value = heap_getattr(tuple, resno, tupType, isNull);
|
||||
|
||||
return true;
|
||||
/* Ooops! We couldn't find this attribute... */
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/executor/execQual.c,v 1.171 2004/12/31 21:59:45 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/executor/execQual.c,v 1.172 2005/03/14 04:41:12 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -438,11 +438,8 @@ ExecEvalVar(ExprState *exprstate, ExprContext *econtext,
|
|||
bool *isNull, ExprDoneCond *isDone)
|
||||
{
|
||||
Var *variable = (Var *) exprstate->expr;
|
||||
Datum result;
|
||||
TupleTableSlot *slot;
|
||||
AttrNumber attnum;
|
||||
HeapTuple heapTuple;
|
||||
TupleDesc tuple_type;
|
||||
|
||||
if (isDone)
|
||||
*isDone = ExprSingleResult;
|
||||
|
|
@ -475,35 +472,19 @@ ExecEvalVar(ExprState *exprstate, ExprContext *econtext,
|
|||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* extract tuple information from the slot
|
||||
*/
|
||||
heapTuple = slot->val;
|
||||
tuple_type = slot->ttc_tupleDescriptor;
|
||||
|
||||
#ifdef USE_ASSERT_CHECKING
|
||||
/*
|
||||
* Some checks that are only applied for user attribute numbers (bogus
|
||||
* system attnums will be caught inside heap_getattr).
|
||||
* system attnums will be caught inside slot_getattr).
|
||||
*/
|
||||
if (attnum > 0)
|
||||
{
|
||||
TupleDesc tuple_type = slot->ttc_tupleDescriptor;
|
||||
|
||||
/*
|
||||
* This assert checks that the attnum is valid.
|
||||
*/
|
||||
Assert(attnum <= tuple_type->natts &&
|
||||
tuple_type->attrs[attnum - 1] != NULL);
|
||||
|
||||
/*
|
||||
* If the attribute's column has been dropped, we force a NULL
|
||||
* result. This case should not happen in normal use, but it could
|
||||
* happen if we are executing a plan cached before the column was
|
||||
* dropped.
|
||||
*/
|
||||
if (tuple_type->attrs[attnum - 1]->attisdropped)
|
||||
{
|
||||
*isNull = true;
|
||||
return (Datum) 0;
|
||||
}
|
||||
Assert(attnum <= tuple_type->natts);
|
||||
|
||||
/*
|
||||
* This assert checks that the datatype the plan expects to get
|
||||
|
|
@ -515,16 +496,12 @@ ExecEvalVar(ExprState *exprstate, ExprContext *econtext,
|
|||
* Note that we can't check dropped columns, since their atttypid has
|
||||
* been zeroed.
|
||||
*/
|
||||
Assert(variable->vartype == tuple_type->attrs[attnum - 1]->atttypid);
|
||||
Assert(variable->vartype == tuple_type->attrs[attnum - 1]->atttypid ||
|
||||
tuple_type->attrs[attnum - 1]->attisdropped);
|
||||
}
|
||||
#endif /* USE_ASSERT_CHECKING */
|
||||
|
||||
result = heap_getattr(heapTuple, /* tuple containing attribute */
|
||||
attnum, /* attribute number of desired
|
||||
* attribute */
|
||||
tuple_type, /* tuple descriptor of tuple */
|
||||
isNull); /* return: is attribute null? */
|
||||
|
||||
return result;
|
||||
return slot_getattr(slot, attnum, isNull);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/executor/execTuples.c,v 1.83 2004/12/31 21:59:45 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/executor/execTuples.c,v 1.84 2005/03/14 04:41:12 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -31,13 +31,11 @@
|
|||
*
|
||||
* SLOT ACCESSORS
|
||||
* ExecStoreTuple - store a tuple in the table
|
||||
* ExecFetchTuple - fetch a tuple from the table
|
||||
* ExecClearTuple - clear contents of a table slot
|
||||
* ExecSetSlotDescriptor - set a slot's tuple descriptor
|
||||
* ExecSetSlotDescriptorIsNew - diddle the slot-desc-is-new flag
|
||||
*
|
||||
* SLOT STATUS PREDICATES
|
||||
* TupIsNull - true when slot contains no tuple(Macro)
|
||||
* TupIsNull - true when slot contains no tuple (macro)
|
||||
*
|
||||
* CONVENIENCE INITIALIZATION ROUTINES
|
||||
* ExecInitResultTupleSlot \ convenience routines to initialize
|
||||
|
|
@ -60,7 +58,7 @@
|
|||
* - ExecInitSeqScan() calls ExecInitScanTupleSlot() and
|
||||
* ExecInitResultTupleSlot() to reserve places in the tuple
|
||||
* table for the tuples returned by the access methods and the
|
||||
* tuples resulting from preforming target list projections.
|
||||
* tuples resulting from performing target list projections.
|
||||
*
|
||||
* During ExecRun()
|
||||
* ----------------
|
||||
|
|
@ -71,8 +69,8 @@
|
|||
* tuple from ExecProject() and place it into the result tuple slot.
|
||||
*
|
||||
* - ExecutePlan() calls ExecRetrieve() which gets the tuple out of
|
||||
* the slot passed to it by calling ExecFetchTuple(). this tuple
|
||||
* is then returned.
|
||||
* the slot passed to it (by direct access to slot->val, which is
|
||||
* ugly but not worth changing). this tuple is then returned.
|
||||
*
|
||||
* At ExecEnd()
|
||||
* ----------------
|
||||
|
|
@ -87,23 +85,6 @@
|
|||
* this information is also kept in the ExprContext of each node.
|
||||
* Soon the executor will be redesigned and ExprContext's will contain
|
||||
* only slot pointers. -cim 3/14/91
|
||||
*
|
||||
* NOTES
|
||||
* The tuple table stuff is relatively new, put here to alleviate
|
||||
* the process growth problems in the executor. The other routines
|
||||
* are old (from the original lisp system) and may someday become
|
||||
* obsolete. -cim 6/23/90
|
||||
*
|
||||
* In the implementation of nested-dot queries such as
|
||||
* "retrieve (EMP.hobbies.all)", a single scan may return tuples
|
||||
* of many types, so now we return pointers to tuple descriptors
|
||||
* along with tuples returned via the tuple table. This means
|
||||
* we now have a bunch of routines to diddle the slot descriptors
|
||||
* too. -cim 1/18/90
|
||||
*
|
||||
* The tuple table stuff depends on the executor/tuptable.h macros,
|
||||
* and the TupleTableSlot node in execnodes.h.
|
||||
*
|
||||
*/
|
||||
#include "postgres.h"
|
||||
|
||||
|
|
@ -124,43 +105,52 @@ static TupleDesc ExecTypeFromTLInternal(List *targetList,
|
|||
* tuple table create/delete functions
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* --------------------------------
|
||||
* ExecCreateTupleTable
|
||||
*
|
||||
* This creates a new tuple table of the specified initial
|
||||
* size. If the size is insufficient, ExecAllocTableSlot()
|
||||
* will grow the table as necessary.
|
||||
* This creates a new tuple table of the specified size.
|
||||
*
|
||||
* This should be used by InitPlan() to allocate the table.
|
||||
* The table's address will be stored in the EState structure.
|
||||
* --------------------------------
|
||||
*/
|
||||
TupleTable /* return: address of table */
|
||||
ExecCreateTupleTable(int initialSize) /* initial number of slots in
|
||||
* table */
|
||||
TupleTable
|
||||
ExecCreateTupleTable(int tableSize)
|
||||
{
|
||||
TupleTable newtable; /* newly allocated table */
|
||||
TupleTableSlot *array; /* newly allocated slot array */
|
||||
TupleTable newtable;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* sanity checks
|
||||
*/
|
||||
Assert(initialSize >= 1);
|
||||
Assert(tableSize >= 1);
|
||||
|
||||
/*
|
||||
* Now allocate our new table along with space for the pointers to the
|
||||
* tuples. Zero out the slots.
|
||||
* allocate the table itself
|
||||
*/
|
||||
|
||||
newtable = (TupleTable) palloc(sizeof(TupleTableData));
|
||||
array = (TupleTableSlot *) palloc0(initialSize * sizeof(TupleTableSlot));
|
||||
|
||||
/*
|
||||
* initialize the new table and return it to the caller.
|
||||
*/
|
||||
newtable->size = initialSize;
|
||||
newtable = (TupleTable) palloc(sizeof(TupleTableData) +
|
||||
(tableSize - 1) * sizeof(TupleTableSlot));
|
||||
newtable->size = tableSize;
|
||||
newtable->next = 0;
|
||||
newtable->array = array;
|
||||
|
||||
/*
|
||||
* initialize all the slots to empty states
|
||||
*/
|
||||
for (i = 0; i < tableSize; i++)
|
||||
{
|
||||
TupleTableSlot *slot = &(newtable->array[i]);
|
||||
|
||||
slot->type = T_TupleTableSlot;
|
||||
slot->val = NULL;
|
||||
slot->ttc_tupleDescriptor = NULL;
|
||||
slot->ttc_shouldFree = false;
|
||||
slot->ttc_shouldFreeDesc = false;
|
||||
slot->ttc_buffer = InvalidBuffer;
|
||||
slot->ttc_mcxt = CurrentMemoryContext;
|
||||
slot->cache_values = NULL;
|
||||
slot->cache_natts = 0; /* mark slot_getattr state invalid */
|
||||
}
|
||||
|
||||
return newtable;
|
||||
}
|
||||
|
|
@ -178,21 +168,11 @@ ExecDropTupleTable(TupleTable table, /* tuple table */
|
|||
bool shouldFree) /* true if we should free slot
|
||||
* contents */
|
||||
{
|
||||
int next; /* next available slot */
|
||||
TupleTableSlot *array; /* start of table array */
|
||||
int i; /* counter */
|
||||
|
||||
/*
|
||||
* sanity checks
|
||||
*/
|
||||
Assert(table != NULL);
|
||||
|
||||
/*
|
||||
* get information from the table
|
||||
*/
|
||||
array = table->array;
|
||||
next = table->next;
|
||||
|
||||
/*
|
||||
* first free all the valid pointers in the tuple array and drop
|
||||
* refcounts of any referenced buffers, if that's what the caller
|
||||
|
|
@ -201,86 +181,27 @@ ExecDropTupleTable(TupleTable table, /* tuple table */
|
|||
*/
|
||||
if (shouldFree)
|
||||
{
|
||||
int next = table->next;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < next; i++)
|
||||
{
|
||||
ExecClearTuple(&array[i]);
|
||||
if (array[i].ttc_shouldFreeDesc &&
|
||||
array[i].ttc_tupleDescriptor != NULL)
|
||||
FreeTupleDesc(array[i].ttc_tupleDescriptor);
|
||||
TupleTableSlot *slot = &(table->array[i]);
|
||||
|
||||
ExecClearTuple(slot);
|
||||
if (slot->ttc_shouldFreeDesc)
|
||||
FreeTupleDesc(slot->ttc_tupleDescriptor);
|
||||
if (slot->cache_values)
|
||||
pfree(slot->cache_values);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* finally free the tuple array and the table itself.
|
||||
* finally free the tuple table itself.
|
||||
*/
|
||||
pfree(array);
|
||||
pfree(table);
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* tuple table slot reservation functions
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
/* --------------------------------
|
||||
* ExecAllocTableSlot
|
||||
*
|
||||
* This routine is used to reserve slots in the table for
|
||||
* use by the various plan nodes. It is expected to be
|
||||
* called by the node init routines (ex: ExecInitNestLoop)
|
||||
* once per slot needed by the node. Not all nodes need
|
||||
* slots (some just pass tuples around).
|
||||
* --------------------------------
|
||||
*/
|
||||
TupleTableSlot *
|
||||
ExecAllocTableSlot(TupleTable table)
|
||||
{
|
||||
int slotnum; /* new slot number */
|
||||
TupleTableSlot *slot;
|
||||
|
||||
/*
|
||||
* sanity checks
|
||||
*/
|
||||
Assert(table != NULL);
|
||||
|
||||
/*
|
||||
* if our table is full we have to allocate a larger size table. Since
|
||||
* ExecAllocTableSlot() is only called before the table is ever used
|
||||
* to store tuples, we don't have to worry about the contents of the
|
||||
* old table. If this changes, then we will have to preserve the
|
||||
* contents. -cim 6/23/90
|
||||
*
|
||||
* Unfortunately, we *cannot* do this. All of the nodes in the plan that
|
||||
* have already initialized their slots will have pointers into
|
||||
* _freed_ memory. This leads to bad ends. We now count the number
|
||||
* of slots we will need and create all the slots we will need ahead
|
||||
* of time. The if below should never happen now. Fail if it does.
|
||||
* -mer 4 Aug 1992
|
||||
*/
|
||||
if (table->next >= table->size)
|
||||
elog(ERROR, "plan requires more slots than are available");
|
||||
|
||||
/*
|
||||
* at this point, space in the table is guaranteed so we reserve the
|
||||
* next slot, initialize and return it.
|
||||
*/
|
||||
slotnum = table->next;
|
||||
table->next++;
|
||||
|
||||
slot = &(table->array[slotnum]);
|
||||
|
||||
/* Make sure the allocated slot is valid (and empty) */
|
||||
slot->type = T_TupleTableSlot;
|
||||
slot->val = NULL;
|
||||
slot->ttc_shouldFree = true;
|
||||
slot->ttc_descIsNew = true;
|
||||
slot->ttc_shouldFreeDesc = true;
|
||||
slot->ttc_tupleDescriptor = NULL;
|
||||
slot->ttc_buffer = InvalidBuffer;
|
||||
|
||||
return slot;
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
* MakeTupleTableSlot
|
||||
*
|
||||
|
|
@ -295,17 +216,59 @@ MakeTupleTableSlot(void)
|
|||
{
|
||||
TupleTableSlot *slot = makeNode(TupleTableSlot);
|
||||
|
||||
/* This should match ExecAllocTableSlot() */
|
||||
/* This should match ExecCreateTupleTable() */
|
||||
slot->val = NULL;
|
||||
slot->ttc_shouldFree = true;
|
||||
slot->ttc_descIsNew = true;
|
||||
slot->ttc_shouldFreeDesc = true;
|
||||
slot->ttc_tupleDescriptor = NULL;
|
||||
slot->ttc_shouldFree = false;
|
||||
slot->ttc_shouldFreeDesc = false;
|
||||
slot->ttc_buffer = InvalidBuffer;
|
||||
slot->ttc_mcxt = CurrentMemoryContext;
|
||||
slot->cache_values = NULL;
|
||||
slot->cache_natts = 0; /* mark slot_getattr state invalid */
|
||||
|
||||
return slot;
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* tuple table slot reservation functions
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* --------------------------------
|
||||
* ExecAllocTableSlot
|
||||
*
|
||||
* This routine is used to reserve slots in the table for
|
||||
* use by the various plan nodes. It is expected to be
|
||||
* called by the node init routines (ex: ExecInitNestLoop)
|
||||
* once per slot needed by the node. Not all nodes need
|
||||
* slots (some just pass tuples around).
|
||||
* --------------------------------
|
||||
*/
|
||||
TupleTableSlot *
|
||||
ExecAllocTableSlot(TupleTable table)
|
||||
{
|
||||
int slotnum; /* new slot number */
|
||||
|
||||
/*
|
||||
* sanity checks
|
||||
*/
|
||||
Assert(table != NULL);
|
||||
|
||||
/*
|
||||
* We expect that the table was made big enough to begin with.
|
||||
* We cannot reallocate it on the fly since previous plan nodes
|
||||
* have already got pointers to individual entries.
|
||||
*/
|
||||
if (table->next >= table->size)
|
||||
elog(ERROR, "plan requires more slots than are available");
|
||||
|
||||
slotnum = table->next;
|
||||
table->next++;
|
||||
|
||||
return &(table->array[slotnum]);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* tuple table slot accessor functions
|
||||
* ----------------------------------------------------------------
|
||||
|
|
@ -356,21 +319,22 @@ ExecStoreTuple(HeapTuple tuple,
|
|||
/* passing shouldFree=true for a tuple on a disk page is not sane */
|
||||
Assert(BufferIsValid(buffer) ? (!shouldFree) : true);
|
||||
|
||||
/* clear out any old contents of the slot */
|
||||
/*
|
||||
* clear out any old contents of the slot
|
||||
*/
|
||||
ExecClearTuple(slot);
|
||||
|
||||
/*
|
||||
* store the new tuple into the specified slot and return the slot
|
||||
* into which we stored the tuple.
|
||||
* store the new tuple into the specified slot.
|
||||
*/
|
||||
slot->val = tuple;
|
||||
slot->ttc_buffer = buffer;
|
||||
slot->ttc_shouldFree = shouldFree;
|
||||
|
||||
/*
|
||||
* If tuple is on a disk page, keep the page pinned as long as we hold
|
||||
* a pointer into it.
|
||||
* a pointer into it. We assume the caller already has such a pin.
|
||||
*/
|
||||
slot->ttc_buffer = buffer;
|
||||
if (BufferIsValid(buffer))
|
||||
IncrBufferRefCount(buffer);
|
||||
|
||||
|
|
@ -388,27 +352,23 @@ ExecStoreTuple(HeapTuple tuple,
|
|||
TupleTableSlot * /* return: slot passed */
|
||||
ExecClearTuple(TupleTableSlot *slot) /* slot in which to store tuple */
|
||||
{
|
||||
HeapTuple oldtuple; /* prior contents of slot */
|
||||
|
||||
/*
|
||||
* sanity checks
|
||||
*/
|
||||
Assert(slot != NULL);
|
||||
|
||||
/*
|
||||
* get information from the tuple table
|
||||
* Free the old contents of the specified slot if necessary. (Note:
|
||||
* we allow slot->val to be null even when shouldFree is true, because
|
||||
* there are a few callers of ExecStoreTuple that are too lazy to
|
||||
* distinguish whether they are passing a NULL tuple, and always pass
|
||||
* shouldFree = true.)
|
||||
*/
|
||||
oldtuple = slot->val;
|
||||
|
||||
/*
|
||||
* free the old contents of the specified slot if necessary.
|
||||
*/
|
||||
if (slot->ttc_shouldFree && oldtuple != NULL)
|
||||
heap_freetuple(oldtuple);
|
||||
if (slot->ttc_shouldFree && slot->val != NULL)
|
||||
heap_freetuple(slot->val);
|
||||
|
||||
slot->val = NULL;
|
||||
|
||||
slot->ttc_shouldFree = true; /* probably useless code... */
|
||||
slot->ttc_shouldFree = false;
|
||||
|
||||
/*
|
||||
* Drop the pin on the referenced buffer, if there is one.
|
||||
|
|
@ -418,6 +378,11 @@ ExecClearTuple(TupleTableSlot *slot) /* slot in which to store tuple */
|
|||
|
||||
slot->ttc_buffer = InvalidBuffer;
|
||||
|
||||
/*
|
||||
* mark slot_getattr state invalid
|
||||
*/
|
||||
slot->cache_natts = 0;
|
||||
|
||||
return slot;
|
||||
}
|
||||
|
||||
|
|
@ -433,36 +398,31 @@ ExecSetSlotDescriptor(TupleTableSlot *slot, /* slot to change */
|
|||
TupleDesc tupdesc, /* new tuple descriptor */
|
||||
bool shouldFree) /* is desc owned by slot? */
|
||||
{
|
||||
if (slot->ttc_shouldFreeDesc &&
|
||||
slot->ttc_tupleDescriptor != NULL)
|
||||
if (slot->ttc_shouldFreeDesc)
|
||||
FreeTupleDesc(slot->ttc_tupleDescriptor);
|
||||
|
||||
slot->ttc_tupleDescriptor = tupdesc;
|
||||
slot->ttc_shouldFreeDesc = shouldFree;
|
||||
|
||||
/*
|
||||
* mark slot_getattr state invalid
|
||||
*/
|
||||
slot->cache_natts = 0;
|
||||
|
||||
/*
|
||||
* release any old cache array since tupledesc's natts may have changed
|
||||
*/
|
||||
if (slot->cache_values)
|
||||
pfree(slot->cache_values);
|
||||
slot->cache_values = NULL;
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
* ExecSetSlotDescriptorIsNew
|
||||
*
|
||||
* This function is used to change the setting of the "isNew" flag
|
||||
* --------------------------------
|
||||
*/
|
||||
void
|
||||
ExecSetSlotDescriptorIsNew(TupleTableSlot *slot, /* slot to change */
|
||||
bool isNew) /* "isNew" setting */
|
||||
{
|
||||
slot->ttc_descIsNew = isNew;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* tuple table slot status predicates
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* convenience initialization routines
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* --------------------------------
|
||||
* ExecInit{Result,Scan,Extra}TupleSlot
|
||||
*
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/include/access/heapam.h,v 1.94 2005/01/27 23:24:11 neilc Exp $
|
||||
* $PostgreSQL: pgsql/src/include/access/heapam.h,v 1.95 2005/03/14 04:41:13 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -40,9 +40,6 @@
|
|||
* ----------------
|
||||
*/
|
||||
|
||||
extern Datum nocachegetattr(HeapTuple tup, int attnum,
|
||||
TupleDesc att, bool *isnull);
|
||||
|
||||
#if !defined(DISABLE_COMPLEX_MACRO)
|
||||
|
||||
#define fastgetattr(tup, attnum, tupleDesc, isnull) \
|
||||
|
|
@ -115,9 +112,6 @@ extern Datum fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc,
|
|||
) \
|
||||
)
|
||||
|
||||
extern Datum heap_getsysattr(HeapTuple tup, int attnum, TupleDesc tupleDesc,
|
||||
bool *isnull);
|
||||
|
||||
|
||||
/* ----------------
|
||||
* function prototypes for heap access method
|
||||
|
|
@ -191,6 +185,8 @@ extern void DataFill(char *data, TupleDesc tupleDesc,
|
|||
extern int heap_attisnull(HeapTuple tup, int attnum);
|
||||
extern Datum nocachegetattr(HeapTuple tup, int attnum,
|
||||
TupleDesc att, bool *isnull);
|
||||
extern Datum heap_getsysattr(HeapTuple tup, int attnum, TupleDesc tupleDesc,
|
||||
bool *isnull);
|
||||
extern HeapTuple heap_copytuple(HeapTuple tuple);
|
||||
extern void heap_copytuple_with_tuple(HeapTuple src, HeapTuple dest);
|
||||
extern HeapTuple heap_formtuple(TupleDesc tupleDescriptor,
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/include/executor/executor.h,v 1.115 2004/12/31 22:03:29 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/include/executor/executor.h,v 1.116 2005/03/14 04:41:13 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -158,10 +158,10 @@ extern void ExecAssignScanProjectionInfo(ScanState *node);
|
|||
/*
|
||||
* prototypes from functions in execTuples.c
|
||||
*/
|
||||
extern TupleTable ExecCreateTupleTable(int initialSize);
|
||||
extern TupleTable ExecCreateTupleTable(int tableSize);
|
||||
extern void ExecDropTupleTable(TupleTable table, bool shouldFree);
|
||||
extern TupleTableSlot *ExecAllocTableSlot(TupleTable table);
|
||||
extern TupleTableSlot *MakeTupleTableSlot(void);
|
||||
extern TupleTableSlot *ExecAllocTableSlot(TupleTable table);
|
||||
extern TupleTableSlot *ExecStoreTuple(HeapTuple tuple,
|
||||
TupleTableSlot *slot,
|
||||
Buffer buffer,
|
||||
|
|
@ -169,7 +169,6 @@ extern TupleTableSlot *ExecStoreTuple(HeapTuple tuple,
|
|||
extern TupleTableSlot *ExecClearTuple(TupleTableSlot *slot);
|
||||
extern void ExecSetSlotDescriptor(TupleTableSlot *slot,
|
||||
TupleDesc tupdesc, bool shouldFree);
|
||||
extern void ExecSetSlotDescriptorIsNew(TupleTableSlot *slot, bool isNew);
|
||||
extern void ExecInitResultTupleSlot(EState *estate, PlanState *planstate);
|
||||
extern void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate);
|
||||
extern TupleTableSlot *ExecInitExtraTupleSlot(EState *estate);
|
||||
|
|
|
|||
|
|
@ -7,11 +7,7 @@
|
|||
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/include/executor/tuptable.h,v 1.26 2004/12/31 22:03:29 pgsql Exp $
|
||||
*
|
||||
* NOTES
|
||||
* The tuple table interface is getting pretty ugly.
|
||||
* It should be redesigned soon.
|
||||
* $PostgreSQL: pgsql/src/include/executor/tuptable.h,v 1.27 2005/03/14 04:41:13 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -20,65 +16,60 @@
|
|||
|
||||
#include "access/htup.h"
|
||||
|
||||
/* ----------------
|
||||
* The executor tuple table is managed and manipulated by special
|
||||
* code in executor/execTuples.c.
|
||||
|
||||
/*
|
||||
* The executor stores pointers to tuples in a "tuple table"
|
||||
* which is composed of TupleTableSlots. Sometimes the tuples
|
||||
* are pointers to buffer pages, while others are pointers to
|
||||
* palloc'ed memory; the shouldFree variable tells us whether
|
||||
* we may call pfree() on a tuple. When shouldFree is true,
|
||||
* the tuple is "owned" by the TupleTableSlot and should be
|
||||
* freed when the slot's reference to the tuple is dropped.
|
||||
*
|
||||
* TupleTableSlot information
|
||||
* shouldFreeDesc is similar to shouldFree: if it's true, then the
|
||||
* tupleDescriptor is "owned" by the TupleTableSlot and should be
|
||||
* freed when the slot's reference to the descriptor is dropped.
|
||||
*
|
||||
* val current tuple, or NULL if no tuple
|
||||
* shouldFree boolean - should we pfree() tuple
|
||||
* descIsNew boolean - true when tupleDescriptor changes
|
||||
* tupleDescriptor type information for the tuple data
|
||||
* shouldFreeDesc boolean - should we free tupleDescriptor
|
||||
* buffer the buffer for tuples pointing to disk pages
|
||||
* If buffer is not InvalidBuffer, then the slot is holding a pin
|
||||
* on the indicated buffer page; drop the pin when we release the
|
||||
* slot's reference to that buffer. (shouldFree should always be
|
||||
* false in such a case, since presumably val is pointing at the
|
||||
* buffer page.)
|
||||
*
|
||||
* The executor stores pointers to tuples in a ``tuple table''
|
||||
* which is composed of TupleTableSlots. Sometimes the tuples
|
||||
* are pointers to buffer pages, while others are pointers to
|
||||
* palloc'ed memory; the shouldFree variable tells us when
|
||||
* we may call pfree() on a tuple. -cim 9/23/90
|
||||
*
|
||||
* If buffer is not InvalidBuffer, then the slot is holding a pin
|
||||
* on the indicated buffer page; drop the pin when we release the
|
||||
* slot's reference to that buffer.
|
||||
*
|
||||
* In the implementation of nested-dot queries such as
|
||||
* "retrieve (EMP.hobbies.all)", a single scan may return tuples
|
||||
* of many types, so now we return pointers to tuple descriptors
|
||||
* along with tuples returned via the tuple table. -cim 1/18/90
|
||||
*
|
||||
* shouldFreeDesc is similar to shouldFree: if it's true, then the
|
||||
* tupleDescriptor is "owned" by the TupleTableSlot and should be
|
||||
* freed when the slot's reference to the descriptor is dropped.
|
||||
*
|
||||
* See executor.h for decls of functions defined in execTuples.c
|
||||
* -jolly
|
||||
*
|
||||
* ----------------
|
||||
* The slot_getattr() routine allows extraction of attribute values from
|
||||
* a TupleTableSlot's current tuple. It is equivalent to heap_getattr()
|
||||
* except that it can optimize fetching of multiple values more efficiently.
|
||||
* The cache_xxx fields of TupleTableSlot are support for slot_getattr().
|
||||
*/
|
||||
typedef struct TupleTableSlot
|
||||
{
|
||||
NodeTag type;
|
||||
HeapTuple val;
|
||||
bool ttc_shouldFree;
|
||||
bool ttc_descIsNew;
|
||||
bool ttc_shouldFreeDesc;
|
||||
TupleDesc ttc_tupleDescriptor;
|
||||
Buffer ttc_buffer;
|
||||
NodeTag type; /* vestigial ... allows IsA tests */
|
||||
HeapTuple val; /* current tuple, or NULL if none */
|
||||
TupleDesc ttc_tupleDescriptor; /* tuple's descriptor */
|
||||
bool ttc_shouldFree; /* should pfree tuple? */
|
||||
bool ttc_shouldFreeDesc; /* should pfree descriptor? */
|
||||
Buffer ttc_buffer; /* tuple's buffer, or InvalidBuffer */
|
||||
MemoryContext ttc_mcxt; /* slot itself is in this context */
|
||||
Datum *cache_values; /* currently extracted values */
|
||||
int cache_natts; /* # of valid values in cache_values */
|
||||
bool cache_slow; /* saved state for slot_getattr */
|
||||
long cache_off; /* saved state for slot_getattr */
|
||||
} TupleTableSlot;
|
||||
|
||||
/* ----------------
|
||||
* tuple table data structure
|
||||
* ----------------
|
||||
/*
|
||||
* Tuple table data structure: an array of TupleTableSlots.
|
||||
*/
|
||||
typedef struct TupleTableData
|
||||
{
|
||||
int size; /* size of the table */
|
||||
int size; /* size of the table (number of slots) */
|
||||
int next; /* next available slot number */
|
||||
TupleTableSlot *array; /* array of TupleTableSlot's */
|
||||
} TupleTableData;
|
||||
TupleTableSlot array[1]; /* VARIABLE LENGTH ARRAY - must be last */
|
||||
} TupleTableData; /* VARIABLE LENGTH STRUCT */
|
||||
|
||||
typedef TupleTableData *TupleTable;
|
||||
|
||||
|
||||
/* in access/common/heaptuple.c */
|
||||
extern Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull);
|
||||
|
||||
#endif /* TUPTABLE_H */
|
||||
|
|
|
|||
Loading…
Reference in New Issue