PostgreSQL Source Code  git master
execAmi.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * execAmi.c
4  * miscellaneous executor access method routines
5  *
6  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  * src/backend/executor/execAmi.c
10  *
11  *-------------------------------------------------------------------------
12  */
13 #include "postgres.h"
14 
15 #include "access/amapi.h"
16 #include "access/htup_details.h"
17 #include "executor/execdebug.h"
18 #include "executor/nodeAgg.h"
19 #include "executor/nodeAppend.h"
20 #include "executor/nodeBitmapAnd.h"
23 #include "executor/nodeBitmapOr.h"
24 #include "executor/nodeCtescan.h"
25 #include "executor/nodeCustom.h"
28 #include "executor/nodeGather.h"
30 #include "executor/nodeGroup.h"
31 #include "executor/nodeHash.h"
32 #include "executor/nodeHashjoin.h"
34 #include "executor/nodeIndexscan.h"
35 #include "executor/nodeLimit.h"
36 #include "executor/nodeLockRows.h"
37 #include "executor/nodeMaterial.h"
39 #include "executor/nodeMergejoin.h"
42 #include "executor/nodeNestloop.h"
45 #include "executor/nodeResult.h"
47 #include "executor/nodeSeqscan.h"
48 #include "executor/nodeSetOp.h"
49 #include "executor/nodeSort.h"
50 #include "executor/nodeSubplan.h"
53 #include "executor/nodeTidscan.h"
54 #include "executor/nodeUnique.h"
56 #include "executor/nodeWindowAgg.h"
58 #include "nodes/extensible.h"
59 #include "nodes/nodeFuncs.h"
60 #include "nodes/pathnodes.h"
61 #include "utils/rel.h"
62 #include "utils/syscache.h"
63 
64 static bool IndexSupportsBackwardScan(Oid indexid);
65 
66 
67 /*
68  * ExecReScan
69  * Reset a plan node so that its output can be re-scanned.
70  *
71  * Note that if the plan node has parameters that have changed value,
72  * the output might be different from last time.
73  */
74 void
76 {
77  /* If collecting timing stats, update them */
78  if (node->instrument)
79  InstrEndLoop(node->instrument);
80 
81  /*
82  * If we have changed parameters, propagate that info.
83  *
84  * Note: ExecReScanSetParamPlan() can add bits to node->chgParam,
85  * corresponding to the output param(s) that the InitPlan will update.
86  * Since we make only one pass over the list, that means that an InitPlan
87  * can depend on the output param(s) of a sibling InitPlan only if that
88  * sibling appears earlier in the list. This is workable for now given
89  * the limited ways in which one InitPlan could depend on another, but
90  * eventually we might need to work harder (or else make the planner
91  * enlarge the extParam/allParam sets to include the params of depended-on
92  * InitPlans).
93  */
94  if (node->chgParam != NULL)
95  {
96  ListCell *l;
97 
98  foreach(l, node->initPlan)
99  {
100  SubPlanState *sstate = (SubPlanState *) lfirst(l);
101  PlanState *splan = sstate->planstate;
102 
103  if (splan->plan->extParam != NULL) /* don't care about child
104  * local Params */
105  UpdateChangedParamSet(splan, node->chgParam);
106  if (splan->chgParam != NULL)
107  ExecReScanSetParamPlan(sstate, node);
108  }
109  foreach(l, node->subPlan)
110  {
111  SubPlanState *sstate = (SubPlanState *) lfirst(l);
112  PlanState *splan = sstate->planstate;
113 
114  if (splan->plan->extParam != NULL)
115  UpdateChangedParamSet(splan, node->chgParam);
116  }
117  /* Well. Now set chgParam for left/right trees. */
118  if (node->lefttree != NULL)
120  if (node->righttree != NULL)
122  }
123 
124  /* Call expression callbacks */
125  if (node->ps_ExprContext)
127 
128  /* And do node-type-specific processing */
129  switch (nodeTag(node))
130  {
131  case T_ResultState:
132  ExecReScanResult((ResultState *) node);
133  break;
134 
135  case T_ProjectSetState:
137  break;
138 
139  case T_ModifyTableState:
141  break;
142 
143  case T_AppendState:
144  ExecReScanAppend((AppendState *) node);
145  break;
146 
147  case T_MergeAppendState:
149  break;
150 
153  break;
154 
155  case T_BitmapAndState:
157  break;
158 
159  case T_BitmapOrState:
161  break;
162 
163  case T_SeqScanState:
165  break;
166 
167  case T_SampleScanState:
169  break;
170 
171  case T_GatherState:
172  ExecReScanGather((GatherState *) node);
173  break;
174 
175  case T_GatherMergeState:
177  break;
178 
179  case T_IndexScanState:
181  break;
182 
185  break;
186 
189  break;
190 
193  break;
194 
195  case T_TidScanState:
197  break;
198 
199  case T_SubqueryScanState:
201  break;
202 
203  case T_FunctionScanState:
205  break;
206 
209  break;
210 
211  case T_ValuesScanState:
213  break;
214 
215  case T_CteScanState:
217  break;
218 
221  break;
222 
225  break;
226 
227  case T_ForeignScanState:
229  break;
230 
231  case T_CustomScanState:
233  break;
234 
235  case T_NestLoopState:
237  break;
238 
239  case T_MergeJoinState:
241  break;
242 
243  case T_HashJoinState:
245  break;
246 
247  case T_MaterialState:
249  break;
250 
251  case T_SortState:
252  ExecReScanSort((SortState *) node);
253  break;
254 
255  case T_GroupState:
256  ExecReScanGroup((GroupState *) node);
257  break;
258 
259  case T_AggState:
260  ExecReScanAgg((AggState *) node);
261  break;
262 
263  case T_WindowAggState:
265  break;
266 
267  case T_UniqueState:
268  ExecReScanUnique((UniqueState *) node);
269  break;
270 
271  case T_HashState:
272  ExecReScanHash((HashState *) node);
273  break;
274 
275  case T_SetOpState:
276  ExecReScanSetOp((SetOpState *) node);
277  break;
278 
279  case T_LockRowsState:
281  break;
282 
283  case T_LimitState:
284  ExecReScanLimit((LimitState *) node);
285  break;
286 
287  default:
288  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
289  break;
290  }
291 
292  if (node->chgParam != NULL)
293  {
294  bms_free(node->chgParam);
295  node->chgParam = NULL;
296  }
297 }
298 
299 /*
300  * ExecMarkPos
301  *
302  * Marks the current scan position.
303  *
304  * NOTE: mark/restore capability is currently needed only for plan nodes
305  * that are the immediate inner child of a MergeJoin node. Since MergeJoin
306  * requires sorted input, there is never any need to support mark/restore in
307  * node types that cannot produce sorted output. There are some cases in
308  * which a node can pass through sorted data from its child; if we don't
309  * implement mark/restore for such a node type, the planner compensates by
310  * inserting a Material node above that node.
311  */
312 void
314 {
315  switch (nodeTag(node))
316  {
317  case T_IndexScanState:
319  break;
320 
323  break;
324 
325  case T_CustomScanState:
327  break;
328 
329  case T_MaterialState:
331  break;
332 
333  case T_SortState:
334  ExecSortMarkPos((SortState *) node);
335  break;
336 
337  case T_ResultState:
338  ExecResultMarkPos((ResultState *) node);
339  break;
340 
341  default:
342  /* don't make hard error unless caller asks to restore... */
343  elog(DEBUG2, "unrecognized node type: %d", (int) nodeTag(node));
344  break;
345  }
346 }
347 
348 /*
349  * ExecRestrPos
350  *
351  * restores the scan position previously saved with ExecMarkPos()
352  *
353  * NOTE: the semantics of this are that the first ExecProcNode following
354  * the restore operation will yield the same tuple as the first one following
355  * the mark operation. It is unspecified what happens to the plan node's
356  * result TupleTableSlot. (In most cases the result slot is unchanged by
357  * a restore, but the node may choose to clear it or to load it with the
358  * restored-to tuple.) Hence the caller should discard any previously
359  * returned TupleTableSlot after doing a restore.
360  */
361 void
363 {
364  switch (nodeTag(node))
365  {
366  case T_IndexScanState:
368  break;
369 
372  break;
373 
374  case T_CustomScanState:
376  break;
377 
378  case T_MaterialState:
380  break;
381 
382  case T_SortState:
383  ExecSortRestrPos((SortState *) node);
384  break;
385 
386  case T_ResultState:
388  break;
389 
390  default:
391  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
392  break;
393  }
394 }
395 
396 /*
397  * ExecSupportsMarkRestore - does a Path support mark/restore?
398  *
399  * This is used during planning and so must accept a Path, not a Plan.
400  * We keep it here to be adjacent to the routines above, which also must
401  * know which plan types support mark/restore.
402  */
403 bool
405 {
406  /*
407  * For consistency with the routines above, we do not examine the nodeTag
408  * but rather the pathtype, which is the Plan node type the Path would
409  * produce.
410  */
411  switch (pathnode->pathtype)
412  {
413  case T_IndexScan:
414  case T_IndexOnlyScan:
415  case T_Material:
416  case T_Sort:
417  return true;
418 
419  case T_CustomScan:
420  {
421  CustomPath *customPath = castNode(CustomPath, pathnode);
422 
423  if (customPath->flags & CUSTOMPATH_SUPPORT_MARK_RESTORE)
424  return true;
425  return false;
426  }
427  case T_Result:
428 
429  /*
430  * Result supports mark/restore iff it has a child plan that does.
431  *
432  * We have to be careful here because there is more than one Path
433  * type that can produce a Result plan node.
434  */
435  if (IsA(pathnode, ProjectionPath))
436  return ExecSupportsMarkRestore(((ProjectionPath *) pathnode)->subpath);
437  else if (IsA(pathnode, MinMaxAggPath))
438  return false; /* childless Result */
439  else if (IsA(pathnode, GroupResultPath))
440  return false; /* childless Result */
441  else
442  {
443  /* Simple RTE_RESULT base relation */
444  Assert(IsA(pathnode, Path));
445  return false; /* childless Result */
446  }
447 
448  case T_Append:
449  {
450  AppendPath *appendPath = castNode(AppendPath, pathnode);
451 
452  /*
453  * If there's exactly one child, then there will be no Append
454  * in the final plan, so we can handle mark/restore if the
455  * child plan node can.
456  */
457  if (list_length(appendPath->subpaths) == 1)
458  return ExecSupportsMarkRestore((Path *) linitial(appendPath->subpaths));
459  /* Otherwise, Append can't handle it */
460  return false;
461  }
462 
463  case T_MergeAppend:
464  {
465  MergeAppendPath *mapath = castNode(MergeAppendPath, pathnode);
466 
467  /*
468  * Like the Append case above, single-subpath MergeAppends
469  * won't be in the final plan, so just return the child's
470  * mark/restore ability.
471  */
472  if (list_length(mapath->subpaths) == 1)
473  return ExecSupportsMarkRestore((Path *) linitial(mapath->subpaths));
474  /* Otherwise, MergeAppend can't handle it */
475  return false;
476  }
477 
478  default:
479  break;
480  }
481 
482  return false;
483 }
484 
485 /*
486  * ExecSupportsBackwardScan - does a plan type support backwards scanning?
487  *
488  * Ideally, all plan types would support backwards scan, but that seems
489  * unlikely to happen soon. In some cases, a plan node passes the backwards
490  * scan down to its children, and so supports backwards scan only if its
491  * children do. Therefore, this routine must be passed a complete plan tree.
492  */
493 bool
495 {
496  if (node == NULL)
497  return false;
498 
499  /*
500  * Parallel-aware nodes return a subset of the tuples in each worker, and
501  * in general we can't expect to have enough bookkeeping state to know
502  * which ones we returned in this worker as opposed to some other worker.
503  */
504  if (node->parallel_aware)
505  return false;
506 
507  switch (nodeTag(node))
508  {
509  case T_Result:
510  if (outerPlan(node) != NULL)
511  return ExecSupportsBackwardScan(outerPlan(node));
512  else
513  return false;
514 
515  case T_Append:
516  {
517  ListCell *l;
518 
519  foreach(l, ((Append *) node)->appendplans)
520  {
521  if (!ExecSupportsBackwardScan((Plan *) lfirst(l)))
522  return false;
523  }
524  /* need not check tlist because Append doesn't evaluate it */
525  return true;
526  }
527 
528  case T_SampleScan:
529  /* Simplify life for tablesample methods by disallowing this */
530  return false;
531 
532  case T_Gather:
533  return false;
534 
535  case T_IndexScan:
536  return IndexSupportsBackwardScan(((IndexScan *) node)->indexid);
537 
538  case T_IndexOnlyScan:
539  return IndexSupportsBackwardScan(((IndexOnlyScan *) node)->indexid);
540 
541  case T_SubqueryScan:
542  return ExecSupportsBackwardScan(((SubqueryScan *) node)->subplan);
543 
544  case T_CustomScan:
545  {
546  uint32 flags = ((CustomScan *) node)->flags;
547 
549  return true;
550  }
551  return false;
552 
553  case T_SeqScan:
554  case T_TidScan:
555  case T_FunctionScan:
556  case T_ValuesScan:
557  case T_CteScan:
558  case T_Material:
559  case T_Sort:
560  return true;
561 
562  case T_LockRows:
563  case T_Limit:
564  return ExecSupportsBackwardScan(outerPlan(node));
565 
566  default:
567  return false;
568  }
569 }
570 
571 /*
572  * An IndexScan or IndexOnlyScan node supports backward scan only if the
573  * index's AM does.
574  */
575 static bool
577 {
578  bool result;
579  HeapTuple ht_idxrel;
580  Form_pg_class idxrelrec;
581  IndexAmRoutine *amroutine;
582 
583  /* Fetch the pg_class tuple of the index relation */
584  ht_idxrel = SearchSysCache1(RELOID, ObjectIdGetDatum(indexid));
585  if (!HeapTupleIsValid(ht_idxrel))
586  elog(ERROR, "cache lookup failed for relation %u", indexid);
587  idxrelrec = (Form_pg_class) GETSTRUCT(ht_idxrel);
588 
589  /* Fetch the index AM's API struct */
590  amroutine = GetIndexAmRoutineByAmId(idxrelrec->relam, false);
591 
592  result = amroutine->amcanbackward;
593 
594  pfree(amroutine);
595  ReleaseSysCache(ht_idxrel);
596 
597  return result;
598 }
599 
600 /*
601  * ExecMaterializesOutput - does a plan type materialize its output?
602  *
603  * Returns true if the plan node type is one that automatically materializes
604  * its output (typically by keeping it in a tuplestore). For such plans,
605  * a rescan without any parameter change will have zero startup cost and
606  * very low per-tuple cost.
607  */
608 bool
610 {
611  switch (plantype)
612  {
613  case T_Material:
614  case T_FunctionScan:
615  case T_TableFuncScan:
616  case T_CteScan:
618  case T_WorkTableScan:
619  case T_Sort:
620  return true;
621 
622  default:
623  break;
624  }
625 
626  return false;
627 }
void ExecReScanBitmapHeapScan(BitmapHeapScanState *node)
#define IsA(nodeptr, _type_)
Definition: nodes.h:576
void ExecReScanGroup(GroupState *node)
Definition: nodeGroup.c:241
bool ExecSupportsMarkRestore(Path *pathnode)
Definition: execAmi.c:404
void ExecMaterialRestrPos(MaterialState *node)
Definition: nodeMaterial.c:295
#define GETSTRUCT(TUP)
Definition: htup_details.h:655
#define CUSTOMPATH_SUPPORT_BACKWARD_SCAN
Definition: extensible.h:81
void ExecReScanModifyTable(ModifyTableState *node)
Instrumentation * instrument
Definition: execnodes.h:949
#define castNode(_type_, nodeptr)
Definition: nodes.h:594
#define CUSTOMPATH_SUPPORT_MARK_RESTORE
Definition: extensible.h:82
List * initPlan
Definition: execnodes.h:964
void ExecReScanMaterial(MaterialState *node)
Definition: nodeMaterial.c:318
void ExecIndexOnlyRestrPos(IndexOnlyScanState *node)
ExprContext * ps_ExprContext
Definition: execnodes.h:978
void ExecReScanLockRows(LockRowsState *node)
Definition: nodeLockRows.c:390
void ExecReScan(PlanState *node)
Definition: execAmi.c:75
void ExecReScanFunctionScan(FunctionScanState *node)
List * subPlan
Definition: execnodes.h:966
Definition: nodes.h:49
void ExecReScanIndexOnlyScan(IndexOnlyScanState *node)
uint32 flags
Definition: pathnodes.h:1347
Definition: nodes.h:76
void ExecReScanLimit(LimitState *node)
Definition: nodeLimit.c:410
void ExecReScanWorkTableScan(WorkTableScanState *node)
struct PlanState * righttree
Definition: execnodes.h:962
unsigned int Oid
Definition: postgres_ext.h:31
NodeTag
Definition: nodes.h:26
void ExecReScanResult(ResultState *node)
Definition: nodeResult.c:260
void ExecResultRestrPos(ResultState *node)
Definition: nodeResult.c:162
void ExecReScanSetOp(SetOpState *node)
Definition: nodeSetOp.c:598
static bool IndexSupportsBackwardScan(Oid indexid)
Definition: execAmi.c:576
void ExecReScanSort(SortState *node)
Definition: nodeSort.c:302
void ExecReScanForeignScan(ForeignScanState *node)
struct PlanState * lefttree
Definition: execnodes.h:961
void InstrEndLoop(Instrumentation *instr)
Definition: instrument.c:110
NodeTag pathtype
Definition: pathnodes.h:1112
List * subpaths
Definition: pathnodes.h:1374
void ExecCustomRestrPos(CustomScanState *node)
Definition: nodeCustom.c:151
void ExecRestrPos(PlanState *node)
Definition: execAmi.c:362
void ExecReScanHash(HashState *node)
Definition: nodeHash.c:2189
void pfree(void *pointer)
Definition: mcxt.c:1056
void ExecIndexOnlyMarkPos(IndexOnlyScanState *node)
#define linitial(l)
Definition: pg_list.h:195
void ExecReScanProjectSet(ProjectSetState *node)
Definition: nodes.h:46
#define ObjectIdGetDatum(X)
Definition: postgres.h:507
#define ERROR
Definition: elog.h:43
struct PlanState * planstate
Definition: execnodes.h:847
void ExecReScanSetParamPlan(SubPlanState *node, PlanState *parent)
Definition: nodeSubplan.c:1268
IndexAmRoutine * GetIndexAmRoutineByAmId(Oid amoid, bool noerror)
Definition: amapi.c:56
#define DEBUG2
Definition: elog.h:24
void ExecSortMarkPos(SortState *node)
Definition: nodeSort.c:269
void ExecReScanBitmapIndexScan(BitmapIndexScanState *node)
bool amcanbackward
Definition: amapi.h:179
void ExecIndexMarkPos(IndexScanState *node)
void ExecReScanUnique(UniqueState *node)
Definition: nodeUnique.c:181
void ExecReScanIndexScan(IndexScanState *node)
void ExecReScanGatherMerge(GatherMergeState *node)
bool parallel_aware
Definition: plannodes.h:133
void ExecReScanMergeAppend(MergeAppendState *node)
unsigned int uint32
Definition: c.h:359
void ExecReScanNestLoop(NestLoopState *node)
Definition: nodeNestloop.c:392
static SPIPlanPtr splan
Definition: regress.c:258
Bitmapset * chgParam
Definition: execnodes.h:971
#define outerPlan(node)
Definition: plannodes.h:170
void ExecReScanGather(GatherState *node)
Definition: nodeGather.c:443
void ExecReScanNamedTuplestoreScan(NamedTuplestoreScanState *node)
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:1116
void ExecReScanAppend(AppendState *node)
Definition: nodeAppend.c:334
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:1164
bool ExecSupportsBackwardScan(Plan *node)
Definition: execAmi.c:494
void ExecReScanSubqueryScan(SubqueryScanState *node)
void ExecCustomMarkPos(CustomScanState *node)
Definition: nodeCustom.c:140
Plan * plan
Definition: execnodes.h:939
void ExecMarkPos(PlanState *node)
Definition: execAmi.c:313
void ExecReScanBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:219
void ExecReScanRecursiveUnion(RecursiveUnionState *node)
void UpdateChangedParamSet(PlanState *node, Bitmapset *newchg)
Definition: execUtils.c:802
void bms_free(Bitmapset *a)
Definition: bitmapset.c:208
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define Assert(condition)
Definition: c.h:739
#define lfirst(lc)
Definition: pg_list.h:190
void ExecReScanBitmapAnd(BitmapAndState *node)
void ExecReScanAgg(AggState *node)
Definition: nodeAgg.c:3433
void ExecSortRestrPos(SortState *node)
Definition: nodeSort.c:287
void ExecResultMarkPos(ResultState *node)
Definition: nodeResult.c:147
static int list_length(const List *l)
Definition: pg_list.h:169
Bitmapset * extParam
Definition: plannodes.h:158
void ReScanExprContext(ExprContext *econtext)
Definition: execUtils.c:402
void ExecIndexRestrPos(IndexScanState *node)
#define nodeTag(nodeptr)
Definition: nodes.h:530
void ExecReScanValuesScan(ValuesScanState *node)
FormData_pg_class * Form_pg_class
Definition: pg_class.h:150
Definition: nodes.h:81
#define elog(elevel,...)
Definition: elog.h:228
void ExecReScanSampleScan(SampleScanState *node)
void ExecReScanCteScan(CteScanState *node)
Definition: nodeCtescan.c:319
void ExecMaterialMarkPos(MaterialState *node)
Definition: nodeMaterial.c:267
void ExecReScanWindowAgg(WindowAggState *node)
bool ExecMaterializesOutput(NodeTag plantype)
Definition: execAmi.c:609
void ExecReScanTidScan(TidScanState *node)
Definition: nodeTidscan.c:446
void ExecReScanMergeJoin(MergeJoinState *node)
void ExecReScanCustomScan(CustomScanState *node)
Definition: nodeCustom.c:133
void ExecReScanTableFuncScan(TableFuncScanState *node)
Datum subpath(PG_FUNCTION_ARGS)
Definition: ltree_op.c:241
void ExecReScanSeqScan(SeqScanState *node)
Definition: nodeSeqscan.c:224
Definition: nodes.h:86
void ExecReScanHashJoin(HashJoinState *node)