mirror of https://github.com/postgres/postgres
This commit changes index-only scans so that data is read directly from the index tuple without first generating a faux heap tuple. The only immediate benefit is that indexes on system columns (such as OID) can be used in index-only scans, but this is necessary infrastructure if we are ever to support index-only scans on expression indexes. The executor is now ready for that, though the planner still needs substantial work to recognize the possibility. To do this, Vars in index-only plan nodes have to refer to index columns not heap columns. I introduced a new special varno, INDEX_VAR, to mark such Vars to avoid confusion. (In passing, this commit renames the two existing special varnos to OUTER_VAR and INNER_VAR.) This allows ruleutils.c to handle them with logic similar to what we use for subplan reference Vars. Since index-only scans are now fundamentally different from regular indexscans so far as their expression subtrees are concerned, I also chose to change them to have their own plan node type (and hence, their own executor source file).pull/1/head
Tom Lane
14 years ago
parent
fa351d5a0d
commit
a0185461dd
@ -0,0 +1,542 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* nodeIndexonlyscan.c |
||||||
|
* Routines to support index-only scans |
||||||
|
* |
||||||
|
* Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group |
||||||
|
* Portions Copyright (c) 1994, Regents of the University of California |
||||||
|
* |
||||||
|
* |
||||||
|
* IDENTIFICATION |
||||||
|
* src/backend/executor/nodeIndexonlyscan.c |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
/*
|
||||||
|
* INTERFACE ROUTINES |
||||||
|
* ExecIndexOnlyScan scans an index |
||||||
|
* IndexOnlyNext retrieve next tuple |
||||||
|
* ExecInitIndexOnlyScan creates and initializes state info. |
||||||
|
* ExecReScanIndexOnlyScan rescans the indexed relation. |
||||||
|
* ExecEndIndexOnlyScan releases all storage. |
||||||
|
* ExecIndexOnlyMarkPos marks scan position. |
||||||
|
* ExecIndexOnlyRestrPos restores scan position. |
||||||
|
*/ |
||||||
|
#include "postgres.h" |
||||||
|
|
||||||
|
#include "access/relscan.h" |
||||||
|
#include "access/visibilitymap.h" |
||||||
|
#include "catalog/pg_opfamily.h" |
||||||
|
#include "catalog/pg_type.h" |
||||||
|
#include "executor/execdebug.h" |
||||||
|
#include "executor/nodeIndexonlyscan.h" |
||||||
|
#include "executor/nodeIndexscan.h" |
||||||
|
#include "storage/bufmgr.h" |
||||||
|
#include "utils/memutils.h" |
||||||
|
#include "utils/rel.h" |
||||||
|
|
||||||
|
|
||||||
|
static TupleTableSlot *IndexOnlyNext(IndexOnlyScanState *node); |
||||||
|
static void StoreIndexTuple(TupleTableSlot *slot, IndexTuple itup, |
||||||
|
Relation indexRel); |
||||||
|
|
||||||
|
|
||||||
|
/* ----------------------------------------------------------------
|
||||||
|
* IndexOnlyNext |
||||||
|
* |
||||||
|
* Retrieve a tuple from the IndexOnlyScan node's index. |
||||||
|
* ---------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
static TupleTableSlot * |
||||||
|
IndexOnlyNext(IndexOnlyScanState *node) |
||||||
|
{ |
||||||
|
EState *estate; |
||||||
|
ExprContext *econtext; |
||||||
|
ScanDirection direction; |
||||||
|
IndexScanDesc scandesc; |
||||||
|
HeapTuple tuple; |
||||||
|
TupleTableSlot *slot; |
||||||
|
ItemPointer tid; |
||||||
|
|
||||||
|
/*
|
||||||
|
* extract necessary information from index scan node |
||||||
|
*/ |
||||||
|
estate = node->ss.ps.state; |
||||||
|
direction = estate->es_direction; |
||||||
|
/* flip direction if this is an overall backward scan */ |
||||||
|
if (ScanDirectionIsBackward(((IndexOnlyScan *) node->ss.ps.plan)->indexorderdir)) |
||||||
|
{ |
||||||
|
if (ScanDirectionIsForward(direction)) |
||||||
|
direction = BackwardScanDirection; |
||||||
|
else if (ScanDirectionIsBackward(direction)) |
||||||
|
direction = ForwardScanDirection; |
||||||
|
} |
||||||
|
scandesc = node->ioss_ScanDesc; |
||||||
|
econtext = node->ss.ps.ps_ExprContext; |
||||||
|
slot = node->ss.ss_ScanTupleSlot; |
||||||
|
|
||||||
|
/*
|
||||||
|
* OK, now that we have what we need, fetch the next tuple. |
||||||
|
*/ |
||||||
|
while ((tid = index_getnext_tid(scandesc, direction)) != NULL) |
||||||
|
{ |
||||||
|
/*
|
||||||
|
* We can skip the heap fetch if the TID references a heap page on |
||||||
|
* which all tuples are known visible to everybody. In any case, |
||||||
|
* we'll use the index tuple not the heap tuple as the data source. |
||||||
|
*/ |
||||||
|
if (!visibilitymap_test(scandesc->heapRelation, |
||||||
|
ItemPointerGetBlockNumber(tid), |
||||||
|
&node->ioss_VMBuffer)) |
||||||
|
{ |
||||||
|
/*
|
||||||
|
* Rats, we have to visit the heap to check visibility. |
||||||
|
*/ |
||||||
|
tuple = index_fetch_heap(scandesc); |
||||||
|
if (tuple == NULL) |
||||||
|
continue; /* no visible tuple, try next index entry */ |
||||||
|
|
||||||
|
/*
|
||||||
|
* Only MVCC snapshots are supported here, so there should be no |
||||||
|
* need to keep following the HOT chain once a visible entry has |
||||||
|
* been found. If we did want to allow that, we'd need to keep |
||||||
|
* more state to remember not to call index_getnext_tid next time. |
||||||
|
*/ |
||||||
|
if (scandesc->xs_continue_hot) |
||||||
|
elog(ERROR, "non-MVCC snapshots are not supported in index-only scans"); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Note: at this point we are holding a pin on the heap page, as |
||||||
|
* recorded in scandesc->xs_cbuf. We could release that pin now, |
||||||
|
* but it's not clear whether it's a win to do so. The next index |
||||||
|
* entry might require a visit to the same heap page. |
||||||
|
*/ |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Fill the scan tuple slot with data from the index. |
||||||
|
*/ |
||||||
|
StoreIndexTuple(slot, scandesc->xs_itup, scandesc->indexRelation); |
||||||
|
|
||||||
|
/*
|
||||||
|
* If the index was lossy, we have to recheck the index quals. |
||||||
|
* (Currently, this can never happen, but we should support the case |
||||||
|
* for possible future use, eg with GiST indexes.) |
||||||
|
*/ |
||||||
|
if (scandesc->xs_recheck) |
||||||
|
{ |
||||||
|
econtext->ecxt_scantuple = slot; |
||||||
|
ResetExprContext(econtext); |
||||||
|
if (!ExecQual(node->indexqual, econtext, false)) |
||||||
|
{ |
||||||
|
/* Fails recheck, so drop it and loop back for another */ |
||||||
|
InstrCountFiltered2(node, 1); |
||||||
|
continue; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return slot; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* if we get here it means the index scan failed so we are at the end of |
||||||
|
* the scan.. |
||||||
|
*/ |
||||||
|
return ExecClearTuple(slot); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* StoreIndexTuple |
||||||
|
* Fill the slot with data from the index tuple. |
||||||
|
* |
||||||
|
* At some point this might be generally-useful functionality, but |
||||||
|
* right now we don't need it elsewhere. |
||||||
|
*/ |
||||||
|
static void |
||||||
|
StoreIndexTuple(TupleTableSlot *slot, IndexTuple itup, Relation indexRel) |
||||||
|
{ |
||||||
|
TupleDesc indexDesc = RelationGetDescr(indexRel); |
||||||
|
int nindexatts = indexDesc->natts; |
||||||
|
Datum *values = slot->tts_values; |
||||||
|
bool *isnull = slot->tts_isnull; |
||||||
|
int i; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Note: we must use the index relation's tupdesc in index_getattr, |
||||||
|
* not the slot's tupdesc, because of index_descriptor_hack(). |
||||||
|
*/ |
||||||
|
Assert(slot->tts_tupleDescriptor->natts == nindexatts); |
||||||
|
|
||||||
|
ExecClearTuple(slot); |
||||||
|
for (i = 0; i < nindexatts; i++) |
||||||
|
values[i] = index_getattr(itup, i + 1, indexDesc, &isnull[i]); |
||||||
|
ExecStoreVirtualTuple(slot); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* index_descriptor_hack -- ugly kluge to make index's tupdesc OK for slot |
||||||
|
* |
||||||
|
* This is necessary because, alone among btree opclasses, name_ops uses |
||||||
|
* a storage type (cstring) different from its input type. The index |
||||||
|
* tuple descriptor will show "cstring", which is correct, but we have to |
||||||
|
* expose "name" as the slot datatype or ExecEvalVar will whine. If we |
||||||
|
* ever want to have any other cases with a different storage type, we ought |
||||||
|
* to think of a cleaner solution than this. |
||||||
|
*/ |
||||||
|
static TupleDesc |
||||||
|
index_descriptor_hack(Relation indexRel) |
||||||
|
{ |
||||||
|
TupleDesc tupdesc = RelationGetDescr(indexRel); |
||||||
|
int i; |
||||||
|
|
||||||
|
/* copy so we can scribble on it safely */ |
||||||
|
tupdesc = CreateTupleDescCopy(tupdesc); |
||||||
|
|
||||||
|
for (i = 0; i < tupdesc->natts; i++) |
||||||
|
{ |
||||||
|
if (indexRel->rd_opfamily[i] == NAME_BTREE_FAM_OID && |
||||||
|
tupdesc->attrs[i]->atttypid == CSTRINGOID) |
||||||
|
{ |
||||||
|
tupdesc->attrs[i]->atttypid = NAMEOID; |
||||||
|
|
||||||
|
/*
|
||||||
|
* We set attlen to match the type OID just in case anything looks |
||||||
|
* at it. Note that this is safe only because StoreIndexTuple |
||||||
|
* will insert the data as a virtual tuple, and we don't expect |
||||||
|
* anything will try to materialize the scan tuple slot. |
||||||
|
*/ |
||||||
|
tupdesc->attrs[i]->attlen = NAMEDATALEN; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return tupdesc; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* IndexOnlyRecheck -- access method routine to recheck a tuple in EvalPlanQual |
||||||
|
* |
||||||
|
* This can't really happen, since an index can't supply CTID which would |
||||||
|
* be necessary data for any potential EvalPlanQual target relation. If it |
||||||
|
* did happen, the EPQ code would pass us the wrong data, namely a heap |
||||||
|
* tuple not an index tuple. So throw an error. |
||||||
|
*/ |
||||||
|
static bool |
||||||
|
IndexOnlyRecheck(IndexOnlyScanState *node, TupleTableSlot *slot) |
||||||
|
{ |
||||||
|
elog(ERROR, "EvalPlanQual recheck is not supported in index-only scans"); |
||||||
|
return false; /* keep compiler quiet */ |
||||||
|
} |
||||||
|
|
||||||
|
/* ----------------------------------------------------------------
|
||||||
|
* ExecIndexOnlyScan(node) |
||||||
|
* ---------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
TupleTableSlot * |
||||||
|
ExecIndexOnlyScan(IndexOnlyScanState *node) |
||||||
|
{ |
||||||
|
/*
|
||||||
|
* If we have runtime keys and they've not already been set up, do it now. |
||||||
|
*/ |
||||||
|
if (node->ioss_NumRuntimeKeys != 0 && !node->ioss_RuntimeKeysReady) |
||||||
|
ExecReScan((PlanState *) node); |
||||||
|
|
||||||
|
return ExecScan(&node->ss, |
||||||
|
(ExecScanAccessMtd) IndexOnlyNext, |
||||||
|
(ExecScanRecheckMtd) IndexOnlyRecheck); |
||||||
|
} |
||||||
|
|
||||||
|
/* ----------------------------------------------------------------
|
||||||
|
* ExecReScanIndexOnlyScan(node) |
||||||
|
* |
||||||
|
* Recalculates the values of any scan keys whose value depends on |
||||||
|
* information known at runtime, then 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 |
||||||
|
ExecReScanIndexOnlyScan(IndexOnlyScanState *node) |
||||||
|
{ |
||||||
|
/*
|
||||||
|
* If we are doing runtime key calculations (ie, any of the index key |
||||||
|
* values weren't simple Consts), compute the new key values. But first, |
||||||
|
* reset the context so we don't leak memory as each outer tuple is |
||||||
|
* scanned. Note this assumes that we will recalculate *all* runtime keys |
||||||
|
* on each call. |
||||||
|
*/ |
||||||
|
if (node->ioss_NumRuntimeKeys != 0) |
||||||
|
{ |
||||||
|
ExprContext *econtext = node->ioss_RuntimeContext; |
||||||
|
|
||||||
|
ResetExprContext(econtext); |
||||||
|
ExecIndexEvalRuntimeKeys(econtext, |
||||||
|
node->ioss_RuntimeKeys, |
||||||
|
node->ioss_NumRuntimeKeys); |
||||||
|
} |
||||||
|
node->ioss_RuntimeKeysReady = true; |
||||||
|
|
||||||
|
/* reset index scan */ |
||||||
|
index_rescan(node->ioss_ScanDesc, |
||||||
|
node->ioss_ScanKeys, node->ioss_NumScanKeys, |
||||||
|
node->ioss_OrderByKeys, node->ioss_NumOrderByKeys); |
||||||
|
|
||||||
|
ExecScanReScan(&node->ss); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/* ----------------------------------------------------------------
|
||||||
|
* ExecEndIndexOnlyScan |
||||||
|
* ---------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
void |
||||||
|
ExecEndIndexOnlyScan(IndexOnlyScanState *node) |
||||||
|
{ |
||||||
|
Relation indexRelationDesc; |
||||||
|
IndexScanDesc indexScanDesc; |
||||||
|
Relation relation; |
||||||
|
|
||||||
|
/*
|
||||||
|
* extract information from the node |
||||||
|
*/ |
||||||
|
indexRelationDesc = node->ioss_RelationDesc; |
||||||
|
indexScanDesc = node->ioss_ScanDesc; |
||||||
|
relation = node->ss.ss_currentRelation; |
||||||
|
|
||||||
|
/* Release VM buffer pin, if any. */ |
||||||
|
if (node->ioss_VMBuffer != InvalidBuffer) |
||||||
|
{ |
||||||
|
ReleaseBuffer(node->ioss_VMBuffer); |
||||||
|
node->ioss_VMBuffer = InvalidBuffer; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Free the exprcontext(s) ... now dead code, see ExecFreeExprContext |
||||||
|
*/ |
||||||
|
#ifdef NOT_USED |
||||||
|
ExecFreeExprContext(&node->ss.ps); |
||||||
|
if (node->ioss_RuntimeContext) |
||||||
|
FreeExprContext(node->ioss_RuntimeContext, true); |
||||||
|
#endif |
||||||
|
|
||||||
|
/*
|
||||||
|
* clear out tuple table slots |
||||||
|
*/ |
||||||
|
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot); |
||||||
|
ExecClearTuple(node->ss.ss_ScanTupleSlot); |
||||||
|
|
||||||
|
/*
|
||||||
|
* close the index relation (no-op if we didn't open it) |
||||||
|
*/ |
||||||
|
if (indexScanDesc) |
||||||
|
index_endscan(indexScanDesc); |
||||||
|
if (indexRelationDesc) |
||||||
|
index_close(indexRelationDesc, NoLock); |
||||||
|
|
||||||
|
/*
|
||||||
|
* close the heap relation. |
||||||
|
*/ |
||||||
|
ExecCloseScanRelation(relation); |
||||||
|
} |
||||||
|
|
||||||
|
/* ----------------------------------------------------------------
|
||||||
|
* ExecIndexOnlyMarkPos |
||||||
|
* ---------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
void |
||||||
|
ExecIndexOnlyMarkPos(IndexOnlyScanState *node) |
||||||
|
{ |
||||||
|
index_markpos(node->ioss_ScanDesc); |
||||||
|
} |
||||||
|
|
||||||
|
/* ----------------------------------------------------------------
|
||||||
|
* ExecIndexOnlyRestrPos |
||||||
|
* ---------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
void |
||||||
|
ExecIndexOnlyRestrPos(IndexOnlyScanState *node) |
||||||
|
{ |
||||||
|
index_restrpos(node->ioss_ScanDesc); |
||||||
|
} |
||||||
|
|
||||||
|
/* ----------------------------------------------------------------
|
||||||
|
* ExecInitIndexOnlyScan |
||||||
|
* |
||||||
|
* 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 relation. |
||||||
|
* ---------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
IndexOnlyScanState * |
||||||
|
ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags) |
||||||
|
{ |
||||||
|
IndexOnlyScanState *indexstate; |
||||||
|
Relation currentRelation; |
||||||
|
bool relistarget; |
||||||
|
TupleDesc tupDesc; |
||||||
|
|
||||||
|
/*
|
||||||
|
* create state structure |
||||||
|
*/ |
||||||
|
indexstate = makeNode(IndexOnlyScanState); |
||||||
|
indexstate->ss.ps.plan = (Plan *) node; |
||||||
|
indexstate->ss.ps.state = estate; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Miscellaneous initialization |
||||||
|
* |
||||||
|
* create expression context for node |
||||||
|
*/ |
||||||
|
ExecAssignExprContext(estate, &indexstate->ss.ps); |
||||||
|
|
||||||
|
indexstate->ss.ps.ps_TupFromTlist = false; |
||||||
|
|
||||||
|
/*
|
||||||
|
* initialize child expressions |
||||||
|
* |
||||||
|
* Note: we don't initialize all of the indexorderby expression, only the |
||||||
|
* sub-parts corresponding to runtime keys (see below). |
||||||
|
*/ |
||||||
|
indexstate->ss.ps.targetlist = (List *) |
||||||
|
ExecInitExpr((Expr *) node->scan.plan.targetlist, |
||||||
|
(PlanState *) indexstate); |
||||||
|
indexstate->ss.ps.qual = (List *) |
||||||
|
ExecInitExpr((Expr *) node->scan.plan.qual, |
||||||
|
(PlanState *) indexstate); |
||||||
|
indexstate->indexqual = (List *) |
||||||
|
ExecInitExpr((Expr *) node->indexqual, |
||||||
|
(PlanState *) indexstate); |
||||||
|
|
||||||
|
/*
|
||||||
|
* tuple table initialization |
||||||
|
*/ |
||||||
|
ExecInitResultTupleSlot(estate, &indexstate->ss.ps); |
||||||
|
ExecInitScanTupleSlot(estate, &indexstate->ss); |
||||||
|
|
||||||
|
/*
|
||||||
|
* open the base relation and acquire appropriate lock on it. |
||||||
|
*/ |
||||||
|
currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid); |
||||||
|
|
||||||
|
indexstate->ss.ss_currentRelation = currentRelation; |
||||||
|
indexstate->ss.ss_currentScanDesc = NULL; /* no heap scan here */ |
||||||
|
|
||||||
|
/*
|
||||||
|
* Initialize result tuple type. |
||||||
|
*/ |
||||||
|
ExecAssignResultTypeFromTL(&indexstate->ss.ps); |
||||||
|
|
||||||
|
/*
|
||||||
|
* If we are just doing EXPLAIN (ie, aren't going to run the plan), stop |
||||||
|
* here. This allows an index-advisor plugin to EXPLAIN a plan containing |
||||||
|
* references to nonexistent indexes. |
||||||
|
*/ |
||||||
|
if (eflags & EXEC_FLAG_EXPLAIN_ONLY) |
||||||
|
return indexstate; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Open the index relation. |
||||||
|
* |
||||||
|
* If the parent table is one of the target relations of the query, then |
||||||
|
* InitPlan already opened and write-locked the index, so we can avoid |
||||||
|
* taking another lock here. Otherwise we need a normal reader's lock. |
||||||
|
*/ |
||||||
|
relistarget = ExecRelationIsTargetRelation(estate, node->scan.scanrelid); |
||||||
|
indexstate->ioss_RelationDesc = index_open(node->indexid, |
||||||
|
relistarget ? NoLock : AccessShareLock); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Now we can get the scan tuple's type (which is the index's rowtype, |
||||||
|
* not the heap's) and initialize result projection info. |
||||||
|
*/ |
||||||
|
tupDesc = index_descriptor_hack(indexstate->ioss_RelationDesc); |
||||||
|
ExecAssignScanType(&indexstate->ss, tupDesc); |
||||||
|
ExecAssignScanProjectionInfo(&indexstate->ss); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Initialize index-specific scan state |
||||||
|
*/ |
||||||
|
indexstate->ioss_RuntimeKeysReady = false; |
||||||
|
indexstate->ioss_RuntimeKeys = NULL; |
||||||
|
indexstate->ioss_NumRuntimeKeys = 0; |
||||||
|
|
||||||
|
/*
|
||||||
|
* build the index scan keys from the index qualification |
||||||
|
*/ |
||||||
|
ExecIndexBuildScanKeys((PlanState *) indexstate, |
||||||
|
indexstate->ioss_RelationDesc, |
||||||
|
node->indexqual, |
||||||
|
false, |
||||||
|
&indexstate->ioss_ScanKeys, |
||||||
|
&indexstate->ioss_NumScanKeys, |
||||||
|
&indexstate->ioss_RuntimeKeys, |
||||||
|
&indexstate->ioss_NumRuntimeKeys, |
||||||
|
NULL, /* no ArrayKeys */ |
||||||
|
NULL); |
||||||
|
|
||||||
|
/*
|
||||||
|
* any ORDER BY exprs have to be turned into scankeys in the same way |
||||||
|
*/ |
||||||
|
ExecIndexBuildScanKeys((PlanState *) indexstate, |
||||||
|
indexstate->ioss_RelationDesc, |
||||||
|
node->indexorderby, |
||||||
|
true, |
||||||
|
&indexstate->ioss_OrderByKeys, |
||||||
|
&indexstate->ioss_NumOrderByKeys, |
||||||
|
&indexstate->ioss_RuntimeKeys, |
||||||
|
&indexstate->ioss_NumRuntimeKeys, |
||||||
|
NULL, /* no ArrayKeys */ |
||||||
|
NULL); |
||||||
|
|
||||||
|
/*
|
||||||
|
* If we have runtime keys, we need an ExprContext to evaluate them. The |
||||||
|
* node's standard context won't do because we want to reset that context |
||||||
|
* for every tuple. So, build another context just like the other one... |
||||||
|
* -tgl 7/11/00 |
||||||
|
*/ |
||||||
|
if (indexstate->ioss_NumRuntimeKeys != 0) |
||||||
|
{ |
||||||
|
ExprContext *stdecontext = indexstate->ss.ps.ps_ExprContext; |
||||||
|
|
||||||
|
ExecAssignExprContext(estate, &indexstate->ss.ps); |
||||||
|
indexstate->ioss_RuntimeContext = indexstate->ss.ps.ps_ExprContext; |
||||||
|
indexstate->ss.ps.ps_ExprContext = stdecontext; |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
indexstate->ioss_RuntimeContext = NULL; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Initialize scan descriptor. |
||||||
|
*/ |
||||||
|
indexstate->ioss_ScanDesc = index_beginscan(currentRelation, |
||||||
|
indexstate->ioss_RelationDesc, |
||||||
|
estate->es_snapshot, |
||||||
|
indexstate->ioss_NumScanKeys, |
||||||
|
indexstate->ioss_NumOrderByKeys); |
||||||
|
|
||||||
|
/* Set it up for index-only scan */ |
||||||
|
indexstate->ioss_ScanDesc->xs_want_itup = true; |
||||||
|
indexstate->ioss_VMBuffer = InvalidBuffer; |
||||||
|
|
||||||
|
/*
|
||||||
|
* If no run-time keys to calculate, go ahead and pass the scankeys to the |
||||||
|
* index AM. |
||||||
|
*/ |
||||||
|
if (indexstate->ioss_NumRuntimeKeys == 0) |
||||||
|
index_rescan(indexstate->ioss_ScanDesc, |
||||||
|
indexstate->ioss_ScanKeys, |
||||||
|
indexstate->ioss_NumScanKeys, |
||||||
|
indexstate->ioss_OrderByKeys, |
||||||
|
indexstate->ioss_NumOrderByKeys); |
||||||
|
|
||||||
|
/*
|
||||||
|
* all done. |
||||||
|
*/ |
||||||
|
return indexstate; |
||||||
|
} |
||||||
@ -0,0 +1,26 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* nodeIndexonlyscan.h |
||||||
|
* |
||||||
|
* |
||||||
|
* |
||||||
|
* Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group |
||||||
|
* Portions Copyright (c) 1994, Regents of the University of California |
||||||
|
* |
||||||
|
* src/include/executor/nodeIndexonlyscan.h |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
#ifndef NODEINDEXONLYSCAN_H |
||||||
|
#define NODEINDEXONLYSCAN_H |
||||||
|
|
||||||
|
#include "nodes/execnodes.h" |
||||||
|
|
||||||
|
extern IndexOnlyScanState *ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags); |
||||||
|
extern TupleTableSlot *ExecIndexOnlyScan(IndexOnlyScanState *node); |
||||||
|
extern void ExecEndIndexOnlyScan(IndexOnlyScanState *node); |
||||||
|
extern void ExecIndexOnlyMarkPos(IndexOnlyScanState *node); |
||||||
|
extern void ExecIndexOnlyRestrPos(IndexOnlyScanState *node); |
||||||
|
extern void ExecReScanIndexOnlyScan(IndexOnlyScanState *node); |
||||||
|
|
||||||
|
#endif /* NODEINDEXONLYSCAN_H */ |
||||||
Loading…
Reference in new issue