PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
nodeIndexonlyscan.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * nodeIndexonlyscan.c
4  * Routines to support index-only scans
5  *
6  * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/executor/nodeIndexonlyscan.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 /*
16  * INTERFACE ROUTINES
17  * ExecIndexOnlyScan scans an index
18  * IndexOnlyNext retrieve next tuple
19  * ExecInitIndexOnlyScan creates and initializes state info.
20  * ExecReScanIndexOnlyScan rescans the indexed relation.
21  * ExecEndIndexOnlyScan releases all storage.
22  * ExecIndexOnlyMarkPos marks scan position.
23  * ExecIndexOnlyRestrPos restores scan position.
24  * ExecIndexOnlyScanEstimate estimates DSM space needed for
25  * parallel index-only scan
26  * ExecIndexOnlyScanInitializeDSM initialize DSM for parallel
27  * index-only scan
28  * ExecIndexOnlyScanReInitializeDSM reinitialize DSM for fresh scan
29  * ExecIndexOnlyScanInitializeWorker attach to DSM info in parallel worker
30  */
31 #include "postgres.h"
32 
33 #include "access/relscan.h"
34 #include "access/visibilitymap.h"
35 #include "executor/execdebug.h"
37 #include "executor/nodeIndexscan.h"
38 #include "miscadmin.h"
39 #include "storage/bufmgr.h"
40 #include "storage/predicate.h"
41 #include "utils/memutils.h"
42 #include "utils/rel.h"
43 
44 
46 static void StoreIndexTuple(TupleTableSlot *slot, IndexTuple itup,
47  TupleDesc itupdesc);
48 
49 
50 /* ----------------------------------------------------------------
51  * IndexOnlyNext
52  *
53  * Retrieve a tuple from the IndexOnlyScan node's index.
54  * ----------------------------------------------------------------
55  */
56 static TupleTableSlot *
58 {
59  EState *estate;
60  ExprContext *econtext;
61  ScanDirection direction;
62  IndexScanDesc scandesc;
63  TupleTableSlot *slot;
64  ItemPointer tid;
65 
66  /*
67  * extract necessary information from index scan node
68  */
69  estate = node->ss.ps.state;
70  direction = estate->es_direction;
71  /* flip direction if this is an overall backward scan */
72  if (ScanDirectionIsBackward(((IndexOnlyScan *) node->ss.ps.plan)->indexorderdir))
73  {
74  if (ScanDirectionIsForward(direction))
75  direction = BackwardScanDirection;
76  else if (ScanDirectionIsBackward(direction))
77  direction = ForwardScanDirection;
78  }
79  scandesc = node->ioss_ScanDesc;
80  econtext = node->ss.ps.ps_ExprContext;
81  slot = node->ss.ss_ScanTupleSlot;
82 
83  if (scandesc == NULL)
84  {
85  /*
86  * We reach here if the index only scan is not parallel, or if we're
87  * executing a index only scan that was intended to be parallel
88  * serially.
89  */
90  scandesc = index_beginscan(node->ss.ss_currentRelation,
91  node->ioss_RelationDesc,
92  estate->es_snapshot,
93  node->ioss_NumScanKeys,
94  node->ioss_NumOrderByKeys);
95 
96  node->ioss_ScanDesc = scandesc;
97 
98 
99  /* Set it up for index-only scan */
100  node->ioss_ScanDesc->xs_want_itup = true;
102 
103  /*
104  * If no run-time keys to calculate or they are ready, go ahead and
105  * pass the scankeys to the index AM.
106  */
107  if (node->ioss_NumRuntimeKeys == 0 || node->ioss_RuntimeKeysReady)
108  index_rescan(scandesc,
109  node->ioss_ScanKeys,
110  node->ioss_NumScanKeys,
111  node->ioss_OrderByKeys,
112  node->ioss_NumOrderByKeys);
113  }
114 
115  /*
116  * OK, now that we have what we need, fetch the next tuple.
117  */
118  while ((tid = index_getnext_tid(scandesc, direction)) != NULL)
119  {
120  HeapTuple tuple = NULL;
121 
123 
124  /*
125  * We can skip the heap fetch if the TID references a heap page on
126  * which all tuples are known visible to everybody. In any case,
127  * we'll use the index tuple not the heap tuple as the data source.
128  *
129  * Note on Memory Ordering Effects: visibilitymap_get_status does not
130  * lock the visibility map buffer, and therefore the result we read
131  * here could be slightly stale. However, it can't be stale enough to
132  * matter.
133  *
134  * We need to detect clearing a VM bit due to an insert right away,
135  * because the tuple is present in the index page but not visible. The
136  * reading of the TID by this scan (using a shared lock on the index
137  * buffer) is serialized with the insert of the TID into the index
138  * (using an exclusive lock on the index buffer). Because the VM bit
139  * is cleared before updating the index, and locking/unlocking of the
140  * index page acts as a full memory barrier, we are sure to see the
141  * cleared bit if we see a recently-inserted TID.
142  *
143  * Deletes do not update the index page (only VACUUM will clear out
144  * the TID), so the clearing of the VM bit by a delete is not
145  * serialized with this test below, and we may see a value that is
146  * significantly stale. However, we don't care about the delete right
147  * away, because the tuple is still visible until the deleting
148  * transaction commits or the statement ends (if it's our
149  * transaction). In either case, the lock on the VM buffer will have
150  * been released (acting as a write barrier) after clearing the bit.
151  * And for us to have a snapshot that includes the deleting
152  * transaction (making the tuple invisible), we must have acquired
153  * ProcArrayLock after that time, acting as a read barrier.
154  *
155  * It's worth going through this complexity to avoid needing to lock
156  * the VM buffer, which could cause significant contention.
157  */
158  if (!VM_ALL_VISIBLE(scandesc->heapRelation,
160  &node->ioss_VMBuffer))
161  {
162  /*
163  * Rats, we have to visit the heap to check visibility.
164  */
165  node->ioss_HeapFetches++;
166  tuple = index_fetch_heap(scandesc);
167  if (tuple == NULL)
168  continue; /* no visible tuple, try next index entry */
169 
170  /*
171  * Only MVCC snapshots are supported here, so there should be no
172  * need to keep following the HOT chain once a visible entry has
173  * been found. If we did want to allow that, we'd need to keep
174  * more state to remember not to call index_getnext_tid next time.
175  */
176  if (scandesc->xs_continue_hot)
177  elog(ERROR, "non-MVCC snapshots are not supported in index-only scans");
178 
179  /*
180  * Note: at this point we are holding a pin on the heap page, as
181  * recorded in scandesc->xs_cbuf. We could release that pin now,
182  * but it's not clear whether it's a win to do so. The next index
183  * entry might require a visit to the same heap page.
184  */
185  }
186 
187  /*
188  * Fill the scan tuple slot with data from the index. This might be
189  * provided in either HeapTuple or IndexTuple format. Conceivably an
190  * index AM might fill both fields, in which case we prefer the heap
191  * format, since it's probably a bit cheaper to fill a slot from.
192  */
193  if (scandesc->xs_hitup)
194  {
195  /*
196  * We don't take the trouble to verify that the provided tuple has
197  * exactly the slot's format, but it seems worth doing a quick
198  * check on the number of fields.
199  */
201  scandesc->xs_hitupdesc->natts);
202  ExecStoreTuple(scandesc->xs_hitup, slot, InvalidBuffer, false);
203  }
204  else if (scandesc->xs_itup)
205  StoreIndexTuple(slot, scandesc->xs_itup, scandesc->xs_itupdesc);
206  else
207  elog(ERROR, "no data returned for index-only scan");
208 
209  /*
210  * If the index was lossy, we have to recheck the index quals.
211  * (Currently, this can never happen, but we should support the case
212  * for possible future use, eg with GiST indexes.)
213  */
214  if (scandesc->xs_recheck)
215  {
216  econtext->ecxt_scantuple = slot;
217  ResetExprContext(econtext);
218  if (!ExecQual(node->indexqual, econtext))
219  {
220  /* Fails recheck, so drop it and loop back for another */
221  InstrCountFiltered2(node, 1);
222  continue;
223  }
224  }
225 
226  /*
227  * We don't currently support rechecking ORDER BY distances. (In
228  * principle, if the index can support retrieval of the originally
229  * indexed value, it should be able to produce an exact distance
230  * calculation too. So it's not clear that adding code here for
231  * recheck/re-sort would be worth the trouble. But we should at least
232  * throw an error if someone tries it.)
233  */
234  if (scandesc->numberOfOrderBys > 0 && scandesc->xs_recheckorderby)
235  ereport(ERROR,
236  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
237  errmsg("lossy distance functions are not supported in index-only scans")));
238 
239  /*
240  * Predicate locks for index-only scans must be acquired at the page
241  * level when the heap is not accessed, since tuple-level predicate
242  * locks need the tuple's xmin value. If we had to visit the tuple
243  * anyway, then we already have the tuple-level lock and can skip the
244  * page lock.
245  */
246  if (tuple == NULL)
249  estate->es_snapshot);
250 
251  return slot;
252  }
253 
254  /*
255  * if we get here it means the index scan failed so we are at the end of
256  * the scan..
257  */
258  return ExecClearTuple(slot);
259 }
260 
261 /*
262  * StoreIndexTuple
263  * Fill the slot with data from the index tuple.
264  *
265  * At some point this might be generally-useful functionality, but
266  * right now we don't need it elsewhere.
267  */
268 static void
270 {
271  int nindexatts = itupdesc->natts;
272  Datum *values = slot->tts_values;
273  bool *isnull = slot->tts_isnull;
274  int i;
275 
276  /*
277  * Note: we must use the tupdesc supplied by the AM in index_getattr, not
278  * the slot's tupdesc, in case the latter has different datatypes (this
279  * happens for btree name_ops in particular). They'd better have the same
280  * number of columns though, as well as being datatype-compatible which is
281  * something we can't so easily check.
282  */
283  Assert(slot->tts_tupleDescriptor->natts == nindexatts);
284 
285  ExecClearTuple(slot);
286  for (i = 0; i < nindexatts; i++)
287  values[i] = index_getattr(itup, i + 1, itupdesc, &isnull[i]);
288  ExecStoreVirtualTuple(slot);
289 }
290 
291 /*
292  * IndexOnlyRecheck -- access method routine to recheck a tuple in EvalPlanQual
293  *
294  * This can't really happen, since an index can't supply CTID which would
295  * be necessary data for any potential EvalPlanQual target relation. If it
296  * did happen, the EPQ code would pass us the wrong data, namely a heap
297  * tuple not an index tuple. So throw an error.
298  */
299 static bool
301 {
302  elog(ERROR, "EvalPlanQual recheck is not supported in index-only scans");
303  return false; /* keep compiler quiet */
304 }
305 
306 /* ----------------------------------------------------------------
307  * ExecIndexOnlyScan(node)
308  * ----------------------------------------------------------------
309  */
310 static TupleTableSlot *
312 {
314 
315  /*
316  * If we have runtime keys and they've not already been set up, do it now.
317  */
318  if (node->ioss_NumRuntimeKeys != 0 && !node->ioss_RuntimeKeysReady)
319  ExecReScan((PlanState *) node);
320 
321  return ExecScan(&node->ss,
324 }
325 
326 /* ----------------------------------------------------------------
327  * ExecReScanIndexOnlyScan(node)
328  *
329  * Recalculates the values of any scan keys whose value depends on
330  * information known at runtime, then rescans the indexed relation.
331  *
332  * Updating the scan key was formerly done separately in
333  * ExecUpdateIndexScanKeys. Integrating it into ReScan makes
334  * rescans of indices and relations/general streams more uniform.
335  * ----------------------------------------------------------------
336  */
337 void
339 {
340  /*
341  * If we are doing runtime key calculations (ie, any of the index key
342  * values weren't simple Consts), compute the new key values. But first,
343  * reset the context so we don't leak memory as each outer tuple is
344  * scanned. Note this assumes that we will recalculate *all* runtime keys
345  * on each call.
346  */
347  if (node->ioss_NumRuntimeKeys != 0)
348  {
349  ExprContext *econtext = node->ioss_RuntimeContext;
350 
351  ResetExprContext(econtext);
352  ExecIndexEvalRuntimeKeys(econtext,
353  node->ioss_RuntimeKeys,
354  node->ioss_NumRuntimeKeys);
355  }
356  node->ioss_RuntimeKeysReady = true;
357 
358  /* reset index scan */
359  if (node->ioss_ScanDesc)
361  node->ioss_ScanKeys, node->ioss_NumScanKeys,
363 
364  ExecScanReScan(&node->ss);
365 }
366 
367 
368 /* ----------------------------------------------------------------
369  * ExecEndIndexOnlyScan
370  * ----------------------------------------------------------------
371  */
372 void
374 {
375  Relation indexRelationDesc;
376  IndexScanDesc indexScanDesc;
377  Relation relation;
378 
379  /*
380  * extract information from the node
381  */
382  indexRelationDesc = node->ioss_RelationDesc;
383  indexScanDesc = node->ioss_ScanDesc;
384  relation = node->ss.ss_currentRelation;
385 
386  /* Release VM buffer pin, if any. */
387  if (node->ioss_VMBuffer != InvalidBuffer)
388  {
391  }
392 
393  /*
394  * Free the exprcontext(s) ... now dead code, see ExecFreeExprContext
395  */
396 #ifdef NOT_USED
397  ExecFreeExprContext(&node->ss.ps);
398  if (node->ioss_RuntimeContext)
400 #endif
401 
402  /*
403  * clear out tuple table slots
404  */
407 
408  /*
409  * close the index relation (no-op if we didn't open it)
410  */
411  if (indexScanDesc)
412  index_endscan(indexScanDesc);
413  if (indexRelationDesc)
414  index_close(indexRelationDesc, NoLock);
415 
416  /*
417  * close the heap relation.
418  */
419  ExecCloseScanRelation(relation);
420 }
421 
422 /* ----------------------------------------------------------------
423  * ExecIndexOnlyMarkPos
424  * ----------------------------------------------------------------
425  */
426 void
428 {
430 }
431 
432 /* ----------------------------------------------------------------
433  * ExecIndexOnlyRestrPos
434  * ----------------------------------------------------------------
435  */
436 void
438 {
440 }
441 
442 /* ----------------------------------------------------------------
443  * ExecInitIndexOnlyScan
444  *
445  * Initializes the index scan's state information, creates
446  * scan keys, and opens the base and index relations.
447  *
448  * Note: index scans have 2 sets of state information because
449  * we have to keep track of the base relation and the
450  * index relation.
451  * ----------------------------------------------------------------
452  */
454 ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags)
455 {
456  IndexOnlyScanState *indexstate;
457  Relation currentRelation;
458  bool relistarget;
459  TupleDesc tupDesc;
460 
461  /*
462  * create state structure
463  */
464  indexstate = makeNode(IndexOnlyScanState);
465  indexstate->ss.ps.plan = (Plan *) node;
466  indexstate->ss.ps.state = estate;
467  indexstate->ss.ps.ExecProcNode = ExecIndexOnlyScan;
468  indexstate->ioss_HeapFetches = 0;
469 
470  /*
471  * Miscellaneous initialization
472  *
473  * create expression context for node
474  */
475  ExecAssignExprContext(estate, &indexstate->ss.ps);
476 
477  /*
478  * initialize child expressions
479  *
480  * Note: we don't initialize all of the indexorderby expression, only the
481  * sub-parts corresponding to runtime keys (see below).
482  */
483  indexstate->ss.ps.qual =
484  ExecInitQual(node->scan.plan.qual, (PlanState *) indexstate);
485  indexstate->indexqual =
486  ExecInitQual(node->indexqual, (PlanState *) indexstate);
487 
488  /*
489  * tuple table initialization
490  */
491  ExecInitResultTupleSlot(estate, &indexstate->ss.ps);
492  ExecInitScanTupleSlot(estate, &indexstate->ss);
493 
494  /*
495  * open the base relation and acquire appropriate lock on it.
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, false);
510  ExecAssignScanType(&indexstate->ss, tupDesc);
511 
512  /*
513  * Initialize result tuple type and projection info. The node's
514  * targetlist will contain Vars with varno = INDEX_VAR, referencing the
515  * scan tuple.
516  */
517  ExecAssignResultTypeFromTL(&indexstate->ss.ps);
519 
520  /*
521  * If we are just doing EXPLAIN (ie, aren't going to run the plan), stop
522  * here. This allows an index-advisor plugin to EXPLAIN a plan containing
523  * references to nonexistent indexes.
524  */
525  if (eflags & EXEC_FLAG_EXPLAIN_ONLY)
526  return indexstate;
527 
528  /*
529  * Open the index relation.
530  *
531  * If the parent table is one of the target relations of the query, then
532  * InitPlan already opened and write-locked the index, so we can avoid
533  * taking another lock here. Otherwise we need a normal reader's lock.
534  */
535  relistarget = ExecRelationIsTargetRelation(estate, node->scan.scanrelid);
536  indexstate->ioss_RelationDesc = index_open(node->indexid,
537  relistarget ? NoLock : AccessShareLock);
538 
539  /*
540  * Initialize index-specific scan state
541  */
542  indexstate->ioss_RuntimeKeysReady = false;
543  indexstate->ioss_RuntimeKeys = NULL;
544  indexstate->ioss_NumRuntimeKeys = 0;
545 
546  /*
547  * build the index scan keys from the index qualification
548  */
549  ExecIndexBuildScanKeys((PlanState *) indexstate,
550  indexstate->ioss_RelationDesc,
551  node->indexqual,
552  false,
553  &indexstate->ioss_ScanKeys,
554  &indexstate->ioss_NumScanKeys,
555  &indexstate->ioss_RuntimeKeys,
556  &indexstate->ioss_NumRuntimeKeys,
557  NULL, /* no ArrayKeys */
558  NULL);
559 
560  /*
561  * any ORDER BY exprs have to be turned into scankeys in the same way
562  */
563  ExecIndexBuildScanKeys((PlanState *) indexstate,
564  indexstate->ioss_RelationDesc,
565  node->indexorderby,
566  true,
567  &indexstate->ioss_OrderByKeys,
568  &indexstate->ioss_NumOrderByKeys,
569  &indexstate->ioss_RuntimeKeys,
570  &indexstate->ioss_NumRuntimeKeys,
571  NULL, /* no ArrayKeys */
572  NULL);
573 
574  /*
575  * If we have runtime keys, we need an ExprContext to evaluate them. The
576  * node's standard context won't do because we want to reset that context
577  * for every tuple. So, build another context just like the other one...
578  * -tgl 7/11/00
579  */
580  if (indexstate->ioss_NumRuntimeKeys != 0)
581  {
582  ExprContext *stdecontext = indexstate->ss.ps.ps_ExprContext;
583 
584  ExecAssignExprContext(estate, &indexstate->ss.ps);
585  indexstate->ioss_RuntimeContext = indexstate->ss.ps.ps_ExprContext;
586  indexstate->ss.ps.ps_ExprContext = stdecontext;
587  }
588  else
589  {
590  indexstate->ioss_RuntimeContext = NULL;
591  }
592 
593  /*
594  * all done.
595  */
596  return indexstate;
597 }
598 
599 /* ----------------------------------------------------------------
600  * Parallel Index-only Scan Support
601  * ----------------------------------------------------------------
602  */
603 
604 /* ----------------------------------------------------------------
605  * ExecIndexOnlyScanEstimate
606  *
607  * estimates the space required to serialize index-only scan node.
608  * ----------------------------------------------------------------
609  */
610 void
612  ParallelContext *pcxt)
613 {
614  EState *estate = node->ss.ps.state;
615 
617  estate->es_snapshot);
619  shm_toc_estimate_keys(&pcxt->estimator, 1);
620 }
621 
622 /* ----------------------------------------------------------------
623  * ExecIndexOnlyScanInitializeDSM
624  *
625  * Set up a parallel index-only scan descriptor.
626  * ----------------------------------------------------------------
627  */
628 void
630  ParallelContext *pcxt)
631 {
632  EState *estate = node->ss.ps.state;
633  ParallelIndexScanDesc piscan;
634 
635  piscan = shm_toc_allocate(pcxt->toc, node->ioss_PscanLen);
637  node->ioss_RelationDesc,
638  estate->es_snapshot,
639  piscan);
640  shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, piscan);
641  node->ioss_ScanDesc =
643  node->ioss_RelationDesc,
644  node->ioss_NumScanKeys,
645  node->ioss_NumOrderByKeys,
646  piscan);
647  node->ioss_ScanDesc->xs_want_itup = true;
649 
650  /*
651  * If no run-time keys to calculate or they are ready, go ahead and pass
652  * the scankeys to the index AM.
653  */
654  if (node->ioss_NumRuntimeKeys == 0 || node->ioss_RuntimeKeysReady)
656  node->ioss_ScanKeys, node->ioss_NumScanKeys,
658 }
659 
660 /* ----------------------------------------------------------------
661  * ExecIndexOnlyScanReInitializeDSM
662  *
663  * Reset shared state before beginning a fresh scan.
664  * ----------------------------------------------------------------
665  */
666 void
668  ParallelContext *pcxt)
669 {
671 }
672 
673 /* ----------------------------------------------------------------
674  * ExecIndexOnlyScanInitializeWorker
675  *
676  * Copy relevant information from TOC into planstate.
677  * ----------------------------------------------------------------
678  */
679 void
681 {
682  ParallelIndexScanDesc piscan;
683 
684  piscan = shm_toc_lookup(toc, node->ss.ps.plan->plan_node_id, false);
685  node->ioss_ScanDesc =
687  node->ioss_RelationDesc,
688  node->ioss_NumScanKeys,
689  node->ioss_NumOrderByKeys,
690  piscan);
691  node->ioss_ScanDesc->xs_want_itup = true;
692 
693  /*
694  * If no run-time keys to calculate or they are ready, go ahead and pass
695  * the scankeys to the index AM.
696  */
697  if (node->ioss_NumRuntimeKeys == 0 || node->ioss_RuntimeKeysReady)
699  node->ioss_ScanKeys, node->ioss_NumScanKeys,
701 }
bool ioss_RuntimeKeysReady
Definition: execnodes.h:1238
TupleTableSlot * ExecStoreTuple(HeapTuple tuple, TupleTableSlot *slot, Buffer buffer, bool shouldFree)
Definition: execTuples.c:320
List * qual
Definition: plannodes.h:145
void PredicateLockPage(Relation relation, BlockNumber blkno, Snapshot snapshot)
Definition: predicate.c:2521
Plan plan
Definition: plannodes.h:328
void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate)
Definition: execTuples.c:842
Index scanrelid
Definition: plannodes.h:329
void ExecIndexOnlyScanInitializeWorker(IndexOnlyScanState *node, shm_toc *toc)
#define ScanDirectionIsForward(direction)
Definition: sdir.h:55
IndexTuple xs_itup
Definition: relscan.h:114
#define castNode(_type_, nodeptr)
Definition: nodes.h:578
IndexScanDesc index_beginscan_parallel(Relation heaprel, Relation indexrel, int nkeys, int norderbys, ParallelIndexScanDesc pscan)
Definition: indexam.c:496
void ExecIndexOnlyRestrPos(IndexOnlyScanState *node)
TupleTableSlot * ExecScan(ScanState *node, ExecScanAccessMtd accessMtd, ExecScanRecheckMtd recheckMtd)
Definition: execScan.c:123
void index_markpos(IndexScanDesc scan)
Definition: indexam.c:370
ExprContext * ps_ExprContext
Definition: execnodes.h:881
shm_toc_estimator estimator
Definition: parallel.h:41
void ExecReScan(PlanState *node)
Definition: execAmi.c:76
TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: execTuples.c:439
int plan_node_id
Definition: plannodes.h:143
#define AccessShareLock
Definition: lockdefs.h:36
#define InvalidBuffer
Definition: buf.h:25
void index_rescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int norderbys)
Definition: indexam.c:310
int errcode(int sqlerrcode)
Definition: elog.c:575
IndexRuntimeKeyInfo * ioss_RuntimeKeys
Definition: execnodes.h:1236
bool xs_recheckorderby
Definition: relscan.h:134
Snapshot es_snapshot
Definition: execnodes.h:429
Datum * tts_values
Definition: tuptable.h:125
TupleTableSlot * ss_ScanTupleSlot
Definition: execnodes.h:1103
void ExecReScanIndexOnlyScan(IndexOnlyScanState *node)
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3309
TupleDesc xs_itupdesc
Definition: relscan.h:115
Relation ss_currentRelation
Definition: execnodes.h:1101
EState * state
Definition: execnodes.h:849
static bool ExecQual(ExprState *state, ExprContext *econtext)
Definition: executor.h:366
#define shm_toc_estimate_chunk(e, sz)
Definition: shm_toc.h:51
static bool IndexOnlyRecheck(IndexOnlyScanState *node, TupleTableSlot *slot)
int natts
Definition: tupdesc.h:73
void ExecFreeExprContext(PlanState *planstate)
Definition: execUtils.c:521
TupleDesc xs_hitupdesc
Definition: relscan.h:117
ScanDirection es_direction
Definition: execnodes.h:428
ExprState * ExecInitQual(List *qual, PlanState *parent)
Definition: execExpr.c:160
void ExecAssignResultTypeFromTL(PlanState *planstate)
Definition: execUtils.c:445
Size index_parallelscan_estimate(Relation indexRelation, Snapshot snapshot)
Definition: indexam.c:417
void index_parallelrescan(IndexScanDesc scan)
Definition: indexam.c:481
TupleTableSlot *(* ExecScanAccessMtd)(ScanState *node)
Definition: executor.h:409
Relation heapRelation
Definition: relscan.h:89
void ExecAssignScanProjectionInfoWithVarno(ScanState *node, Index varno)
Definition: execScan.c:249
void index_restrpos(IndexScanDesc scan)
Definition: indexam.c:395
PlanState ps
Definition: execnodes.h:1100
ScanKey ioss_ScanKeys
Definition: execnodes.h:1232
#define ScanDirectionIsBackward(direction)
Definition: sdir.h:41
bool(* ExecScanRecheckMtd)(ScanState *node, TupleTableSlot *slot)
Definition: executor.h:410
ItemPointer index_getnext_tid(IndexScanDesc scan, ScanDirection direction)
Definition: indexam.c:526
TupleTableSlot * ps_ResultTupleSlot
Definition: execnodes.h:880
void ExecIndexOnlyMarkPos(IndexOnlyScanState *node)
#define ERROR
Definition: elog.h:43
void ExecInitResultTupleSlot(EState *estate, PlanState *planstate)
Definition: execTuples.c:832
Relation ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags)
Definition: execUtils.c:608
void ExecIndexOnlyScanEstimate(IndexOnlyScanState *node, ParallelContext *pcxt)
ExprContext * ioss_RuntimeContext
Definition: execnodes.h:1239
#define NoLock
Definition: lockdefs.h:34
bool * tts_isnull
Definition: tuptable.h:126
HeapTuple index_fetch_heap(IndexScanDesc scan)
Definition: indexam.c:583
IndexScanDesc ioss_ScanDesc
Definition: execnodes.h:1241
ScanDirection
Definition: sdir.h:22
bool xs_continue_hot
Definition: relscan.h:137
void ExecEndIndexOnlyScan(IndexOnlyScanState *node)
void index_endscan(IndexScanDesc scan)
Definition: indexam.c:340
#define ereport(elevel, rest)
Definition: elog.h:122
ScanKey ioss_OrderByKeys
Definition: execnodes.h:1234
TupleDesc ExecTypeFromTL(List *targetList, bool hasoid)
Definition: execTuples.c:888
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:121
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:853
uintptr_t Datum
Definition: postgres.h:372
void FreeExprContext(ExprContext *econtext, bool isCommit)
Definition: execUtils.c:354
Plan * plan
Definition: execnodes.h:847
Relation ioss_RelationDesc
Definition: execnodes.h:1240
List * indextlist
Definition: plannodes.h:421
bool xs_want_itup
Definition: relscan.h:96
List * indexorderby
Definition: plannodes.h:420
#define makeNode(_type_)
Definition: nodes.h:557
IndexOnlyScanState * ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags)
#define Assert(condition)
Definition: c.h:664
static TupleTableSlot * ExecIndexOnlyScan(PlanState *pstate)
static void StoreIndexTuple(TupleTableSlot *slot, IndexTuple itup, TupleDesc itupdesc)
static TupleTableSlot * IndexOnlyNext(IndexOnlyScanState *node)
#define InstrCountFiltered2(node, delta)
Definition: execnodes.h:901
#define VM_ALL_VISIBLE(r, b, v)
Definition: visibilitymap.h:32
void ExecAssignExprContext(EState *estate, PlanState *planstate)
Definition: execUtils.c:423
void ExecIndexBuildScanKeys(PlanState *planstate, Relation index, List *quals, bool isorderby, ScanKey *scanKeys, int *numScanKeys, IndexRuntimeKeyInfo **runtimeKeys, int *numRuntimeKeys, IndexArrayKeyInfo **arrayKeys, int *numArrayKeys)
#define shm_toc_estimate_keys(e, cnt)
Definition: shm_toc.h:53
void ExecCloseScanRelation(Relation scanrel)
Definition: execUtils.c:666
List * indexqual
Definition: plannodes.h:419
ExprState * indexqual
Definition: execnodes.h:1231
TupleTableSlot * ecxt_scantuple
Definition: execnodes.h:197
#define index_getattr(tup, attnum, tupleDesc, isnull)
Definition: itup.h:100
void * shm_toc_allocate(shm_toc *toc, Size nbytes)
Definition: shm_toc.c:88
void ExecIndexOnlyScanReInitializeDSM(IndexOnlyScanState *node, ParallelContext *pcxt)
void ExecIndexEvalRuntimeKeys(ExprContext *econtext, IndexRuntimeKeyInfo *runtimeKeys, int numRuntimeKeys)
ExprState * qual
Definition: execnodes.h:865
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:176
static Datum values[MAXATTR]
Definition: bootstrap.c:164
HeapScanDesc ss_currentScanDesc
Definition: execnodes.h:1102
void shm_toc_insert(shm_toc *toc, uint64 key, void *address)
Definition: shm_toc.c:171
int errmsg(const char *fmt,...)
Definition: elog.c:797
HeapTuple xs_hitup
Definition: relscan.h:116
void index_parallelscan_initialize(Relation heapRelation, Relation indexRelation, Snapshot snapshot, ParallelIndexScanDesc target)
Definition: indexam.c:450
int i
void ExecScanReScan(ScanState *node)
Definition: execScan.c:329
void ExecAssignScanType(ScanState *scanstate, TupleDesc tupDesc)
Definition: execUtils.c:545
void ExecIndexOnlyScanInitializeDSM(IndexOnlyScanState *node, ParallelContext *pcxt)
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:98
int numberOfOrderBys
Definition: relscan.h:93
#define elog
Definition: elog.h:219
#define ItemPointerGetBlockNumber(pointer)
Definition: itemptr.h:76
#define INDEX_VAR
Definition: primnodes.h:155
#define EXEC_FLAG_EXPLAIN_ONLY
Definition: executor.h:58
void * shm_toc_lookup(shm_toc *toc, uint64 key, bool noError)
Definition: shm_toc.c:232
Relation index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:151
bool ExecRelationIsTargetRelation(EState *estate, Index scanrelid)
Definition: execUtils.c:582
#define ResetExprContext(econtext)
Definition: executor.h:470
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:488
shm_toc * toc
Definition: parallel.h:44
IndexScanDesc index_beginscan(Relation heapRelation, Relation indexRelation, Snapshot snapshot, int nkeys, int norderbys)
Definition: indexam.c:221