/*------------------------------------------------------------------------- * * 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.2 1996/10/30 06:08:10 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; if (isNull) { scan_keys[j].sk_flags |= SK_ISNULL; } else { scan_keys[j].sk_flags &= ~SK_ISNULL; } } } } /* * 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; icstate.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 */ ¤tRelation, /* return: rel desc */ (Pointer *) ¤tScanDesc); /* 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; }