PostgreSQL Source Code  git master
explain.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * explain.c
4  * Explain query execution plans
5  *
6  * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994-5, Regents of the University of California
8  *
9  * IDENTIFICATION
10  * src/backend/commands/explain.c
11  *
12  *-------------------------------------------------------------------------
13  */
14 #include "postgres.h"
15 
16 #include "access/xact.h"
17 #include "catalog/pg_type.h"
18 #include "commands/createas.h"
19 #include "commands/defrem.h"
20 #include "commands/prepare.h"
21 #include "executor/nodeHash.h"
22 #include "foreign/fdwapi.h"
23 #include "jit/jit.h"
24 #include "nodes/extensible.h"
25 #include "nodes/makefuncs.h"
26 #include "nodes/nodeFuncs.h"
27 #include "parser/parsetree.h"
28 #include "rewrite/rewriteHandler.h"
29 #include "storage/bufmgr.h"
30 #include "tcop/tcopprot.h"
31 #include "utils/builtins.h"
32 #include "utils/guc_tables.h"
33 #include "utils/json.h"
34 #include "utils/lsyscache.h"
35 #include "utils/rel.h"
36 #include "utils/ruleutils.h"
37 #include "utils/snapmgr.h"
38 #include "utils/tuplesort.h"
39 #include "utils/typcache.h"
40 #include "utils/xml.h"
41 
42 
43 /* Hook for plugins to get control in ExplainOneQuery() */
44 ExplainOneQuery_hook_type ExplainOneQuery_hook = NULL;
45 
46 /* Hook for plugins to get control in explain_get_index_name() */
47 explain_get_index_name_hook_type explain_get_index_name_hook = NULL;
48 
49 
50 /* OR-able flags for ExplainXMLTag() */
51 #define X_OPENING 0
52 #define X_CLOSING 1
53 #define X_CLOSE_IMMEDIATE 2
54 #define X_NOWHITESPACE 4
55 
56 static void ExplainOneQuery(Query *query, int cursorOptions,
57  IntoClause *into, ExplainState *es,
58  const char *queryString, ParamListInfo params,
59  QueryEnvironment *queryEnv);
60 static void ExplainPrintJIT(ExplainState *es, int jit_flags,
61  JitInstrumentation *ji);
62 static void report_triggers(ResultRelInfo *rInfo, bool show_relname,
63  ExplainState *es);
64 static double elapsed_time(instr_time *starttime);
65 static bool ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used);
66 static void ExplainNode(PlanState *planstate, List *ancestors,
67  const char *relationship, const char *plan_name,
68  ExplainState *es);
69 static void show_plan_tlist(PlanState *planstate, List *ancestors,
70  ExplainState *es);
71 static void show_expression(Node *node, const char *qlabel,
72  PlanState *planstate, List *ancestors,
73  bool useprefix, ExplainState *es);
74 static void show_qual(List *qual, const char *qlabel,
75  PlanState *planstate, List *ancestors,
76  bool useprefix, ExplainState *es);
77 static void show_scan_qual(List *qual, const char *qlabel,
78  PlanState *planstate, List *ancestors,
79  ExplainState *es);
80 static void show_upper_qual(List *qual, const char *qlabel,
81  PlanState *planstate, List *ancestors,
82  ExplainState *es);
83 static void show_sort_keys(SortState *sortstate, List *ancestors,
84  ExplainState *es);
85 static void show_incremental_sort_keys(IncrementalSortState *incrsortstate,
86  List *ancestors, ExplainState *es);
87 static void show_merge_append_keys(MergeAppendState *mstate, List *ancestors,
88  ExplainState *es);
89 static void show_agg_keys(AggState *astate, List *ancestors,
90  ExplainState *es);
91 static void show_grouping_sets(PlanState *planstate, Agg *agg,
92  List *ancestors, ExplainState *es);
93 static void show_grouping_set_keys(PlanState *planstate,
94  Agg *aggnode, Sort *sortnode,
95  List *context, bool useprefix,
96  List *ancestors, ExplainState *es);
97 static void show_group_keys(GroupState *gstate, List *ancestors,
98  ExplainState *es);
99 static void show_sort_group_keys(PlanState *planstate, const char *qlabel,
100  int nkeys, int nPresortedKeys, AttrNumber *keycols,
101  Oid *sortOperators, Oid *collations, bool *nullsFirst,
102  List *ancestors, ExplainState *es);
103 static void show_sortorder_options(StringInfo buf, Node *sortexpr,
104  Oid sortOperator, Oid collation, bool nullsFirst);
105 static void show_tablesample(TableSampleClause *tsc, PlanState *planstate,
106  List *ancestors, ExplainState *es);
107 static void show_sort_info(SortState *sortstate, ExplainState *es);
108 static void show_incremental_sort_info(IncrementalSortState *incrsortstate,
109  ExplainState *es);
110 static void show_hash_info(HashState *hashstate, ExplainState *es);
111 static void show_hashagg_info(AggState *hashstate, ExplainState *es);
112 static void show_tidbitmap_info(BitmapHeapScanState *planstate,
113  ExplainState *es);
114 static void show_instrumentation_count(const char *qlabel, int which,
115  PlanState *planstate, ExplainState *es);
116 static void show_foreignscan_info(ForeignScanState *fsstate, ExplainState *es);
117 static void show_eval_params(Bitmapset *bms_params, ExplainState *es);
118 static const char *explain_get_index_name(Oid indexId);
119 static void show_buffer_usage(ExplainState *es, const BufferUsage *usage);
120 static void show_wal_usage(ExplainState *es, const WalUsage *usage);
121 static void ExplainIndexScanDetails(Oid indexid, ScanDirection indexorderdir,
122  ExplainState *es);
123 static void ExplainScanTarget(Scan *plan, ExplainState *es);
124 static void ExplainModifyTarget(ModifyTable *plan, ExplainState *es);
125 static void ExplainTargetRel(Plan *plan, Index rti, ExplainState *es);
126 static void show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
127  ExplainState *es);
128 static void ExplainMemberNodes(PlanState **planstates, int nplans,
129  List *ancestors, ExplainState *es);
130 static void ExplainMissingMembers(int nplans, int nchildren, ExplainState *es);
131 static void ExplainSubPlans(List *plans, List *ancestors,
132  const char *relationship, ExplainState *es);
133 static void ExplainCustomChildren(CustomScanState *css,
134  List *ancestors, ExplainState *es);
135 static ExplainWorkersState *ExplainCreateWorkersState(int num_workers);
136 static void ExplainOpenWorker(int n, ExplainState *es);
137 static void ExplainCloseWorker(int n, ExplainState *es);
138 static void ExplainFlushWorkersState(ExplainState *es);
139 static void ExplainProperty(const char *qlabel, const char *unit,
140  const char *value, bool numeric, ExplainState *es);
141 static void ExplainOpenSetAsideGroup(const char *objtype, const char *labelname,
142  bool labeled, int depth, ExplainState *es);
143 static void ExplainSaveGroup(ExplainState *es, int depth, int *state_save);
144 static void ExplainRestoreGroup(ExplainState *es, int depth, int *state_save);
145 static void ExplainDummyGroup(const char *objtype, const char *labelname,
146  ExplainState *es);
147 static void ExplainXMLTag(const char *tagname, int flags, ExplainState *es);
148 static void ExplainIndentText(ExplainState *es);
149 static void ExplainJSONLineEnding(ExplainState *es);
150 static void ExplainYAMLLineStarting(ExplainState *es);
151 static void escape_yaml(StringInfo buf, const char *str);
152 
153 
154 
155 /*
156  * ExplainQuery -
157  * execute an EXPLAIN command
158  */
159 void
160 ExplainQuery(ParseState *pstate, ExplainStmt *stmt,
161  ParamListInfo params, DestReceiver *dest)
162 {
163  ExplainState *es = NewExplainState();
164  TupOutputState *tstate;
165  List *rewritten;
166  ListCell *lc;
167  bool timing_set = false;
168  bool summary_set = false;
169 
170  /* Parse options list. */
171  foreach(lc, stmt->options)
172  {
173  DefElem *opt = (DefElem *) lfirst(lc);
174 
175  if (strcmp(opt->defname, "analyze") == 0)
176  es->analyze = defGetBoolean(opt);
177  else if (strcmp(opt->defname, "verbose") == 0)
178  es->verbose = defGetBoolean(opt);
179  else if (strcmp(opt->defname, "costs") == 0)
180  es->costs = defGetBoolean(opt);
181  else if (strcmp(opt->defname, "buffers") == 0)
182  es->buffers = defGetBoolean(opt);
183  else if (strcmp(opt->defname, "wal") == 0)
184  es->wal = defGetBoolean(opt);
185  else if (strcmp(opt->defname, "settings") == 0)
186  es->settings = defGetBoolean(opt);
187  else if (strcmp(opt->defname, "timing") == 0)
188  {
189  timing_set = true;
190  es->timing = defGetBoolean(opt);
191  }
192  else if (strcmp(opt->defname, "summary") == 0)
193  {
194  summary_set = true;
195  es->summary = defGetBoolean(opt);
196  }
197  else if (strcmp(opt->defname, "format") == 0)
198  {
199  char *p = defGetString(opt);
200 
201  if (strcmp(p, "text") == 0)
202  es->format = EXPLAIN_FORMAT_TEXT;
203  else if (strcmp(p, "xml") == 0)
204  es->format = EXPLAIN_FORMAT_XML;
205  else if (strcmp(p, "json") == 0)
206  es->format = EXPLAIN_FORMAT_JSON;
207  else if (strcmp(p, "yaml") == 0)
208  es->format = EXPLAIN_FORMAT_YAML;
209  else
210  ereport(ERROR,
211  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
212  errmsg("unrecognized value for EXPLAIN option \"%s\": \"%s\"",
213  opt->defname, p),
214  parser_errposition(pstate, opt->location)));
215  }
216  else
217  ereport(ERROR,
218  (errcode(ERRCODE_SYNTAX_ERROR),
219  errmsg("unrecognized EXPLAIN option \"%s\"",
220  opt->defname),
221  parser_errposition(pstate, opt->location)));
222  }
223 
224  if (es->buffers && !es->analyze)
225  ereport(ERROR,
226  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
227  errmsg("EXPLAIN option BUFFERS requires ANALYZE")));
228 
229  if (es->wal && !es->analyze)
230  ereport(ERROR,
231  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
232  errmsg("EXPLAIN option WAL requires ANALYZE")));
233 
234  /* if the timing was not set explicitly, set default value */
235  es->timing = (timing_set) ? es->timing : es->analyze;
236 
237  /* check that timing is used with EXPLAIN ANALYZE */
238  if (es->timing && !es->analyze)
239  ereport(ERROR,
240  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
241  errmsg("EXPLAIN option TIMING requires ANALYZE")));
242 
243  /* if the summary was not set explicitly, set default value */
244  es->summary = (summary_set) ? es->summary : es->analyze;
245 
246  /*
247  * Parse analysis was done already, but we still have to run the rule
248  * rewriter. We do not do AcquireRewriteLocks: we assume the query either
249  * came straight from the parser, or suitable locks were acquired by
250  * plancache.c.
251  *
252  * Because the rewriter and planner tend to scribble on the input, we make
253  * a preliminary copy of the source querytree. This prevents problems in
254  * the case that the EXPLAIN is in a portal or plpgsql function and is
255  * executed repeatedly. (See also the same hack in DECLARE CURSOR and
256  * PREPARE.) XXX FIXME someday.
257  */
258  rewritten = QueryRewrite(castNode(Query, copyObject(stmt->query)));
259 
260  /* emit opening boilerplate */
261  ExplainBeginOutput(es);
262 
263  if (rewritten == NIL)
264  {
265  /*
266  * In the case of an INSTEAD NOTHING, tell at least that. But in
267  * non-text format, the output is delimited, so this isn't necessary.
268  */
269  if (es->format == EXPLAIN_FORMAT_TEXT)
270  appendStringInfoString(es->str, "Query rewrites to nothing\n");
271  }
272  else
273  {
274  ListCell *l;
275 
276  /* Explain every plan */
277  foreach(l, rewritten)
278  {
279  ExplainOneQuery(lfirst_node(Query, l),
280  CURSOR_OPT_PARALLEL_OK, NULL, es,
281  pstate->p_sourcetext, params, pstate->p_queryEnv);
282 
283  /* Separate plans with an appropriate separator */
284  if (lnext(rewritten, l) != NULL)
285  ExplainSeparatePlans(es);
286  }
287  }
288 
289  /* emit closing boilerplate */
290  ExplainEndOutput(es);
291  Assert(es->indent == 0);
292 
293  /* output tuples */
294  tstate = begin_tup_output_tupdesc(dest, ExplainResultDesc(stmt),
295  &TTSOpsVirtual);
296  if (es->format == EXPLAIN_FORMAT_TEXT)
297  do_text_output_multiline(tstate, es->str->data);
298  else
299  do_text_output_oneline(tstate, es->str->data);
300  end_tup_output(tstate);
301 
302  pfree(es->str->data);
303 }
304 
305 /*
306  * Create a new ExplainState struct initialized with default options.
307  */
308 ExplainState *
309 NewExplainState(void)
310 {
311  ExplainState *es = (ExplainState *) palloc0(sizeof(ExplainState));
312 
313  /* Set default options (most fields can be left as zeroes). */
314  es->costs = true;
315  /* Prepare output buffer. */
316  es->str = makeStringInfo();
317 
318  return es;
319 }
320 
321 /*
322  * ExplainResultDesc -
323  * construct the result tupledesc for an EXPLAIN
324  */
325 TupleDesc
326 ExplainResultDesc(ExplainStmt *stmt)
327 {
328  TupleDesc tupdesc;
329  ListCell *lc;
330  Oid result_type = TEXTOID;
331 
332  /* Check for XML format option */
333  foreach(lc, stmt->options)
334  {
335  DefElem *opt = (DefElem *) lfirst(lc);
336 
337  if (strcmp(opt->defname, "format") == 0)
338  {
339  char *p = defGetString(opt);
340 
341  if (strcmp(p, "xml") == 0)
342  result_type = XMLOID;
343  else if (strcmp(p, "json") == 0)
344  result_type = JSONOID;
345  else
346  result_type = TEXTOID;
347  /* don't "break", as ExplainQuery will use the last value */
348  }
349  }
350 
351  /* Need a tuple descriptor representing a single TEXT or XML column */
352  tupdesc = CreateTemplateTupleDesc(1);
353  TupleDescInitEntry(tupdesc, (AttrNumber) 1, "QUERY PLAN",
354  result_type, -1, 0);
355  return tupdesc;
356 }
357 
358 /*
359  * ExplainOneQuery -
360  * print out the execution plan for one Query
361  *
362  * "into" is NULL unless we are explaining the contents of a CreateTableAsStmt.
363  */
364 static void
365 ExplainOneQuery(Query *query, int cursorOptions,
366  IntoClause *into, ExplainState *es,
367  const char *queryString, ParamListInfo params,
368  QueryEnvironment *queryEnv)
369 {
370  /* planner will not cope with utility statements */
371  if (query->commandType == CMD_UTILITY)
372  {
373  ExplainOneUtility(query->utilityStmt, into, es, queryString, params,
374  queryEnv);
375  return;
376  }
377 
378  /* if an advisor plugin is present, let it manage things */
379  if (ExplainOneQuery_hook)
380  (*ExplainOneQuery_hook) (query, cursorOptions, into, es,
381  queryString, params, queryEnv);
382  else
383  {
384  PlannedStmt *plan;
385  instr_time planstart,
386  planduration;
387  BufferUsage bufusage_start,
388  bufusage;
389 
390  if (es->buffers)
391  bufusage_start = pgBufferUsage;
392  INSTR_TIME_SET_CURRENT(planstart);
393 
394  /* plan the query */
395  plan = pg_plan_query(query, queryString, cursorOptions, params);
396 
397  INSTR_TIME_SET_CURRENT(planduration);
398  INSTR_TIME_SUBTRACT(planduration, planstart);
399 
400  /* calc differences of buffer counters. */
401  if (es->buffers)
402  {
403  memset(&bufusage, 0, sizeof(BufferUsage));
404  BufferUsageAccumDiff(&bufusage, &pgBufferUsage, &bufusage_start);
405  }
406 
407  /* run it (if needed) and produce output */
408  ExplainOnePlan(plan, into, es, queryString, params, queryEnv,
409  &planduration, (es->buffers ? &bufusage : NULL));
410  }
411 }
412 
413 /*
414  * ExplainOneUtility -
415  * print out the execution plan for one utility statement
416  * (In general, utility statements don't have plans, but there are some
417  * we treat as special cases)
418  *
419  * "into" is NULL unless we are explaining the contents of a CreateTableAsStmt.
420  *
421  * This is exported because it's called back from prepare.c in the
422  * EXPLAIN EXECUTE case.
423  */
424 void
425 ExplainOneUtility(Node *utilityStmt, IntoClause *into, ExplainState *es,
426  const char *queryString, ParamListInfo params,
427  QueryEnvironment *queryEnv)
428 {
429  if (utilityStmt == NULL)
430  return;
431 
432  if (IsA(utilityStmt, CreateTableAsStmt))
433  {
434  /*
435  * We have to rewrite the contained SELECT and then pass it back to
436  * ExplainOneQuery. It's probably not really necessary to copy the
437  * contained parsetree another time, but let's be safe.
438  */
439  CreateTableAsStmt *ctas = (CreateTableAsStmt *) utilityStmt;
440  List *rewritten;
441 
442  rewritten = QueryRewrite(castNode(Query, copyObject(ctas->query)));
443  Assert(list_length(rewritten) == 1);
444  ExplainOneQuery(linitial_node(Query, rewritten),
445  CURSOR_OPT_PARALLEL_OK, ctas->into, es,
446  queryString, params, queryEnv);
447  }
448  else if (IsA(utilityStmt, DeclareCursorStmt))
449  {
450  /*
451  * Likewise for DECLARE CURSOR.
452  *
453  * Notice that if you say EXPLAIN ANALYZE DECLARE CURSOR then we'll
454  * actually run the query. This is different from pre-8.3 behavior
455  * but seems more useful than not running the query. No cursor will
456  * be created, however.
457  */
458  DeclareCursorStmt *dcs = (DeclareCursorStmt *) utilityStmt;
459  List *rewritten;
460 
461  rewritten = QueryRewrite(castNode(Query, copyObject(dcs->query)));
462  Assert(list_length(rewritten) == 1);
463  ExplainOneQuery(linitial_node(Query, rewritten),
464  dcs->options, NULL, es,
465  queryString, params, queryEnv);
466  }
467  else if (IsA(utilityStmt, ExecuteStmt))
468  ExplainExecuteQuery((ExecuteStmt *) utilityStmt, into, es,
469  queryString, params, queryEnv);
470  else if (IsA(utilityStmt, NotifyStmt))
471  {
472  if (es->format == EXPLAIN_FORMAT_TEXT)
473  appendStringInfoString(es->str, "NOTIFY\n");
474  else
475  ExplainDummyGroup("Notify", NULL, es);
476  }
477  else
478  {
479  if (es->format == EXPLAIN_FORMAT_TEXT)
480  appendStringInfoString(es->str,
481  "Utility statements have no plan structure\n");
482  else
483  ExplainDummyGroup("Utility Statement", NULL, es);
484  }
485 }
486 
487 /*
488  * ExplainOnePlan -
489  * given a planned query, execute it if needed, and then print
490  * EXPLAIN output
491  *
492  * "into" is NULL unless we are explaining the contents of a CreateTableAsStmt,
493  * in which case executing the query should result in creating that table.
494  *
495  * This is exported because it's called back from prepare.c in the
496  * EXPLAIN EXECUTE case, and because an index advisor plugin would need
497  * to call it.
498  */
499 void
500 ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es,
501  const char *queryString, ParamListInfo params,
502  QueryEnvironment *queryEnv, const instr_time *planduration,
503  const BufferUsage *bufusage)
504 {
505  DestReceiver *dest;
506  QueryDesc *queryDesc;
507  instr_time starttime;
508  double totaltime = 0;
509  int eflags;
510  int instrument_option = 0;
511 
512  Assert(plannedstmt->commandType != CMD_UTILITY);
513 
514  if (es->analyze && es->timing)
515  instrument_option |= INSTRUMENT_TIMER;
516  else if (es->analyze)
517  instrument_option |= INSTRUMENT_ROWS;
518 
519  if (es->buffers)
520  instrument_option |= INSTRUMENT_BUFFERS;
521  if (es->wal)
522  instrument_option |= INSTRUMENT_WAL;
523 
524  /*
525  * We always collect timing for the entire statement, even when node-level
526  * timing is off, so we don't look at es->timing here. (We could skip
527  * this if !es->summary, but it's hardly worth the complication.)
528  */
529  INSTR_TIME_SET_CURRENT(starttime);
530 
531  /*
532  * Use a snapshot with an updated command ID to ensure this query sees
533  * results of any previously executed queries.
534  */
535  PushCopiedSnapshot(GetActiveSnapshot());
536  UpdateActiveSnapshotCommandId();
537 
538  /*
539  * Normally we discard the query's output, but if explaining CREATE TABLE
540  * AS, we'd better use the appropriate tuple receiver.
541  */
542  if (into)
543  dest = CreateIntoRelDestReceiver(into);
544  else
545  dest = None_Receiver;
546 
547  /* Create a QueryDesc for the query */
548  queryDesc = CreateQueryDesc(plannedstmt, queryString,
549  GetActiveSnapshot(), InvalidSnapshot,
550  dest, params, queryEnv, instrument_option);
551 
552  /* Select execution options */
553  if (es->analyze)
554  eflags = 0; /* default run-to-completion flags */
555  else
556  eflags = EXEC_FLAG_EXPLAIN_ONLY;
557  if (into)
558  eflags |= GetIntoRelEFlags(into);
559 
560  /* call ExecutorStart to prepare the plan for execution */
561  ExecutorStart(queryDesc, eflags);
562 
563  /* Execute the plan for statistics if asked for */
564  if (es->analyze)
565  {
566  ScanDirection dir;
567 
568  /* EXPLAIN ANALYZE CREATE TABLE AS WITH NO DATA is weird */
569  if (into && into->skipData)
570  dir = NoMovementScanDirection;
571  else
572  dir = ForwardScanDirection;
573 
574  /* run the plan */
575  ExecutorRun(queryDesc, dir, 0L, true);
576 
577  /* run cleanup too */
578  ExecutorFinish(queryDesc);
579 
580  /* We can't run ExecutorEnd 'till we're done printing the stats... */
581  totaltime += elapsed_time(&starttime);
582  }
583 
584  ExplainOpenGroup("Query", NULL, true, es);
585 
586  /* Create textual dump of plan tree */
587  ExplainPrintPlan(es, queryDesc);
588 
589  if (es->summary && (planduration || bufusage))
590  ExplainOpenGroup("Planning", "Planning", true, es);
591 
592  if (es->summary && planduration)
593  {
594  double plantime = INSTR_TIME_GET_DOUBLE(*planduration);
595 
596  ExplainPropertyFloat("Planning Time", "ms", 1000.0 * plantime, 3, es);
597  }
598 
599  /* Show buffer usage */
600  if (es->summary && bufusage)
601  {
602  if (es->format == EXPLAIN_FORMAT_TEXT)
603  es->indent++;
604  show_buffer_usage(es, bufusage);
605  if (es->format == EXPLAIN_FORMAT_TEXT)
606  es->indent--;
607  }
608 
609  if (es->summary && (planduration || bufusage))
610  ExplainCloseGroup("Planning", "Planning", true, es);
611 
612  /* Print info about runtime of triggers */
613  if (es->analyze)
614  ExplainPrintTriggers(es, queryDesc);
615 
616  /*
617  * Print info about JITing. Tied to es->costs because we don't want to
618  * display this in regression tests, as it'd cause output differences
619  * depending on build options. Might want to separate that out from COSTS
620  * at a later stage.
621  */
622  if (es->costs)
623  ExplainPrintJITSummary(es, queryDesc);
624 
625  /*
626  * Close down the query and free resources. Include time for this in the
627  * total execution time (although it should be pretty minimal).
628  */
629  INSTR_TIME_SET_CURRENT(starttime);
630 
631  ExecutorEnd(queryDesc);
632 
633  FreeQueryDesc(queryDesc);
634 
635  PopActiveSnapshot();
636 
637  /* We need a CCI just in case query expanded to multiple plans */
638  if (es->analyze)
639  CommandCounterIncrement();
640 
641  totaltime += elapsed_time(&starttime);
642 
643  /*
644  * We only report execution time if we actually ran the query (that is,
645  * the user specified ANALYZE), and if summary reporting is enabled (the
646  * user can set SUMMARY OFF to not have the timing information included in
647  * the output). By default, ANALYZE sets SUMMARY to true.
648  */
649  if (es->summary && es->analyze)
650  ExplainPropertyFloat("Execution Time", "ms", 1000.0 * totaltime, 3,
651  es);
652 
653  ExplainCloseGroup("Query", NULL, true, es);
654 }
655 
656 /*
657  * ExplainPrintSettings -
658  * Print summary of modified settings affecting query planning.
659  */
660 static void
661 ExplainPrintSettings(ExplainState *es)
662 {
663  int num;
664  struct config_generic **gucs;
665 
666  /* bail out if information about settings not requested */
667  if (!es->settings)
668  return;
669 
670  /* request an array of relevant settings */
671  gucs = get_explain_guc_options(&num);
672 
673  if (es->format != EXPLAIN_FORMAT_TEXT)
674  {
675  ExplainOpenGroup("Settings", "Settings", true, es);
676 
677  for (int i = 0; i < num; i++)
678  {
679  char *setting;
680  struct config_generic *conf = gucs[i];
681 
682  setting = GetConfigOptionByName(conf->name, NULL, true);
683 
684  ExplainPropertyText(conf->name, setting, es);
685  }
686 
687  ExplainCloseGroup("Settings", "Settings", true, es);
688  }
689  else
690  {
691  StringInfoData str;
692 
693  /* In TEXT mode, print nothing if there are no options */
694  if (num <= 0)
695  return;
696 
697  initStringInfo(&str);
698 
699  for (int i = 0; i < num; i++)
700  {
701  char *setting;
702  struct config_generic *conf = gucs[i];
703 
704  if (i > 0)
705  appendStringInfoString(&str, ", ");
706 
707  setting = GetConfigOptionByName(conf->name, NULL, true);
708 
709  if (setting)
710  appendStringInfo(&str, "%s = '%s'", conf->name, setting);
711  else
712  appendStringInfo(&str, "%s = NULL", conf->name);
713  }
714 
715  ExplainPropertyText("Settings", str.data, es);
716  }
717 }
718 
719 /*
720  * ExplainPrintPlan -
721  * convert a QueryDesc's plan tree to text and append it to es->str
722  *
723  * The caller should have set up the options fields of *es, as well as
724  * initializing the output buffer es->str. Also, output formatting state
725  * such as the indent level is assumed valid. Plan-tree-specific fields
726  * in *es are initialized here.
727  *
728  * NB: will not work on utility statements
729  */
730 void
731 ExplainPrintPlan(ExplainState *es, QueryDesc *queryDesc)
732 {
733  Bitmapset *rels_used = NULL;
734  PlanState *ps;
735 
736  /* Set up ExplainState fields associated with this plan tree */
737  Assert(queryDesc->plannedstmt != NULL);
738  es->pstmt = queryDesc->plannedstmt;
739  es->rtable = queryDesc->plannedstmt->rtable;
740  ExplainPreScanNode(queryDesc->planstate, &rels_used);
741  es->rtable_names = select_rtable_names_for_explain(es->rtable, rels_used);
742  es->deparse_cxt = deparse_context_for_plan_tree(queryDesc->plannedstmt,
743  es->rtable_names);
744  es->printed_subplans = NULL;
745 
746  /*
747  * Sometimes we mark a Gather node as "invisible", which means that it's
748  * not to be displayed in EXPLAIN output. The purpose of this is to allow
749  * running regression tests with force_parallel_mode=regress to get the
750  * same results as running the same tests with force_parallel_mode=off.
751  * Such marking is currently only supported on a Gather at the top of the
752  * plan. We skip that node, and we must also hide per-worker detail data
753  * further down in the plan tree.
754  */
755  ps = queryDesc->planstate;
756  if (IsA(ps, GatherState) && ((Gather *) ps->plan)->invisible)
757  {
758  ps = outerPlanState(ps);
759  es->hide_workers = true;
760  }
761  ExplainNode(ps, NIL, NULL, NULL, es);
762 
763  /*
764  * If requested, include information about GUC parameters with values that
765  * don't match the built-in defaults.
766  */
767  ExplainPrintSettings(es);
768 }
769 
770 /*
771  * ExplainPrintTriggers -
772  * convert a QueryDesc's trigger statistics to text and append it to
773  * es->str
774  *
775  * The caller should have set up the options fields of *es, as well as
776  * initializing the output buffer es->str. Other fields in *es are
777  * initialized here.
778  */
779 void
780 ExplainPrintTriggers(ExplainState *es, QueryDesc *queryDesc)
781 {
782  ResultRelInfo *rInfo;
783  bool show_relname;
784  int numrels = queryDesc->estate->es_num_result_relations;
785  int numrootrels = queryDesc->estate->es_num_root_result_relations;
786  List *routerels;
787  List *targrels;
788  int nr;
789  ListCell *l;
790 
791  routerels = queryDesc->estate->es_tuple_routing_result_relations;
792  targrels = queryDesc->estate->es_trig_target_relations;
793 
794  ExplainOpenGroup("Triggers", "Triggers", false, es);
795 
796  show_relname = (numrels > 1 || numrootrels > 0 ||
797  routerels != NIL || targrels != NIL);
798  rInfo = queryDesc->estate->es_result_relations;
799  for (nr = 0; nr < numrels; rInfo++, nr++)
800  report_triggers(rInfo, show_relname, es);
801 
802  rInfo = queryDesc->estate->es_root_result_relations;
803  for (nr = 0; nr < numrootrels; rInfo++, nr++)
804  report_triggers(rInfo, show_relname, es);
805 
806  foreach(l, routerels)
807  {
808  rInfo = (ResultRelInfo *) lfirst(l);
809  report_triggers(rInfo, show_relname, es);
810  }
811 
812  foreach(l, targrels)
813  {
814  rInfo = (ResultRelInfo *) lfirst(l);
815  report_triggers(rInfo, show_relname, es);
816  }
817 
818  ExplainCloseGroup("Triggers", "Triggers", false, es);
819 }
820 
821 /*
822  * ExplainPrintJITSummary -
823  * Print summarized JIT instrumentation from leader and workers
824  */
825 void
826 ExplainPrintJITSummary(ExplainState *es, QueryDesc *queryDesc)
827 {
828  JitInstrumentation ji = {0};
829 
830  if (!(queryDesc->estate->es_jit_flags & PGJIT_PERFORM))
831  return;
832 
833  /*
834  * Work with a copy instead of modifying the leader state, since this
835  * function may be called twice
836  */
837  if (queryDesc->estate->es_jit)
838  InstrJitAgg(&ji, &queryDesc->estate->es_jit->instr);
839 
840  /* If this process has done JIT in parallel workers, merge stats */
841  if (queryDesc->estate->es_jit_worker_instr)
842  InstrJitAgg(&ji, queryDesc->estate->es_jit_worker_instr);
843 
844  ExplainPrintJIT(es, queryDesc->estate->es_jit_flags, &ji);
845 }
846 
847 /*
848  * ExplainPrintJIT -
849  * Append information about JITing to es->str.
850  */
851 static void
852 ExplainPrintJIT(ExplainState *es, int jit_flags, JitInstrumentation *ji)
853 {
854  instr_time total_time;
855 
856  /* don't print information if no JITing happened */
857  if (!ji || ji->created_functions == 0)
858  return;
859 
860  /* calculate total time */
861  INSTR_TIME_SET_ZERO(total_time);
862  INSTR_TIME_ADD(total_time, ji->generation_counter);
863  INSTR_TIME_ADD(total_time, ji->inlining_counter);
864  INSTR_TIME_ADD(total_time, ji->optimization_counter);
865  INSTR_TIME_ADD(total_time, ji->emission_counter);
866 
867  ExplainOpenGroup("JIT", "JIT", true, es);
868 
869  /* for higher density, open code the text output format */
870  if (es->format == EXPLAIN_FORMAT_TEXT)
871  {
872  ExplainIndentText(es);
873  appendStringInfoString(es->str, "JIT:\n");
874  es->indent++;
875 
876  ExplainPropertyInteger("Functions", NULL, ji->created_functions, es);
877 
878  ExplainIndentText(es);
879  appendStringInfo(es->str, "Options: %s %s, %s %s, %s %s, %s %s\n",
880  "Inlining", jit_flags & PGJIT_INLINE ? "true" : "false",
881  "Optimization", jit_flags & PGJIT_OPT3 ? "true" : "false",
882  "Expressions", jit_flags & PGJIT_EXPR ? "true" : "false",
883  "Deforming", jit_flags & PGJIT_DEFORM ? "true" : "false");
884 
885  if (es->analyze && es->timing)
886  {
887  ExplainIndentText(es);
888  appendStringInfo(es->str,
889  "Timing: %s %.3f ms, %s %.3f ms, %s %.3f ms, %s %.3f ms, %s %.3f ms\n",
890  "Generation", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->generation_counter),
891  "Inlining", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->inlining_counter),
892  "Optimization", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->optimization_counter),
893  "Emission", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->emission_counter),
894  "Total", 1000.0 * INSTR_TIME_GET_DOUBLE(total_time));
895  }
896 
897  es->indent--;
898  }
899  else
900  {
901  ExplainPropertyInteger("Functions", NULL, ji->created_functions, es);
902 
903  ExplainOpenGroup("Options", "Options", true, es);
904  ExplainPropertyBool("Inlining", jit_flags & PGJIT_INLINE, es);
905  ExplainPropertyBool("Optimization", jit_flags & PGJIT_OPT3, es);
906  ExplainPropertyBool("Expressions", jit_flags & PGJIT_EXPR, es);
907  ExplainPropertyBool("Deforming", jit_flags & PGJIT_DEFORM, es);
908  ExplainCloseGroup("Options", "Options", true, es);
909 
910  if (es->analyze && es->timing)
911  {
912  ExplainOpenGroup("Timing", "Timing", true, es);
913 
914  ExplainPropertyFloat("Generation", "ms",
915  1000.0 * INSTR_TIME_GET_DOUBLE(ji->generation_counter),
916  3, es);
917  ExplainPropertyFloat("Inlining", "ms",
918  1000.0 * INSTR_TIME_GET_DOUBLE(ji->inlining_counter),
919  3, es);
920  ExplainPropertyFloat("Optimization", "ms",
921  1000.0 * INSTR_TIME_GET_DOUBLE(ji->optimization_counter),
922  3, es);
923  ExplainPropertyFloat("Emission", "ms",
924  1000.0 * INSTR_TIME_GET_DOUBLE(ji->emission_counter),
925  3, es);
926  ExplainPropertyFloat("Total", "ms",
927  1000.0 * INSTR_TIME_GET_DOUBLE(total_time),
928  3, es);
929 
930  ExplainCloseGroup("Timing", "Timing", true, es);
931  }
932  }
933 
934  ExplainCloseGroup("JIT", "JIT", true, es);
935 }
936 
937 /*
938  * ExplainQueryText -
939  * add a "Query Text" node that contains the actual text of the query
940  *
941  * The caller should have set up the options fields of *es, as well as
942  * initializing the output buffer es->str.
943  *
944  */
945 void
946 ExplainQueryText(ExplainState *es, QueryDesc *queryDesc)
947 {
948  if (queryDesc->sourceText)
949  ExplainPropertyText("Query Text", queryDesc->sourceText, es);
950 }
951 
952 /*
953  * report_triggers -
954  * report execution stats for a single relation's triggers
955  */
956 static void
957 report_triggers(ResultRelInfo *rInfo, bool show_relname, ExplainState *es)
958 {
959  int nt;
960 
961  if (!rInfo->ri_TrigDesc || !rInfo->ri_TrigInstrument)
962  return;
963  for (nt = 0; nt < rInfo->ri_TrigDesc->numtriggers; nt++)
964  {
965  Trigger *trig = rInfo->ri_TrigDesc->triggers + nt;
966  Instrumentation *instr = rInfo->ri_TrigInstrument + nt;
967  char *relname;
968  char *conname = NULL;
969 
970  /* Must clean up instrumentation state */
971  InstrEndLoop(instr);
972 
973  /*
974  * We ignore triggers that were never invoked; they likely aren't
975  * relevant to the current query type.
976  */
977  if (instr->ntuples == 0)
978  continue;
979 
980  ExplainOpenGroup("Trigger", NULL, true, es);
981 
982  relname = RelationGetRelationName(rInfo->ri_RelationDesc);
983  if (OidIsValid(trig->tgconstraint))
984  conname = get_constraint_name(trig->tgconstraint);
985 
986  /*
987  * In text format, we avoid printing both the trigger name and the
988  * constraint name unless VERBOSE is specified. In non-text formats
989  * we just print everything.
990  */
991  if (es->format == EXPLAIN_FORMAT_TEXT)
992  {
993  if (es->verbose || conname == NULL)
994  appendStringInfo(es->str, "Trigger %s", trig->tgname);
995  else
996  appendStringInfoString(es->str, "Trigger");
997  if (conname)
998  appendStringInfo(es->str, " for constraint %s", conname);
999  if (show_relname)
1000  appendStringInfo(es->str, " on %s", relname);
1001  if (es->timing)
1002  appendStringInfo(es->str, ": time=%.3f calls=%.0f\n",
1003  1000.0 * instr->total, instr->ntuples);
1004  else
1005  appendStringInfo(es->str, ": calls=%.0f\n", instr->ntuples);
1006  }
1007  else
1008  {
1009  ExplainPropertyText("Trigger Name", trig->tgname, es);
1010  if (conname)
1011  ExplainPropertyText("Constraint Name", conname, es);
1012  ExplainPropertyText("Relation", relname, es);
1013  if (es->timing)
1014  ExplainPropertyFloat("Time", "ms", 1000.0 * instr->total, 3,
1015  es);
1016  ExplainPropertyFloat("Calls", NULL, instr->ntuples, 0, es);
1017  }
1018 
1019  if (conname)
1020  pfree(conname);
1021 
1022  ExplainCloseGroup("Trigger", NULL, true, es);
1023  }
1024 }
1025 
1026 /* Compute elapsed time in seconds since given timestamp */
1027 static double
1028 elapsed_time(instr_time *starttime)
1029 {
1030  instr_time endtime;
1031 
1032  INSTR_TIME_SET_CURRENT(endtime);
1033  INSTR_TIME_SUBTRACT(endtime, *starttime);
1034  return INSTR_TIME_GET_DOUBLE(endtime);
1035 }
1036 
1037 /*
1038  * ExplainPreScanNode -
1039  * Prescan the planstate tree to identify which RTEs are referenced
1040  *
1041  * Adds the relid of each referenced RTE to *rels_used. The result controls
1042  * which RTEs are assigned aliases by select_rtable_names_for_explain.
1043  * This ensures that we don't confusingly assign un-suffixed aliases to RTEs
1044  * that never appear in the EXPLAIN output (such as inheritance parents).
1045  */
1046 static bool
1047 ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used)
1048 {
1049  Plan *plan = planstate->plan;
1050 
1051  switch (nodeTag(plan))
1052  {
1053  case T_SeqScan:
1054  case T_SampleScan:
1055  case T_IndexScan:
1056  case T_IndexOnlyScan:
1057  case T_BitmapHeapScan:
1058  case T_TidScan:
1059  case T_SubqueryScan:
1060  case T_FunctionScan:
1061  case T_TableFuncScan:
1062  case T_ValuesScan:
1063  case T_CteScan:
1064  case T_NamedTuplestoreScan:
1065  case T_WorkTableScan:
1066  *rels_used = bms_add_member(*rels_used,
1067  ((Scan *) plan)->scanrelid);
1068  break;
1069  case T_ForeignScan:
1070  *rels_used = bms_add_members(*rels_used,
1071  ((ForeignScan *) plan)->fs_relids);
1072  break;
1073  case T_CustomScan:
1074  *rels_used = bms_add_members(*rels_used,
1075  ((CustomScan *) plan)->custom_relids);
1076  break;
1077  case T_ModifyTable:
1078  *rels_used = bms_add_member(*rels_used,
1079  ((ModifyTable *) plan)->nominalRelation);
1080  if (((ModifyTable *) plan)->exclRelRTI)
1081  *rels_used = bms_add_member(*rels_used,
1082  ((ModifyTable *) plan)->exclRelRTI);
1083  break;
1084  case T_Append:
1085  *rels_used = bms_add_members(*rels_used,
1086  ((Append *) plan)->apprelids);
1087  break;
1088  case T_MergeAppend:
1089  *rels_used = bms_add_members(*rels_used,
1090  ((MergeAppend *) plan)->apprelids);
1091  break;
1092  default:
1093  break;
1094  }
1095 
1096  return planstate_tree_walker(planstate, ExplainPreScanNode, rels_used);
1097 }
1098 
1099 /*
1100  * ExplainNode -
1101  * Appends a description of a plan tree to es->str
1102  *
1103  * planstate points to the executor state node for the current plan node.
1104  * We need to work from a PlanState node, not just a Plan node, in order to
1105  * get at the instrumentation data (if any) as well as the list of subplans.
1106  *
1107  * ancestors is a list of parent Plan and SubPlan nodes, most-closely-nested
1108  * first. These are needed in order to interpret PARAM_EXEC Params.
1109  *
1110  * relationship describes the relationship of this plan node to its parent
1111  * (eg, "Outer", "Inner"); it can be null at top level. plan_name is an
1112  * optional name to be attached to the node.
1113  *
1114  * In text format, es->indent is controlled in this function since we only
1115  * want it to change at plan-node boundaries (but a few subroutines will
1116  * transiently increment it). In non-text formats, es->indent corresponds
1117  * to the nesting depth of logical output groups, and therefore is controlled
1118  * by ExplainOpenGroup/ExplainCloseGroup.
1119  */
1120 static void
1121 ExplainNode(PlanState *planstate, List *ancestors,
1122  const char *relationship, const char *plan_name,
1123  ExplainState *es)
1124 {
1125  Plan *plan = planstate->plan;
1126  const char *pname; /* node type name for text output */
1127  const char *sname; /* node type name for non-text output */
1128  const char *strategy = NULL;
1129  const char *partialmode = NULL;
1130  const char *operation = NULL;
1131  const char *custom_name = NULL;
1132  ExplainWorkersState *save_workers_state = es->workers_state;
1133  int save_indent = es->indent;
1134  bool haschildren;
1135 
1136  /*
1137  * Prepare per-worker output buffers, if needed. We'll append the data in
1138  * these to the main output string further down.
1139  */
1140  if (planstate->worker_instrument && es->analyze && !es->hide_workers)
1141  es->workers_state = ExplainCreateWorkersState(planstate->worker_instrument->num_workers);
1142  else
1143  es->workers_state = NULL;
1144 
1145  /* Identify plan node type, and print generic details */
1146  switch (nodeTag(plan))
1147  {
1148  case T_Result:
1149  pname = sname = "Result";
1150  break;
1151  case T_ProjectSet:
1152  pname = sname = "ProjectSet";
1153  break;
1154  case T_ModifyTable:
1155  sname = "ModifyTable";
1156  switch (((ModifyTable *) plan)->operation)
1157  {
1158  case CMD_INSERT:
1159  pname = operation = "Insert";
1160  break;
1161  case CMD_UPDATE:
1162  pname = operation = "Update";
1163  break;
1164  case CMD_DELETE:
1165  pname = operation = "Delete";
1166  break;
1167  default:
1168  pname = "???";
1169  break;
1170  }
1171  break;
1172  case T_Append:
1173  pname = sname = "Append";
1174  break;
1175  case T_MergeAppend:
1176  pname = sname = "Merge Append";
1177  break;
1178  case T_RecursiveUnion:
1179  pname = sname = "Recursive Union";
1180  break;
1181  case T_BitmapAnd:
1182  pname = sname = "BitmapAnd";
1183  break;
1184  case T_BitmapOr:
1185  pname = sname = "BitmapOr";
1186  break;
1187  case T_NestLoop:
1188  pname = sname = "Nested Loop";
1189  break;
1190  case T_MergeJoin:
1191  pname = "Merge"; /* "Join" gets added by jointype switch */
1192  sname = "Merge Join";
1193  break;
1194  case T_HashJoin:
1195  pname = "Hash"; /* "Join" gets added by jointype switch */
1196  sname = "Hash Join";
1197  break;
1198  case T_SeqScan:
1199  pname = sname = "Seq Scan";
1200  break;
1201  case T_SampleScan:
1202  pname = sname = "Sample Scan";
1203  break;
1204  case T_Gather:
1205  pname = sname = "Gather";
1206  break;
1207  case T_GatherMerge:
1208  pname = sname = "Gather Merge";
1209  break;
1210  case T_IndexScan:
1211  pname = sname = "Index Scan";
1212  break;
1213  case T_IndexOnlyScan:
1214  pname = sname = "Index Only Scan";
1215  break;
1216  case T_BitmapIndexScan:
1217  pname = sname = "Bitmap Index Scan";
1218  break;
1219  case T_BitmapHeapScan:
1220  pname = sname = "Bitmap Heap Scan";
1221  break;
1222  case T_TidScan:
1223  pname = sname = "Tid Scan";
1224  break;
1225  case T_SubqueryScan:
1226  pname = sname = "Subquery Scan";
1227  break;
1228  case T_FunctionScan:
1229  pname = sname = "Function Scan";
1230  break;
1231  case T_TableFuncScan:
1232  pname = sname = "Table Function Scan";
1233  break;
1234  case T_ValuesScan:
1235  pname = sname = "Values Scan";
1236  break;
1237  case T_CteScan:
1238  pname = sname = "CTE Scan";
1239  break;
1240  case T_NamedTuplestoreScan:
1241  pname = sname = "Named Tuplestore Scan";
1242  break;
1243  case T_WorkTableScan:
1244  pname = sname = "WorkTable Scan";
1245  break;
1246  case T_ForeignScan:
1247  sname = "Foreign Scan";
1248  switch (((ForeignScan *) plan)->operation)
1249  {
1250  case CMD_SELECT:
1251  pname = "Foreign Scan";
1252  operation = "Select";
1253  break;
1254  case CMD_INSERT:
1255  pname = "Foreign Insert";
1256  operation = "Insert";
1257  break;
1258  case CMD_UPDATE:
1259  pname = "Foreign Update";
1260  operation = "Update";
1261  break;
1262  case CMD_DELETE:
1263  pname = "Foreign Delete";
1264  operation = "Delete";
1265  break;
1266  default:
1267  pname = "???";
1268  break;
1269  }
1270  break;
1271  case T_CustomScan:
1272  sname = "Custom Scan";
1273  custom_name = ((CustomScan *) plan)->methods->CustomName;
1274  if (custom_name)
1275  pname = psprintf("Custom Scan (%s)", custom_name);
1276  else
1277  pname = sname;
1278  break;
1279  case T_Material:
1280  pname = sname = "Materialize";
1281  break;
1282  case T_Sort:
1283  pname = sname = "Sort";
1284  break;
1285  case T_IncrementalSort:
1286  pname = sname = "Incremental Sort";
1287  break;
1288  case T_Group:
1289  pname = sname = "Group";
1290  break;
1291  case T_Agg:
1292  {
1293  Agg *agg = (Agg *) plan;
1294 
1295  sname = "Aggregate";
1296  switch (agg->aggstrategy)
1297  {
1298  case AGG_PLAIN:
1299  pname = "Aggregate";
1300  strategy = "Plain";
1301  break;
1302  case AGG_SORTED:
1303  pname = "GroupAggregate";
1304  strategy = "Sorted";
1305  break;
1306  case AGG_HASHED:
1307  pname = "HashAggregate";
1308  strategy = "Hashed";
1309  break;
1310  case AGG_MIXED:
1311  pname = "MixedAggregate";
1312  strategy = "Mixed";
1313  break;
1314  default:
1315  pname = "Aggregate ???";
1316  strategy = "???";
1317  break;
1318  }
1319 
1320  if (DO_AGGSPLIT_SKIPFINAL(agg->aggsplit))
1321  {
1322  partialmode = "Partial";
1323  pname = psprintf("%s %s", partialmode, pname);
1324  }
1325  else if (DO_AGGSPLIT_COMBINE(agg->aggsplit))
1326  {
1327  partialmode = "Finalize";
1328  pname = psprintf("%s %s", partialmode, pname);
1329  }
1330  else
1331  partialmode = "Simple";
1332  }
1333  break;
1334  case T_WindowAgg:
1335  pname = sname = "WindowAgg";
1336  break;
1337  case T_Unique:
1338  pname = sname = "Unique";
1339  break;
1340  case T_SetOp:
1341  sname = "SetOp";
1342  switch (((SetOp *) plan)->strategy)
1343  {
1344  case SETOP_SORTED:
1345  pname = "SetOp";
1346  strategy = "Sorted";
1347  break;
1348  case SETOP_HASHED:
1349  pname = "HashSetOp";
1350  strategy = "Hashed";
1351  break;
1352  default:
1353  pname = "SetOp ???";
1354  strategy = "???";
1355  break;
1356  }
1357  break;
1358  case T_LockRows:
1359  pname = sname = "LockRows";
1360  break;
1361  case T_Limit:
1362  pname = sname = "Limit";
1363  break;
1364  case T_Hash:
1365  pname = sname = "Hash";
1366  break;
1367  default:
1368  pname = sname = "???";
1369  break;
1370  }
1371 
1372  ExplainOpenGroup("Plan",
1373  relationship ? NULL : "Plan",
1374  true, es);
1375 
1376  if (es->format == EXPLAIN_FORMAT_TEXT)
1377  {
1378  if (plan_name)
1379  {
1380  ExplainIndentText(es);
1381  appendStringInfo(es->str, "%s\n", plan_name);
1382  es->indent++;
1383  }
1384  if (es->indent)
1385  {
1386  ExplainIndentText(es);
1387  appendStringInfoString(es->str, "-> ");
1388  es->indent += 2;
1389  }
1390  if (plan->parallel_aware)
1391  appendStringInfoString(es->str, "Parallel ");
1392  appendStringInfoString(es->str, pname);
1393  es->indent++;
1394  }
1395  else
1396  {
1397  ExplainPropertyText("Node Type", sname, es);
1398  if (strategy)
1399  ExplainPropertyText("Strategy", strategy, es);
1400  if (partialmode)
1401  ExplainPropertyText("Partial Mode", partialmode, es);
1402  if (operation)
1403  ExplainPropertyText("Operation", operation, es);
1404  if (relationship)
1405  ExplainPropertyText("Parent Relationship", relationship, es);
1406  if (plan_name)
1407  ExplainPropertyText("Subplan Name", plan_name, es);
1408  if (custom_name)
1409  ExplainPropertyText("Custom Plan Provider", custom_name, es);
1410  ExplainPropertyBool("Parallel Aware", plan->parallel_aware, es);
1411  }
1412 
1413  switch (nodeTag(plan))
1414  {
1415  case T_SeqScan:
1416  case T_SampleScan:
1417  case T_BitmapHeapScan:
1418  case T_TidScan:
1419  case T_SubqueryScan:
1420  case T_FunctionScan:
1421  case T_TableFuncScan:
1422  case T_ValuesScan:
1423  case T_CteScan:
1424  case T_WorkTableScan:
1425  ExplainScanTarget((Scan *) plan, es);
1426  break;
1427  case T_ForeignScan:
1428  case T_CustomScan:
1429  if (((Scan *) plan)->scanrelid > 0)
1430  ExplainScanTarget((Scan *) plan, es);
1431  break;
1432  case T_IndexScan:
1433  {
1434  IndexScan *indexscan = (IndexScan *) plan;
1435 
1436  ExplainIndexScanDetails(indexscan->indexid,
1437  indexscan->indexorderdir,
1438  es);
1439  ExplainScanTarget((Scan *) indexscan, es);
1440  }
1441  break;
1442  case T_IndexOnlyScan:
1443  {
1444  IndexOnlyScan *indexonlyscan = (IndexOnlyScan *) plan;
1445 
1446  ExplainIndexScanDetails(indexonlyscan->indexid,
1447  indexonlyscan->indexorderdir,
1448  es);
1449  ExplainScanTarget((Scan *) indexonlyscan, es);
1450  }
1451  break;
1452  case T_BitmapIndexScan:
1453  {
1454  BitmapIndexScan *bitmapindexscan = (BitmapIndexScan *) plan;
1455  const char *indexname =
1456  explain_get_index_name(bitmapindexscan->indexid);
1457 
1458  if (es->format == EXPLAIN_FORMAT_TEXT)
1459  appendStringInfo(es->str, " on %s", indexname);
1460  else
1461  ExplainPropertyText("Index Name", indexname, es);
1462  }
1463  break;
1464  case T_ModifyTable:
1465  ExplainModifyTarget((ModifyTable *) plan, es);
1466  break;
1467  case T_NestLoop:
1468  case T_MergeJoin:
1469  case T_HashJoin:
1470  {
1471  const char *jointype;
1472 
1473  switch (((Join *) plan)->jointype)
1474  {
1475  case JOIN_INNER:
1476  jointype = "Inner";
1477  break;
1478  case JOIN_LEFT:
1479  jointype = "Left";
1480  break;
1481  case JOIN_FULL:
1482  jointype = "Full";
1483  break;
1484  case JOIN_RIGHT:
1485  jointype = "Right";
1486  break;
1487  case JOIN_SEMI:
1488  jointype = "Semi";
1489  break;
1490  case JOIN_ANTI:
1491  jointype = "Anti";
1492  break;
1493  default:
1494  jointype = "???";
1495  break;
1496  }
1497  if (es->format == EXPLAIN_FORMAT_TEXT)
1498  {
1499  /*
1500  * For historical reasons, the join type is interpolated
1501  * into the node type name...
1502  */
1503  if (((Join *) plan)->jointype != JOIN_INNER)
1504  appendStringInfo(es->str, " %s Join", jointype);
1505  else if (!IsA(plan, NestLoop))
1506  appendStringInfoString(es->str, " Join");
1507  }
1508  else
1509  ExplainPropertyText("Join Type", jointype, es);
1510  }
1511  break;
1512  case T_SetOp:
1513  {
1514  const char *setopcmd;
1515 
1516  switch (((SetOp *) plan)->cmd)
1517  {
1518  case SETOPCMD_INTERSECT:
1519  setopcmd = "Intersect";
1520  break;
1521  case SETOPCMD_INTERSECT_ALL:
1522  setopcmd = "Intersect All";
1523  break;
1524  case SETOPCMD_EXCEPT:
1525  setopcmd = "Except";
1526  break;
1527  case SETOPCMD_EXCEPT_ALL:
1528  setopcmd = "Except All";
1529  break;
1530  default:
1531  setopcmd = "???";
1532  break;
1533  }
1534  if (es->format == EXPLAIN_FORMAT_TEXT)
1535  appendStringInfo(es->str, " %s", setopcmd);
1536  else
1537  ExplainPropertyText("Command", setopcmd, es);
1538  }
1539  break;
1540  default:
1541  break;
1542  }
1543 
1544  if (es->costs)
1545  {
1546  if (es->format == EXPLAIN_FORMAT_TEXT)
1547  {
1548  appendStringInfo(es->str, " (cost=%.2f..%.2f rows=%.0f width=%d)",
1549  plan->startup_cost, plan->total_cost,
1550  plan->plan_rows, plan->plan_width);
1551  }
1552  else
1553  {
1554  ExplainPropertyFloat("Startup Cost", NULL, plan->startup_cost,
1555  2, es);
1556  ExplainPropertyFloat("Total Cost", NULL, plan->total_cost,
1557  2, es);
1558  ExplainPropertyFloat("Plan Rows", NULL, plan->plan_rows,
1559  0, es);
1560  ExplainPropertyInteger("Plan Width", NULL, plan->plan_width,
1561  es);
1562  }
1563  }
1564 
1565  /*
1566  * We have to forcibly clean up the instrumentation state because we
1567  * haven't done ExecutorEnd yet. This is pretty grotty ...
1568  *
1569  * Note: contrib/auto_explain could cause instrumentation to be set up
1570  * even though we didn't ask for it here. Be careful not to print any
1571  * instrumentation results the user didn't ask for. But we do the
1572  * InstrEndLoop call anyway, if possible, to reduce the number of cases
1573  * auto_explain has to contend with.
1574  */
1575  if (planstate->instrument)
1576  InstrEndLoop(planstate->instrument);
1577 
1578  if (es->analyze &&
1579  planstate->instrument && planstate->instrument->nloops > 0)
1580  {
1581  double nloops = planstate->instrument->nloops;
1582  double startup_ms = 1000.0 * planstate->instrument->startup / nloops;
1583  double total_ms = 1000.0 * planstate->instrument->total / nloops;
1584  double rows = planstate->instrument->ntuples / nloops;
1585 
1586  if (es->format == EXPLAIN_FORMAT_TEXT)
1587  {
1588  if (es->timing)
1589  appendStringInfo(es->str,
1590  " (actual time=%.3f..%.3f rows=%.0f loops=%.0f)",
1591  startup_ms, total_ms, rows, nloops);
1592  else
1593  appendStringInfo(es->str,
1594  " (actual rows=%.0f loops=%.0f)",
1595  rows, nloops);
1596  }
1597  else
1598  {
1599  if (es->timing)
1600  {
1601  ExplainPropertyFloat("Actual Startup Time", "s", startup_ms,
1602  3, es);
1603  ExplainPropertyFloat("Actual Total Time", "s", total_ms,
1604  3, es);
1605  }
1606  ExplainPropertyFloat("Actual Rows", NULL, rows, 0, es);
1607  ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es);
1608  }
1609  }
1610  else if (es->analyze)
1611  {
1612  if (es->format == EXPLAIN_FORMAT_TEXT)
1613  appendStringInfoString(es->str, " (never executed)");
1614  else
1615  {
1616  if (es->timing)
1617  {
1618  ExplainPropertyFloat("Actual Startup Time", "ms", 0.0, 3, es);
1619  ExplainPropertyFloat("Actual Total Time", "ms", 0.0, 3, es);
1620  }
1621  ExplainPropertyFloat("Actual Rows", NULL, 0.0, 0, es);
1622  ExplainPropertyFloat("Actual Loops", NULL, 0.0, 0, es);
1623  }
1624  }
1625 
1626  /* in text format, first line ends here */
1627  if (es->format == EXPLAIN_FORMAT_TEXT)
1628  appendStringInfoChar(es->str, '\n');
1629 
1630  /* prepare per-worker general execution details */
1631  if (es->workers_state && es->verbose)
1632  {
1633  WorkerInstrumentation *w = planstate->worker_instrument;
1634 
1635  for (int n = 0; n < w->num_workers; n++)
1636  {
1637  Instrumentation *instrument = &w->instrument[n];
1638  double nloops = instrument->nloops;
1639  double startup_ms;
1640  double total_ms;
1641  double rows;
1642 
1643  if (nloops <= 0)
1644  continue;
1645  startup_ms = 1000.0 * instrument->startup / nloops;
1646  total_ms = 1000.0 * instrument->total / nloops;
1647  rows = instrument->ntuples / nloops;
1648 
1649  ExplainOpenWorker(n, es);
1650 
1651  if (es->format == EXPLAIN_FORMAT_TEXT)
1652  {
1653  ExplainIndentText(es);
1654  if (es->timing)
1655  appendStringInfo(es->str,
1656  "actual time=%.3f..%.3f rows=%.0f loops=%.0f\n",
1657  startup_ms, total_ms, rows, nloops);
1658  else
1659  appendStringInfo(es->str,
1660  "actual rows=%.0f loops=%.0f\n",
1661  rows, nloops);
1662  }
1663  else
1664  {
1665  if (es->timing)
1666  {
1667  ExplainPropertyFloat("Actual Startup Time", "ms",
1668  startup_ms, 3, es);
1669  ExplainPropertyFloat("Actual Total Time", "ms",
1670  total_ms, 3, es);
1671  }
1672  ExplainPropertyFloat("Actual Rows", NULL, rows, 0, es);
1673  ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es);
1674  }
1675 
1676  ExplainCloseWorker(n, es);
1677  }
1678  }
1679 
1680  /* target list */
1681  if (es->verbose)
1682  show_plan_tlist(planstate, ancestors, es);
1683 
1684  /* unique join */
1685  switch (nodeTag(plan))
1686  {
1687  case T_NestLoop:
1688  case T_MergeJoin:
1689  case T_HashJoin:
1690  /* try not to be too chatty about this in text mode */
1691  if (es->format != EXPLAIN_FORMAT_TEXT ||
1692  (es->verbose && ((Join *) plan)->inner_unique))
1693  ExplainPropertyBool("Inner Unique",
1694  ((Join *) plan)->inner_unique,
1695  es);
1696  break;
1697  default:
1698  break;
1699  }
1700 
1701  /* quals, sort keys, etc */
1702  switch (nodeTag(plan))
1703  {
1704  case T_IndexScan:
1705  show_scan_qual(((IndexScan *) plan)->indexqualorig,
1706  "Index Cond", planstate, ancestors, es);
1707  if (((IndexScan *) plan)->indexqualorig)
1708  show_instrumentation_count("Rows Removed by Index Recheck", 2,
1709  planstate, es);
1710  show_scan_qual(((IndexScan *) plan)->indexorderbyorig,
1711  "Order By", planstate, ancestors, es);
1712  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1713  if (plan->qual)
1714  show_instrumentation_count("Rows Removed by Filter", 1,
1715  planstate, es);
1716  break;
1717  case T_IndexOnlyScan:
1718  show_scan_qual(((IndexOnlyScan *) plan)->indexqual,
1719  "Index Cond", planstate, ancestors, es);
1720  if (((IndexOnlyScan *) plan)->indexqual)
1721  show_instrumentation_count("Rows Removed by Index Recheck", 2,
1722  planstate, es);
1723  show_scan_qual(((IndexOnlyScan *) plan)->indexorderby,
1724  "Order By", planstate, ancestors, es);
1725  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1726  if (plan->qual)
1727  show_instrumentation_count("Rows Removed by Filter", 1,
1728  planstate, es);
1729  if (es->analyze)
1730  ExplainPropertyFloat("Heap Fetches", NULL,
1731  planstate->instrument->ntuples2, 0, es);
1732  break;
1733  case T_BitmapIndexScan:
1734  show_scan_qual(((BitmapIndexScan *) plan)->indexqualorig,
1735  "Index Cond", planstate, ancestors, es);
1736  break;
1737  case T_BitmapHeapScan:
1738  show_scan_qual(((BitmapHeapScan *) plan)->bitmapqualorig,
1739  "Recheck Cond", planstate, ancestors, es);
1740  if (((BitmapHeapScan *) plan)->bitmapqualorig)
1741  show_instrumentation_count("Rows Removed by Index Recheck", 2,
1742  planstate, es);
1743  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1744  if (plan->qual)
1745  show_instrumentation_count("Rows Removed by Filter", 1,
1746  planstate, es);
1747  if (es->analyze)
1748  show_tidbitmap_info((BitmapHeapScanState *) planstate, es);
1749  break;
1750  case T_SampleScan:
1751  show_tablesample(((SampleScan *) plan)->tablesample,
1752  planstate, ancestors, es);
1753  /* fall through to print additional fields the same as SeqScan */
1754  /* FALLTHROUGH */
1755  case T_SeqScan:
1756  case T_ValuesScan:
1757  case T_CteScan:
1758  case T_NamedTuplestoreScan:
1759  case T_WorkTableScan:
1760  case T_SubqueryScan:
1761  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1762  if (plan->qual)
1763  show_instrumentation_count("Rows Removed by Filter", 1,
1764  planstate, es);
1765  break;
1766  case T_Gather:
1767  {
1768  Gather *gather = (Gather *) plan;
1769 
1770  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1771  if (plan->qual)
1772  show_instrumentation_count("Rows Removed by Filter", 1,
1773  planstate, es);
1774  ExplainPropertyInteger("Workers Planned", NULL,
1775  gather->num_workers, es);
1776 
1777  /* Show params evaluated at gather node */
1778  if (gather->initParam)
1779  show_eval_params(gather->initParam, es);
1780 
1781  if (es->analyze)
1782  {
1783  int nworkers;
1784 
1785  nworkers = ((GatherState *) planstate)->nworkers_launched;
1786  ExplainPropertyInteger("Workers Launched", NULL,
1787  nworkers, es);
1788  }
1789 
1790  if (gather->single_copy || es->format != EXPLAIN_FORMAT_TEXT)
1791  ExplainPropertyBool("Single Copy", gather->single_copy, es);
1792  }
1793  break;
1794  case T_GatherMerge:
1795  {
1796  GatherMerge *gm = (GatherMerge *) plan;
1797 
1798  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1799  if (plan->qual)
1800  show_instrumentation_count("Rows Removed by Filter", 1,
1801  planstate, es);
1802  ExplainPropertyInteger("Workers Planned", NULL,
1803  gm->num_workers, es);
1804 
1805  /* Show params evaluated at gather-merge node */
1806  if (gm->initParam)
1807  show_eval_params(gm->initParam, es);
1808 
1809  if (es->analyze)
1810  {
1811  int nworkers;
1812 
1813  nworkers = ((GatherMergeState *) planstate)->nworkers_launched;
1814  ExplainPropertyInteger("Workers Launched", NULL,
1815  nworkers, es);
1816  }
1817  }
1818  break;
1819  case T_FunctionScan:
1820  if (es->verbose)
1821  {
1822  List *fexprs = NIL;
1823  ListCell *lc;
1824 
1825  foreach(lc, ((FunctionScan *) plan)->functions)
1826  {
1827  RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
1828 
1829  fexprs = lappend(fexprs, rtfunc->funcexpr);
1830  }
1831  /* We rely on show_expression to insert commas as needed */
1832  show_expression((Node *) fexprs,
1833  "Function Call", planstate, ancestors,
1834  es->verbose, es);
1835  }
1836  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1837  if (plan->qual)
1838  show_instrumentation_count("Rows Removed by Filter", 1,
1839  planstate, es);
1840  break;
1841  case T_TableFuncScan:
1842  if (es->verbose)
1843  {
1844  TableFunc *tablefunc = ((TableFuncScan *) plan)->tablefunc;
1845 
1846  show_expression((Node *) tablefunc,
1847  "Table Function Call", planstate, ancestors,
1848  es->verbose, es);
1849  }
1850  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1851  if (plan->qual)
1852  show_instrumentation_count("Rows Removed by Filter", 1,
1853  planstate, es);
1854  break;
1855  case T_TidScan:
1856  {
1857  /*
1858  * The tidquals list has OR semantics, so be sure to show it
1859  * as an OR condition.
1860  */
1861  List *tidquals = ((TidScan *) plan)->tidquals;
1862 
1863  if (list_length(tidquals) > 1)
1864  tidquals = list_make1(make_orclause(tidquals));
1865  show_scan_qual(tidquals, "TID Cond", planstate, ancestors, es);
1866  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1867  if (plan->qual)
1868  show_instrumentation_count("Rows Removed by Filter", 1,
1869  planstate, es);
1870  }
1871  break;
1872  case T_ForeignScan:
1873  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1874  if (plan->qual)
1875  show_instrumentation_count("Rows Removed by Filter", 1,
1876  planstate, es);
1877  show_foreignscan_info((ForeignScanState *) planstate, es);
1878  break;
1879  case T_CustomScan:
1880  {
1881  CustomScanState *css = (CustomScanState *) planstate;
1882 
1883  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1884  if (plan->qual)
1885  show_instrumentation_count("Rows Removed by Filter", 1,
1886  planstate, es);
1887  if (css->methods->ExplainCustomScan)
1888  css->methods->ExplainCustomScan(css, ancestors, es);
1889  }
1890  break;
1891  case T_NestLoop:
1892  show_upper_qual(((NestLoop *) plan)->join.joinqual,
1893  "Join Filter", planstate, ancestors, es);
1894  if (((NestLoop *) plan)->join.joinqual)
1895  show_instrumentation_count("Rows Removed by Join Filter", 1,
1896  planstate, es);
1897  show_upper_qual(plan->qual, "Filter", planstate, ancestors, es);
1898  if (plan->qual)
1899  show_instrumentation_count("Rows Removed by Filter", 2,
1900  planstate, es);
1901  break;
1902  case T_MergeJoin:
1903  show_upper_qual(((MergeJoin *) plan)->mergeclauses,
1904  "Merge Cond", planstate, ancestors, es);
1905  show_upper_qual(((MergeJoin *) plan)->join.joinqual,
1906  "Join Filter", planstate, ancestors, es);
1907  if (((MergeJoin *) plan)->join.joinqual)
1908  show_instrumentation_count("Rows Removed by Join Filter", 1,
1909  planstate, es);
1910  show_upper_qual(plan->qual, "Filter", planstate, ancestors, es);
1911  if (plan->qual)
1912  show_instrumentation_count("Rows Removed by Filter", 2,
1913  planstate, es);
1914  break;
1915  case T_HashJoin:
1916  show_upper_qual(((HashJoin *) plan)->hashclauses,
1917  "Hash Cond", planstate, ancestors, es);
1918  show_upper_qual(((HashJoin *) plan)->join.joinqual,
1919  "Join Filter", planstate, ancestors, es);
1920  if (((HashJoin *) plan)->join.joinqual)
1921  show_instrumentation_count("Rows Removed by Join Filter", 1,
1922  planstate, es);
1923  show_upper_qual(plan->qual, "Filter", planstate, ancestors, es);
1924  if (plan->qual)
1925  show_instrumentation_count("Rows Removed by Filter", 2,
1926  planstate, es);
1927  break;
1928  case T_Agg:
1929  show_agg_keys(castNode(AggState, planstate), ancestors, es);
1930  show_upper_qual(plan->qual, "Filter", planstate, ancestors, es);
1931  show_hashagg_info((AggState *) planstate, es);
1932  if (plan->qual)
1933  show_instrumentation_count("Rows Removed by Filter", 1,
1934  planstate, es);
1935  break;
1936  case T_Group:
1937  show_group_keys(castNode(GroupState, planstate), ancestors, es);
1938  show_upper_qual(plan->qual, "Filter", planstate, ancestors, es);
1939  if (plan->qual)
1940  show_instrumentation_count("Rows Removed by Filter", 1,
1941  planstate, es);
1942  break;
1943  case T_Sort:
1944  show_sort_keys(castNode(SortState, planstate), ancestors, es);
1945  show_sort_info(castNode(SortState, planstate), es);
1946  break;
1947  case T_IncrementalSort:
1948  show_incremental_sort_keys(castNode(IncrementalSortState, planstate),
1949  ancestors, es);
1950  show_incremental_sort_info(castNode(IncrementalSortState, planstate),
1951  es);
1952  break;
1953  case T_MergeAppend:
1954  show_merge_append_keys(castNode(MergeAppendState, planstate),
1955  ancestors, es);
1956  break;
1957  case T_Result:
1958  show_upper_qual((List *) ((Result *) plan)->resconstantqual,
1959  "One-Time Filter", planstate, ancestors, es);
1960  show_upper_qual(plan->qual, "Filter", planstate, ancestors, es);
1961  if (plan->qual)
1962  show_instrumentation_count("Rows Removed by Filter", 1,
1963  planstate, es);
1964  break;
1965  case T_ModifyTable:
1966  show_modifytable_info(castNode(ModifyTableState, planstate), ancestors,
1967  es);
1968  break;
1969  case T_Hash:
1970  show_hash_info(castNode(HashState, planstate), es);
1971  break;
1972  default:
1973  break;
1974  }
1975 
1976  /*
1977  * Prepare per-worker JIT instrumentation. As with the overall JIT
1978  * summary, this is printed only if printing costs is enabled.
1979  */
1980  if (es->workers_state && es->costs && es->verbose)
1981  {
1982  SharedJitInstrumentation *w = planstate->worker_jit_instrument;
1983 
1984  if (w)
1985  {
1986  for (int n = 0; n < w->num_workers; n++)
1987  {
1988  ExplainOpenWorker(n, es);
1989  ExplainPrintJIT(es, planstate->state->es_jit_flags,
1990  &w->jit_instr[n]);
1991  ExplainCloseWorker(n, es);
1992  }
1993  }
1994  }
1995 
1996  /* Show buffer/WAL usage */
1997  if (es->buffers && planstate->instrument)
1998  show_buffer_usage(es, &planstate->instrument->bufusage);
1999  if (es->wal && planstate->instrument)
2000  show_wal_usage(es, &planstate->instrument->walusage);
2001 
2002  /* Prepare per-worker buffer/WAL usage */
2003  if (es->workers_state && (es->buffers || es->wal) && es->verbose)
2004  {
2005  WorkerInstrumentation *w = planstate->worker_instrument;
2006 
2007  for (int n = 0; n < w->num_workers; n++)
2008  {
2009  Instrumentation *instrument = &w->instrument[n];
2010  double nloops = instrument->nloops;
2011 
2012  if (nloops <= 0)
2013  continue;
2014 
2015  ExplainOpenWorker(n, es);
2016  if (es->buffers)
2017  show_buffer_usage(es, &instrument->bufusage);
2018  if (es->wal)
2019  show_wal_usage(es, &instrument->walusage);
2020  ExplainCloseWorker(n, es);
2021  }
2022  }
2023 
2024  /* Show per-worker details for this plan node, then pop that stack */
2025  if (es->workers_state)
2026  ExplainFlushWorkersState(es);
2027  es->workers_state = save_workers_state;
2028 
2029  /*
2030  * If partition pruning was done during executor initialization, the
2031  * number of child plans we'll display below will be less than the number
2032  * of subplans that was specified in the plan. To make this a bit less
2033  * mysterious, emit an indication that this happened. Note that this
2034  * field is emitted now because we want it to be a property of the parent
2035  * node; it *cannot* be emitted within the Plans sub-node we'll open next.
2036  */
2037  switch (nodeTag(plan))
2038  {
2039  case T_Append:
2040  ExplainMissingMembers(((AppendState *) planstate)->as_nplans,
2041  list_length(((Append *) plan)->appendplans),
2042  es);
2043  break;
2044  case T_MergeAppend:
2045  ExplainMissingMembers(((MergeAppendState *) planstate)->ms_nplans,
2046  list_length(((MergeAppend *) plan)->mergeplans),
2047  es);
2048  break;
2049  default:
2050  break;
2051  }
2052 
2053  /* Get ready to display the child plans */
2054  haschildren = planstate->initPlan ||
2055  outerPlanState(planstate) ||
2056  innerPlanState(planstate) ||
2057  IsA(plan, ModifyTable) ||
2058  IsA(plan, Append) ||
2059  IsA(plan, MergeAppend) ||
2060  IsA(plan, BitmapAnd) ||
2061  IsA(plan, BitmapOr) ||
2062  IsA(plan, SubqueryScan) ||
2063  (IsA(planstate, CustomScanState) &&
2064  ((CustomScanState *) planstate)->custom_ps != NIL) ||
2065  planstate->subPlan;
2066  if (haschildren)
2067  {
2068  ExplainOpenGroup("Plans", "Plans", false, es);
2069  /* Pass current Plan as head of ancestors list for children */
2070  ancestors = lcons(plan, ancestors);
2071  }
2072 
2073  /* initPlan-s */
2074  if (planstate->initPlan)
2075  ExplainSubPlans(planstate->initPlan, ancestors, "InitPlan", es);
2076 
2077  /* lefttree */
2078  if (outerPlanState(planstate))
2079  ExplainNode(outerPlanState(planstate), ancestors,
2080  "Outer", NULL, es);
2081 
2082  /* righttree */
2083  if (innerPlanState(planstate))
2084  ExplainNode(innerPlanState(planstate), ancestors,
2085  "Inner", NULL, es);
2086 
2087  /* special child plans */
2088  switch (nodeTag(plan))
2089  {
2090  case T_ModifyTable:
2091  ExplainMemberNodes(((ModifyTableState *) planstate)->mt_plans,
2092  ((ModifyTableState *) planstate)->mt_nplans,
2093  ancestors, es);
2094  break;
2095  case T_Append:
2096  ExplainMemberNodes(((AppendState *) planstate)->appendplans,
2097  ((AppendState *) planstate)->as_nplans,
2098  ancestors, es);
2099  break;
2100  case T_MergeAppend:
2101  ExplainMemberNodes(((MergeAppendState *) planstate)->mergeplans,
2102  ((MergeAppendState *) planstate)->ms_nplans,
2103  ancestors, es);
2104  break;
2105  case T_BitmapAnd:
2106  ExplainMemberNodes(((BitmapAndState *) planstate)->bitmapplans,
2107  ((BitmapAndState *) planstate)->nplans,
2108  ancestors, es);
2109  break;
2110  case T_BitmapOr:
2111  ExplainMemberNodes(((BitmapOrState *) planstate)->bitmapplans,
2112  ((BitmapOrState *) planstate)->nplans,
2113  ancestors, es);
2114  break;
2115  case T_SubqueryScan:
2116  ExplainNode(((SubqueryScanState *) planstate)->subplan, ancestors,
2117  "Subquery", NULL, es);
2118  break;
2119  case T_CustomScan:
2120  ExplainCustomChildren((CustomScanState *) planstate,
2121  ancestors, es);
2122  break;
2123  default:
2124  break;
2125  }
2126 
2127  /* subPlan-s */
2128  if (planstate->subPlan)
2129  ExplainSubPlans(planstate->subPlan, ancestors, "SubPlan", es);
2130 
2131  /* end of child plans */
2132  if (haschildren)
2133  {
2134  ancestors = list_delete_first(ancestors);
2135  ExplainCloseGroup("Plans", "Plans", false, es);
2136  }
2137 
2138  /* in text format, undo whatever indentation we added */
2139  if (es->format == EXPLAIN_FORMAT_TEXT)
2140  es->indent = save_indent;
2141 
2142  ExplainCloseGroup("Plan",
2143  relationship ? NULL : "Plan",
2144  true, es);
2145 }
2146 
2147 /*
2148  * Show the targetlist of a plan node
2149  */
2150 static void
2151 show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es)
2152 {
2153  Plan *plan = planstate->plan;
2154  List *context;
2155  List *result = NIL;
2156  bool useprefix;
2157  ListCell *lc;
2158 
2159  /* No work if empty tlist (this occurs eg in bitmap indexscans) */
2160  if (plan->targetlist == NIL)
2161  return;
2162  /* The tlist of an Append isn't real helpful, so suppress it */
2163  if (IsA(plan, Append))
2164  return;
2165  /* Likewise for MergeAppend and RecursiveUnion */
2166  if (IsA(plan, MergeAppend))
2167  return;
2168  if (IsA(plan, RecursiveUnion))
2169  return;
2170 
2171  /*
2172  * Likewise for ForeignScan that executes a direct INSERT/UPDATE/DELETE
2173  *
2174  * Note: the tlist for a ForeignScan that executes a direct INSERT/UPDATE
2175  * might contain subplan output expressions that are confusing in this
2176  * context. The tlist for a ForeignScan that executes a direct UPDATE/
2177  * DELETE always contains "junk" target columns to identify the exact row
2178  * to update or delete, which would be confusing in this context. So, we
2179  * suppress it in all the cases.
2180  */
2181  if (IsA(plan, ForeignScan) &&
2182  ((ForeignScan *) plan)->operation != CMD_SELECT)
2183  return;
2184 
2185  /* Set up deparsing context */
2186  context = set_deparse_context_plan(es->deparse_cxt,
2187  plan,
2188  ancestors);
2189  useprefix = list_length(es->rtable) > 1;
2190 
2191  /* Deparse each result column (we now include resjunk ones) */
2192  foreach(lc, plan->targetlist)
2193  {
2194  TargetEntry *tle = (TargetEntry *) lfirst(lc);
2195 
2196  result = lappend(result,
2197  deparse_expression((Node *) tle->expr, context,
2198  useprefix, false));
2199  }
2200 
2201  /* Print results */
2202  ExplainPropertyList("Output", result, es);
2203 }
2204 
2205 /*
2206  * Show a generic expression
2207  */
2208 static void
2209 show_expression(Node *node, const char *qlabel,
2210  PlanState *planstate, List *ancestors,
2211  bool useprefix, ExplainState *es)
2212 {
2213  List *context;
2214  char *exprstr;
2215 
2216  /* Set up deparsing context */
2217  context = set_deparse_context_plan(es->deparse_cxt,
2218  planstate->plan,
2219  ancestors);
2220 
2221  /* Deparse the expression */
2222  exprstr = deparse_expression(node, context, useprefix, false);
2223 
2224  /* And add to es->str */
2225  ExplainPropertyText(qlabel, exprstr, es);
2226 }
2227 
2228 /*
2229  * Show a qualifier expression (which is a List with implicit AND semantics)
2230  */
2231 static void
2232 show_qual(List *qual, const char *qlabel,
2233  PlanState *planstate, List *ancestors,
2234  bool useprefix, ExplainState *es)
2235 {
2236  Node *node;
2237 
2238  /* No work if empty qual */
2239  if (qual == NIL)
2240  return;
2241 
2242  /* Convert AND list to explicit AND */
2243  node = (Node *) make_ands_explicit(qual);
2244 
2245  /* And show it */
2246  show_expression(node, qlabel, planstate, ancestors, useprefix, es);
2247 }
2248 
2249 /*
2250  * Show a qualifier expression for a scan plan node
2251  */
2252 static void
2253 show_scan_qual(List *qual, const char *qlabel,
2254  PlanState *planstate, List *ancestors,
2255  ExplainState *es)
2256 {
2257  bool useprefix;
2258 
2259  useprefix = (IsA(planstate->plan, SubqueryScan) || es->verbose);
2260  show_qual(qual, qlabel, planstate, ancestors, useprefix, es);
2261 }
2262 
2263 /*
2264  * Show a qualifier expression for an upper-level plan node
2265  */
2266 static void
2267 show_upper_qual(List *qual, const char *qlabel,
2268  PlanState *planstate, List *ancestors,
2269  ExplainState *es)
2270 {
2271  bool useprefix;
2272 
2273  useprefix = (list_length(es->rtable) > 1 || es->verbose);
2274  show_qual(qual, qlabel, planstate, ancestors, useprefix, es);
2275 }
2276 
2277 /*
2278  * Show the sort keys for a Sort node.
2279  */
2280 static void
2281 show_sort_keys(SortState *sortstate, List *ancestors, ExplainState *es)
2282 {
2283  Sort *plan = (Sort *) sortstate->ss.ps.plan;
2284 
2285  show_sort_group_keys((PlanState *) sortstate, "Sort Key",
2286  plan->numCols, 0, plan->sortColIdx,
2287  plan->sortOperators, plan->collations,
2288  plan->nullsFirst,
2289  ancestors, es);
2290 }
2291 
2292 /*
2293  * Show the sort keys for a IncrementalSort node.
2294  */
2295 static void
2296 show_incremental_sort_keys(IncrementalSortState *incrsortstate,
2297  List *ancestors, ExplainState *es)
2298 {
2299  IncrementalSort *plan = (IncrementalSort *) incrsortstate->ss.ps.plan;
2300 
2301  show_sort_group_keys((PlanState *) incrsortstate, "Sort Key",
2302  plan->sort.numCols, plan->nPresortedCols,
2303  plan->sort.sortColIdx,
2304  plan->sort.sortOperators, plan->sort.collations,
2305  plan->sort.nullsFirst,
2306  ancestors, es);
2307 }
2308 
2309 /*
2310  * Likewise, for a MergeAppend node.
2311  */
2312 static void
2313 show_merge_append_keys(MergeAppendState *mstate, List *ancestors,
2314  ExplainState *es)
2315 {
2316  MergeAppend *plan = (MergeAppend *) mstate->ps.plan;
2317 
2318  show_sort_group_keys((PlanState *) mstate, "Sort Key",
2319  plan->numCols, 0, plan->sortColIdx,
2320  plan->sortOperators, plan->collations,
2321  plan->nullsFirst,
2322  ancestors, es);
2323 }
2324 
2325 /*
2326  * Show the grouping keys for an Agg node.
2327  */
2328 static void
2329 show_agg_keys(AggState *astate, List *ancestors,
2330  ExplainState *es)
2331 {
2332  Agg *plan = (Agg *) astate->ss.ps.plan;
2333 
2334  if (plan->numCols > 0 || plan->groupingSets)
2335  {
2336  /* The key columns refer to the tlist of the child plan */
2337  ancestors = lcons(plan, ancestors);
2338 
2339  if (plan->groupingSets)
2340  show_grouping_sets(outerPlanState(astate), plan, ancestors, es);
2341  else
2342  show_sort_group_keys(outerPlanState(astate), "Group Key",
2343  plan->numCols, 0, plan->grpColIdx,
2344  NULL, NULL, NULL,
2345  ancestors, es);
2346 
2347  ancestors = list_delete_first(ancestors);
2348  }
2349 }
2350 
2351 static void
2352 show_grouping_sets(PlanState *planstate, Agg *agg,
2353  List *ancestors, ExplainState *es)
2354 {
2355  List *context;
2356  bool useprefix;
2357  ListCell *lc;
2358 
2359  /* Set up deparsing context */
2360  context = set_deparse_context_plan(es->deparse_cxt,
2361  planstate->plan,
2362  ancestors);
2363  useprefix = (list_length(es->rtable) > 1 || es->verbose);
2364 
2365  ExplainOpenGroup("Grouping Sets", "Grouping Sets", false, es);
2366 
2367  show_grouping_set_keys(planstate, agg, NULL,
2368  context, useprefix, ancestors, es);
2369 
2370  foreach(lc, agg->chain)
2371  {
2372  Agg *aggnode = lfirst(lc);
2373  Sort *sortnode = (Sort *) aggnode->plan.lefttree;
2374 
2375  show_grouping_set_keys(planstate, aggnode, sortnode,
2376  context, useprefix, ancestors, es);
2377  }
2378 
2379  ExplainCloseGroup("Grouping Sets", "Grouping Sets", false, es);
2380 }
2381 
2382 static void
2383 show_grouping_set_keys(PlanState *planstate,
2384  Agg *aggnode, Sort *sortnode,
2385  List *context, bool useprefix,
2386  List *ancestors, ExplainState *es)
2387 {
2388  Plan *plan = planstate->plan;
2389  char *exprstr;
2390  ListCell *lc;
2391  List *gsets = aggnode->groupingSets;
2392  AttrNumber *keycols = aggnode->grpColIdx;
2393  const char *keyname;
2394  const char *keysetname;
2395 
2396  if (aggnode->aggstrategy == AGG_HASHED || aggnode->aggstrategy == AGG_MIXED)
2397  {
2398  keyname = "Hash Key";
2399  keysetname = "Hash Keys";
2400  }
2401  else
2402  {
2403  keyname = "Group Key";
2404  keysetname = "Group Keys";
2405  }
2406 
2407  ExplainOpenGroup("Grouping Set", NULL, true, es);
2408 
2409  if (sortnode)
2410  {
2411  show_sort_group_keys(planstate, "Sort Key",
2412  sortnode->numCols, 0, sortnode->sortColIdx,
2413  sortnode->sortOperators, sortnode->collations,
2414  sortnode->nullsFirst,
2415  ancestors, es);
2416  if (es->format == EXPLAIN_FORMAT_TEXT)
2417  es->indent++;
2418  }
2419 
2420  ExplainOpenGroup(keysetname, keysetname, false, es);
2421 
2422  foreach(lc, gsets)
2423  {
2424  List *result = NIL;
2425  ListCell *lc2;
2426 
2427  foreach(lc2, (List *) lfirst(lc))
2428  {
2429  Index i = lfirst_int(lc2);
2430  AttrNumber keyresno = keycols[i];
2431  TargetEntry *target = get_tle_by_resno(plan->targetlist,
2432  keyresno);
2433 
2434  if (!target)
2435  elog(ERROR, "no tlist entry for key %d", keyresno);
2436  /* Deparse the expression, showing any top-level cast */
2437  exprstr = deparse_expression((Node *) target->expr, context,
2438  useprefix, true);
2439 
2440  result = lappend(result, exprstr);
2441  }
2442 
2443  if (!result && es->format == EXPLAIN_FORMAT_TEXT)
2444  ExplainPropertyText(keyname, "()", es);
2445  else
2446  ExplainPropertyListNested(keyname, result, es);
2447  }
2448 
2449  ExplainCloseGroup(keysetname, keysetname, false, es);
2450 
2451  if (sortnode && es->format == EXPLAIN_FORMAT_TEXT)
2452  es->indent--;
2453 
2454  ExplainCloseGroup("Grouping Set", NULL, true, es);
2455 }
2456 
2457 /*
2458  * Show the grouping keys for a Group node.
2459  */
2460 static void
2461 show_group_keys(GroupState *gstate, List *ancestors,
2462  ExplainState *es)
2463 {
2464  Group *plan = (Group *) gstate->ss.ps.plan;
2465 
2466  /* The key columns refer to the tlist of the child plan */
2467  ancestors = lcons(plan, ancestors);
2468  show_sort_group_keys(outerPlanState(gstate), "Group Key",
2469  plan->numCols, 0, plan->grpColIdx,
2470  NULL, NULL, NULL,
2471  ancestors, es);
2472  ancestors = list_delete_first(ancestors);
2473 }
2474 
2475 /*
2476  * Common code to show sort/group keys, which are represented in plan nodes
2477  * as arrays of targetlist indexes. If it's a sort key rather than a group
2478  * key, also pass sort operators/collations/nullsFirst arrays.
2479  */
2480 static void
2481 show_sort_group_keys(PlanState *planstate, const char *qlabel,
2482  int nkeys, int nPresortedKeys, AttrNumber *keycols,
2483  Oid *sortOperators, Oid *collations, bool *nullsFirst,
2484  List *ancestors, ExplainState *es)
2485 {
2486  Plan *plan = planstate->plan;
2487  List *context;
2488  List *result = NIL;
2489  List *resultPresorted = NIL;
2490  StringInfoData sortkeybuf;
2491  bool useprefix;
2492  int keyno;
2493 
2494  if (nkeys <= 0)
2495  return;
2496 
2497  initStringInfo(&sortkeybuf);
2498 
2499  /* Set up deparsing context */
2500  context = set_deparse_context_plan(es->deparse_cxt,
2501  plan,
2502  ancestors);
2503  useprefix = (list_length(es->rtable) > 1 || es->verbose);
2504 
2505  for (keyno = 0; keyno < nkeys; keyno++)
2506  {
2507  /* find key expression in tlist */
2508  AttrNumber keyresno = keycols[keyno];
2509  TargetEntry *target = get_tle_by_resno(plan->targetlist,
2510  keyresno);
2511  char *exprstr;
2512 
2513  if (!target)
2514  elog(ERROR, "no tlist entry for key %d", keyresno);
2515  /* Deparse the expression, showing any top-level cast */
2516  exprstr = deparse_expression((Node *) target->expr, context,
2517  useprefix, true);
2518  resetStringInfo(&sortkeybuf);
2519  appendStringInfoString(&sortkeybuf, exprstr);
2520  /* Append sort order information, if relevant */
2521  if (sortOperators != NULL)
2522  show_sortorder_options(&sortkeybuf,
2523  (Node *) target->expr,
2524  sortOperators[keyno],
2525  collations[keyno],
2526  nullsFirst[keyno]);
2527  /* Emit one property-list item per sort key */
2528  result = lappend(result, pstrdup(sortkeybuf.data));
2529  if (keyno < nPresortedKeys)
2530  resultPresorted = lappend(resultPresorted, exprstr);
2531  }
2532 
2533  ExplainPropertyList(qlabel, result, es);
2534  if (nPresortedKeys > 0)
2535  ExplainPropertyList("Presorted Key", resultPresorted, es);
2536 }
2537 
2538 /*
2539  * Append nondefault characteristics of the sort ordering of a column to buf
2540  * (collation, direction, NULLS FIRST/LAST)
2541  */
2542 static void
2543 show_sortorder_options(StringInfo buf, Node *sortexpr,
2544  Oid sortOperator, Oid collation, bool nullsFirst)
2545 {
2546  Oid sortcoltype = exprType(sortexpr);
2547  bool reverse = false;
2548  TypeCacheEntry *typentry;
2549 
2550  typentry = lookup_type_cache(sortcoltype,
2551  TYPECACHE_LT_OPR | TYPECACHE_GT_OPR);
2552 
2553  /*
2554  * Print COLLATE if it's not default for the column's type. There are
2555  * some cases where this is redundant, eg if expression is a column whose
2556  * declared collation is that collation, but it's hard to distinguish that
2557  * here (and arguably, printing COLLATE explicitly is a good idea anyway
2558  * in such cases).
2559  */
2560  if (OidIsValid(collation) && collation != get_typcollation(sortcoltype))
2561  {
2562  char *collname = get_collation_name(collation);
2563 
2564  if (collname == NULL)
2565  elog(ERROR, "cache lookup failed for collation %u", collation);
2566  appendStringInfo(buf, " COLLATE %s", quote_identifier(collname));
2567  }
2568 
2569  /* Print direction if not ASC, or USING if non-default sort operator */
2570  if (sortOperator == typentry->gt_opr)
2571  {
2572  appendStringInfoString(buf, " DESC");
2573  reverse = true;
2574  }
2575  else if (sortOperator != typentry->lt_opr)
2576  {
2577  char *opname = get_opname(sortOperator);
2578 
2579  if (opname == NULL)
2580  elog(ERROR, "cache lookup failed for operator %u", sortOperator);
2581  appendStringInfo(buf, " USING %s", opname);
2582  /* Determine whether operator would be considered ASC or DESC */
2583  (void) get_equality_op_for_ordering_op(sortOperator, &reverse);
2584  }
2585 
2586  /* Add NULLS FIRST/LAST only if it wouldn't be default */
2587  if (nullsFirst && !reverse)
2588  {
2589  appendStringInfoString(buf, " NULLS FIRST");
2590  }
2591  else if (!nullsFirst && reverse)
2592  {
2593  appendStringInfoString(buf, " NULLS LAST");
2594  }
2595 }
2596 
2597 /*
2598  * Show TABLESAMPLE properties
2599  */
2600 static void
2601 show_tablesample(TableSampleClause *tsc, PlanState *planstate,
2602  List *ancestors, ExplainState *es)
2603 {
2604  List *context;
2605  bool useprefix;
2606  char *method_name;
2607  List *params = NIL;
2608  char *repeatable;
2609  ListCell *lc;
2610 
2611  /* Set up deparsing context */
2612  context = set_deparse_context_plan(es->deparse_cxt,
2613  planstate->plan,
2614  ancestors);
2615  useprefix = list_length(es->rtable) > 1;
2616 
2617  /* Get the tablesample method name */
2618  method_name = get_func_name(tsc->tsmhandler);
2619 
2620  /* Deparse parameter expressions */
2621  foreach(lc, tsc->args)
2622  {
2623  Node *arg = (Node *) lfirst(lc);
2624 
2625  params = lappend(params,
2626  deparse_expression(arg, context,
2627  useprefix, false));
2628  }
2629  if (tsc->repeatable)
2630  repeatable = deparse_expression((Node *) tsc->repeatable, context,
2631  useprefix, false);
2632  else
2633  repeatable = NULL;
2634 
2635  /* Print results */
2636  if (es->format == EXPLAIN_FORMAT_TEXT)
2637  {
2638  bool first = true;
2639 
2640  ExplainIndentText(es);
2641  appendStringInfo(es->str, "Sampling: %s (", method_name);
2642  foreach(lc, params)
2643  {
2644  if (!first)
2645  appendStringInfoString(es->str, ", ");
2646  appendStringInfoString(es->str, (const char *) lfirst(lc));
2647  first = false;
2648  }
2649  appendStringInfoChar(es->str, ')');
2650  if (repeatable)
2651  appendStringInfo(es->str, " REPEATABLE (%s)", repeatable);
2652  appendStringInfoChar(es->str, '\n');
2653  }
2654  else
2655  {
2656  ExplainPropertyText("Sampling Method", method_name, es);
2657  ExplainPropertyList("Sampling Parameters", params, es);
2658  if (repeatable)
2659  ExplainPropertyText("Repeatable Seed", repeatable, es);
2660  }
2661 }
2662 
2663 /*
2664  * If it's EXPLAIN ANALYZE, show tuplesort stats for a sort node
2665  */
2666 static void
2667 show_sort_info(SortState *sortstate, ExplainState *es)
2668 {
2669  if (!es->analyze)
2670  return;
2671 
2672  if (sortstate->sort_Done && sortstate->tuplesortstate != NULL)
2673  {
2674  Tuplesortstate *state = (Tuplesortstate *) sortstate->tuplesortstate;
2675  TuplesortInstrumentation stats;
2676  const char *sortMethod;
2677  const char *spaceType;
2678  long spaceUsed;
2679 
2680  tuplesort_get_stats(state, &stats);
2681  sortMethod = tuplesort_method_name(stats.sortMethod);
2682  spaceType = tuplesort_space_type_name(stats.spaceType);
2683  spaceUsed = stats.spaceUsed;
2684 
2685  if (es->format == EXPLAIN_FORMAT_TEXT)
2686  {
2687  ExplainIndentText(es);
2688  appendStringInfo(es->str, "Sort Method: %s %s: %ldkB\n",
2689  sortMethod, spaceType, spaceUsed);
2690  }
2691  else
2692  {
2693  ExplainPropertyText("Sort Method", sortMethod, es);
2694  ExplainPropertyInteger("Sort Space Used", "kB", spaceUsed, es);
2695  ExplainPropertyText("Sort Space Type", spaceType, es);
2696  }
2697  }
2698 
2699  /*
2700  * You might think we should just skip this stanza entirely when
2701  * es->hide_workers is true, but then we'd get no sort-method output at
2702  * all. We have to make it look like worker 0's data is top-level data.
2703  * This is easily done by just skipping the OpenWorker/CloseWorker calls.
2704  * Currently, we don't worry about the possibility that there are multiple
2705  * workers in such a case; if there are, duplicate output fields will be
2706  * emitted.
2707  */
2708  if (sortstate->shared_info != NULL)
2709  {
2710  int n;
2711 
2712  for (n = 0; n < sortstate->shared_info->num_workers; n++)
2713  {
2714  TuplesortInstrumentation *sinstrument;
2715  const char *sortMethod;
2716  const char *spaceType;
2717  long spaceUsed;
2718 
2719  sinstrument = &sortstate->shared_info->sinstrument[n];
2720  if (sinstrument->sortMethod == SORT_TYPE_STILL_IN_PROGRESS)
2721  continue; /* ignore any unfilled slots */
2722  sortMethod = tuplesort_method_name(sinstrument->sortMethod);
2723  spaceType = tuplesort_space_type_name(sinstrument->spaceType);
2724  spaceUsed = sinstrument->spaceUsed;
2725 
2726  if (es->workers_state)
2727  ExplainOpenWorker(n, es);
2728 
2729  if (es->format == EXPLAIN_FORMAT_TEXT)
2730  {
2731  ExplainIndentText(es);
2732  appendStringInfo(es->str,
2733  "Sort Method: %s %s: %ldkB\n",
2734  sortMethod, spaceType, spaceUsed);
2735  }
2736  else
2737  {
2738  ExplainPropertyText("Sort Method", sortMethod, es);
2739  ExplainPropertyInteger("Sort Space Used", "kB", spaceUsed, es);
2740  ExplainPropertyText("Sort Space Type", spaceType, es);
2741  }
2742 
2743  if (es->workers_state)
2744  ExplainCloseWorker(n, es);
2745  }
2746  }
2747 }
2748 
2749 /*
2750  * Incremental sort nodes sort in (a potentially very large number of) batches,
2751  * so EXPLAIN ANALYZE needs to roll up the tuplesort stats from each batch into
2752  * an intelligible summary.
2753  *
2754  * This function is used for both a non-parallel node and each worker in a
2755  * parallel incremental sort node.
2756  */
2757 static void
2758 show_incremental_sort_group_info(IncrementalSortGroupInfo *groupInfo,
2759  const char *groupLabel, bool indent, ExplainState *es)
2760 {
2761  ListCell *methodCell;
2762  List *methodNames = NIL;
2763 
2764  /* Generate a list of sort methods used across all groups. */
2765  for (int bit = 0; bit < NUM_TUPLESORTMETHODS; bit++)
2766  {
2767  TuplesortMethod sortMethod = (1 << bit);
2768 
2769  if (groupInfo->sortMethods & sortMethod)
2770  {
2771  const char *methodName = tuplesort_method_name(sortMethod);
2772 
2773  methodNames = lappend(methodNames, unconstify(char *, methodName));
2774  }
2775  }
2776 
2777  if (es->format == EXPLAIN_FORMAT_TEXT)
2778  {
2779  if (indent)
2780  appendStringInfoSpaces(es->str, es->indent * 2);
2781  appendStringInfo(es->str, "%s Groups: " INT64_FORMAT " Sort Method", groupLabel,
2782  groupInfo->groupCount);
2783  /* plural/singular based on methodNames size */
2784  if (list_length(methodNames) > 1)
2785  appendStringInfo(es->str, "s: ");
2786  else
2787  appendStringInfo(es->str, ": ");
2788  foreach(methodCell, methodNames)
2789  {
2790  appendStringInfo(es->str, "%s", (char *) methodCell->ptr_value);
2791  if (foreach_current_index(methodCell) < list_length(methodNames) - 1)
2792  appendStringInfo(es->str, ", ");
2793  }
2794 
2795  if (groupInfo->maxMemorySpaceUsed > 0)
2796  {
2797  long avgSpace = groupInfo->totalMemorySpaceUsed / groupInfo->groupCount;
2798  const char *spaceTypeName;
2799 
2800  spaceTypeName = tuplesort_space_type_name(SORT_SPACE_TYPE_MEMORY);
2801  appendStringInfo(es->str, " Average %s: %ldkB Peak %s: %ldkB",
2802  spaceTypeName, avgSpace,
2803  spaceTypeName, groupInfo->maxMemorySpaceUsed);
2804  }
2805 
2806  if (groupInfo->maxDiskSpaceUsed > 0)
2807  {
2808  long avgSpace = groupInfo->totalDiskSpaceUsed / groupInfo->groupCount;
2809 
2810  const char *spaceTypeName;
2811 
2812  spaceTypeName = tuplesort_space_type_name(SORT_SPACE_TYPE_DISK);
2813  appendStringInfo(es->str, " Average %s: %ldkB Peak %s: %ldkB",
2814  spaceTypeName, avgSpace,
2815  spaceTypeName, groupInfo->maxDiskSpaceUsed);
2816  }
2817  }
2818  else
2819  {
2820  StringInfoData groupName;
2821 
2822  initStringInfo(&groupName);
2823  appendStringInfo(&groupName, "%s Groups", groupLabel);
2824  ExplainOpenGroup("Incremental Sort Groups", groupName.data, true, es);
2825  ExplainPropertyInteger("Group Count", NULL, groupInfo->groupCount, es);
2826 
2827  ExplainPropertyList("Sort Methods Used", methodNames, es);
2828 
2829  if (groupInfo->maxMemorySpaceUsed > 0)
2830  {
2831  long avgSpace = groupInfo->totalMemorySpaceUsed / groupInfo->groupCount;
2832  const char *spaceTypeName;
2833  StringInfoData memoryName;
2834 
2835  spaceTypeName = tuplesort_space_type_name(SORT_SPACE_TYPE_MEMORY);
2836  initStringInfo(&memoryName);
2837  appendStringInfo(&memoryName, "Sort Space %s", spaceTypeName);
2838  ExplainOpenGroup("Sort Space", memoryName.data, true, es);
2839 
2840  ExplainPropertyInteger("Average Sort Space Used", "kB", avgSpace, es);
2841  ExplainPropertyInteger("Peak Sort Space Used", "kB",
2842  groupInfo->maxMemorySpaceUsed, es);
2843 
2844  ExplainCloseGroup("Sort Spaces", memoryName.data, true, es);
2845  }
2846  if (groupInfo->maxDiskSpaceUsed > 0)
2847  {
2848  long avgSpace = groupInfo->totalDiskSpaceUsed / groupInfo->groupCount;
2849  const char *spaceTypeName;
2850  StringInfoData diskName;
2851 
2852  spaceTypeName = tuplesort_space_type_name(SORT_SPACE_TYPE_DISK);
2853  initStringInfo(&diskName);
2854  appendStringInfo(&diskName, "Sort Space %s", spaceTypeName);
2855  ExplainOpenGroup("Sort Space", diskName.data, true, es);
2856 
2857  ExplainPropertyInteger("Average Sort Space Used", "kB", avgSpace, es);
2858  ExplainPropertyInteger("Peak Sort Space Used", "kB",
2859  groupInfo->maxDiskSpaceUsed, es);
2860 
2861  ExplainCloseGroup("Sort Spaces", diskName.data, true, es);
2862  }
2863 
2864  ExplainCloseGroup("Incremental Sort Groups", groupName.data, true, es);
2865  }
2866 }
2867 
2868 /*
2869  * If it's EXPLAIN ANALYZE, show tuplesort stats for an incremental sort node
2870  */
2871 static void
2872 show_incremental_sort_info(IncrementalSortState *incrsortstate,
2873  ExplainState *es)
2874 {
2875  IncrementalSortGroupInfo *fullsortGroupInfo;
2876  IncrementalSortGroupInfo *prefixsortGroupInfo;
2877 
2878  fullsortGroupInfo = &incrsortstate->incsort_info.fullsortGroupInfo;
2879 
2880  if (!es->analyze)
2881  return;
2882 
2883  /*
2884  * Since we never have any prefix groups unless we've first sorted a full
2885  * groups and transitioned modes (copying the tuples into a prefix group),
2886  * we don't need to do anything if there were 0 full groups.
2887  *
2888  * We still have to continue after this block if there are no full groups,
2889  * though, since it's possible that we have workers that did real work
2890  * even if the leader didn't participate.
2891  */
2892  if (fullsortGroupInfo->groupCount > 0)
2893  {
2894  show_incremental_sort_group_info(fullsortGroupInfo, "Full-sort", true, es);
2895  prefixsortGroupInfo = &incrsortstate->incsort_info.prefixsortGroupInfo;
2896  if (prefixsortGroupInfo->groupCount > 0)
2897  {
2898  if (es->format == EXPLAIN_FORMAT_TEXT)
2899  appendStringInfo(es->str, "\n");
2900  show_incremental_sort_group_info(prefixsortGroupInfo, "Pre-sorted", true, es);
2901  }
2902  if (es->format == EXPLAIN_FORMAT_TEXT)
2903  appendStringInfo(es->str, "\n");
2904  }
2905 
2906  if (incrsortstate->shared_info != NULL)
2907  {
2908  int n;
2909  bool indent_first_line;
2910 
2911  for (n = 0; n < incrsortstate->shared_info->num_workers; n++)
2912  {
2913  IncrementalSortInfo *incsort_info =
2914  &incrsortstate->shared_info->sinfo[n];
2915 
2916  /*
2917  * If a worker hasn't processed any sort groups at all, then
2918  * exclude it from output since it either didn't launch or didn't
2919  * contribute anything meaningful.
2920  */
2921  fullsortGroupInfo = &incsort_info->fullsortGroupInfo;
2922 
2923  /*
2924  * Since we never have any prefix groups unless we've first sorted
2925  * a full groups and transitioned modes (copying the tuples into a
2926  * prefix group), we don't need to do anything if there were 0
2927  * full groups.
2928  */
2929  if (fullsortGroupInfo->groupCount == 0)
2930  continue;
2931 
2932  if (es->workers_state)
2933  ExplainOpenWorker(n, es);
2934 
2935  indent_first_line = es->workers_state == NULL || es->verbose;
2936  show_incremental_sort_group_info(fullsortGroupInfo, "Full-sort",
2937  indent_first_line, es);
2938  prefixsortGroupInfo = &incsort_info->prefixsortGroupInfo;
2939  if (prefixsortGroupInfo->groupCount > 0)
2940  {
2941  if (es->format == EXPLAIN_FORMAT_TEXT)
2942  appendStringInfo(es->str, "\n");
2943  show_incremental_sort_group_info(prefixsortGroupInfo, "Pre-sorted", true, es);
2944  }
2945  if (es->format == EXPLAIN_FORMAT_TEXT)
2946  appendStringInfo(es->str, "\n");
2947 
2948  if (es->workers_state)
2949  ExplainCloseWorker(n, es);
2950  }
2951  }
2952 }
2953 
2954 /*
2955  * Show information on hash buckets/batches.
2956  */
2957 static void
2958 show_hash_info(HashState *hashstate, ExplainState *es)
2959 {
2960  HashInstrumentation hinstrument = {0};
2961 
2962  /*
2963  * Collect stats from the local process, even when it's a parallel query.
2964  * In a parallel query, the leader process may or may not have run the
2965  * hash join, and even if it did it may not have built a hash table due to
2966  * timing (if it started late it might have seen no tuples in the outer
2967  * relation and skipped building the hash table). Therefore we have to be
2968  * prepared to get instrumentation data from all participants.
2969  */
2970  if (hashstate->hinstrument)
2971  memcpy(&hinstrument, hashstate->hinstrument,
2972  sizeof(HashInstrumentation));
2973 
2974  /*
2975  * Merge results from workers. In the parallel-oblivious case, the
2976  * results from all participants should be identical, except where
2977  * participants didn't run the join at all so have no data. In the
2978  * parallel-aware case, we need to consider all the results. Each worker
2979  * may have seen a different subset of batches and we want to report the
2980  * highest memory usage across all batches. We take the maxima of other
2981  * values too, for the same reasons as in ExecHashAccumInstrumentation.
2982  */
2983  if (hashstate->shared_info)
2984  {
2985  SharedHashInfo *shared_info = hashstate->shared_info;
2986  int i;
2987 
2988  for (i = 0; i < shared_info->num_workers; ++i)
2989  {
2990  HashInstrumentation *worker_hi = &shared_info->hinstrument[i];
2991 
2992  hinstrument.nbuckets = Max(hinstrument.nbuckets,
2993  worker_hi->nbuckets);
2994  hinstrument.nbuckets_original = Max(hinstrument.nbuckets_original,
2995  worker_hi->nbuckets_original);
2996  hinstrument.nbatch = Max(hinstrument.nbatch,
2997  worker_hi->nbatch);
2998  hinstrument.nbatch_original = Max(hinstrument.nbatch_original,
2999  worker_hi->nbatch_original);
3000  hinstrument.space_peak = Max(hinstrument.space_peak,
3001  worker_hi->space_peak);
3002  }
3003  }
3004 
3005  if (hinstrument.nbatch > 0)
3006  {
3007  long spacePeakKb = (hinstrument.space_peak + 1023) / 1024;
3008 
3009  if (es->format != EXPLAIN_FORMAT_TEXT)
3010  {
3011  ExplainPropertyInteger("Hash Buckets", NULL,
3012  hinstrument.nbuckets, es);
3013  ExplainPropertyInteger("Original Hash Buckets", NULL,
3014  hinstrument.nbuckets_original, es);
3015  ExplainPropertyInteger("Hash Batches", NULL,
3016  hinstrument.nbatch, es);
3017  ExplainPropertyInteger("Original Hash Batches", NULL,
3018  hinstrument.nbatch_original, es);
3019  ExplainPropertyInteger("Peak Memory Usage", "kB",
3020  spacePeakKb, es);
3021  }
3022  else if (hinstrument.nbatch_original != hinstrument.nbatch ||
3023  hinstrument.nbuckets_original != hinstrument.nbuckets)
3024  {
3025  ExplainIndentText(es);
3026  appendStringInfo(es->str,
3027  "Buckets: %d (originally %d) Batches: %d (originally %d) Memory Usage: %ldkB\n",
3028  hinstrument.nbuckets,
3029  hinstrument.nbuckets_original,
3030  hinstrument.nbatch,
3031  hinstrument.nbatch_original,
3032  spacePeakKb);
3033  }
3034  else
3035  {
3036  ExplainIndentText(es);
3037  appendStringInfo(es->str,
3038  "Buckets: %d Batches: %d Memory Usage: %ldkB\n",
3039  hinstrument.nbuckets, hinstrument.nbatch,
3040  spacePeakKb);
3041  }
3042  }
3043 }
3044 
3045 /*
3046  * Show information on hash aggregate memory usage and batches.
3047  */
3048 static void
3049 show_hashagg_info(AggState *aggstate, ExplainState *es)
3050 {
3051  Agg *agg = (Agg *) aggstate->ss.ps.plan;
3052  int64 memPeakKb = (aggstate->hash_mem_peak + 1023) / 1024;
3053 
3054  Assert(IsA(aggstate, AggState));
3055 
3056  if (agg->aggstrategy != AGG_HASHED &&
3057  agg->aggstrategy != AGG_MIXED)
3058  return;
3059 
3060  if (es->costs && aggstate->hash_planned_partitions > 0)
3061  {
3062  ExplainPropertyInteger("Planned Partitions", NULL,
3063  aggstate->hash_planned_partitions, es);
3064  }
3065 
3066  if (!es->analyze)
3067  return;
3068 
3069  /* EXPLAIN ANALYZE */
3070  ExplainPropertyInteger("Peak Memory Usage", "kB", memPeakKb, es);
3071  if (aggstate->hash_batches_used > 0)
3072  {
3073  ExplainPropertyInteger("Disk Usage", "kB",
3074  aggstate->hash_disk_used, es);
3075  ExplainPropertyInteger("HashAgg Batches", NULL,
3076  aggstate->hash_batches_used, es);
3077  }
3078 }
3079 
3080 /*
3081  * If it's EXPLAIN ANALYZE, show exact/lossy pages for a BitmapHeapScan node
3082  */
3083 static void
3084 show_tidbitmap_info(BitmapHeapScanState *planstate, ExplainState *es)
3085 {
3086  if (es->format != EXPLAIN_FORMAT_TEXT)
3087  {
3088  ExplainPropertyInteger("Exact Heap Blocks", NULL,
3089  planstate->exact_pages, es);
3090  ExplainPropertyInteger("Lossy Heap Blocks", NULL,
3091  planstate->lossy_pages, es);
3092  }
3093  else
3094  {
3095  if (planstate->exact_pages > 0 || planstate->lossy_pages > 0)
3096  {
3097  ExplainIndentText(es);
3098  appendStringInfoString(es->str, "Heap Blocks:");
3099  if (planstate->exact_pages > 0)
3100  appendStringInfo(es->str, " exact=%ld", planstate->exact_pages);
3101  if (planstate->lossy_pages > 0)
3102  appendStringInfo(es->str, " lossy=%ld", planstate->lossy_pages);
3103  appendStringInfoChar(es->str, '\n');
3104  }
3105  }
3106 }
3107 
3108 /*
3109  * If it's EXPLAIN ANALYZE, show instrumentation information for a plan node
3110  *
3111  * "which" identifies which instrumentation counter to print
3112  */
3113 static void
3114 show_instrumentation_count(const char *qlabel, int which,
3115  PlanState *planstate, ExplainState *es)
3116 {
3117  double nfiltered;
3118  double nloops;
3119 
3120  if (!es->analyze || !planstate->instrument)
3121  return;
3122 
3123  if (which == 2)
3124  nfiltered = planstate->instrument->nfiltered2;
3125  else
3126  nfiltered = planstate->instrument->nfiltered1;
3127  nloops = planstate->instrument->nloops;
3128 
3129  /* In text mode, suppress zero counts; they're not interesting enough */
3130  if (nfiltered > 0 || es->format != EXPLAIN_FORMAT_TEXT)
3131  {
3132  if (nloops > 0)
3133  ExplainPropertyFloat(qlabel, NULL, nfiltered / nloops, 0, es);
3134  else
3135  ExplainPropertyFloat(qlabel, NULL, 0.0, 0, es);
3136  }
3137 }
3138 
3139 /*
3140  * Show extra information for a ForeignScan node.
3141  */
3142 static void
3143 show_foreignscan_info(ForeignScanState *fsstate, ExplainState *es)
3144 {
3145  FdwRoutine *fdwroutine = fsstate->fdwroutine;
3146 
3147  /* Let the FDW emit whatever fields it wants */
3148  if (((ForeignScan *) fsstate->ss.ps.plan)->operation != CMD_SELECT)
3149  {
3150  if (fdwroutine->ExplainDirectModify != NULL)
3151  fdwroutine->ExplainDirectModify(fsstate, es);
3152  }
3153  else
3154  {
3155  if (fdwroutine->ExplainForeignScan != NULL)
3156  fdwroutine->ExplainForeignScan(fsstate, es);
3157  }
3158 }
3159 
3160 /*
3161  * Show initplan params evaluated at Gather or Gather Merge node.
3162  */
3163 static void
3164 show_eval_params(Bitmapset *bms_params, ExplainState *es)
3165 {
3166  int paramid = -1;
3167  List *params = NIL;
3168 
3169  Assert(bms_params);
3170 
3171  while ((paramid = bms_next_member(bms_params, paramid)) >= 0)
3172  {
3173  char param[32];
3174 
3175  snprintf(param, sizeof(param), "$%d", paramid);
3176  params = lappend(params, pstrdup(param));
3177  }
3178 
3179  if (params)
3180  ExplainPropertyList("Params Evaluated", params, es);
3181 }
3182 
3183 /*
3184  * Fetch the name of an index in an EXPLAIN
3185  *
3186  * We allow plugins to get control here so that plans involving hypothetical
3187  * indexes can be explained.
3188  */
3189 static const char *
3190 explain_get_index_name(Oid indexId)
3191 {
3192  const char *result;
3193 
3194  if (explain_get_index_name_hook)
3195  result = (*explain_get_index_name_hook) (indexId);
3196  else
3197  result = NULL;
3198  if (result == NULL)
3199  {
3200  /* default behavior: look in the catalogs and quote it */
3201  result = get_rel_name(indexId);
3202  if (result == NULL)
3203  elog(ERROR, "cache lookup failed for index %u", indexId);
3204  result = quote_identifier(result);
3205  }
3206  return result;
3207 }
3208 
3209 /*
3210  * Show buffer usage details.
3211  */
3212 static void
3213 show_buffer_usage(ExplainState *es, const BufferUsage *usage)
3214 {
3215  if (es->format == EXPLAIN_FORMAT_TEXT)
3216  {
3217  bool has_shared = (usage->shared_blks_hit > 0 ||
3218  usage->shared_blks_read > 0 ||
3219  usage->shared_blks_dirtied > 0 ||
3220  usage->shared_blks_written > 0);
3221  bool has_local = (usage->local_blks_hit > 0 ||
3222  usage->local_blks_read > 0 ||
3223  usage->local_blks_dirtied > 0 ||
3224  usage->local_blks_written > 0);
3225  bool has_temp = (usage->temp_blks_read > 0 ||
3226  usage->temp_blks_written > 0);
3227  bool has_timing = (!INSTR_TIME_IS_ZERO(usage->blk_read_time) ||
3228  !INSTR_TIME_IS_ZERO(usage->blk_write_time));
3229 
3230  /* Show only positive counter values. */
3231  if (has_shared || has_local || has_temp)
3232  {
3233  ExplainIndentText(es);
3234  appendStringInfoString(es->str, "Buffers:");
3235 
3236  if (has_shared)
3237  {
3238  appendStringInfoString(es->str, " shared");
3239  if (usage->shared_blks_hit > 0)
3240  appendStringInfo(es->str, " hit=%ld",
3241  usage->shared_blks_hit);
3242  if (usage->shared_blks_read > 0)
3243  appendStringInfo(es->str, " read=%ld",
3244  usage->shared_blks_read);
3245  if (usage->shared_blks_dirtied > 0)
3246  appendStringInfo(es->str, " dirtied=%ld",
3247  usage->shared_blks_dirtied);
3248  if (usage->shared_blks_written > 0)
3249  appendStringInfo(es->str, " written=%ld",
3250  usage->shared_blks_written);
3251  if (has_local || has_temp)
3252  appendStringInfoChar(es->str, ',');
3253  }
3254  if (has_local)
3255  {
3256  appendStringInfoString(es->str, " local");
3257  if (usage->local_blks_hit > 0)
3258  appendStringInfo(es->str, " hit=%ld",
3259  usage->local_blks_hit);
3260  if (usage->local_blks_read > 0)
3261  appendStringInfo(es->str, " read=%ld",
3262  usage->local_blks_read);
3263  if (usage->local_blks_dirtied > 0)
3264  appendStringInfo(es->str, " dirtied=%ld",
3265  usage->local_blks_dirtied);
3266  if (usage->local_blks_written > 0)
3267  appendStringInfo(es->str, " written=%ld",
3268  usage->local_blks_written);
3269  if (has_temp)
3270  appendStringInfoChar(es->str, ',');
3271  }
3272  if (has_temp)
3273  {
3274  appendStringInfoString(es->str, " temp");
3275  if (usage->temp_blks_read > 0)
3276  appendStringInfo(es->str, " read=%ld",
3277  usage->temp_blks_read);
3278  if (usage->temp_blks_written > 0)
3279  appendStringInfo(es->str, " written=%ld",
3280  usage->temp_blks_written);
3281  }
3282  appendStringInfoChar(es->str, '\n');
3283  }
3284 
3285  /* As above, show only positive counter values. */
3286  if (has_timing)
3287  {
3288  ExplainIndentText(es);
3289  appendStringInfoString(es->str, "I/O Timings:");
3290  if (!INSTR_TIME_IS_ZERO(usage->blk_read_time))
3291  appendStringInfo(es->str, " read=%0.3f",
3292  INSTR_TIME_GET_MILLISEC(usage->blk_read_time));
3293  if (!INSTR_TIME_IS_ZERO(usage->blk_write_time))
3294  appendStringInfo(es->str, " write=%0.3f",
3295  INSTR_TIME_GET_MILLISEC(usage->blk_write_time));
3296  appendStringInfoChar(es->str, '\n');
3297  }
3298  }
3299  else
3300  {
3301  ExplainPropertyInteger("Shared Hit Blocks", NULL,
3302  usage->shared_blks_hit, es);
3303  ExplainPropertyInteger("Shared Read Blocks", NULL,
3304  usage->shared_blks_read, es);
3305  ExplainPropertyInteger("Shared Dirtied Blocks", NULL,
3306  usage->shared_blks_dirtied, es);
3307  ExplainPropertyInteger("Shared Written Blocks", NULL,
3308  usage->shared_blks_written, es);
3309  ExplainPropertyInteger("Local Hit Blocks", NULL,
3310  usage->local_blks_hit, es);
3311  ExplainPropertyInteger("Local Read Blocks", NULL,
3312  usage->local_blks_read, es);
3313  ExplainPropertyInteger("Local Dirtied Blocks", NULL,
3314  usage->local_blks_dirtied, es);
3315  ExplainPropertyInteger("Local Written Blocks", NULL,
3316  usage->local_blks_written, es);
3317  ExplainPropertyInteger("Temp Read Blocks", NULL,
3318  usage->temp_blks_read, es);
3319  ExplainPropertyInteger("Temp Written Blocks", NULL,
3320  usage->temp_blks_written, es);
3321  if (track_io_timing)
3322  {
3323  ExplainPropertyFloat("I/O Read Time", "ms",
3324  INSTR_TIME_GET_MILLISEC(usage->blk_read_time),
3325  3, es);
3326  ExplainPropertyFloat("I/O Write Time", "ms",
3327  INSTR_TIME_GET_MILLISEC(usage->blk_write_time),
3328  3, es);
3329  }
3330  }
3331 }
3332 
3333 /*
3334  * Show WAL usage details.
3335  */
3336 static void
3337 show_wal_usage(ExplainState *es, const WalUsage *usage)
3338 {
3339  if (es->format == EXPLAIN_FORMAT_TEXT)
3340  {
3341  /* Show only positive counter values. */
3342  if ((usage->wal_records > 0) || (usage->wal_fpi > 0) ||
3343  (usage->wal_bytes > 0))
3344  {
3345  ExplainIndentText(es);
3346  appendStringInfoString(es->str, "WAL:");
3347 
3348  if (usage->wal_records > 0)
3349  appendStringInfo(es->str, " records=%ld",
3350  usage->wal_records);
3351  if (usage->wal_fpi > 0)
3352  appendStringInfo(es->str, " fpi=%ld",
3353  usage->wal_fpi);
3354  if (usage->wal_bytes > 0)
3355  appendStringInfo(es->str, " bytes=" UINT64_FORMAT,
3356  usage->wal_bytes);
3357  appendStringInfoChar(es->str, '\n');
3358  }
3359  }
3360  else
3361  {
3362  ExplainPropertyInteger("WAL Records", NULL,
3363  usage->wal_records, es);
3364  ExplainPropertyInteger("WAL FPI", NULL,
3365  usage->wal_fpi, es);
3366  ExplainPropertyUInteger("WAL Bytes", NULL,
3367  usage->wal_bytes, es);
3368  }
3369 }
3370 
3371 /*
3372  * Add some additional details about an IndexScan or IndexOnlyScan
3373  */
3374 static void
3375 ExplainIndexScanDetails(Oid indexid, ScanDirection indexorderdir,
3376  ExplainState *es)
3377 {
3378  const char *indexname = explain_get_index_name(indexid);
3379 
3380  if (es->format == EXPLAIN_FORMAT_TEXT)
3381  {
3382  if (ScanDirectionIsBackward(indexorderdir))
3383  appendStringInfoString(es->str, " Backward");
3384  appendStringInfo(es->str, " using %s", indexname);
3385  }
3386  else
3387  {
3388  const char *scandir;
3389 
3390  switch (indexorderdir)
3391  {
3392  case BackwardScanDirection:
3393  scandir = "Backward";
3394  break;
3395  case NoMovementScanDirection:
3396  scandir = "NoMovement";
3397  break;
3398  case ForwardScanDirection:
3399  scandir = "Forward";
3400  break;
3401  default:
3402  scandir = "???";
3403  break;
3404  }
3405  ExplainPropertyText("Scan Direction", scandir, es);
3406  ExplainPropertyText("Index Name", indexname, es);
3407  }
3408 }
3409 
3410 /*
3411  * Show the target of a Scan node
3412  */
3413 static void
3414 ExplainScanTarget(Scan *plan, ExplainState *es)
3415 {
3416  ExplainTargetRel((Plan *) plan, plan->scanrelid, es);
3417 }
3418 
3419 /*
3420  * Show the target of a ModifyTable node
3421  *
3422  * Here we show the nominal target (ie, the relation that was named in the
3423  * original query). If the actual target(s) is/are different, we'll show them
3424  * in show_modifytable_info().
3425  */
3426 static void
3427 ExplainModifyTarget(ModifyTable *plan, ExplainState *es)
3428 {
3429  ExplainTargetRel((Plan *) plan, plan->nominalRelation, es);
3430 }
3431 
3432 /*
3433  * Show the target relation of a scan or modify node
3434  */
3435 static void
3436 ExplainTargetRel(Plan *plan, Index rti, ExplainState *es)
3437 {
3438  char *objectname = NULL;
3439  char *namespace = NULL;
3440  const char *objecttag = NULL;
3441  RangeTblEntry *rte;
3442  char *refname;
3443 
3444  rte = rt_fetch(rti, es->rtable);
3445  refname = (char *) list_nth(es->rtable_names, rti - 1);
3446  if (refname == NULL)
3447  refname = rte->eref->aliasname;
3448 
3449  switch (nodeTag(plan))
3450  {
3451  case T_SeqScan:
3452  case T_SampleScan:
3453  case T_IndexScan:
3454  case T_IndexOnlyScan:
3455  case T_BitmapHeapScan:
3456  case T_TidScan:
3457  case T_ForeignScan:
3458  case T_CustomScan:
3459  case T_ModifyTable:
3460  /* Assert it's on a real relation */
3461  Assert(rte->rtekind == RTE_RELATION);
3462  objectname = get_rel_name(rte->relid);
3463  if (es->verbose)
3464  namespace = get_namespace_name(get_rel_namespace(rte->relid));
3465  objecttag = "Relation Name";
3466  break;
3467  case T_FunctionScan:
3468  {
3469  FunctionScan *fscan = (FunctionScan *) plan;
3470 
3471  /* Assert it's on a RangeFunction */
3472  Assert(rte->rtekind == RTE_FUNCTION);
3473 
3474  /*
3475  * If the expression is still a function call of a single
3476  * function, we can get the real name of the function.
3477  * Otherwise, punt. (Even if it was a single function call
3478  * originally, the optimizer could have simplified it away.)
3479  */
3480  if (list_length(fscan->functions) == 1)
3481  {
3482  RangeTblFunction *rtfunc = (RangeTblFunction *) linitial(fscan->functions);
3483 
3484  if (IsA(rtfunc->funcexpr, FuncExpr))
3485  {
3486  FuncExpr *funcexpr = (FuncExpr *) rtfunc->funcexpr;
3487  Oid funcid = funcexpr->funcid;
3488 
3489  objectname = get_func_name(funcid);
3490  if (es->verbose)
3491  namespace =
3492  get_namespace_name(get_func_namespace(funcid));
3493  }
3494  }
3495  objecttag = "Function Name";
3496  }
3497  break;
3498  case T_TableFuncScan:
3499  Assert(rte->rtekind == RTE_TABLEFUNC);
3500  objectname = "xmltable";
3501  objecttag = "Table Function Name";
3502  break;
3503  case T_ValuesScan:
3504  Assert(rte->rtekind == RTE_VALUES);
3505  break;
3506  case T_CteScan:
3507  /* Assert it's on a non-self-reference CTE */
3508  Assert(rte->rtekind == RTE_CTE);
3509  Assert(!rte->self_reference);
3510  objectname = rte->ctename;
3511  objecttag = "CTE Name";
3512  break;
3513  case T_NamedTuplestoreScan:
3514  Assert(rte->rtekind == RTE_NAMEDTUPLESTORE);
3515  objectname = rte->enrname;
3516  objecttag = "Tuplestore Name";
3517  break;
3518  case T_WorkTableScan:
3519  /* Assert it's on a self-reference CTE */
3520  Assert(rte->rtekind == RTE_CTE);
3521  Assert(rte->self_reference);
3522  objectname = rte->ctename;
3523  objecttag = "CTE Name";
3524  break;
3525  default:
3526  break;
3527  }
3528 
3529  if (es->format == EXPLAIN_FORMAT_TEXT)
3530  {
3531  appendStringInfoString(es->str, " on");
3532  if (namespace != NULL)
3533  appendStringInfo(es->str, " %s.%s", quote_identifier(namespace),
3534  quote_identifier(objectname));
3535  else if (objectname != NULL)
3536  appendStringInfo(es->str, " %s", quote_identifier(objectname));
3537  if (objectname == NULL || strcmp(refname, objectname) != 0)
3538  appendStringInfo(es->str, " %s", quote_identifier(refname));
3539  }
3540  else
3541  {
3542  if (objecttag != NULL && objectname != NULL)
3543  ExplainPropertyText(objecttag, objectname, es);
3544  if (namespace != NULL)
3545  ExplainPropertyText("Schema", namespace, es);
3546  ExplainPropertyText("Alias", refname, es);
3547  }
3548 }
3549 
3550 /*
3551  * Show extra information for a ModifyTable node
3552  *
3553  * We have three objectives here. First, if there's more than one target
3554  * table or it's different from the nominal target, identify the actual
3555  * target(s). Second, give FDWs a chance to display extra info about foreign
3556  * targets. Third, show information about ON CONFLICT.
3557  */
3558 static void
3559 show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
3560  ExplainState *es)
3561 {
3562  ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
3563  const char *operation;
3564  const char *foperation;
3565  bool labeltargets;
3566  int j;
3567  List *idxNames = NIL;
3568  ListCell *lst;
3569 
3570  switch (node->operation)
3571  {
3572  case CMD_INSERT:
3573  operation = "Insert";
3574  foperation = "Foreign Insert";
3575  break;
3576  case CMD_UPDATE:
3577  operation = "Update";
3578  foperation = "Foreign Update";
3579  break;
3580  case CMD_DELETE:
3581  operation = "Delete";
3582  foperation = "Foreign Delete";
3583  break;
3584  default:
3585  operation = "???";
3586  foperation = "Foreign ???";
3587  break;
3588  }
3589 
3590  /* Should we explicitly label target relations? */
3591  labeltargets = (mtstate->mt_nplans > 1 ||
3592  (mtstate->mt_nplans == 1 &&
3593  mtstate->resultRelInfo->ri_RangeTableIndex != node->nominalRelation));
3594 
3595  if (labeltargets)
3596  ExplainOpenGroup("Target Tables", "Target Tables", false, es);
3597 
3598  for (j = 0; j < mtstate->mt_nplans; j++)
3599  {
3600  ResultRelInfo *resultRelInfo = mtstate->resultRelInfo + j;
3601  FdwRoutine *fdwroutine = resultRelInfo->ri_FdwRoutine;
3602 
3603  if (labeltargets)
3604  {
3605  /* Open a group for this target */
3606  ExplainOpenGroup("Target Table", NULL, true, es);
3607 
3608  /*
3609  * In text mode, decorate each target with operation type, so that
3610  * ExplainTargetRel's output of " on foo" will read nicely.
3611  */
3612  if (es->format == EXPLAIN_FORMAT_TEXT)
3613  {
3614  ExplainIndentText(es);
3615  appendStringInfoString(es->str,
3616  fdwroutine ? foperation : operation);
3617  }
3618 
3619  /* Identify target */
3620  ExplainTargetRel((Plan *) node,
3621  resultRelInfo->ri_RangeTableIndex,
3622  es);
3623 
3624  if (es->format == EXPLAIN_FORMAT_TEXT)
3625  {
3626  appendStringInfoChar(es->str, '\n');
3627  es->indent++;
3628  }
3629  }
3630 
3631  /* Give FDW a chance if needed */
3632  if (!resultRelInfo->ri_usesFdwDirectModify &&
3633  fdwroutine != NULL &&
3634  fdwroutine->ExplainForeignModify != NULL)
3635  {
3636  List *fdw_private = (List *) list_nth(node->fdwPrivLists, j);
3637 
3638  fdwroutine->ExplainForeignModify(mtstate,
3639  resultRelInfo,
3640  fdw_private,
3641  j,
3642  es);
3643  }
3644 
3645  if (labeltargets)
3646  {
3647  /* Undo the indentation we added in text format */
3648  if (es->format == EXPLAIN_FORMAT_TEXT)
3649  es->indent--;
3650 
3651  /* Close the group */
3652  ExplainCloseGroup("Target Table", NULL, true, es);
3653  }
3654  }
3655 
3656  /* Gather names of ON CONFLICT arbiter indexes */
3657  foreach(lst, node->arbiterIndexes)
3658  {
3659  char *indexname = get_rel_name(lfirst_oid(lst));
3660 
3661  idxNames = lappend(idxNames, indexname);
3662  }
3663 
3664  if (node->onConflictAction != ONCONFLICT_NONE)
3665  {
3666  ExplainPropertyText("Conflict Resolution",
3667  node->onConflictAction == ONCONFLICT_NOTHING ?
3668  "NOTHING" : "UPDATE",
3669  es);
3670 
3671  /*
3672  * Don't display arbiter indexes at all when DO NOTHING variant
3673  * implicitly ignores all conflicts
3674  */
3675  if (idxNames)
3676  ExplainPropertyList("Conflict Arbiter Indexes", idxNames, es);
3677 
3678  /* ON CONFLICT DO UPDATE WHERE qual is specially displayed */
3679  if (node->onConflictWhere)
3680  {
3681  show_upper_qual((List *) node->onConflictWhere, "Conflict Filter",
3682  &mtstate->ps, ancestors, es);
3683  show_instrumentation_count("Rows Removed by Conflict Filter", 1, &mtstate->ps, es);
3684  }
3685 
3686  /* EXPLAIN ANALYZE display of actual outcome for each tuple proposed */
3687  if (es->analyze && mtstate->ps.instrument)
3688  {
3689  double total;
3690  double insert_path;
3691  double other_path;
3692 
3693  InstrEndLoop(mtstate->mt_plans[0]->instrument);
3694 
3695  /* count the number of source rows */
3696  total = mtstate->mt_plans[0]->instrument->ntuples;
3697  other_path = mtstate->ps.instrument->ntuples2;
3698  insert_path = total - other_path;
3699 
3700  ExplainPropertyFloat("Tuples Inserted", NULL,
3701  insert_path, 0, es);
3702  ExplainPropertyFloat("Conflicting Tuples", NULL,
3703  other_path, 0, es);
3704  }
3705  }
3706 
3707  if (labeltargets)
3708  ExplainCloseGroup("Target Tables", "Target Tables", false, es);
3709 }
3710 
3711 /*
3712  * Explain the constituent plans of a ModifyTable, Append, MergeAppend,
3713  * BitmapAnd, or BitmapOr node.
3714  *
3715  * The ancestors list should already contain the immediate parent of these
3716  * plans.
3717  */
3718 static void
3719 ExplainMemberNodes(PlanState **planstates, int nplans,
3720  List *ancestors, ExplainState *es)
3721 {
3722  int j;
3723 
3724  for (j = 0; j < nplans; j++)
3725  ExplainNode(planstates[j], ancestors,
3726  "Member", NULL, es);
3727 }
3728 
3729 /*
3730  * Report about any pruned subnodes of an Append or MergeAppend node.
3731  *
3732  * nplans indicates the number of live subplans.
3733  * nchildren indicates the original number of subnodes in the Plan;
3734  * some of these may have been pruned by the run-time pruning code.
3735  */
3736 static void
3737 ExplainMissingMembers(int nplans, int nchildren, ExplainState *es)
3738 {
3739  if (nplans < nchildren || es->format != EXPLAIN_FORMAT_TEXT)
3740  ExplainPropertyInteger("Subplans Removed", NULL,
3741  nchildren - nplans, es);
3742 }
3743 
3744 /*
3745  * Explain a list of SubPlans (or initPlans, which also use SubPlan nodes).
3746  *
3747  * The ancestors list should already contain the immediate parent of these
3748  * SubPlans.
3749  */
3750 static void
3751 ExplainSubPlans(List *plans, List *ancestors,
3752  const char *relationship, ExplainState *es)
3753 {
3754  ListCell *lst;
3755 
3756  foreach(lst, plans)
3757  {
3758  SubPlanState *sps = (SubPlanState *) lfirst(lst);
3759  SubPlan *sp = sps->subplan;
3760 
3761  /*
3762  * There can be multiple SubPlan nodes referencing the same physical
3763  * subplan (same plan_id, which is its index in PlannedStmt.subplans).
3764  * We should print a subplan only once, so track which ones we already
3765  * printed. This state must be global across the plan tree, since the
3766  * duplicate nodes could be in different plan nodes, eg both a bitmap
3767  * indexscan's indexqual and its parent heapscan's recheck qual. (We
3768  * do not worry too much about which plan node we show the subplan as
3769  * attached to in such cases.)
3770  */
3771  if (bms_is_member(sp->plan_id, es->printed_subplans))
3772  continue;
3773  es->printed_subplans = bms_add_member(es->printed_subplans,
3774  sp->plan_id);
3775 
3776  /*
3777  * Treat the SubPlan node as an ancestor of the plan node(s) within
3778  * it, so that ruleutils.c can find the referents of subplan
3779  * parameters.
3780  */
3781  ancestors = lcons(sp, ancestors);
3782 
3783  ExplainNode(sps->planstate, ancestors,
3784  relationship, sp->plan_name, es);
3785 
3786  ancestors = list_delete_first(ancestors);
3787  }
3788 }
3789 
3790 /*
3791  * Explain a list of children of a CustomScan.
3792  */
3793 static void
3794 ExplainCustomChildren(CustomScanState *css, List *ancestors, ExplainState *es)
3795 {
3796  ListCell *cell;
3797  const char *label =
3798  (list_length(css->custom_ps) != 1 ? "children" : "child");
3799 
3800  foreach(cell, css->custom_ps)
3801  ExplainNode((PlanState *) lfirst(cell), ancestors, label, NULL, es);
3802 }
3803 
3804 /*
3805  * Create a per-plan-node workspace for collecting per-worker data.
3806  *
3807  * Output related to each worker will be temporarily "set aside" into a
3808  * separate buffer, which we'll merge into the main output stream once
3809  * we've processed all data for the plan node. This makes it feasible to
3810  * generate a coherent sub-group of fields for each worker, even though the
3811  * code that produces the fields is in several different places in this file.
3812  * Formatting of such a set-aside field group is managed by
3813  * ExplainOpenSetAsideGroup and ExplainSaveGroup/ExplainRestoreGroup.
3814  */
3815 static ExplainWorkersState *
3816 ExplainCreateWorkersState(int num_workers)
3817 {
3818  ExplainWorkersState *wstate;
3819 
3820  wstate = (ExplainWorkersState *) palloc(sizeof(ExplainWorkersState));
3821  wstate->num_workers = num_workers;
3822  wstate->worker_inited = (bool *) palloc0(num_workers * sizeof(bool));
3823  wstate->worker_str = (StringInfoData *)
3824  palloc0(num_workers * sizeof(StringInfoData));
3825  wstate->worker_state_save = (int *) palloc(num_workers * sizeof(int));
3826  return wstate;
3827 }
3828 
3829 /*
3830  * Begin or resume output into the set-aside group for worker N.
3831  */
3832 static void
3833 ExplainOpenWorker(int n, ExplainState *es)
3834 {
3835  ExplainWorkersState *wstate = es->workers_state;
3836 
3837  Assert(wstate);
3838  Assert(n >= 0 && n < wstate->num_workers);
3839 
3840  /* Save prior output buffer pointer */
3841  wstate->prev_str = es->str;
3842 
3843  if (!wstate->worker_inited[n])
3844  {
3845  /* First time through, so create the buffer for this worker */
3846  initStringInfo(&wstate->worker_str[n]);
3847  es->str = &wstate->worker_str[n];
3848 
3849  /*
3850  * Push suitable initial formatting state for this worker's field
3851  * group. We allow one extra logical nesting level, since this group
3852  * will eventually be wrapped in an outer "Workers" group.
3853  */
3854  ExplainOpenSetAsideGroup("Worker", NULL, true, 2, es);
3855 
3856  /*
3857  * In non-TEXT formats we always emit a "Worker Number" field, even if
3858  * there's no other data for this worker.
3859  */
3860  if (es->format != EXPLAIN_FORMAT_TEXT)
3861  ExplainPropertyInteger("Worker Number", NULL, n, es);
3862 
3863  wstate->worker_inited[n] = true;
3864  }
3865  else
3866  {
3867  /* Resuming output for a worker we've already emitted some data for */
3868  es->str = &wstate->worker_str[n];
3869 
3870  /* Restore formatting state saved by last ExplainCloseWorker() */
3871  ExplainRestoreGroup(es, 2, &wstate->worker_state_save[n]);
3872  }
3873 
3874  /*
3875  * In TEXT format, prefix the first output line for this worker with
3876  * "Worker N:". Then, any additional lines should be indented one more
3877  * stop than the "Worker N" line is.
3878  */
3879  if (es->format == EXPLAIN_FORMAT_TEXT)
3880  {
3881  if (es->str->len == 0)
3882  {
3883  ExplainIndentText(es);
3884  appendStringInfo(es->str, "Worker %d: ", n);
3885  }
3886 
3887  es->indent++;
3888  }
3889 }
3890 
3891 /*
3892  * End output for worker N --- must pair with previous ExplainOpenWorker call
3893  */
3894 static void
3895 ExplainCloseWorker(int n, ExplainState *es)
3896 {
3897  ExplainWorkersState *wstate = es->workers_state;
3898 
3899  Assert(wstate);
3900  Assert(n >= 0 && n < wstate->num_workers);
3901  Assert(wstate->worker_inited[n]);
3902 
3903  /*
3904  * Save formatting state in case we do another ExplainOpenWorker(), then
3905  * pop the formatting stack.
3906  */
3907  ExplainSaveGroup(es, 2, &wstate->worker_state_save[n]);
3908 
3909  /*
3910  * In TEXT format, if we didn't actually produce any output line(s) then
3911  * truncate off the partial line emitted by ExplainOpenWorker. (This is
3912  * to avoid bogus output if, say, show_buffer_usage chooses not to print
3913  * anything for the worker.) Also fix up the indent level.
3914  */
3915  if (es->format == EXPLAIN_FORMAT_TEXT)
3916  {
3917  while (es->str->len > 0 && es->str->data[es->str->len - 1] != '\n')
3918  es->str->data[--(es->str->len)] = '\0';
3919 
3920  es->indent--;
3921  }
3922 
3923  /* Restore prior output buffer pointer */
3924  es->str = wstate->prev_str;
3925 }
3926 
3927 /*
3928  * Print per-worker info for current node, then free the ExplainWorkersState.
3929  */
3930 static void
3931 ExplainFlushWorkersState(ExplainState *es)
3932 {
3933  ExplainWorkersState *wstate = es->workers_state;
3934 
3935  ExplainOpenGroup("Workers", "Workers", false, es);
3936  for (int i = 0; i < wstate->num_workers; i++)
3937  {
3938  if (wstate->worker_inited[i])
3939  {
3940  /* This must match previous ExplainOpenSetAsideGroup call */
3941  ExplainOpenGroup("Worker", NULL, true, es);
3942  appendStringInfoString(es->str, wstate->worker_str[i].data);
3943  ExplainCloseGroup("Worker", NULL, true, es);
3944 
3945  pfree(wstate->worker_str[i].data);
3946  }
3947  }
3948  ExplainCloseGroup("Workers", "Workers", false, es);
3949 
3950  pfree(wstate->worker_inited);
3951  pfree(wstate->worker_str);
3952  pfree(wstate->worker_state_save);
3953  pfree(wstate);
3954 }
3955 
3956 /*
3957  * Explain a property, such as sort keys or targets, that takes the form of
3958  * a list of unlabeled items. "data" is a list of C strings.
3959  */
3960 void
3961 ExplainPropertyList(const char *qlabel, List *data, ExplainState *es)
3962 {
3963  ListCell *lc;
3964  bool first = true;
3965 
3966  switch (es->format)
3967  {
3968  case EXPLAIN_FORMAT_TEXT:
3969  ExplainIndentText(es);
3970  appendStringInfo(es->str, "%s: ", qlabel);
3971  foreach(lc, data)
3972  {
3973  if (!first)
3974  appendStringInfoString(es->str, ", ");
3975  appendStringInfoString(es->str, (const char *) lfirst(lc));
3976  first = false;
3977  }
3978  appendStringInfoChar(es->str, '\n');
3979  break;
3980 
3981  case EXPLAIN_FORMAT_XML:
3982  ExplainXMLTag(qlabel, X_OPENING, es);
3983  foreach(lc, data)
3984  {
3985  char *str;
3986 
3987  appendStringInfoSpaces(es->str, es->indent * 2 + 2);
3988  appendStringInfoString(es->str, "<Item>");
3989  str = escape_xml((const char *) lfirst(lc));
3990  appendStringInfoString(es->str, str);
3991  pfree(str);
3992  appendStringInfoString(es->str, "</Item>\n");
3993  }
3994  ExplainXMLTag(qlabel, X_CLOSING, es);
3995  break;
3996 
3997  case EXPLAIN_FORMAT_JSON:
3998  ExplainJSONLineEnding(es);
3999  appendStringInfoSpaces(es->str, es->indent * 2);
4000  escape_json(es->str, qlabel);
4001  appendStringInfoString(es->str, ": [");
4002  foreach(lc, data)
4003  {
4004  if (!first)
4005  appendStringInfoString(es->str, ", ");
4006  escape_json(es->str, (const char *) lfirst(lc));
4007  first = false;
4008  }
4009  appendStringInfoChar(es->str, ']');
4010  break;
4011 
4012  case EXPLAIN_FORMAT_YAML:
4013  ExplainYAMLLineStarting(es);
4014  appendStringInfo(es->str, "%s: ", qlabel);
4015  foreach(lc, data)
4016  {
4017  appendStringInfoChar(es->str, '\n');
4018  appendStringInfoSpaces(es->str, es->indent * 2 + 2);
4019  appendStringInfoString(es->str, "- ");
4020  escape_yaml(es->str, (const char *) lfirst(lc));
4021  }
4022  break;
4023  }
4024 }
4025 
4026 /*
4027  * Explain a property that takes the form of a list of unlabeled items within
4028  * another list. "data" is a list of C strings.
4029  */
4030 void
4031 ExplainPropertyListNested(const char *qlabel, List *data, ExplainState *es)
4032 {
4033  ListCell *lc;
4034  bool first = true;
4035 
4036  switch (es->format)
4037  {
4038  case EXPLAIN_FORMAT_TEXT:
4039  case EXPLAIN_FORMAT_XML:
4040  ExplainPropertyList(qlabel, data, es);
4041  return;
4042 
4043  case EXPLAIN_FORMAT_JSON:
4044  ExplainJSONLineEnding(es);
4045  appendStringInfoSpaces(es->str, es->indent * 2);
4046  appendStringInfoChar(es->str, '[');
4047  foreach(lc, data)
4048  {
4049  if (!first)
4050  appendStringInfoString(es->str, ", ");
4051  escape_json(es->str, (const char *) lfirst(lc));
4052  first = false;
4053  }
4054  appendStringInfoChar(es->str, ']');
4055  break;
4056 
4057  case EXPLAIN_FORMAT_YAML:
4058  ExplainYAMLLineStarting(es);
4059  appendStringInfoString(es->str, "- [");
4060  foreach(lc, data)
4061  {
4062  if (!first)
4063  appendStringInfoString(es->str, ", ");
4064  escape_yaml(es->str, (const char *) lfirst(lc));
4065  first = false;
4066  }
4067  appendStringInfoChar(es->str, ']');
4068  break;
4069  }
4070 }
4071 
4072 /*
4073  * Explain a simple property.
4074  *
4075  * If "numeric" is true, the value is a number (or other value that
4076  * doesn't need quoting in JSON).
4077  *
4078  * If unit is non-NULL the text format will display it after the value.
4079  *
4080  * This usually should not be invoked directly, but via one of the datatype
4081  * specific routines ExplainPropertyText, ExplainPropertyInteger, etc.
4082  */
4083 static void
4084 ExplainProperty(const char *qlabel, const char *unit, const char *value,
4085  bool numeric, ExplainState *es)
4086 {
4087  switch (es->format)
4088  {
4089  case EXPLAIN_FORMAT_TEXT:
4090  ExplainIndentText(es);
4091  if (unit)
4092  appendStringInfo(es->str, "%s: %s %s\n", qlabel, value, unit);
4093  else
4094  appendStringInfo(es->str, "%s: %s\n", qlabel, value);
4095  break;
4096 
4097  case EXPLAIN_FORMAT_XML:
4098  {
4099  char *str;
4100 
4101  appendStringInfoSpaces(es->str, es->indent * 2);
4102  ExplainXMLTag(qlabel, X_OPENING | X_NOWHITESPACE, es);
4103  str = escape_xml(value);
4104  appendStringInfoString(es->str, str);
4105  pfree(str);
4106  ExplainXMLTag(qlabel, X_CLOSING | X_NOWHITESPACE, es);
4107  appendStringInfoChar(es->str, '\n');
4108  }
4109  break;
4110 
4111  case EXPLAIN_FORMAT_JSON:
4112  ExplainJSONLineEnding(es);
4113  appendStringInfoSpaces(es->str, es->indent * 2);
4114  escape_json(es->str, qlabel);
4115  appendStringInfoString(es->str, ": ");
4116  if (numeric)
4117  appendStringInfoString(es->str, value);
4118  else
4119  escape_json(es->str, value);
4120  break;
4121 
4122  case EXPLAIN_FORMAT_YAML:
4123  ExplainYAMLLineStarting(es);
4124  appendStringInfo(es->str, "%s: ", qlabel);
4125  if (numeric)
4126  appendStringInfoString(es->str, value);
4127  else
4128  escape_yaml(es->str, value);
4129  break;
4130  }
4131 }
4132 
4133 /*
4134  * Explain a string-valued property.
4135  */
4136 void
4137 ExplainPropertyText(const char *qlabel, const char *value, ExplainState *es)
4138 {
4139  ExplainProperty(qlabel, NULL, value, false, es);
4140 }
4141 
4142 /*
4143  * Explain an integer-valued property.
4144  */
4145 void
4146 ExplainPropertyInteger(const char *qlabel, const char *unit, int64 value,
4147  ExplainState *es)
4148 {
4149  char buf[32];
4150 
4151  snprintf(buf, sizeof(buf), INT64_FORMAT, value);
4152  ExplainProperty(qlabel, unit, buf, true, es);
4153 }
4154 
4155 /*
4156  * Explain an unsigned integer-valued property.
4157  */
4158 void
4159 ExplainPropertyUInteger(const char *qlabel, const char *unit, uint64 value,
4160  ExplainState *es)
4161 {
4162  char buf[32];
4163 
4164  snprintf(buf, sizeof(buf), UINT64_FORMAT, value);
4165  ExplainProperty(qlabel, unit, buf, true, es);
4166 }
4167 
4168 /*
4169  * Explain a float-valued property, using the specified number of
4170  * fractional digits.
4171  */
4172 void
4173 ExplainPropertyFloat(const char *qlabel, const char *unit, double value,
4174  int ndigits, ExplainState *es)
4175 {
4176  char *buf;
4177 
4178  buf = psprintf("%.*f", ndigits, value);
4179  ExplainProperty(qlabel, unit, buf, true, es);
4180  pfree(buf);
4181 }
4182 
4183 /*
4184  * Explain a bool-valued property.
4185  */
4186 void
4187 ExplainPropertyBool(const char *qlabel, bool value, ExplainState *es)
4188 {
4189  ExplainProperty(qlabel, NULL, value ? "true" : "false", true, es);
4190 }
4191 
4192 /*
4193  * Open a group of related objects.
4194  *
4195  * objtype is the type of the group object, labelname is its label within
4196  * a containing object (if any).
4197  *
4198  * If labeled is true, the group members will be labeled properties,
4199  * while if it's false, they'll be unlabeled objects.
4200  */
4201 void
4202 ExplainOpenGroup(const char *objtype, const char *labelname,
4203  bool labeled, ExplainState *es)
4204 {
4205  switch (es->format)
4206  {
4207  case EXPLAIN_FORMAT_TEXT:
4208  /* nothing to do */
4209  break;
4210 
4211  case EXPLAIN_FORMAT_XML:
4212  ExplainXMLTag(objtype, X_OPENING, es);
4213  es->indent++;
4214  break;
4215 
4216  case EXPLAIN_FORMAT_JSON:
4217  ExplainJSONLineEnding(es);
4218  appendStringInfoSpaces(es->str, 2 * es->indent);
4219  if (labelname)
4220  {
4221  escape_json(es->str, labelname);
4222  appendStringInfoString(es->str, ": ");
4223  }
4224  appendStringInfoChar(es->str, labeled ? '{' : '[');
4225 
4226  /*
4227  * In JSON format, the grouping_stack is an integer list. 0 means
4228  * we've emitted nothing at this grouping level, 1 means we've
4229  * emitted something (and so the next item needs a comma). See
4230  * ExplainJSONLineEnding().
4231  */
4232  es->grouping_stack = lcons_int(0, es->grouping_stack);
4233  es->indent++;
4234  break;
4235 
4236  case EXPLAIN_FORMAT_YAML:
4237 
4238  /*
4239  * In YAML format, the grouping stack is an integer list. 0 means
4240  * we've emitted nothing at this grouping level AND this grouping
4241  * level is unlabelled and must be marked with "- ". See
4242  * ExplainYAMLLineStarting().
4243  */
4244  ExplainYAMLLineStarting(es);
4245  if (labelname)
4246  {
4247  appendStringInfo(es->str, "%s: ", labelname);
4248  es->grouping_stack = lcons_int(1, es->grouping_stack);
4249  }
4250  else
4251  {
4252  appendStringInfoString(es->str, "- ");
4253  es->grouping_stack = lcons_int(0, es->grouping_stack);
4254  }
4255  es->indent++;
4256  break;
4257  }
4258 }
4259 
4260 /*
4261  * Close a group of related objects.
4262  * Parameters must match the corresponding ExplainOpenGroup call.
4263  */
4264 void
4265 ExplainCloseGroup(const char *objtype, const char *labelname,
4266  bool labeled, ExplainState *es)
4267 {
4268  switch (es->format)
4269  {
4270  case EXPLAIN_FORMAT_TEXT:
4271  /* nothing to do */
4272  break;
4273 
4274  case EXPLAIN_FORMAT_XML:
4275  es->indent--;
4276  ExplainXMLTag(objtype, X_CLOSING, es);
4277  break;
4278 
4279  case EXPLAIN_FORMAT_JSON:
4280  es->indent--;
4281  appendStringInfoChar(es->str, '\n');
4282  appendStringInfoSpaces(es->str, 2 * es->indent);
4283  appendStringInfoChar(es->str, labeled ? '}' : ']');
4284  es->grouping_stack = list_delete_first(es->grouping_stack);
4285  break;
4286 
4287  case EXPLAIN_FORMAT_YAML:
4288  es->indent--;
4289  es->grouping_stack = list_delete_first(es->grouping_stack);
4290  break;
4291  }
4292 }
4293 
4294 /*
4295  * Open a group of related objects, without emitting actual data.
4296  *
4297  * Prepare the formatting state as though we were beginning a group with
4298  * the identified properties, but don't actually emit anything. Output
4299  * subsequent to this call can be redirected into a separate output buffer,
4300  * and then eventually appended to the main output buffer after doing a
4301  * regular ExplainOpenGroup call (with the same parameters).
4302  *
4303  * The extra "depth" parameter is the new group's depth compared to current.
4304  * It could be more than one, in case the eventual output will be enclosed
4305  * in additional nesting group levels. We assume we don't need to track
4306  * formatting state for those levels while preparing this group's output.
4307  *
4308  * There is no ExplainCloseSetAsideGroup --- in current usage, we always
4309  * pop this state with ExplainSaveGroup.
4310  */
4311 static void
4312 ExplainOpenSetAsideGroup(const char *objtype, const char *labelname,
4313  bool labeled, int depth, ExplainState *es)
4314 {
4315  switch (es->format)
4316  {
4317  case EXPLAIN_FORMAT_TEXT:
4318  /* nothing to do */
4319  break;
4320 
4321  case EXPLAIN_FORMAT_XML:
4322  es->indent += depth;
4323  break;
4324 
4325  case EXPLAIN_FORMAT_JSON:
4326  es->grouping_stack = lcons_int(0, es->grouping_stack);
4327  es->indent += depth;
4328  break;
4329 
4330  case EXPLAIN_FORMAT_YAML:
4331  if (labelname)
4332  es->grouping_stack = lcons_int(1, es->grouping_stack);
4333  else
4334  es->grouping_stack = lcons_int(0, es->grouping_stack);
4335  es->indent += depth;
4336  break;
4337  }
4338 }
4339 
4340 /*
4341  * Pop one level of grouping state, allowing for a re-push later.
4342  *
4343  * This is typically used after ExplainOpenSetAsideGroup; pass the
4344  * same "depth" used for that.
4345  *
4346  * This should not emit any output. If state needs to be saved,
4347  * save it at *state_save. Currently, an integer save area is sufficient
4348  * for all formats, but we might need to revisit that someday.
4349  */
4350 static void
4351 ExplainSaveGroup(ExplainState *es, int depth, int *state_save)
4352 {
4353  switch (es->format)
4354  {
4355  case EXPLAIN_FORMAT_TEXT:
4356  /* nothing to do */
4357  break;
4358 
4359  case EXPLAIN_FORMAT_XML:
4360  es->indent -= depth;
4361  break;
4362 
4363  case EXPLAIN_FORMAT_JSON:
4364  es->indent -= depth;
4365  *state_save = linitial_int(es->grouping_stack);
4366  es->grouping_stack = list_delete_first(es->grouping_stack);
4367  break;
4368 
4369  case EXPLAIN_FORMAT_YAML:
4370  es->indent -= depth;
4371  *state_save = linitial_int(es->grouping_stack);
4372  es->grouping_stack = list_delete_first(es->grouping_stack);
4373  break;
4374  }
4375 }
4376 
4377 /*
4378  * Re-push one level of grouping state, undoing the effects of ExplainSaveGroup.
4379  */
4380 static void
4381 ExplainRestoreGroup(ExplainState *es, int depth, int *state_save)
4382 {
4383  switch (es->format)
4384  {
4385  case EXPLAIN_FORMAT_TEXT:
4386  /* nothing to do */
4387  break;
4388 
4389  case EXPLAIN_FORMAT_XML:
4390  es->indent += depth;
4391  break;
4392 
4393  case EXPLAIN_FORMAT_JSON:
4394  es->grouping_stack = lcons_int(*state_save, es->grouping_stack);
4395  es->indent += depth;
4396  break;
4397 
4398  case EXPLAIN_FORMAT_YAML:
4399  es->grouping_stack = lcons_int(*state_save, es->grouping_stack);
4400  es->indent += depth;
4401  break;
4402  }
4403 }
4404 
4405 /*
4406  * Emit a "dummy" group that never has any members.
4407  *
4408  * objtype is the type of the group object, labelname is its label within
4409  * a containing object (if any).
4410  */
4411 static void
4412 ExplainDummyGroup(const char *objtype, const char *labelname, ExplainState *es)
4413 {
4414  switch (es->format)
4415  {
4416  case EXPLAIN_FORMAT_TEXT:
4417  /* nothing to do */
4418  break;
4419 
4420  case EXPLAIN_FORMAT_XML:
4421  ExplainXMLTag(objtype, X_CLOSE_IMMEDIATE, es);
4422  break;
4423 
4424  case EXPLAIN_FORMAT_JSON:
4425  ExplainJSONLineEnding(es);
4426  appendStringInfoSpaces(es->str, 2 * es->indent);
4427  if (labelname)
4428  {
4429  escape_json(es->str, labelname);
4430  appendStringInfoString(es->str, ": ");
4431  }
4432  escape_json(es->str, objtype);
4433  break;
4434 
4435  case EXPLAIN_FORMAT_YAML:
4436  ExplainYAMLLineStarting(es);
4437  if (labelname)
4438  {
4439  escape_yaml(es->str, labelname);
4440  appendStringInfoString(es->str, ": ");
4441  }
4442  else
4443  {
4444  appendStringInfoString(es->str, "- ");
4445  }
4446  escape_yaml(es->str, objtype);
4447  break;
4448  }
4449 }
4450 
4451 /*
4452  * Emit the start-of-output boilerplate.
4453  *
4454  * This is just enough different from processing a subgroup that we need
4455  * a separate pair of subroutines.
4456  */
4457 void
4458 ExplainBeginOutput(ExplainState *es)
4459 {
4460  switch (es->format)
4461  {
4462  case EXPLAIN_FORMAT_TEXT:
4463  /* nothing to do */
4464  break;
4465 
4466  case EXPLAIN_FORMAT_XML:
4467  appendStringInfoString(es->str,
4468  "<explain xmlns=\"http://www.postgresql.org/2009/explain\">\n");
4469  es->indent++;
4470  break;
4471 
4472  case EXPLAIN_FORMAT_JSON:
4473  /* top-level structure is an array of plans */
4474  appendStringInfoChar(es->str, '[');
4475  es->grouping_stack = lcons_int(0, es->grouping_stack);
4476  es->indent++;
4477  break;
4478 
4479  case EXPLAIN_FORMAT_YAML:
4480  es->grouping_stack = lcons_int(0, es->grouping_stack);
4481  break;
4482  }
4483 }
4484 
4485 /*
4486  * Emit the end-of-output boilerplate.
4487  */
4488 void
4489 ExplainEndOutput(ExplainState *es)
4490 {
4491  switch (es->format)
4492  {
4493  case EXPLAIN_FORMAT_TEXT:
4494  /* nothing to do */
4495  break;
4496 
4497  case EXPLAIN_FORMAT_XML:
4498  es->indent--;
4499  appendStringInfoString(es->str, "</explain>");
4500  break;
4501 
4502  case EXPLAIN_FORMAT_JSON:
4503  es->indent--;
4504  appendStringInfoString(es->str, "\n]");
4505  es->grouping_stack = list_delete_first(es->grouping_stack);
4506  break;
4507 
4508  case EXPLAIN_FORMAT_YAML:
4509  es->grouping_stack = list_delete_first(es->grouping_stack);
4510  break;
4511  }
4512 }
4513 
4514 /*
4515  * Put an appropriate separator between multiple plans
4516  */
4517 void
4518 ExplainSeparatePlans(ExplainState *es)
4519 {
4520  switch (es->format)
4521  {
4522  case EXPLAIN_FORMAT_TEXT:
4523  /* add a blank line */
4524  appendStringInfoChar(es->str, '\n');
4525  break;
4526 
4527  case EXPLAIN_FORMAT_XML:
4528  case EXPLAIN_FORMAT_JSON:
4529  case EXPLAIN_FORMAT_YAML:
4530  /* nothing to do */
4531  break;
4532  }
4533 }
4534 
4535 /*
4536  * Emit opening or closing XML tag.
4537  *
4538  * "flags" must contain X_OPENING, X_CLOSING, or X_CLOSE_IMMEDIATE.
4539  * Optionally, OR in X_NOWHITESPACE to suppress the whitespace we'd normally
4540  * add.
4541  *
4542  * XML restricts tag names more than our other output formats, eg they can't
4543  * contain white space or slashes. Replace invalid characters with dashes,
4544  * so that for example "I/O Read Time" becomes "I-O-Read-Time".
4545  */
4546 static void
4547 ExplainXMLTag(const char *tagname, int flags, ExplainState *es)
4548 {
4549  const char *s;
4550  const char *valid = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.";
4551 
4552  if ((flags & X_NOWHITESPACE) == 0)
4553  appendStringInfoSpaces(es->str, 2 * es->indent);
4554  appendStringInfoCharMacro(es->str, '<');
4555  if ((flags & X_CLOSING) != 0)
4556  appendStringInfoCharMacro(es->str, '/');
4557  for (s = tagname; *s; s++)
4558  appendStringInfoChar(es->str, strchr(valid, *s) ? *s : '-');
4559  if ((flags & X_CLOSE_IMMEDIATE) != 0)
4560  appendStringInfoString(es->str, " /");
4561  appendStringInfoCharMacro(es->str, '>');
4562  if ((flags & X_NOWHITESPACE) == 0)
4563  appendStringInfoCharMacro(es->str, '\n');
4564 }
4565 
4566 /*
4567  * Indent a text-format line.
4568  *
4569  * We indent by two spaces per indentation level. However, when emitting
4570  * data for a parallel worker there might already be data on the current line
4571  * (cf. ExplainOpenWorker); in that case, don't indent any more.
4572  */
4573 static void
4574 ExplainIndentText(ExplainState *es)
4575 {
4576  Assert(es->format == EXPLAIN_FORMAT_TEXT);
4577  if (es->str->len == 0 || es->str->data[es->str->len - 1] == '\n')
4578  appendStringInfoSpaces(es->str, es->indent * 2);
4579 }
4580 
4581 /*
4582  * Emit a JSON line ending.
4583  *
4584  * JSON requires a comma after each property but the last. To facilitate this,
4585  * in JSON format, the text emitted for each property begins just prior to the
4586  * preceding line-break (and comma, if applicable).
4587  */
4588 static void
4589 ExplainJSONLineEnding(ExplainState *es)
4590 {
4591  Assert(es->format == EXPLAIN_FORMAT_JSON);
4592  if (linitial_int(es->grouping_stack) != 0)
4593  appendStringInfoChar(es->str, ',');
4594  else
4595  linitial_int(es->grouping_stack) = 1;
4596  appendStringInfoChar(es->str, '\n');
4597 }
4598 
4599 /*
4600  * Indent a YAML line.
4601  *
4602  * YAML lines are ordinarily indented by two spaces per indentation level.
4603  * The text emitted for each property begins just prior to the preceding
4604  * line-break, except for the first property in an unlabelled group, for which
4605  * it begins immediately after the "- " that introduces the group. The first
4606  * property of the group appears on the same line as the opening "- ".
4607  */
4608 static void
4609 ExplainYAMLLineStarting(ExplainState *es)
4610 {
4611  Assert(es->format == EXPLAIN_FORMAT_YAML);
4612  if (linitial_int(es->grouping_stack) == 0)
4613  {
4614  linitial_int(es->grouping_stack) = 1;
4615  }
4616  else
4617  {
4618  appendStringInfoChar(es->str, '\n');
4619  appendStringInfoSpaces(es->str, es->indent * 2);
4620  }
4621 }
4622 
4623 /*
4624  * YAML is a superset of JSON; unfortunately, the YAML quoting rules are
4625  * ridiculously complicated -- as documented in sections 5.3 and 7.3.3 of
4626  * http://yaml.org/spec/1.2/spec.html -- so we chose to just quote everything.
4627  * Empty strings, strings with leading or trailing whitespace, and strings
4628  * containing a variety of special characters must certainly be quoted or the
4629  * output is invalid; and other seemingly harmless strings like "0xa" or
4630  * "true" must be quoted, lest they be interpreted as a hexadecimal or Boolean
4631  * constant rather than a string.
4632  */
4633 static void
4634 escape_yaml(StringInfo buf, const char *str)
4635 {
4636  escape_json(buf, str);
4637 }
Instrumentation::nfiltered1
double nfiltered1
Definition: instrument.h:72
ExplainPropertyUInteger
void ExplainPropertyUInteger(const char *qlabel, const char *unit, uint64 value, ExplainState *es)
Definition: explain.c:4159
ExplainQuery
void ExplainQuery(ParseState *pstate, ExplainStmt *stmt, ParamListInfo params, DestReceiver *dest)
Definition: explain.c:160
NIL
#define NIL
Definition: pg_list.h:65
ExplainCreateWorkersState
static ExplainWorkersState * ExplainCreateWorkersState(int num_workers)
Definition: explain.c:3816
ForeignScanState::ss
ScanState ss
Definition: execnodes.h:1794
usage
static void usage(void)
Definition: pg_standby.c:589
ExplainWorkersState::worker_state_save
int * worker_state_save
Definition: explain.h:33
ExplainState::summary
bool summary
Definition: explain.h:47
Agg::numCols
int numCols
Definition: plannodes.h:821
ExplainPrintSettings
static void ExplainPrintSettings(ExplainState *es)
Definition: explain.c:661
BufferUsage::local_blks_hit
long local_blks_hit
Definition: instrument.h:25
ModifyTable::arbiterIndexes
List * arbiterIndexes
Definition: plannodes.h:237
Plan::plan_rows
double plan_rows
Definition: plannodes.h:129
ResultRelInfo::ri_RelationDesc
Relation ri_RelationDesc
Definition: execnodes.h:413
T_Agg
Definition: nodes.h:79
ExplainPropertyBool
void ExplainPropertyBool(const char *qlabel, bool value, ExplainState *es)
Definition: explain.c:4187
IndexScan::indexorderdir
ScanDirection indexorderdir
Definition: plannodes.h:411
UpdateActiveSnapshotCommandId
void UpdateActiveSnapshotCommandId(void)
Definition: snapmgr.c:783
PGJIT_EXPR
#define PGJIT_EXPR
Definition: jit.h:23
IsA
#define IsA(nodeptr, _type_)
Definition: nodes.h:580
GatherMerge::initParam
Bitmapset * initParam
Definition: plannodes.h:910
BufferUsage::local_blks_dirtied
long local_blks_dirtied
Definition: instrument.h:27
NewExplainState
ExplainState * NewExplainState(void)
Definition: explain.c:309
QueryRewrite
List * QueryRewrite(Query *parsetree)
Definition: rewriteHandler.c:3927
PlanState::worker_instrument
WorkerInstrumentation * worker_instrument
Definition: execnodes.h:956
config_generic
Definition: guc_tables.h:146
BufferUsage::local_blks_read
long local_blks_read
Definition: instrument.h:26
Instrumentation::walusage
WalUsage walusage
Definition: instrument.h:75
ExplainPropertyInteger
void ExplainPropertyInteger(const char *qlabel, const char *unit, int64 value, ExplainState *es)
Definition: explain.c:4146
ModifyTable::nominalRelation
Index nominalRelation
Definition: plannodes.h:223
SubPlan::plan_id
int plan_id
Definition: primnodes.h:709
SharedIncrementalSortInfo::sinfo
IncrementalSortInfo sinfo[FLEXIBLE_ARRAY_MEMBER]
Definition: execnodes.h:2055
tuplesort_space_type_name
const char * tuplesort_space_type_name(TuplesortSpaceType t)
Definition: tuplesort.c:3369
FdwRoutine::ExplainForeignScan
ExplainForeignScan_function ExplainForeignScan
Definition: fdwapi.h:229
QueryDesc::estate
EState * estate
Definition: execdesc.h:48
T_Unique
Definition: nodes.h:81
escape_json
void escape_json(StringInfo buf, const char *str)
Definition: json.c:1279
Agg::grpColIdx
AttrNumber * grpColIdx
Definition: plannodes.h:822
ExplainState::hide_workers
bool hide_workers
Definition: explain.h:59
PlanState::instrument
Instrumentation * instrument
Definition: execnodes.h:955
ExplainSeparatePlans
void ExplainSeparatePlans(ExplainState *es)
Definition: explain.c:4518
quote_identifier
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:10737
show_modifytable_info
static void show_modifytable_info(ModifyTableState *mtstate, List *ancestors, ExplainState *es)
Definition: explain.c:3559
EState::es_jit
struct JitContext * es_jit
Definition: execnodes.h:601
TuplesortMethod
TuplesortMethod
Definition: tuplesort.h:72
lnext
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:321
CreateTemplateTupleDesc
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:44
lcons_int
List * lcons_int(int datum, List *list)
Definition: list.c:471
show_sort_group_keys
static void show_sort_group_keys(PlanState *planstate, const char *qlabel, int nkeys, int nPresortedKeys, AttrNumber *keycols, Oid *sortOperators, Oid *collations, bool *nullsFirst, List *ancestors, ExplainState *es)
Definition: explain.c:2481
get_constraint_name
char * get_constraint_name(Oid conoid)
Definition: lsyscache.c:1079
BufferUsage::blk_read_time
instr_time blk_read_time
Definition: instrument.h:31
MergeAppend::collations
Oid * collations
Definition: plannodes.h:281
castNode
#define castNode(_type_, nodeptr)
Definition: nodes.h:598
FreeQueryDesc
void FreeQueryDesc(QueryDesc *qdesc)
Definition: pquery.c:105
FunctionScan::functions
List * functions
Definition: plannodes.h:525
config_generic::name
const char * name
Definition: guc_tables.h:149
ParseState::p_queryEnv
QueryEnvironment * p_queryEnv
Definition: parse_node.h:203
PlanState::initPlan
List * initPlan
Definition: execnodes.h:970
ModifyTableState::resultRelInfo
ResultRelInfo * resultRelInfo
Definition: execnodes.h:1174
JitInstrumentation::generation_counter
instr_time generation_counter
Definition: jit.h:33
get_explain_guc_options
struct config_generic ** get_explain_guc_options(int *num)
Definition: guc.c:9099
AggState::ss
ScanState ss
Definition: execnodes.h:2125
ExplainPropertyFloat
void ExplainPropertyFloat(const char *qlabel, const char *unit, double value, int ndigits, ExplainState *es)
Definition: explain.c:4173
get_collation_name
char * get_collation_name(Oid colloid)
Definition: lsyscache.c:1033
pstrdup
char * pstrdup(const char *in)
Definition: mcxt.c:1186
ExplainState::printed_subplans
Bitmapset * printed_subplans
Definition: explain.h:58
psprintf
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
EState::es_jit_worker_instr
struct JitInstrumentation * es_jit_worker_instr
Definition: execnodes.h:602
INSTR_TIME_GET_MILLISEC
#define INSTR_TIME_GET_MILLISEC(t)
Definition: instr_time.h:202
instr_time
struct timeval instr_time
Definition: instr_time.h:150
BufferUsage::shared_blks_read
long shared_blks_read
Definition: instrument.h:22
get_equality_op_for_ordering_op
Oid get_equality_op_for_ordering_op(Oid opno, bool *reverse)
Definition: lsyscache.c:265
makeStringInfo
StringInfo makeStringInfo(void)
Definition: stringinfo.c:41
Instrumentation::startup
double startup
Definition: instrument.h:67
bms_next_member
int bms_next_member(const Bitmapset *a, int prevbit)
Definition: bitmapset.c:1043
TTSOpsVirtual
const TupleTableSlotOps TTSOpsVirtual
Definition: execTuples.c:83
ExecutorStart
void ExecutorStart(QueryDesc *queryDesc, int eflags)
Definition: execMain.c:143
PlanState::subPlan
List * subPlan
Definition: execnodes.h:972
GetActiveSnapshot
Snapshot GetActiveSnapshot(void)
Definition: snapmgr.c:841
ResultRelInfo::ri_TrigInstrument
Instrumentation * ri_TrigInstrument
Definition: execnodes.h:434
ExplainXMLTag
static void ExplainXMLTag(const char *tagname, int flags, ExplainState *es)
Definition: explain.c:4547
SortState::shared_info
SharedSortInfo * shared_info
Definition: execnodes.h:2025
X_CLOSING
#define X_CLOSING
Definition: explain.c:52
Node
Definition: nodes.h:529
Sort::nullsFirst
bool * nullsFirst
Definition: plannodes.h:774
T_Append
Definition: nodes.h:49
errcode
int errcode(int sqlerrcode)
Definition: elog.c:610
ExplainState::deparse_cxt
List * deparse_cxt
Definition: explain.h:57
IncrementalSortInfo::prefixsortGroupInfo
IncrementalSortGroupInfo prefixsortGroupInfo
Definition: execnodes.h:2045
generate_unaccent_rules.dest
dest
Definition: generate_unaccent_rules.py:282
show_incremental_sort_info
static void show_incremental_sort_info(IncrementalSortState *incrsortstate, ExplainState *es)
Definition: explain.c:2872
INSTR_TIME_SET_ZERO
#define INSTR_TIME_SET_ZERO(t)
Definition: instr_time.h:154
ExplainOpenWorker
static void ExplainOpenWorker(int n, ExplainState *es)
Definition: explain.c:3833
ExplainCloseWorker
static void ExplainCloseWorker(int n, ExplainState *es)
Definition: explain.c:3895
PopActiveSnapshot
void PopActiveSnapshot(void)
Definition: snapmgr.c:814
ExplainStmt::options
List * options
Definition: parsenodes.h:3257
ExplainPrintJIT
static void ExplainPrintJIT(ExplainState *es, int jit_flags, JitInstrumentation *ji)
Definition: explain.c:852
T_Sort
Definition: nodes.h:76
INSTR_TIME_GET_DOUBLE
#define INSTR_TIME_GET_DOUBLE(t)
Definition: instr_time.h:199
BufferUsage::temp_blks_written
long temp_blks_written
Definition: instrument.h:30
IntoClause::skipData
bool skipData
Definition: primnodes.h:119
PlanState::state
EState * state
Definition: execnodes.h:947
CustomScanState::custom_ps
List * custom_ps
Definition: execnodes.h:1822
relname
NameData relname
Definition: pg_class.h:38
Oid
unsigned int Oid
Definition: postgres_ext.h:31
make_orclause
Expr * make_orclause(List *orclauses)
Definition: makefuncs.c:649
pg_type.h
Query::utilityStmt
Node * utilityStmt
Definition: parsenodes.h:120
linitial_node
#define linitial_node(type, l)
Definition: pg_list.h:198
ExplainState::costs
bool costs
Definition: explain.h:43
set_deparse_context_plan
List * set_deparse_context_plan(List *dpcontext, Plan *plan, List *ancestors)
Definition: ruleutils.c:3397
None_Receiver
DestReceiver * None_Receiver
Definition: dest.c:96
tuplesort_get_stats
void tuplesort_get_stats(Tuplesortstate *state, TuplesortInstrumentation *stats)
Definition: tuplesort.c:3302
OidIsValid
#define OidIsValid(objectId)
Definition: c.h:644
SharedJitInstrumentation::jit_instr
JitInstrumentation jit_instr[FLEXIBLE_ARRAY_MEMBER]
Definition: jit.h:51
show_scan_qual
static void show_scan_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, ExplainState *es)
Definition: explain.c:2253
DO_AGGSPLIT_COMBINE
#define DO_AGGSPLIT_COMBINE(as)
Definition: nodes.h:791
ExplainState::analyze
bool analyze
Definition: explain.h:42
ExplainDummyGroup
static void ExplainDummyGroup(const char *objtype, const char *labelname, ExplainState *es)
Definition: explain.c:4412
tuplesort_method_name
const char * tuplesort_method_name(TuplesortMethod m)
Definition: tuplesort.c:3346
ExplainRestoreGroup
static void ExplainRestoreGroup(ExplainState *es, int depth, int *state_save)
Definition: explain.c:4381
ExplainState::pstmt
PlannedStmt * pstmt
Definition: explain.h:54
_DestReceiver
Definition: dest.h:116
Sort::sortOperators
Oid * sortOperators
Definition: plannodes.h:772
show_sort_info
static void show_sort_info(SortState *sortstate, ExplainState *es)
Definition: explain.c:2667
IndexScan::indexid
Oid indexid
Definition: plannodes.h:405
ExplainState::rtable_names
List * rtable_names
Definition: explain.h:56
show_upper_qual
static void show_upper_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, ExplainState *es)
Definition: explain.c:2267
ResultRelInfo::ri_RangeTableIndex
Index ri_RangeTableIndex
Definition: execnodes.h:410
INSTR_TIME_IS_ZERO
#define INSTR_TIME_IS_ZERO(t)
Definition: instr_time.h:152
BufferUsageAccumDiff
void BufferUsageAccumDiff(BufferUsage *dst, const BufferUsage *add, const BufferUsage *sub)
Definition: instrument.c:225
JitContext::instr
JitInstrumentation instr
Definition: jit.h:61
show_instrumentation_count
static void show_instrumentation_count(const char *qlabel, int which, PlanState *planstate, ExplainState *es)
Definition: explain.c:3114
InstrEndLoop
void InstrEndLoop(Instrumentation *instr)
Definition: instrument.c:121
HashState::shared_info
SharedHashInfo * shared_info
Definition: execnodes.h:2390
CustomScanState::methods
const struct CustomExecMethods * methods
Definition: execnodes.h:1824
list_make1
#define list_make1(x1)
Definition: pg_list.h:227
ExplainPropertyListNested
void ExplainPropertyListNested(const char *qlabel, List *data, ExplainState *es)
Definition: explain.c:4031
GroupState::ss
ScanState ss
Definition: execnodes.h:2099
NUM_TUPLESORTMETHODS
#define NUM_TUPLESORTMETHODS
Definition: tuplesort.h:81
linitial_int
#define linitial_int(l)
Definition: pg_list.h:196
ExecutorEnd
void ExecutorEnd(QueryDesc *queryDesc)
Definition: execMain.c:462
ScanState::ps
PlanState ps
Definition: execnodes.h:1332
ScanDirectionIsBackward
#define ScanDirectionIsBackward(direction)
Definition: sdir.h:41
select_rtable_names_for_explain
List * select_rtable_names_for_explain(List *rtable, Bitmapset *rels_used)
Definition: ruleutils.c:3420
ExplainStmt::query
Node * query
Definition: parsenodes.h:3256
SortState::tuplesortstate
void * tuplesortstate
Definition: execnodes.h:2023
get_opname
char * get_opname(Oid opno)
Definition: lsyscache.c:1227
ExplainPropertyText
void ExplainPropertyText(const char *qlabel, const char *value, ExplainState *es)
Definition: explain.c:4137
BufferUsage::shared_blks_written
long shared_blks_written
Definition: instrument.h:24
ExplainNode
static void ExplainNode(PlanState *planstate, List *ancestors, const char *relationship, const char *plan_name, ExplainState *es)
Definition: explain.c:1121
ExplainEndOutput
void ExplainEndOutput(ExplainState *es)
Definition: explain.c:4489
GetIntoRelEFlags
int GetIntoRelEFlags(IntoClause *intoClause)
Definition: createas.c:393
defGetBoolean
bool defGetBoolean(DefElem *def)
Definition: define.c:111
appendStringInfoCharMacro
#define appendStringInfoCharMacro(str, ch)
Definition: stringinfo.h:128
ExplainPrintTriggers
void ExplainPrintTriggers(ExplainState *es, QueryDesc *queryDesc)
Definition: explain.c:780
PGJIT_OPT3
#define PGJIT_OPT3
Definition: jit.h:21
pfree
void pfree(void *pointer)
Definition: mcxt.c:1056
IncrementalSortState::incsort_info
IncrementalSortInfo incsort_info
Definition: execnodes.h:2084
Agg::aggstrategy
AggStrategy aggstrategy
Definition: plannodes.h:819
appendStringInfo
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
linitial
#define linitial(l)
Definition: pg_list.h:195
ExplainPrintPlan
void ExplainPrintPlan(ExplainState *es, QueryDesc *queryDesc)
Definition: explain.c:731
GetConfigOptionByName
char * GetConfigOptionByName(const char *name, const char **varname, bool missing_ok)
Definition: guc.c:9192
T_Result
Definition: nodes.h:46
end_tup_output
void end_tup_output(TupOutputState *tstate)
Definition: execTuples.c:2314
FuncExpr::funcid
Oid funcid
Definition: primnodes.h:469
ExplainBeginOutput
void ExplainBeginOutput(ExplainState *es)
Definition: explain.c:4458
ERROR
#define ERROR
Definition: elog.h:43
QueryDesc::planstate
PlanState * planstate
Definition: execdesc.h:49
ExplainExecuteQuery
void ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv)
Definition: prepare.c:606
ModifyTableState::ps
PlanState ps
Definition: execnodes.h:1165
SubPlanState::planstate
struct PlanState * planstate
Definition: execnodes.h:853
Trigger::tgconstraint
Oid tgconstraint
Definition: reltrigger.h:35
Instrumentation::nfiltered2
double nfiltered2
Definition: instrument.h:73
show_qual
static void show_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, bool useprefix, ExplainState *es)
Definition: explain.c:2232
SubPlanState::subplan
SubPlan * subplan
Definition: execnodes.h:852
lfirst_int
#define lfirst_int(lc)
Definition: pg_list.h:191
ExecutorRun
void ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once)
Definition: execMain.c:301
Trigger::tgname
char * tgname
Definition: reltrigger.h:27
list_nth
static void * list_nth(const List *list, int n)
Definition: pg_list.h:277
get_func_name
char * get_func_name(Oid funcid)
Definition: lsyscache.c:1520
ExplainResultDesc
TupleDesc ExplainResultDesc(ExplainStmt *stmt)
Definition: explain.c:326
INSTR_TIME_SUBTRACT
#define INSTR_TIME_SUBTRACT(x, y)
Definition: instr_time.h:170
Gather::single_copy
bool single_copy
Definition: plannodes.h:889
JitInstrumentation::created_functions
size_t created_functions
Definition: jit.h:30
defGetString
char * defGetString(DefElem *def)
Definition: define.c:49
begin_tup_output_tupdesc
TupOutputState * begin_tup_output_tupdesc(DestReceiver *dest, TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:2236
PushCopiedSnapshot
void PushCopiedSnapshot(Snapshot snapshot)
Definition: snapmgr.c:771
CreateQueryDesc
QueryDesc * CreateQueryDesc(PlannedStmt *plannedstmt, const char *sourceText, Snapshot snapshot, Snapshot crosscheck_snapshot, DestReceiver *dest, ParamListInfo params, QueryEnvironment *queryEnv, int instrument_options)
Definition: pquery.c:67
ExplainOneQuery_hook
ExplainOneQuery_hook_type ExplainOneQuery_hook
Definition: explain.c:44
ResultRelInfo::ri_usesFdwDirectModify
bool ri_usesFdwDirectModify
Definition: execnodes.h:448
T_Group
Definition: nodes.h:78
WalUsage::wal_records
long wal_records
Definition: instrument.h:37
lfirst_node
#define lfirst_node(type, lc)
Definition: pg_list.h:193
outerPlanState
#define outerPlanState(node)
Definition: execnodes.h:1039
ExplainWorkersState::worker_str
StringInfoData * worker_str
Definition: explain.h:32
appendStringInfoString
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
TriggerDesc::triggers
Trigger * triggers
Definition: reltrigger.h:49
generate_unaccent_rules.str
str
Definition: generate_unaccent_rules.py:282
get_namespace_name
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3191
deparse_context_for_plan_tree
List * deparse_context_for_plan_tree(PlannedStmt *pstmt, List *rtable_names)
Definition: ruleutils.c:3328
buf
static char * buf
Definition: pg_test_fsync.c:67
Plan::startup_cost
Cost startup_cost
Definition: plannodes.h:123
INSTR_TIME_ADD
#define INSTR_TIME_ADD(x, y)
Definition: instr_time.h:158
JitInstrumentation::optimization_counter
instr_time optimization_counter
Definition: jit.h:39
TuplesortInstrumentation::sortMethod
TuplesortMethod sortMethod
Definition: tuplesort.h:91
EState::es_jit_flags
int es_jit_flags
Definition: execnodes.h:600
ExplainQueryText
void ExplainQueryText(ExplainState *es, QueryDesc *queryDesc)
Definition: explain.c:946
EState::es_result_relations
ResultRelInfo * es_result_relations
Definition: execnodes.h:525
ExplainYAMLLineStarting
static void ExplainYAMLLineStarting(ExplainState *es)
Definition: explain.c:4609
DefElem::location
int location
Definition: parsenodes.h:735
show_grouping_sets
static void show_grouping_sets(PlanState *planstate, Agg *agg, List *ancestors, ExplainState *es)
Definition: explain.c:2352
show_tablesample
static void show_tablesample(TableSampleClause *tsc, PlanState *planstate, List *ancestors, ExplainState *es)
Definition: explain.c:2601
ModifyTable::fdwPrivLists
List * fdwPrivLists
Definition: plannodes.h:232
ScanDirection
ScanDirection
Definition: sdir.h:22
FdwRoutine::ExplainDirectModify
ExplainDirectModify_function ExplainDirectModify
Definition: fdwapi.h:231
CreateIntoRelDestReceiver
DestReceiver * CreateIntoRelDestReceiver(IntoClause *intoClause)
Definition: createas.c:411
AggState::hash_planned_partitions
int hash_planned_partitions
Definition: execnodes.h:2175
RelationGetRelationName
#define RelationGetRelationName(relation)
Definition: rel.h:490
BufferUsage::shared_blks_dirtied
long shared_blks_dirtied
Definition: instrument.h:23
Plan::parallel_aware
bool parallel_aware
Definition: plannodes.h:135
resetStringInfo
void resetStringInfo(StringInfo str)
Definition: stringinfo.c:75
ExplainState::grouping_stack
List * grouping_stack
Definition: explain.h:52
ResultRelInfo::ri_FdwRoutine
struct FdwRoutine * ri_FdwRoutine
Definition: execnodes.h:442
ForeignScanState::fdwroutine
struct FdwRoutine * fdwroutine
Definition: execnodes.h:1798
IndexOnlyScan::indexorderdir
ScanDirection indexorderdir
Definition: plannodes.h:438
SortState::ss
ScanState ss
Definition: execnodes.h:2016
TYPECACHE_GT_OPR
#define TYPECACHE_GT_OPR
Definition: typcache.h:132
Group::numCols
int numCols
Definition: plannodes.h:796
Instrumentation::ntuples
double ntuples
Definition: instrument.h:69
ExplainState::indent
int indent
Definition: explain.h:51
show_wal_usage
static void show_wal_usage(ExplainState *es, const WalUsage *usage)
Definition: explain.c:3337
ParseState::p_sourcetext
const char * p_sourcetext
Definition: parse_node.h:179
BufferUsage::temp_blks_read
long temp_blks_read
Definition: instrument.h:29
show_tidbitmap_info
static void show_tidbitmap_info(BitmapHeapScanState *planstate, ExplainState *es)
Definition: explain.c:3084
TupleDescInitEntry
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:603
ExplainModifyTarget
static void ExplainModifyTarget(ModifyTable *plan, ExplainState *es)
Definition: explain.c:3427
ExplainMissingMembers
static void ExplainMissingMembers(int nplans, int nchildren, ExplainState *es)
Definition: explain.c:3737
rt_fetch
#define rt_fetch(rangetable_index, rangetable)
Definition: parsetree.h:31
HashState::hinstrument
HashInstrumentation * hinstrument
Definition: execnodes.h:2397
ExplainIndexScanDetails
static void ExplainIndexScanDetails(Oid indexid, ScanDirection indexorderdir, ExplainState *es)
Definition: explain.c:3375
show_group_keys
static void show_group_keys(GroupState *gstate, List *ancestors, ExplainState *es)
Definition: explain.c:2461
PlanState::worker_jit_instrument
struct SharedJitInstrumentation * worker_jit_instrument
Definition: execnodes.h:959
ResultRelInfo::ri_TrigDesc
TriggerDesc * ri_TrigDesc
Definition: execnodes.h:425
SharedHashInfo::hinstrument
HashInstrumentation hinstrument[FLEXIBLE_ARRAY_MEMBER]
Definition: execnodes.h:2371
show_buffer_usage
static void show_buffer_usage(ExplainState *es, const BufferUsage *usage)
Definition: explain.c:3213
AggState::hash_batches_used
int hash_batches_used
Definition: execnodes.h:2182
ExecutorFinish
void ExecutorFinish(QueryDesc *queryDesc)
Definition: execMain.c:402
show_plan_tlist
static void show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es)
Definition: explain.c:2151
lappend
List * lappend(List *list, void *datum)
Definition: list.c:321
report_triggers
static void report_triggers(ResultRelInfo *rInfo, bool show_relname, ExplainState *es)
Definition: explain.c:957
ExplainState::timing
bool timing
Definition: explain.h:46
ExplainOneQuery
static void ExplainOneQuery(Query *query, int cursorOptions, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv)
Definition: explain.c:365
appendStringInfoChar
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
EState::es_num_root_result_relations
int es_num_root_result_relations
Definition: execnodes.h:536
initStringInfo
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
ModifyTableState::mt_plans
PlanState ** mt_plans
Definition: execnodes.h:1169
Sort::numCols
int numCols
Definition: plannodes.h:770
unconstify
#define unconstify(underlying_type, expr)
Definition: c.h:1206
Agg::plan
Plan plan
Definition: plannodes.h:818
TriggerDesc::numtriggers
int numtriggers
Definition: reltrigger.h:50
escape_yaml
static void escape_yaml(StringInfo buf, const char *str)
Definition: explain.c:4634
InvalidSnapshot
#define InvalidSnapshot
Definition: snapshot.h:123
EState::es_trig_target_relations
List * es_trig_target_relations
Definition: execnodes.h:546
JitInstrumentation::inlining_counter
instr_time inlining_counter
Definition: jit.h:36
do_text_output_multiline
void do_text_output_multiline(TupOutputState *tstate, const char *txt)
Definition: execTuples.c:2284
WorkerInstrumentation::instrument
Instrumentation instrument[FLEXIBLE_ARRAY_MEMBER]
Definition: instrument.h:81
palloc0
void * palloc0(Size size)
Definition: mcxt.c:980
CommandCounterIncrement
void CommandCounterIncrement(void)
Definition: xact.c:1006
PlannedStmt::commandType
CmdType commandType
Definition: plannodes.h:46
IncrementalSortInfo::fullsortGroupInfo
IncrementalSortGroupInfo fullsortGroupInfo
Definition: execnodes.h:2044
PGJIT_INLINE
#define PGJIT_INLINE
Definition: jit.h:22
make_ands_explicit
Expr * make_ands_explicit(List *andclauses)
Definition: makefuncs.c:705
InstrJitAgg
void InstrJitAgg(JitInstrumentation *dst, JitInstrumentation *add)
Definition: jit.c:184
label
static char * label
Definition: pg_basebackup.c:131
ExplainState::verbose
bool verbose
Definition: explain.h:41
ExplainTargetRel
static void ExplainTargetRel(Plan *plan, Index rti, ExplainState *es)
Definition: explain.c:3436
EState::es_num_result_relations
int es_num_result_relations
Definition: execnodes.h:526
Agg::groupingSets
List * groupingSets
Definition: plannodes.h:829
Instrumentation::bufusage
BufferUsage bufusage
Definition: instrument.h:74
Index
unsigned int Index
Definition: c.h:475
appendStringInfoSpaces
void appendStringInfoSpaces(StringInfo str, int count)
Definition: stringinfo.c:206
ExplainCustomChildren
static void ExplainCustomChildren(CustomScanState *css, List *ancestors, ExplainState *es)
Definition: explain.c:3794
ExplainJSONLineEnding
static void ExplainJSONLineEnding(ExplainState *es)
Definition: explain.c:4589
T_Hash
Definition: nodes.h:84
PlanState::plan
Plan * plan
Definition: execnodes.h:945
lookup_type_cache
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition: typcache.c:331
Gather::num_workers
int num_workers
Definition: plannodes.h:887
EState::es_tuple_routing_result_relations
List * es_tuple_routing_result_relations
Definition: execnodes.h:543
CustomExecMethods::ExplainCustomScan
void(* ExplainCustomScan)(CustomScanState *node, List *ancestors, ExplainState *es)
Definition: extensible.h:151
MergeAppendState::ps
PlanState ps
Definition: execnodes.h:1251
value
static struct @143 value
ereport
#define ereport(elevel,...)
Definition: elog.h:144
get_typcollation
Oid get_typcollation(Oid typid)
Definition: lsyscache.c:2933
ExplainWorkersState::worker_inited
bool * worker_inited
Definition: explain.h:31
CreateTableAsStmt::into
IntoClause * into
Definition: parsenodes.h:3277