PostgreSQL Source Code  git master
nodeIndexonlyscan.h File Reference
#include "access/parallel.h"
#include "nodes/execnodes.h"
Include dependency graph for nodeIndexonlyscan.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

IndexOnlyScanStateExecInitIndexOnlyScan (IndexOnlyScan *node, EState *estate, int eflags)
 
void ExecEndIndexOnlyScan (IndexOnlyScanState *node)
 
void ExecIndexOnlyMarkPos (IndexOnlyScanState *node)
 
void ExecIndexOnlyRestrPos (IndexOnlyScanState *node)
 
void ExecReScanIndexOnlyScan (IndexOnlyScanState *node)
 
void ExecIndexOnlyScanEstimate (IndexOnlyScanState *node, ParallelContext *pcxt)
 
void ExecIndexOnlyScanInitializeDSM (IndexOnlyScanState *node, ParallelContext *pcxt)
 
void ExecIndexOnlyScanReInitializeDSM (IndexOnlyScanState *node, ParallelContext *pcxt)
 
void ExecIndexOnlyScanInitializeWorker (IndexOnlyScanState *node, ParallelWorkerContext *pwcxt)
 

Function Documentation

◆ ExecEndIndexOnlyScan()

void ExecEndIndexOnlyScan ( IndexOnlyScanState node)

Definition at line 364 of file nodeIndexonlyscan.c.

365 {
366  Relation indexRelationDesc;
367  IndexScanDesc indexScanDesc;
368 
369  /*
370  * extract information from the node
371  */
372  indexRelationDesc = node->ioss_RelationDesc;
373  indexScanDesc = node->ioss_ScanDesc;
374 
375  /* Release VM buffer pin, if any. */
376  if (node->ioss_VMBuffer != InvalidBuffer)
377  {
380  }
381 
382  /*
383  * close the index relation (no-op if we didn't open it)
384  */
385  if (indexScanDesc)
386  index_endscan(indexScanDesc);
387  if (indexRelationDesc)
388  index_close(indexRelationDesc, NoLock);
389 }
#define InvalidBuffer
Definition: buf.h:25
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:4560
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:177
void index_endscan(IndexScanDesc scan)
Definition: indexam.c:379
#define NoLock
Definition: lockdefs.h:34
struct IndexScanDescData * ioss_ScanDesc
Definition: execnodes.h:1700
Relation ioss_RelationDesc
Definition: execnodes.h:1699

References index_close(), index_endscan(), InvalidBuffer, IndexOnlyScanState::ioss_RelationDesc, IndexOnlyScanState::ioss_ScanDesc, IndexOnlyScanState::ioss_VMBuffer, NoLock, and ReleaseBuffer().

Referenced by ExecEndNode().

◆ ExecIndexOnlyMarkPos()

void ExecIndexOnlyMarkPos ( IndexOnlyScanState node)

Definition at line 399 of file nodeIndexonlyscan.c.

400 {
401  EState *estate = node->ss.ps.state;
402  EPQState *epqstate = estate->es_epq_active;
403 
404  if (epqstate != NULL)
405  {
406  /*
407  * We are inside an EvalPlanQual recheck. If a test tuple exists for
408  * this relation, then we shouldn't access the index at all. We would
409  * instead need to save, and later restore, the state of the
410  * relsubs_done flag, so that re-fetching the test tuple is possible.
411  * However, given the assumption that no caller sets a mark at the
412  * start of the scan, we can only get here with relsubs_done[i]
413  * already set, and so no state need be saved.
414  */
415  Index scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid;
416 
417  Assert(scanrelid > 0);
418  if (epqstate->relsubs_slot[scanrelid - 1] != NULL ||
419  epqstate->relsubs_rowmark[scanrelid - 1] != NULL)
420  {
421  /* Verify the claim above */
422  if (!epqstate->relsubs_done[scanrelid - 1])
423  elog(ERROR, "unexpected ExecIndexOnlyMarkPos call in EPQ recheck");
424  return;
425  }
426  }
427 
429 }
unsigned int Index
Definition: c.h:601
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
void index_markpos(IndexScanDesc scan)
Definition: indexam.c:409
Assert(fmt[strlen(fmt) - 1] !='\n')
ExecAuxRowMark ** relsubs_rowmark
Definition: execnodes.h:1291
TupleTableSlot ** relsubs_slot
Definition: execnodes.h:1263
bool * relsubs_done
Definition: execnodes.h:1298
struct EPQState * es_epq_active
Definition: execnodes.h:697
Plan * plan
Definition: execnodes.h:1116
EState * state
Definition: execnodes.h:1118
PlanState ps
Definition: execnodes.h:1556

References Assert(), elog, ERROR, EState::es_epq_active, index_markpos(), IndexOnlyScanState::ioss_ScanDesc, PlanState::plan, ScanState::ps, EPQState::relsubs_done, EPQState::relsubs_rowmark, EPQState::relsubs_slot, IndexOnlyScanState::ss, and PlanState::state.

Referenced by ExecMarkPos().

◆ ExecIndexOnlyRestrPos()

void ExecIndexOnlyRestrPos ( IndexOnlyScanState node)

Definition at line 436 of file nodeIndexonlyscan.c.

437 {
438  EState *estate = node->ss.ps.state;
439  EPQState *epqstate = estate->es_epq_active;
440 
441  if (estate->es_epq_active != NULL)
442  {
443  /* See comments in ExecIndexMarkPos */
444  Index scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid;
445 
446  Assert(scanrelid > 0);
447  if (epqstate->relsubs_slot[scanrelid - 1] != NULL ||
448  epqstate->relsubs_rowmark[scanrelid - 1] != NULL)
449  {
450  /* Verify the claim above */
451  if (!epqstate->relsubs_done[scanrelid - 1])
452  elog(ERROR, "unexpected ExecIndexOnlyRestrPos call in EPQ recheck");
453  return;
454  }
455  }
456 
458 }
void index_restrpos(IndexScanDesc scan)
Definition: indexam.c:433

References Assert(), elog, ERROR, EState::es_epq_active, index_restrpos(), IndexOnlyScanState::ioss_ScanDesc, PlanState::plan, ScanState::ps, EPQState::relsubs_done, EPQState::relsubs_rowmark, EPQState::relsubs_slot, IndexOnlyScanState::ss, and PlanState::state.

Referenced by ExecRestrPos().

◆ ExecIndexOnlyScanEstimate()

void ExecIndexOnlyScanEstimate ( IndexOnlyScanState node,
ParallelContext pcxt 
)

Definition at line 625 of file nodeIndexonlyscan.c.

627 {
628  EState *estate = node->ss.ps.state;
629 
631  estate->es_snapshot);
633  shm_toc_estimate_keys(&pcxt->estimator, 1);
634 }
Size index_parallelscan_estimate(Relation indexRelation, Snapshot snapshot)
Definition: indexam.c:458
#define shm_toc_estimate_chunk(e, sz)
Definition: shm_toc.h:51
#define shm_toc_estimate_keys(e, cnt)
Definition: shm_toc.h:53
Snapshot es_snapshot
Definition: execnodes.h:622
shm_toc_estimator estimator
Definition: parallel.h:41

References EState::es_snapshot, ParallelContext::estimator, index_parallelscan_estimate(), IndexOnlyScanState::ioss_PscanLen, IndexOnlyScanState::ioss_RelationDesc, ScanState::ps, shm_toc_estimate_chunk, shm_toc_estimate_keys, IndexOnlyScanState::ss, and PlanState::state.

Referenced by ExecParallelEstimate().

◆ ExecIndexOnlyScanInitializeDSM()

void ExecIndexOnlyScanInitializeDSM ( IndexOnlyScanState node,
ParallelContext pcxt 
)

Definition at line 643 of file nodeIndexonlyscan.c.

645 {
646  EState *estate = node->ss.ps.state;
647  ParallelIndexScanDesc piscan;
648 
649  piscan = shm_toc_allocate(pcxt->toc, node->ioss_PscanLen);
651  node->ioss_RelationDesc,
652  estate->es_snapshot,
653  piscan);
654  shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, piscan);
655  node->ioss_ScanDesc =
657  node->ioss_RelationDesc,
658  node->ioss_NumScanKeys,
659  node->ioss_NumOrderByKeys,
660  piscan);
661  node->ioss_ScanDesc->xs_want_itup = true;
663 
664  /*
665  * If no run-time keys to calculate or they are ready, go ahead and pass
666  * the scankeys to the index AM.
667  */
668  if (node->ioss_NumRuntimeKeys == 0 || node->ioss_RuntimeKeysReady)
670  node->ioss_ScanKeys, node->ioss_NumScanKeys,
672 }
IndexScanDesc index_beginscan_parallel(Relation heaprel, Relation indexrel, int nkeys, int norderbys, ParallelIndexScanDesc pscan)
Definition: indexam.c:544
void index_parallelscan_initialize(Relation heapRelation, Relation indexRelation, Snapshot snapshot, ParallelIndexScanDesc target)
Definition: indexam.c:493
void index_rescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int norderbys)
Definition: indexam.c:353
void shm_toc_insert(shm_toc *toc, uint64 key, void *address)
Definition: shm_toc.c:171
void * shm_toc_allocate(shm_toc *toc, Size nbytes)
Definition: shm_toc.c:88
bool ioss_RuntimeKeysReady
Definition: execnodes.h:1697
struct ScanKeyData * ioss_ScanKeys
Definition: execnodes.h:1691
struct ScanKeyData * ioss_OrderByKeys
Definition: execnodes.h:1693
shm_toc * toc
Definition: parallel.h:44
int plan_node_id
Definition: plannodes.h:151
Relation ss_currentRelation
Definition: execnodes.h:1557

References EState::es_snapshot, index_beginscan_parallel(), index_parallelscan_initialize(), index_rescan(), InvalidBuffer, IndexOnlyScanState::ioss_NumOrderByKeys, IndexOnlyScanState::ioss_NumRuntimeKeys, IndexOnlyScanState::ioss_NumScanKeys, IndexOnlyScanState::ioss_OrderByKeys, IndexOnlyScanState::ioss_PscanLen, IndexOnlyScanState::ioss_RelationDesc, IndexOnlyScanState::ioss_RuntimeKeysReady, IndexOnlyScanState::ioss_ScanDesc, IndexOnlyScanState::ioss_ScanKeys, IndexOnlyScanState::ioss_VMBuffer, PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_allocate(), shm_toc_insert(), IndexOnlyScanState::ss, ScanState::ss_currentRelation, PlanState::state, ParallelContext::toc, and IndexScanDescData::xs_want_itup.

Referenced by ExecParallelInitializeDSM().

◆ ExecIndexOnlyScanInitializeWorker()

void ExecIndexOnlyScanInitializeWorker ( IndexOnlyScanState node,
ParallelWorkerContext pwcxt 
)

Definition at line 694 of file nodeIndexonlyscan.c.

696 {
697  ParallelIndexScanDesc piscan;
698 
699  piscan = shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, false);
700  node->ioss_ScanDesc =
702  node->ioss_RelationDesc,
703  node->ioss_NumScanKeys,
704  node->ioss_NumOrderByKeys,
705  piscan);
706  node->ioss_ScanDesc->xs_want_itup = true;
707 
708  /*
709  * If no run-time keys to calculate or they are ready, go ahead and pass
710  * the scankeys to the index AM.
711  */
712  if (node->ioss_NumRuntimeKeys == 0 || node->ioss_RuntimeKeysReady)
714  node->ioss_ScanKeys, node->ioss_NumScanKeys,
716 }
void * shm_toc_lookup(shm_toc *toc, uint64 key, bool noError)
Definition: shm_toc.c:232

References index_beginscan_parallel(), index_rescan(), IndexOnlyScanState::ioss_NumOrderByKeys, IndexOnlyScanState::ioss_NumRuntimeKeys, IndexOnlyScanState::ioss_NumScanKeys, IndexOnlyScanState::ioss_OrderByKeys, IndexOnlyScanState::ioss_RelationDesc, IndexOnlyScanState::ioss_RuntimeKeysReady, IndexOnlyScanState::ioss_ScanDesc, IndexOnlyScanState::ioss_ScanKeys, PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_lookup(), IndexOnlyScanState::ss, ScanState::ss_currentRelation, ParallelWorkerContext::toc, and IndexScanDescData::xs_want_itup.

Referenced by ExecParallelInitializeWorker().

◆ ExecIndexOnlyScanReInitializeDSM()

void ExecIndexOnlyScanReInitializeDSM ( IndexOnlyScanState node,
ParallelContext pcxt 
)

Definition at line 681 of file nodeIndexonlyscan.c.

683 {
685 }
void index_parallelrescan(IndexScanDesc scan)
Definition: indexam.c:526

References index_parallelrescan(), and IndexOnlyScanState::ioss_ScanDesc.

Referenced by ExecParallelReInitializeDSM().

◆ ExecInitIndexOnlyScan()

IndexOnlyScanState* ExecInitIndexOnlyScan ( IndexOnlyScan node,
EState estate,
int  eflags 
)

Definition at line 472 of file nodeIndexonlyscan.c.

473 {
474  IndexOnlyScanState *indexstate;
475  Relation currentRelation;
476  LOCKMODE lockmode;
477  TupleDesc tupDesc;
478 
479  /*
480  * create state structure
481  */
482  indexstate = makeNode(IndexOnlyScanState);
483  indexstate->ss.ps.plan = (Plan *) node;
484  indexstate->ss.ps.state = estate;
485  indexstate->ss.ps.ExecProcNode = ExecIndexOnlyScan;
486 
487  /*
488  * Miscellaneous initialization
489  *
490  * create expression context for node
491  */
492  ExecAssignExprContext(estate, &indexstate->ss.ps);
493 
494  /*
495  * open the scan relation
496  */
497  currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);
498 
499  indexstate->ss.ss_currentRelation = currentRelation;
500  indexstate->ss.ss_currentScanDesc = NULL; /* no heap scan here */
501 
502  /*
503  * Build the scan tuple type using the indextlist generated by the
504  * planner. We use this, rather than the index's physical tuple
505  * descriptor, because the latter contains storage column types not the
506  * types of the original datums. (It's the AM's responsibility to return
507  * suitable data anyway.)
508  */
509  tupDesc = ExecTypeFromTL(node->indextlist);
510  ExecInitScanTupleSlot(estate, &indexstate->ss, tupDesc,
511  &TTSOpsVirtual);
512 
513  /*
514  * We need another slot, in a format that's suitable for the table AM, for
515  * when we need to fetch a tuple from the table for rechecking visibility.
516  */
517  indexstate->ioss_TableSlot =
519  RelationGetDescr(currentRelation),
520  table_slot_callbacks(currentRelation));
521 
522  /*
523  * Initialize result type and projection info. The node's targetlist will
524  * contain Vars with varno = INDEX_VAR, referencing the scan tuple.
525  */
526  ExecInitResultTypeTL(&indexstate->ss.ps);
528 
529  /*
530  * initialize child expressions
531  *
532  * Note: we don't initialize all of the indexorderby expression, only the
533  * sub-parts corresponding to runtime keys (see below).
534  */
535  indexstate->ss.ps.qual =
536  ExecInitQual(node->scan.plan.qual, (PlanState *) indexstate);
537  indexstate->recheckqual =
538  ExecInitQual(node->recheckqual, (PlanState *) indexstate);
539 
540  /*
541  * If we are just doing EXPLAIN (ie, aren't going to run the plan), stop
542  * here. This allows an index-advisor plugin to EXPLAIN a plan containing
543  * references to nonexistent indexes.
544  */
545  if (eflags & EXEC_FLAG_EXPLAIN_ONLY)
546  return indexstate;
547 
548  /* Open the index relation. */
549  lockmode = exec_rt_fetch(node->scan.scanrelid, estate)->rellockmode;
550  indexstate->ioss_RelationDesc = index_open(node->indexid, lockmode);
551 
552  /*
553  * Initialize index-specific scan state
554  */
555  indexstate->ioss_RuntimeKeysReady = false;
556  indexstate->ioss_RuntimeKeys = NULL;
557  indexstate->ioss_NumRuntimeKeys = 0;
558 
559  /*
560  * build the index scan keys from the index qualification
561  */
562  ExecIndexBuildScanKeys((PlanState *) indexstate,
563  indexstate->ioss_RelationDesc,
564  node->indexqual,
565  false,
566  &indexstate->ioss_ScanKeys,
567  &indexstate->ioss_NumScanKeys,
568  &indexstate->ioss_RuntimeKeys,
569  &indexstate->ioss_NumRuntimeKeys,
570  NULL, /* no ArrayKeys */
571  NULL);
572 
573  /*
574  * any ORDER BY exprs have to be turned into scankeys in the same way
575  */
576  ExecIndexBuildScanKeys((PlanState *) indexstate,
577  indexstate->ioss_RelationDesc,
578  node->indexorderby,
579  true,
580  &indexstate->ioss_OrderByKeys,
581  &indexstate->ioss_NumOrderByKeys,
582  &indexstate->ioss_RuntimeKeys,
583  &indexstate->ioss_NumRuntimeKeys,
584  NULL, /* no ArrayKeys */
585  NULL);
586 
587  /*
588  * If we have runtime keys, we need an ExprContext to evaluate them. The
589  * node's standard context won't do because we want to reset that context
590  * for every tuple. So, build another context just like the other one...
591  * -tgl 7/11/00
592  */
593  if (indexstate->ioss_NumRuntimeKeys != 0)
594  {
595  ExprContext *stdecontext = indexstate->ss.ps.ps_ExprContext;
596 
597  ExecAssignExprContext(estate, &indexstate->ss.ps);
598  indexstate->ioss_RuntimeContext = indexstate->ss.ps.ps_ExprContext;
599  indexstate->ss.ps.ps_ExprContext = stdecontext;
600  }
601  else
602  {
603  indexstate->ioss_RuntimeContext = NULL;
604  }
605 
606  /*
607  * all done.
608  */
609  return indexstate;
610 }
ExprState * ExecInitQual(List *qual, PlanState *parent)
Definition: execExpr.c:220
void ExecAssignScanProjectionInfoWithVarno(ScanState *node, int varno)
Definition: execScan.c:283
const TupleTableSlotOps TTSOpsVirtual
Definition: execTuples.c:84
void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1898
void ExecInitResultTypeTL(PlanState *planstate)
Definition: execTuples.c:1842
TupleDesc ExecTypeFromTL(List *targetList)
Definition: execTuples.c:2025
TupleTableSlot * ExecAllocTableSlot(List **tupleTable, TupleDesc desc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1258
void ExecAssignExprContext(EState *estate, PlanState *planstate)
Definition: execUtils.c:483
Relation ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags)
Definition: execUtils.c:697
static RangeTblEntry * exec_rt_fetch(Index rti, EState *estate)
Definition: executor.h:587
#define EXEC_FLAG_EXPLAIN_ONLY
Definition: executor.h:65
Relation index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:133
int LOCKMODE
Definition: lockdefs.h:26
static TupleTableSlot * ExecIndexOnlyScan(PlanState *pstate)
void ExecIndexBuildScanKeys(PlanState *planstate, Relation index, List *quals, bool isorderby, ScanKey *scanKeys, int *numScanKeys, IndexRuntimeKeyInfo **runtimeKeys, int *numRuntimeKeys, IndexArrayKeyInfo **arrayKeys, int *numArrayKeys)
#define makeNode(_type_)
Definition: nodes.h:155
#define INDEX_VAR
Definition: primnodes.h:224
#define RelationGetDescr(relation)
Definition: rel.h:533
List * es_tupleTable
Definition: execnodes.h:667
TupleTableSlot * ioss_TableSlot
Definition: execnodes.h:1701
ExprState * recheckqual
Definition: execnodes.h:1690
ExprContext * ioss_RuntimeContext
Definition: execnodes.h:1698
IndexRuntimeKeyInfo * ioss_RuntimeKeys
Definition: execnodes.h:1695
List * indexqual
Definition: plannodes.h:494
List * recheckqual
Definition: plannodes.h:495
List * indextlist
Definition: plannodes.h:497
List * indexorderby
Definition: plannodes.h:496
ExprState * qual
Definition: execnodes.h:1137
ExprContext * ps_ExprContext
Definition: execnodes.h:1155
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:1122
struct TableScanDescData * ss_currentScanDesc
Definition: execnodes.h:1558
Index scanrelid
Definition: plannodes.h:387
const TupleTableSlotOps * table_slot_callbacks(Relation relation)
Definition: tableam.c:58

References EState::es_tupleTable, EXEC_FLAG_EXPLAIN_ONLY, exec_rt_fetch(), ExecAllocTableSlot(), ExecAssignExprContext(), ExecAssignScanProjectionInfoWithVarno(), ExecIndexBuildScanKeys(), ExecIndexOnlyScan(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), PlanState::ExecProcNode, ExecTypeFromTL(), index_open(), INDEX_VAR, IndexOnlyScan::indexid, IndexOnlyScan::indexorderby, IndexOnlyScan::indexqual, IndexOnlyScan::indextlist, IndexOnlyScanState::ioss_NumOrderByKeys, IndexOnlyScanState::ioss_NumRuntimeKeys, IndexOnlyScanState::ioss_NumScanKeys, IndexOnlyScanState::ioss_OrderByKeys, IndexOnlyScanState::ioss_RelationDesc, IndexOnlyScanState::ioss_RuntimeContext, IndexOnlyScanState::ioss_RuntimeKeys, IndexOnlyScanState::ioss_RuntimeKeysReady, IndexOnlyScanState::ioss_ScanKeys, IndexOnlyScanState::ioss_TableSlot, makeNode, PlanState::plan, ScanState::ps, PlanState::ps_ExprContext, PlanState::qual, IndexOnlyScanState::recheckqual, IndexOnlyScan::recheckqual, RelationGetDescr, IndexOnlyScan::scan, Scan::scanrelid, IndexOnlyScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, table_slot_callbacks(), and TTSOpsVirtual.

Referenced by ExecInitNode().

◆ ExecReScanIndexOnlyScan()

void ExecReScanIndexOnlyScan ( IndexOnlyScanState node)

Definition at line 329 of file nodeIndexonlyscan.c.

330 {
331  /*
332  * If we are doing runtime key calculations (ie, any of the index key
333  * values weren't simple Consts), compute the new key values. But first,
334  * reset the context so we don't leak memory as each outer tuple is
335  * scanned. Note this assumes that we will recalculate *all* runtime keys
336  * on each call.
337  */
338  if (node->ioss_NumRuntimeKeys != 0)
339  {
340  ExprContext *econtext = node->ioss_RuntimeContext;
341 
342  ResetExprContext(econtext);
343  ExecIndexEvalRuntimeKeys(econtext,
344  node->ioss_RuntimeKeys,
345  node->ioss_NumRuntimeKeys);
346  }
347  node->ioss_RuntimeKeysReady = true;
348 
349  /* reset index scan */
350  if (node->ioss_ScanDesc)
352  node->ioss_ScanKeys, node->ioss_NumScanKeys,
354 
355  ExecScanReScan(&node->ss);
356 }
void ExecScanReScan(ScanState *node)
Definition: execScan.c:297
#define ResetExprContext(econtext)
Definition: executor.h:544
void ExecIndexEvalRuntimeKeys(ExprContext *econtext, IndexRuntimeKeyInfo *runtimeKeys, int numRuntimeKeys)

References ExecIndexEvalRuntimeKeys(), ExecScanReScan(), index_rescan(), IndexOnlyScanState::ioss_NumOrderByKeys, IndexOnlyScanState::ioss_NumRuntimeKeys, IndexOnlyScanState::ioss_NumScanKeys, IndexOnlyScanState::ioss_OrderByKeys, IndexOnlyScanState::ioss_RuntimeContext, IndexOnlyScanState::ioss_RuntimeKeys, IndexOnlyScanState::ioss_RuntimeKeysReady, IndexOnlyScanState::ioss_ScanDesc, IndexOnlyScanState::ioss_ScanKeys, ResetExprContext, and IndexOnlyScanState::ss.

Referenced by ExecReScan().