Postgres95 1.01 Distribution - Virgin SourcesPG95-1_01

1 files changed, 902 insertions, 0 deletions

diff --git a/src/backend/executor/nodeIndexscan.c b/src/backend/executor/nodeIndexscan.c
new file mode 100644
index 00000000000..758fabdefe5
--- /dev/null
+++ b/src/backend/executor/nodeIndexscan.c
@@ -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;
+}