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