database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-02 09:02:37 +03:00
Code Activity

Postgres95 1.01 Distribution - Virgin Sources

Browse Source
This commit is contained in:
Marc G. Fournier
1996-07-09 06:22:35 +00:00
commit d31084e9d1
868 changed files with 242656 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

902
src/backend/executor/nodeIndexscan.c Normal file
View File

@ -0,0 +1,902 @@
/*-------------------------------------------------------------------------
*
* nodeIndexscan.c--
* Routines to support indexes and indexed scans of relations
*
* Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeIndexscan.c,v 1.1.1.1 1996/07/09 06:21:26 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
/*
* INTERFACE ROUTINES
* ExecInsertIndexTuples inserts tuples into indices on result relation
*
* ExecIndexScan scans a relation using indices
* ExecIndexNext using index to retrieve next tuple
* ExecInitIndexScan creates and initializes state info.
* ExecIndexReScan rescans the indexed relation.
* ExecEndIndexScan releases all storage.
* ExecIndexMarkPos marks scan position.
* ExecIndexRestrPos restores scan position.
*
* NOTES
* the code supporting ExecInsertIndexTuples should be
* collected and merged with the genam stuff.
*
*/
#include "executor/executor.h"
#include "executor/nodeIndexscan.h"
#include "optimizer/clauses.h" /* for get_op, get_leftop, get_rightop */
#include "parser/parsetree.h" /* for rt_fetch() */
#include "access/skey.h"
#include "utils/palloc.h"
#include "catalog/index.h"
#include "storage/bufmgr.h"
#include "storage/lmgr.h"
#include "nodes/nodeFuncs.h"
/* ----------------
* Misc stuff to move to executor.h soon -cim 6/5/90
* ----------------
*/
#define NO_OP 0
#define LEFT_OP 1
#define RIGHT_OP 2
static TupleTableSlot *IndexNext(IndexScan *node);
/* ----------------------------------------------------------------
* IndexNext
*
* Retrieve a tuple from the IndexScan node's currentRelation
* using the indices in the IndexScanState information.
*
* note: the old code mentions 'Primary indices'. to my knowledge
* we only support a single secondary index. -cim 9/11/89
*
* old comments:
* retrieve a tuple from relation using the indices given.
* The indices are used in the order they appear in 'indices'.
* The indices may be primary or secondary indices:
* * primary index -- scan the relation 'relID' using keys supplied.
* * secondary index -- scan the index relation to get the 'tid' for
* a tuple in the relation 'relID'.
* If the current index(pointed by 'indexPtr') fails to return a
* tuple, the next index in the indices is used.
*
* bug fix so that it should retrieve on a null scan key.
* ----------------------------------------------------------------
*/
static TupleTableSlot *
IndexNext(IndexScan *node)
{
EState *estate;
CommonScanState *scanstate;
IndexScanState *indexstate;
ScanDirection direction;
int indexPtr;
IndexScanDescPtr scanDescs;
IndexScanDesc scandesc;
Relation heapRelation;
RetrieveIndexResult result;
ItemPointer iptr;
HeapTuple tuple;
TupleTableSlot *slot;
Buffer buffer = InvalidBuffer;
/* ----------------
* extract necessary information from index scan node
* ----------------
*/
estate = node->scan.plan.state;
direction = estate->es_direction;
scanstate = node->scan.scanstate;
indexstate = node->indxstate;
indexPtr = indexstate->iss_IndexPtr;
scanDescs = indexstate->iss_ScanDescs;
scandesc = scanDescs[ indexPtr ];
heapRelation = scanstate->css_currentRelation;
slot = scanstate->css_ScanTupleSlot;
/* ----------------
* ok, now that we have what we need, fetch an index tuple.
* ----------------
*/
for(;;) {
result = index_getnext(scandesc, direction);
/* ----------------
* if scanning this index succeeded then return the
* appropriate heap tuple.. else return NULL.
* ----------------
*/
if (result) {
iptr = &result->heap_iptr;
tuple = heap_fetch(heapRelation,
NowTimeQual,
iptr,
&buffer);
/* be tidy */
pfree(result);
if (tuple == NULL) {
/* ----------------
* we found a deleted tuple, so keep on scanning..
* ----------------
*/
if (BufferIsValid(buffer))
ReleaseBuffer(buffer);
continue;
}
/* ----------------
* store the scanned tuple in the scan tuple slot of
* the scan state. Eventually we will only do this and not
* return a tuple. Note: we pass 'false' because tuples
* returned by amgetnext are pointers onto disk pages and
* were not created with palloc() and so should not be pfree()'d.
* ----------------
*/
ExecStoreTuple(tuple, /* tuple to store */
slot, /* slot to store in */
buffer, /* buffer associated with tuple */
false); /* don't pfree */
return slot;
}
/* ----------------
* if we get here it means the index scan failed so we
* are at the end of the scan..
* ----------------
*/
return ExecClearTuple(slot);
}
}
/* ----------------------------------------------------------------
* ExecIndexScan(node)
*
* old comments:
* Scans the relation using primary or secondary indices and returns
* the next qualifying tuple in the direction specified.
* It calls ExecScan() and passes it the access methods which returns
* the next tuple using the indices.
*
* Conditions:
* -- the "cursor" maintained by the AMI is positioned at the tuple
* returned previously.
*
* Initial States:
* -- the relation indicated is opened for scanning so that the
* "cursor" is positioned before the first qualifying tuple.
* -- all index realtions are opened for scanning.
* -- indexPtr points to the first index.
* -- state variable ruleFlag = nil.
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecIndexScan(IndexScan *node)
{
TupleTableSlot *returnTuple;
/* ----------------
* use IndexNext as access method
* ----------------
*/
returnTuple = ExecScan(&node->scan, IndexNext);
return returnTuple;
}
/* ----------------------------------------------------------------
* ExecIndexReScan(node)
*
* Recalculates the value of the scan keys whose value depends on
* information known at runtime and rescans the indexed relation.
* Updating the scan key was formerly done separately in
* ExecUpdateIndexScanKeys. Integrating it into ReScan
* makes rescans of indices and
* relations/general streams more uniform.
*
* ----------------------------------------------------------------
*/
void
ExecIndexReScan(IndexScan *node, ExprContext *exprCtxt, Plan* parent)
{
EState *estate;
IndexScanState *indexstate;
ScanDirection direction;
IndexScanDescPtr scanDescs;
ScanKey *scanKeys;
IndexScanDesc sdesc;
ScanKey skey;
int numIndices;
int i;
Pointer *runtimeKeyInfo;
int indexPtr;
int *numScanKeys;
List *indxqual;
List *qual;
int n_keys;
ScanKey scan_keys;
int *run_keys;
int j;
Expr *clause;
Node *scanexpr;
Datum scanvalue;
bool isNull;
bool isDone;
indexstate = node->indxstate;
estate = node->scan.plan.state;
direction = estate->es_direction;
indexstate = node->indxstate;
numIndices = indexstate->iss_NumIndices;
scanDescs = indexstate->iss_ScanDescs;
scanKeys = indexstate->iss_ScanKeys;
runtimeKeyInfo = (Pointer *) indexstate->iss_RuntimeKeyInfo;
if (runtimeKeyInfo != NULL) {
/*
* get the index qualifications and
* recalculate the appropriate values
*/
indexPtr = indexstate->iss_IndexPtr;
indxqual = node->indxqual;
qual = nth(indexPtr, indxqual);
numScanKeys = indexstate->iss_NumScanKeys;
n_keys = numScanKeys[indexPtr];
run_keys = (int *) runtimeKeyInfo[indexPtr];
scan_keys = (ScanKey) scanKeys[indexPtr];
for (j=0; j < n_keys; j++) {
/*
* If we have a run-time key, then extract the run-time
* expression and evaluate it with respect to the current
* outer tuple. We then stick the result into the scan
* key.
*/
if (run_keys[j] != NO_OP) {
clause = nth(j, qual);
scanexpr = (run_keys[j] == RIGHT_OP) ?
(Node*) get_rightop(clause) : (Node*) get_leftop(clause) ;
/* pass in isDone but ignore it. We don't iterate in quals */
scanvalue = (Datum)
ExecEvalExpr(scanexpr, exprCtxt, &isNull, &isDone);
scan_keys[j].sk_argument = scanvalue;
}
}
}
/*
* rescans all indices
*
* note: AMrescan assumes only one scan key. This may have
* to change if we ever decide to support multiple keys.
*/
for (i = 0; i < numIndices; i++) {
sdesc = scanDescs[ i ];
skey = scanKeys[ i ];
index_rescan(sdesc, direction, skey);
}
/* ----------------
* perhaps return something meaningful
* ----------------
*/
return;
}
/* ----------------------------------------------------------------
* ExecEndIndexScan
*
* old comments
* Releases any storage allocated through C routines.
* Returns nothing.
* ----------------------------------------------------------------
*/
void
ExecEndIndexScan(IndexScan *node)
{
CommonScanState *scanstate;
IndexScanState *indexstate;
ScanKey *scanKeys;
int numIndices;
int i;
scanstate = node->scan.scanstate;
indexstate = node->indxstate;
/* ----------------
* extract information from the node
* ----------------
*/
numIndices = indexstate->iss_NumIndices;
scanKeys = indexstate->iss_ScanKeys;
/* ----------------
* Free the projection info and the scan attribute info
*
* Note: we don't ExecFreeResultType(scanstate)
* because the rule manager depends on the tupType
* returned by ExecMain(). So for now, this
* is freed at end-transaction time. -cim 6/2/91
* ----------------
*/
ExecFreeProjectionInfo(&scanstate->cstate);
/* ----------------
* close the heap and index relations
* ----------------
*/
ExecCloseR((Plan *) node);
/* ----------------
* free the scan keys used in scanning the indices
* ----------------
*/
for (i=0; i<numIndices; i++) {
if (scanKeys[i]!=NULL)
pfree(scanKeys[i]);
}
/* ----------------
* clear out tuple table slots
* ----------------
*/
ExecClearTuple(scanstate->cstate.cs_ResultTupleSlot);
ExecClearTuple(scanstate->css_ScanTupleSlot);
/* ExecClearTuple(scanstate->css_RawTupleSlot); */
}
/* ----------------------------------------------------------------
* ExecIndexMarkPos
*
* old comments
* Marks scan position by marking the current index.
* Returns nothing.
* ----------------------------------------------------------------
*/
void
ExecIndexMarkPos(IndexScan *node)
{
IndexScanState *indexstate;
IndexScanDescPtr indexScanDescs;
IndexScanDesc scanDesc;
int indexPtr;
indexstate = node->indxstate;
indexPtr = indexstate->iss_IndexPtr;
indexScanDescs = indexstate->iss_ScanDescs;
scanDesc = indexScanDescs[ indexPtr ];
/* ----------------
* XXX access methods don't return marked positions so
* ----------------
*/
IndexScanMarkPosition( scanDesc );
return;
}
/* ----------------------------------------------------------------
* ExecIndexRestrPos
*
* old comments
* Restores scan position by restoring the current index.
* Returns nothing.
*
* XXX Assumes previously marked scan position belongs to current index
* ----------------------------------------------------------------
*/
void
ExecIndexRestrPos(IndexScan *node)
{
IndexScanState *indexstate;
IndexScanDescPtr indexScanDescs;
IndexScanDesc scanDesc;
int indexPtr;
indexstate = node->indxstate;
indexPtr = indexstate->iss_IndexPtr;
indexScanDescs = indexstate->iss_ScanDescs;
scanDesc = indexScanDescs[ indexPtr ];
IndexScanRestorePosition( scanDesc );
}
/* ----------------------------------------------------------------
* ExecInitIndexScan
*
* Initializes the index scan's state information, creates
* scan keys, and opens the base and index relations.
*
* Note: index scans have 2 sets of state information because
* we have to keep track of the base relation and the
* index relations.
*
* old comments
* Creates the run-time state information for the node and
* sets the relation id to contain relevant decriptors.
*
* Parameters:
* node: IndexNode node produced by the planner.
* estate: the execution state initialized in InitPlan.
* ----------------------------------------------------------------
*/
bool
ExecInitIndexScan(IndexScan *node, EState *estate, Plan *parent)
{
IndexScanState *indexstate;
CommonScanState *scanstate;
List *indxqual;
List *indxid;
int i;
int numIndices;
int indexPtr;
ScanKey *scanKeys;
int *numScanKeys;
RelationPtr relationDescs;
IndexScanDescPtr scanDescs;
Pointer *runtimeKeyInfo;
bool have_runtime_keys;
List *rangeTable;
RangeTblEntry *rtentry;
Index relid;
Oid reloid;
TimeQual timeQual;
Relation currentRelation;
HeapScanDesc currentScanDesc;
ScanDirection direction;
int baseid;
/* ----------------
* assign execution state to node
* ----------------
*/
node->scan.plan.state = estate;
/* --------------------------------
* Part 1) initialize scan state
*
* create new CommonScanState for node
* --------------------------------
*/
scanstate = makeNode(CommonScanState);
/*
scanstate->ss_ProcOuterFlag = false;
scanstate->ss_OldRelId = 0;
*/
node->scan.scanstate = scanstate;
/* ----------------
* assign node's base_id .. we don't use AssignNodeBaseid() because
* the increment is done later on after we assign the index scan's
* scanstate. see below.
* ----------------
*/
baseid = estate->es_BaseId;
/* scanstate->csstate.cstate.bnode.base_id = baseid; */
scanstate->cstate.cs_base_id = baseid;
/* ----------------
* create expression context for node
* ----------------
*/
ExecAssignExprContext(estate, &scanstate->cstate);
#define INDEXSCAN_NSLOTS 3
/* ----------------
* tuple table initialization
* ----------------
*/
ExecInitResultTupleSlot(estate, &scanstate->cstate);
ExecInitScanTupleSlot(estate, scanstate);
/* ExecInitRawTupleSlot(estate, scanstate); */
/* ----------------
* initialize projection info. result type comes from scan desc
* below..
* ----------------
*/
ExecAssignProjectionInfo((Plan *) node, &scanstate->cstate);
/* --------------------------------
* Part 2) initialize index scan state
*
* create new IndexScanState for node
* --------------------------------
*/
indexstate = makeNode(IndexScanState);
indexstate->iss_NumIndices = 0;
indexstate->iss_IndexPtr = 0;
indexstate->iss_ScanKeys = NULL;
indexstate->iss_NumScanKeys = NULL;
indexstate->iss_RuntimeKeyInfo = NULL;
indexstate->iss_RelationDescs = NULL;
indexstate->iss_ScanDescs = NULL;
node->indxstate = indexstate;
/* ----------------
* assign base id to index scan state also
* ----------------
*/
indexstate->cstate.cs_base_id = baseid;
baseid++;
estate->es_BaseId = baseid;
/* ----------------
* get the index node information
* ----------------
*/
indxid = node->indxid;
indxqual = node->indxqual;
numIndices = length(indxid);
indexPtr = 0;
CXT1_printf("ExecInitIndexScan: context is %d\n", CurrentMemoryContext);
/* ----------------
* scanKeys is used to keep track of the ScanKey's. This is needed
* because a single scan may use several indices and each index has
* its own ScanKey.
* ----------------
*/
numScanKeys = (int *) palloc(numIndices * sizeof(int));
scanKeys = (ScanKey *) palloc(numIndices * sizeof(ScanKey));
relationDescs = (RelationPtr) palloc(numIndices * sizeof(Relation));
scanDescs = (IndexScanDescPtr) palloc(numIndices * sizeof(IndexScanDesc));
/* ----------------
* initialize runtime key info.
* ----------------
*/
have_runtime_keys = false;
runtimeKeyInfo = (Pointer *)
palloc(numIndices * sizeof(Pointer));
/* ----------------
* build the index scan keys from the index qualification
* ----------------
*/
for (i=0; i < numIndices; i++) {
int j;
List *qual;
int n_keys;
ScanKey scan_keys;
int *run_keys;
qual = nth(i, indxqual);
n_keys = length(qual);
scan_keys = (n_keys <= 0) ? NULL :
(ScanKey)palloc(n_keys * sizeof(ScanKeyData));
CXT1_printf("ExecInitIndexScan: context is %d\n",
CurrentMemoryContext);
if (n_keys > 0) {
run_keys = (int *) palloc(n_keys * sizeof(int));
}
/* ----------------
* for each opclause in the given qual,
* convert each qual's opclause into a single scan key
* ----------------
*/
for (j=0; j < n_keys; j++) {
Expr *clause; /* one part of index qual */
Oper *op; /* operator used in scan.. */
Node *leftop; /* expr on lhs of operator */
Node *rightop; /* expr on rhs ... */
int scanvar; /* which var identifies varattno */
AttrNumber varattno; /* att number used in scan */
Oid opid; /* operator id used in scan */
Datum scanvalue; /* value used in scan (if const) */
/* ----------------
* extract clause information from the qualification
* ----------------
*/
clause = nth(j, qual);
op = (Oper*)clause->oper;
if (!IsA(op,Oper))
elog(WARN, "ExecInitIndexScan: op not an Oper!");
opid = op->opid;
/* ----------------
* Here we figure out the contents of the index qual.
* The usual case is (op var const) or (op const var)
* which means we form a scan key for the attribute
* listed in the var node and use the value of the const.
*
* If we don't have a const node, then it means that
* one of the var nodes refers to the "scan" tuple and
* is used to determine which attribute to scan, and the
* other expression is used to calculate the value used in
* scanning the index.
*
* This means our index scan's scan key is a function of
* information obtained during the execution of the plan
* in which case we need to recalculate the index scan key
* at run time.
*
* Hence, we set have_runtime_keys to true and then set
* the appropriate flag in run_keys to LEFT_OP or RIGHT_OP.
* The corresponding scan keys are recomputed at run time.
* ----------------
*/
scanvar = NO_OP;
/* ----------------
* determine information in leftop
* ----------------
*/
leftop = (Node*) get_leftop(clause);
if (IsA(leftop,Var) && var_is_rel((Var*)leftop)) {
/* ----------------
* if the leftop is a "rel-var", then it means
* that it is a var node which tells us which
* attribute to use for our scan key.
* ----------------
*/
varattno = ((Var*) leftop)->varattno;
scanvar = LEFT_OP;
} else if (IsA(leftop,Const)) {
/* ----------------
* if the leftop is a const node then it means
* it identifies the value to place in our scan key.
* ----------------
*/
run_keys[ j ] = NO_OP;
scanvalue = ((Const*) leftop)->constvalue;
} else if (leftop != NULL &&
is_funcclause(leftop) &&
var_is_rel(lfirst(((Expr*)leftop)->args))) {
/* ----------------
* if the leftop is a func node then it means
* it identifies the value to place in our scan key.
* Since functional indices have only one attribute
* the attno must always be set to 1.
* ----------------
*/
varattno = 1;
scanvar = LEFT_OP;
} else {
/* ----------------
* otherwise, the leftop contains information usable
* at runtime to figure out the value to place in our
* scan key.
* ----------------
*/
have_runtime_keys = true;
run_keys[ j ] = LEFT_OP;
scanvalue = Int32GetDatum((int32) true);
}
/* ----------------
* now determine information in rightop
* ----------------
*/
rightop = (Node*) get_rightop(clause);
if (IsA(rightop,Var) && var_is_rel((Var*)rightop)) {
/* ----------------
* here we make sure only one op identifies the
* scan-attribute...
* ----------------
*/
if (scanvar == LEFT_OP)
elog(WARN, "ExecInitIndexScan: %s",
"both left and right op's are rel-vars");
/* ----------------
* if the rightop is a "rel-var", then it means
* that it is a var node which tells us which
* attribute to use for our scan key.
* ----------------
*/
varattno = ((Var*) rightop)->varattno;
scanvar = RIGHT_OP;
} else if (IsA(rightop,Const)) {
/* ----------------
* if the leftop is a const node then it means
* it identifies the value to place in our scan key.
* ----------------
*/
run_keys[ j ] = NO_OP;
scanvalue = ((Const*) rightop)->constvalue;
} else if (rightop!=NULL &&
is_funcclause(rightop) &&
var_is_rel(lfirst(((Expr*)rightop)->args))) {
/* ----------------
* if the rightop is a func node then it means
* it identifies the value to place in our scan key.
* Since functional indices have only one attribute
* the attno must always be set to 1.
* ----------------
*/
if (scanvar == LEFT_OP)
elog(WARN, "ExecInitIndexScan: %s",
"both left and right ops are rel-vars");
varattno = 1;
scanvar = RIGHT_OP;
} else {
/* ----------------
* otherwise, the leftop contains information usable
* at runtime to figure out the value to place in our
* scan key.
* ----------------
*/
have_runtime_keys = true;
run_keys[ j ] = RIGHT_OP;
scanvalue = Int32GetDatum((int32) true);
}
/* ----------------
* now check that at least one op tells us the scan
* attribute...
* ----------------
*/
if (scanvar == NO_OP)
elog(WARN, "ExecInitIndexScan: %s",
"neither leftop nor rightop refer to scan relation");
/* ----------------
* initialize the scan key's fields appropriately
* ----------------
*/
ScanKeyEntryInitialize(&scan_keys[j],
0,
varattno, /* attribute number to scan */
(RegProcedure) opid, /* reg proc to use */
(Datum) scanvalue); /* constant */
}
/* ----------------
* store the key information into our array.
* ----------------
*/
numScanKeys[ i ] = n_keys;
scanKeys[ i ] = scan_keys;
runtimeKeyInfo[ i ] = (Pointer) run_keys;
}
indexstate->iss_NumIndices = numIndices;
indexstate->iss_IndexPtr = indexPtr;
indexstate->iss_ScanKeys = scanKeys;
indexstate->iss_NumScanKeys = numScanKeys;
/* ----------------
* If all of our keys have the form (op var const) , then we have no
* runtime keys so we store NULL in the runtime key info.
* Otherwise runtime key info contains an array of pointers
* (one for each index) to arrays of flags (one for each key)
* which indicate that the qual needs to be evaluated at runtime.
* -cim 10/24/89
* ----------------
*/
if (have_runtime_keys)
{
indexstate->iss_RuntimeKeyInfo = (Pointer) runtimeKeyInfo;
}
else {
indexstate->iss_RuntimeKeyInfo = NULL;
for (i=0; i < numIndices; i++) {
List *qual;
int n_keys;
qual = nth(i, indxqual);
n_keys = length(qual);
if (n_keys > 0)
pfree(runtimeKeyInfo[i]);
}
pfree(runtimeKeyInfo);
}
/* ----------------
* get the range table and direction information
* from the execution state (these are needed to
* open the relations).
* ----------------
*/
rangeTable = estate->es_range_table;
direction = estate->es_direction;
/* ----------------
* open the base relation
* ----------------
*/
relid = node->scan.scanrelid;
rtentry = rt_fetch(relid, rangeTable);
reloid = rtentry->relid;
timeQual = rtentry->timeQual;
ExecOpenScanR(reloid, /* relation */
0, /* nkeys */
(ScanKey) NULL, /* scan key */
0, /* is index */
direction, /* scan direction */
timeQual, /* time qual */
&currentRelation, /* return: rel desc */
(Pointer *) &currentScanDesc); /* return: scan desc */
scanstate->css_currentRelation = currentRelation;
scanstate->css_currentScanDesc = currentScanDesc;
/* ----------------
* get the scan type from the relation descriptor.
* ----------------
*/
ExecAssignScanType(scanstate, RelationGetTupleDescriptor(currentRelation));
ExecAssignResultTypeFromTL((Plan *) node, &scanstate->cstate);
/* ----------------
* index scans don't have subtrees..
* ----------------
*/
/* scanstate->ss_ProcOuterFlag = false; */
/* ----------------
* open the index relations and initialize
* relation and scan descriptors.
* ----------------
*/
for (i=0; i < numIndices; i++) {
Oid indexOid;
indexOid = (Oid)nth(i, indxid);
if (indexOid != 0) {
ExecOpenScanR(indexOid, /* relation */
numScanKeys[ i ], /* nkeys */
scanKeys[ i ], /* scan key */
true, /* is index */
direction, /* scan direction */
timeQual, /* time qual */
&(relationDescs[ i ]), /* return: rel desc */
(Pointer *) &(scanDescs[ i ]));
/* return: scan desc */
}
}
indexstate->iss_RelationDescs = relationDescs;
indexstate->iss_ScanDescs = scanDescs;
indexstate->cstate.cs_TupFromTlist = false;
/* ----------------
* all done.
* ----------------
*/
return TRUE;
}
int
ExecCountSlotsIndexScan(IndexScan *node)
{
return ExecCountSlotsNode(outerPlan((Plan *)node)) +
ExecCountSlotsNode(innerPlan((Plan *)node)) +
INDEXSCAN_NSLOTS;
}