/
githubmirror
/
postgres
Обзор
Документация
Войти
/
githubmirror
/
postgres
Код
Запросы
0
Пакеты
0
Релизы
0
Аналитика
Безопасность
master
src/backend/commands/explain.c
5 329 строк
152 KB
David Rowley
Show estimated number of groups for Incremental Sort in EXPLAIN
12 часов назад
12 часов назад
d29d469
Код
Авторство
О чём код?
/*------------------------------------------------------------------------- * * explain.c * Explain query execution plans * * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group * Portions Copyright (c) 1994-5, Regents of the University of California * * IDENTIFICATION * src/backend/commands/explain.c * *------------------------------------------------------------------------- */ #include "postgres.h" #include "access/relscan.h" #include "access/xact.h" #include "catalog/pg_type.h" #include "commands/createas.h" #include "commands/defrem.h" #include "commands/explain.h" #include "commands/explain_dr.h" #include "commands/explain_format.h" #include "commands/explain_state.h" #include "commands/prepare.h" #include "foreign/fdwapi.h" #include "jit/jit.h" #include "libpq/pqformat.h" #include "libpq/protocol.h" #include "nodes/extensible.h" #include "nodes/makefuncs.h" #include "nodes/nodeFuncs.h" #include "parser/analyze.h" #include "parser/parsetree.h" #include "rewrite/rewriteHandler.h" #include "storage/bufmgr.h" #include "tcop/tcopprot.h" #include "utils/builtins.h" #include "utils/guc_tables.h" #include "utils/json.h" #include "utils/lsyscache.h" #include "utils/rel.h" #include "utils/ruleutils.h" #include "utils/snapmgr.h" #include "utils/tuplesort.h" #include "utils/tuplestore.h" #include "utils/typcache.h" #include "utils/xml.h" /* Hook for plugins to get control in ExplainOneQuery() */ ExplainOneQuery_hook_type ExplainOneQuery_hook = NULL; /* Hook for plugins to get control in explain_get_index_name() */ explain_get_index_name_hook_type explain_get_index_name_hook = NULL; /* per-plan and per-node hooks for plugins to print additional info */ explain_per_plan_hook_type explain_per_plan_hook = NULL; explain_per_node_hook_type explain_per_node_hook = NULL; /* * Various places within need to convert bytes to kilobytes. Round these up * to the next whole kilobyte. */ #define BYTES_TO_KILOBYTES(b) (((b) + 1023) / 1024) static void ExplainOneQuery(Query *query, int cursorOptions, IntoClause *into, ExplainState *es, ParseState *pstate, ParamListInfo params); static void ExplainPrintJIT(ExplainState *es, int jit_flags, JitInstrumentation *ji); static void ExplainPrintSerialize(ExplainState *es, SerializeMetrics *metrics); static void report_triggers(ResultRelInfo *rInfo, bool show_relname, ExplainState *es); static double elapsed_time(instr_time *starttime); static bool ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used); static void ExplainNode(PlanState *planstate, List *ancestors, const char *relationship, const char *plan_name, ExplainState *es); static void show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es); static void show_expression(Node *node, const char *qlabel, PlanState *planstate, List *ancestors, bool useprefix, ExplainState *es); static void show_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, bool useprefix, ExplainState *es); static void show_scan_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, ExplainState *es); static void show_upper_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, ExplainState *es); static void show_sort_keys(SortState *sortstate, List *ancestors, ExplainState *es); static void show_incremental_sort_keys(IncrementalSortState *incrsortstate, List *ancestors, ExplainState *es); static void show_merge_append_keys(MergeAppendState *mstate, List *ancestors, ExplainState *es); static void show_agg_keys(AggState *astate, List *ancestors, ExplainState *es); static void show_grouping_sets(PlanState *planstate, Agg *agg, List *ancestors, ExplainState *es); static void show_grouping_set_keys(PlanState *planstate, Agg *aggnode, Sort *sortnode, List *context, bool useprefix, List *ancestors, ExplainState *es); static void show_group_keys(GroupState *gstate, List *ancestors, ExplainState *es); static void show_sort_group_keys(PlanState *planstate, const char *qlabel, int nkeys, int nPresortedKeys, AttrNumber *keycols, Oid *sortOperators, Oid *collations, bool *nullsFirst, List *ancestors, ExplainState *es); static void show_sortorder_options(StringInfo buf, Node *sortexpr, Oid sortOperator, Oid collation, bool nullsFirst); static void show_window_def(WindowAggState *planstate, List *ancestors, ExplainState *es); static void show_window_keys(StringInfo buf, PlanState *planstate, int nkeys, AttrNumber *keycols, List *ancestors, ExplainState *es); static void show_storage_info(char *maxStorageType, int64 maxSpaceUsed, ExplainState *es); static void show_tablesample(TableSampleClause *tsc, PlanState *planstate, List *ancestors, ExplainState *es); static void show_sort_info(SortState *sortstate, ExplainState *es); static void show_incremental_sort_info(IncrementalSortState *incrsortstate, ExplainState *es); static void show_hash_info(HashState *hashstate, ExplainState *es); static void show_material_info(MaterialState *mstate, ExplainState *es); static void show_windowagg_info(WindowAggState *winstate, ExplainState *es); static void show_ctescan_info(CteScanState *ctescanstate, ExplainState *es); static void show_table_func_scan_info(TableFuncScanState *tscanstate, ExplainState *es); static void show_recursive_union_info(RecursiveUnionState *rstate, ExplainState *es); static void show_memoize_info(MemoizeState *mstate, List *ancestors, ExplainState *es); static void show_hashagg_info(AggState *aggstate, ExplainState *es); static void show_indexsearches_info(PlanState *planstate, ExplainState *es); static void show_tidbitmap_info(BitmapHeapScanState *planstate, ExplainState *es); static void show_scan_io_usage(ScanState *planstate, ExplainState *es); static void show_instrumentation_count(const char *qlabel, int which, PlanState *planstate, ExplainState *es); static void show_foreignscan_info(ForeignScanState *fsstate, ExplainState *es); static const char *explain_get_index_name(Oid indexId); static bool peek_buffer_usage(ExplainState *es, const BufferUsage *usage); static void show_buffer_usage(ExplainState *es, const BufferUsage *usage); static void show_wal_usage(ExplainState *es, const WalUsage *usage); static void show_memory_counters(ExplainState *es, const MemoryContextCounters *mem_counters); static void show_result_replacement_info(Result *result, ExplainState *es); static void ExplainIndexScanDetails(Oid indexid, ScanDirection indexorderdir, ExplainState *es); static void ExplainScanTarget(Scan *plan, ExplainState *es); static void ExplainModifyTarget(ModifyTable *plan, ExplainState *es); static void ExplainTargetRel(Plan *plan, Index rti, ExplainState *es); static void show_modifytable_info(ModifyTableState *mtstate, List *ancestors, ExplainState *es); static void ExplainMemberNodes(PlanState **planstates, int nplans, List *ancestors, ExplainState *es); static void ExplainMissingMembers(int nplans, int nchildren, ExplainState *es); static void ExplainSubPlans(List *plans, List *ancestors, const char *relationship, ExplainState *es); static void ExplainCustomChildren(CustomScanState *css, List *ancestors, ExplainState *es); static ExplainWorkersState *ExplainCreateWorkersState(int num_workers); static void ExplainOpenWorker(int n, ExplainState *es); static void ExplainCloseWorker(int n, ExplainState *es); static void ExplainFlushWorkersState(ExplainState *es); /* * ExplainQuery - * execute an EXPLAIN command */ void ExplainQuery(ParseState *pstate, ExplainStmt *stmt, ParamListInfo params, DestReceiver *dest) { ExplainState *es = NewExplainState(); TupOutputState *tstate; JumbleState *jstate = NULL; Query *query; List *rewritten; /* Configure the ExplainState based on the provided options */ ParseExplainOptionList(es, stmt->options, pstate); /* Extract the query and, if enabled, jumble it */ query = castNode(Query, stmt->query); if (IsQueryIdEnabled()) jstate = JumbleQuery(query); if (post_parse_analyze_hook) (*post_parse_analyze_hook) (pstate, query, jstate); /* * Parse analysis was done already, but we still have to run the rule * rewriter. We do not do AcquireRewriteLocks: we assume the query either * came straight from the parser, or suitable locks were acquired by * plancache.c. */ rewritten = QueryRewrite(castNode(Query, stmt->query)); /* emit opening boilerplate */ ExplainBeginOutput(es); if (rewritten == NIL) { /* * In the case of an INSTEAD NOTHING, tell at least that. But in * non-text format, the output is delimited, so this isn't necessary. */ if (es->format == EXPLAIN_FORMAT_TEXT) appendStringInfoString(es->str, "Query rewrites to nothing\n"); } else { ListCell *l; /* Explain every plan */ foreach(l, rewritten) { ExplainOneQuery(lfirst_node(Query, l), CURSOR_OPT_PARALLEL_OK, NULL, es, pstate, params); /* Separate plans with an appropriate separator */ if (lnext(rewritten, l) != NULL) ExplainSeparatePlans(es); } } /* emit closing boilerplate */ ExplainEndOutput(es); Assert(es->indent == 0); /* output tuples */ tstate = begin_tup_output_tupdesc(dest, ExplainResultDesc(stmt), &TTSOpsVirtual); if (es->format == EXPLAIN_FORMAT_TEXT) do_text_output_multiline(tstate, es->str->data); else do_text_output_oneline(tstate, es->str->data); end_tup_output(tstate); pfree(es->str->data); } /* * ExplainResultDesc - * construct the result tupledesc for an EXPLAIN */ TupleDesc ExplainResultDesc(ExplainStmt *stmt) { TupleDesc tupdesc; ListCell *lc; Oid result_type = TEXTOID; /* Check for XML format option */ foreach(lc, stmt->options) { DefElem *opt = (DefElem *) lfirst(lc); if (strcmp(opt->defname, "format") == 0) { char *p = defGetString(opt); if (strcmp(p, "xml") == 0) result_type = XMLOID; else if (strcmp(p, "json") == 0) result_type = JSONOID; else result_type = TEXTOID; /* don't "break", as ExplainQuery will use the last value */ } } /* Need a tuple descriptor representing a single TEXT or XML column */ tupdesc = CreateTemplateTupleDesc(1); TupleDescInitEntry(tupdesc, (AttrNumber) 1, "QUERY PLAN", result_type, -1, 0); TupleDescFinalize(tupdesc); return tupdesc; } /* * ExplainOneQuery - * print out the execution plan for one Query * * "into" is NULL unless we are explaining the contents of a CreateTableAsStmt. */ static void ExplainOneQuery(Query *query, int cursorOptions, IntoClause *into, ExplainState *es, ParseState *pstate, ParamListInfo params) { /* planner will not cope with utility statements */ if (query->commandType == CMD_UTILITY) { ExplainOneUtility(query->utilityStmt, into, es, pstate, params); return; } /* if an advisor plugin is present, let it manage things */ if (ExplainOneQuery_hook) (*ExplainOneQuery_hook) (query, cursorOptions, into, es, pstate->p_sourcetext, params, pstate->p_queryEnv); else standard_ExplainOneQuery(query, cursorOptions, into, es, pstate->p_sourcetext, params, pstate->p_queryEnv); } /* * standard_ExplainOneQuery - * print out the execution plan for one Query, without calling a hook. */ void standard_ExplainOneQuery(Query *query, int cursorOptions, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv) { PlannedStmt *plan; instr_time planstart, planduration; BufferUsage bufusage_start, bufusage; MemoryContextCounters mem_counters; MemoryContext planner_ctx = NULL; MemoryContext saved_ctx = NULL; if (es->memory) { /* * Create a new memory context to measure planner's memory consumption * accurately. Note that if the planner were to be modified to use a * different memory context type, here we would be changing that to * AllocSet, which might be undesirable. However, we don't have a way * to create a context of the same type as another, so we pray and * hope that this is OK. */ planner_ctx = AllocSetContextCreate(CurrentMemoryContext, "explain analyze planner context", ALLOCSET_DEFAULT_SIZES); saved_ctx = MemoryContextSwitchTo(planner_ctx); } if (es->buffers) bufusage_start = pgBufferUsage; INSTR_TIME_SET_CURRENT(planstart); /* plan the query */ plan = pg_plan_query(query, queryString, cursorOptions, params, es); INSTR_TIME_SET_CURRENT(planduration); INSTR_TIME_SUBTRACT(planduration, planstart); if (es->memory) { MemoryContextSwitchTo(saved_ctx); MemoryContextMemConsumed(planner_ctx, &mem_counters); } /* calc differences of buffer counters. */ if (es->buffers) { memset(&bufusage, 0, sizeof(BufferUsage)); BufferUsageAccumDiff(&bufusage, &pgBufferUsage, &bufusage_start); } /* run it (if needed) and produce output */ ExplainOnePlan(plan, into, es, queryString, params, queryEnv, &planduration, (es->buffers ? &bufusage : NULL), es->memory ? &mem_counters : NULL); } /* * ExplainOneUtility - * print out the execution plan for one utility statement * (In general, utility statements don't have plans, but there are some * we treat as special cases) * * "into" is NULL unless we are explaining the contents of a CreateTableAsStmt. * * This is exported because it's called back from prepare.c in the * EXPLAIN EXECUTE case. In that case, we'll be dealing with a statement * that's in the plan cache, so we have to ensure we don't modify it. */ void ExplainOneUtility(Node *utilityStmt, IntoClause *into, ExplainState *es, ParseState *pstate, ParamListInfo params) { if (utilityStmt == NULL) return; if (IsA(utilityStmt, CreateTableAsStmt)) { /* * We have to rewrite the contained SELECT and then pass it back to * ExplainOneQuery. Copy to be safe in the EXPLAIN EXECUTE case. */ CreateTableAsStmt *ctas = (CreateTableAsStmt *) utilityStmt; Query *ctas_query; List *rewritten; JumbleState *jstate = NULL; /* * Check if the relation exists or not. This is done at this stage to * avoid query planning or execution. */ if (CreateTableAsRelExists(ctas)) { if (ctas->objtype == OBJECT_TABLE) ExplainDummyGroup("CREATE TABLE AS", NULL, es); else if (ctas->objtype == OBJECT_MATVIEW) ExplainDummyGroup("CREATE MATERIALIZED VIEW", NULL, es); else elog(ERROR, "unexpected object type: %d", (int) ctas->objtype); return; } ctas_query = castNode(Query, copyObject(ctas->query)); if (IsQueryIdEnabled()) jstate = JumbleQuery(ctas_query); if (post_parse_analyze_hook) (*post_parse_analyze_hook) (pstate, ctas_query, jstate); rewritten = QueryRewrite(ctas_query); Assert(list_length(rewritten) == 1); ExplainOneQuery(linitial_node(Query, rewritten), CURSOR_OPT_PARALLEL_OK, ctas->into, es, pstate, params); } else if (IsA(utilityStmt, DeclareCursorStmt)) { /* * Likewise for DECLARE CURSOR. * * Notice that if you say EXPLAIN ANALYZE DECLARE CURSOR then we'll * actually run the query. This is different from pre-8.3 behavior * but seems more useful than not running the query. No cursor will * be created, however. */ DeclareCursorStmt *dcs = (DeclareCursorStmt *) utilityStmt; Query *dcs_query; List *rewritten; JumbleState *jstate = NULL; dcs_query = castNode(Query, copyObject(dcs->query)); if (IsQueryIdEnabled()) jstate = JumbleQuery(dcs_query); if (post_parse_analyze_hook) (*post_parse_analyze_hook) (pstate, dcs_query, jstate); rewritten = QueryRewrite(dcs_query); Assert(list_length(rewritten) == 1); ExplainOneQuery(linitial_node(Query, rewritten), dcs->options, NULL, es, pstate, params); } else if (IsA(utilityStmt, ExecuteStmt)) ExplainExecuteQuery((ExecuteStmt *) utilityStmt, into, es, pstate, params); else if (IsA(utilityStmt, NotifyStmt)) { if (es->format == EXPLAIN_FORMAT_TEXT) appendStringInfoString(es->str, "NOTIFY\n"); else ExplainDummyGroup("Notify", NULL, es); } else { if (es->format == EXPLAIN_FORMAT_TEXT) appendStringInfoString(es->str, "Utility statements have no plan structure\n"); else ExplainDummyGroup("Utility Statement", NULL, es); } } /* * ExplainOnePlan - * given a planned query, execute it if needed, and then print * EXPLAIN output * * "into" is NULL unless we are explaining the contents of a CreateTableAsStmt, * in which case executing the query should result in creating that table. * * This is exported because it's called back from prepare.c in the * EXPLAIN EXECUTE case, and because an index advisor plugin would need * to call it. */ void ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv, const instr_time *planduration, const BufferUsage *bufusage, const MemoryContextCounters *mem_counters) { DestReceiver *dest; QueryDesc *queryDesc; instr_time starttime; double totaltime = 0; int eflags; int instrument_option = 0; SerializeMetrics serializeMetrics = {0}; Assert(plannedstmt->commandType != CMD_UTILITY); if (es->analyze && es->timing) instrument_option |= INSTRUMENT_TIMER; else if (es->analyze) instrument_option |= INSTRUMENT_ROWS; if (es->buffers) instrument_option |= INSTRUMENT_BUFFERS; if (es->wal) instrument_option |= INSTRUMENT_WAL; if (es->io) instrument_option |= INSTRUMENT_IO; /* * We always collect timing for the entire statement, even when node-level * timing is off, so we don't look at es->timing here. (We could skip * this if !es->summary, but it's hardly worth the complication.) */ INSTR_TIME_SET_CURRENT(starttime); /* * Use a snapshot with an updated command ID to ensure this query sees * results of any previously executed queries. */ PushCopiedSnapshot(GetActiveSnapshot()); UpdateActiveSnapshotCommandId(); /* * We discard the output if we have no use for it. If we're explaining * CREATE TABLE AS, we'd better use the appropriate tuple receiver, while * the SERIALIZE option requires its own tuple receiver. (If you specify * SERIALIZE while explaining CREATE TABLE AS, you'll see zeroes for the * results, which is appropriate since no data would have gone to the * client.) */ if (into) dest = CreateIntoRelDestReceiver(into); else if (es->serialize != EXPLAIN_SERIALIZE_NONE) dest = CreateExplainSerializeDestReceiver(es); else dest = None_Receiver; /* Create a QueryDesc for the query */ queryDesc = CreateQueryDesc(plannedstmt, queryString, GetActiveSnapshot(), InvalidSnapshot, dest, params, queryEnv, instrument_option); /* Select execution options */ if (es->analyze) eflags = 0; /* default run-to-completion flags */ else eflags = EXEC_FLAG_EXPLAIN_ONLY; if (es->generic) eflags |= EXEC_FLAG_EXPLAIN_GENERIC; if (into) eflags |= GetIntoRelEFlags(into); /* call ExecutorStart to prepare the plan for execution */ ExecutorStart(queryDesc, eflags); /* Execute the plan for statistics if asked for */ if (es->analyze) { ScanDirection dir; /* EXPLAIN ANALYZE CREATE TABLE AS WITH NO DATA is weird */ if (into && into->skipData) dir = NoMovementScanDirection; else dir = ForwardScanDirection; /* run the plan */ ExecutorRun(queryDesc, dir, 0); /* run cleanup too */ ExecutorFinish(queryDesc); /* We can't run ExecutorEnd 'till we're done printing the stats... */ totaltime += elapsed_time(&starttime); } /* grab serialization metrics before we destroy the DestReceiver */ if (es->serialize != EXPLAIN_SERIALIZE_NONE) serializeMetrics = GetSerializationMetrics(dest); /* call the DestReceiver's destroy method even during explain */ dest->rDestroy(dest); ExplainOpenGroup("Query", NULL, true, es); /* Create textual dump of plan tree */ ExplainPrintPlan(es, queryDesc); /* Show buffer and/or memory usage in planning */ if (peek_buffer_usage(es, bufusage) || mem_counters) { ExplainOpenGroup("Planning", "Planning", true, es); if (es->format == EXPLAIN_FORMAT_TEXT) { ExplainIndentText(es); appendStringInfoString(es->str, "Planning:\n"); es->indent++; } if (bufusage) show_buffer_usage(es, bufusage); if (mem_counters) show_memory_counters(es, mem_counters); if (es->format == EXPLAIN_FORMAT_TEXT) es->indent--; ExplainCloseGroup("Planning", "Planning", true, es); } if (es->summary && planduration) { double plantime = INSTR_TIME_GET_DOUBLE(*planduration); ExplainPropertyFloat("Planning Time", "ms", 1000.0 * plantime, 3, es); } /* Print info about runtime of triggers */ if (es->analyze) ExplainPrintTriggers(es, queryDesc); /* * Print info about JITing. Tied to es->costs because we don't want to * display this in regression tests, as it'd cause output differences * depending on build options. Might want to separate that out from COSTS * at a later stage. */ if (es->costs) ExplainPrintJITSummary(es, queryDesc); /* Print info about serialization of output */ if (es->serialize != EXPLAIN_SERIALIZE_NONE) ExplainPrintSerialize(es, &serializeMetrics); /* Allow plugins to print additional information */ if (explain_per_plan_hook) (*explain_per_plan_hook) (plannedstmt, into, es, queryString, params, queryEnv); /* * Close down the query and free resources. Include time for this in the * total execution time (although it should be pretty minimal). */ INSTR_TIME_SET_CURRENT(starttime); ExecutorEnd(queryDesc); FreeQueryDesc(queryDesc); PopActiveSnapshot(); /* We need a CCI just in case query expanded to multiple plans */ if (es->analyze) CommandCounterIncrement(); totaltime += elapsed_time(&starttime); /* * We only report execution time if we actually ran the query (that is, * the user specified ANALYZE), and if summary reporting is enabled (the * user can set SUMMARY OFF to not have the timing information included in * the output). By default, ANALYZE sets SUMMARY to true. */ if (es->summary && es->analyze) ExplainPropertyFloat("Execution Time", "ms", 1000.0 * totaltime, 3, es); ExplainCloseGroup("Query", NULL, true, es); } /* * ExplainPrintSettings - * Print summary of modified settings affecting query planning. */ static void ExplainPrintSettings(ExplainState *es) { int num; struct config_generic **gucs; /* bail out if information about settings not requested */ if (!es->settings) return; /* request an array of relevant settings */ gucs = get_explain_guc_options(&num); if (es->format != EXPLAIN_FORMAT_TEXT) { ExplainOpenGroup("Settings", "Settings", true, es); for (int i = 0; i < num; i++) { char *setting; struct config_generic *conf = gucs[i]; setting = GetConfigOptionByName(conf->name, NULL, true); ExplainPropertyText(conf->name, setting, es); } ExplainCloseGroup("Settings", "Settings", true, es); } else { StringInfoData str; /* In TEXT mode, print nothing if there are no options */ if (num <= 0) return; initStringInfo(&str); for (int i = 0; i < num; i++) { char *setting; struct config_generic *conf = gucs[i]; if (i > 0) appendStringInfoString(&str, ", "); setting = GetConfigOptionByName(conf->name, NULL, true); if (setting) appendStringInfo(&str, "%s = '%s'", conf->name, setting); else appendStringInfo(&str, "%s = NULL", conf->name); } ExplainPropertyText("Settings", str.data, es); } } /* * ExplainPrintPlan - * convert a QueryDesc's plan tree to text and append it to es->str * * The caller should have set up the options fields of *es, as well as * initializing the output buffer es->str. Also, output formatting state * such as the indent level is assumed valid. Plan-tree-specific fields * in *es are initialized here. * * NB: will not work on utility statements */ void ExplainPrintPlan(ExplainState *es, QueryDesc *queryDesc) { Bitmapset *rels_used = NULL; PlanState *ps; ListCell *lc; /* Set up ExplainState fields associated with this plan tree */ Assert(queryDesc->plannedstmt != NULL); es->pstmt = queryDesc->plannedstmt; es->rtable = queryDesc->plannedstmt->rtable; ExplainPreScanNode(queryDesc->planstate, &rels_used); es->rtable_names = select_rtable_names_for_explain(es->rtable, rels_used); es->deparse_cxt = deparse_context_for_plan_tree(queryDesc->plannedstmt, es->rtable_names); es->printed_subplans = NULL; es->rtable_size = list_length(es->rtable); foreach(lc, es->rtable) { RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc); if (rte->rtekind == RTE_GROUP) { es->rtable_size--; break; } } /* * Sometimes we mark a Gather node as "invisible", which means that it's * not to be displayed in EXPLAIN output. The purpose of this is to allow * running regression tests with debug_parallel_query=regress to get the * same results as running the same tests with debug_parallel_query=off. * Such marking is currently only supported on a Gather at the top of the * plan. We skip that node, and we must also hide per-worker detail data * further down in the plan tree. */ ps = queryDesc->planstate; if (IsA(ps, GatherState) && ((Gather *) ps->plan)->invisible) { ps = outerPlanState(ps); es->hide_workers = true; } ExplainNode(ps, NIL, NULL, NULL, es); /* * If requested, include information about GUC parameters with values that * don't match the built-in defaults. */ ExplainPrintSettings(es); /* * COMPUTE_QUERY_ID_REGRESS means COMPUTE_QUERY_ID_AUTO, but we don't show * the queryid in any of the EXPLAIN plans to keep stable the results * generated by regression test suites. */ if (es->verbose && queryDesc->plannedstmt->queryId != INT64CONST(0) && compute_query_id != COMPUTE_QUERY_ID_REGRESS) { ExplainPropertyInteger("Query Identifier", NULL, queryDesc->plannedstmt->queryId, es); } } /* * ExplainPrintTriggers - * convert a QueryDesc's trigger statistics to text and append it to * es->str * * The caller should have set up the options fields of *es, as well as * initializing the output buffer es->str. Other fields in *es are * initialized here. */ void ExplainPrintTriggers(ExplainState *es, QueryDesc *queryDesc) { ResultRelInfo *rInfo; bool show_relname; List *resultrels; List *routerels; List *targrels; ListCell *l; resultrels = queryDesc->estate->es_opened_result_relations; routerels = queryDesc->estate->es_tuple_routing_result_relations; targrels = queryDesc->estate->es_trig_target_relations; ExplainOpenGroup("Triggers", "Triggers", false, es); show_relname = (list_length(resultrels) > 1 || routerels != NIL || targrels != NIL); foreach(l, resultrels) { rInfo = (ResultRelInfo *) lfirst(l); report_triggers(rInfo, show_relname, es); } foreach(l, routerels) { rInfo = (ResultRelInfo *) lfirst(l); report_triggers(rInfo, show_relname, es); } foreach(l, targrels) { rInfo = (ResultRelInfo *) lfirst(l); report_triggers(rInfo, show_relname, es); } ExplainCloseGroup("Triggers", "Triggers", false, es); } /* * ExplainPrintJITSummary - * Print summarized JIT instrumentation from leader and workers */ void ExplainPrintJITSummary(ExplainState *es, QueryDesc *queryDesc) { JitInstrumentation ji = {0}; if (!(queryDesc->estate->es_jit_flags & PGJIT_PERFORM)) return; /* * Work with a copy instead of modifying the leader state, since this * function may be called twice */ if (queryDesc->estate->es_jit) InstrJitAgg(&ji, &queryDesc->estate->es_jit->instr); /* If this process has done JIT in parallel workers, merge stats */ if (queryDesc->estate->es_jit_worker_instr) InstrJitAgg(&ji, queryDesc->estate->es_jit_worker_instr); ExplainPrintJIT(es, queryDesc->estate->es_jit_flags, &ji); } /* * ExplainPrintJIT - * Append information about JITing to es->str. */ static void ExplainPrintJIT(ExplainState *es, int jit_flags, JitInstrumentation *ji) { instr_time total_time; /* don't print information if no JITing happened */ if (!ji || ji->created_functions == 0) return; /* calculate total time */ INSTR_TIME_SET_ZERO(total_time); /* don't add deform_counter, it's included in generation_counter */ INSTR_TIME_ADD(total_time, ji->generation_counter); INSTR_TIME_ADD(total_time, ji->inlining_counter); INSTR_TIME_ADD(total_time, ji->optimization_counter); INSTR_TIME_ADD(total_time, ji->emission_counter); ExplainOpenGroup("JIT", "JIT", true, es); /* for higher density, open code the text output format */ if (es->format == EXPLAIN_FORMAT_TEXT) { ExplainIndentText(es); appendStringInfoString(es->str, "JIT:\n"); es->indent++; ExplainPropertyInteger("Functions", NULL, ji->created_functions, es); ExplainIndentText(es); appendStringInfo(es->str, "Options: %s %s, %s %s, %s %s, %s %s\n", "Inlining", jit_flags & PGJIT_INLINE ? "true" : "false", "Optimization", jit_flags & PGJIT_OPT3 ? "true" : "false", "Expressions", jit_flags & PGJIT_EXPR ? "true" : "false", "Deforming", jit_flags & PGJIT_DEFORM ? "true" : "false"); if (es->analyze && es->timing) { ExplainIndentText(es); appendStringInfo(es->str, "Timing: %s %.3f ms (%s %.3f ms), %s %.3f ms, %s %.3f ms, %s %.3f ms, %s %.3f ms\n", "Generation", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->generation_counter), "Deform", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->deform_counter), "Inlining", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->inlining_counter), "Optimization", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->optimization_counter), "Emission", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->emission_counter), "Total", 1000.0 * INSTR_TIME_GET_DOUBLE(total_time)); } es->indent--; } else { ExplainPropertyInteger("Functions", NULL, ji->created_functions, es); ExplainOpenGroup("Options", "Options", true, es); ExplainPropertyBool("Inlining", jit_flags & PGJIT_INLINE, es); ExplainPropertyBool("Optimization", jit_flags & PGJIT_OPT3, es); ExplainPropertyBool("Expressions", jit_flags & PGJIT_EXPR, es); ExplainPropertyBool("Deforming", jit_flags & PGJIT_DEFORM, es); ExplainCloseGroup("Options", "Options", true, es); if (es->analyze && es->timing) { ExplainOpenGroup("Timing", "Timing", true, es); ExplainOpenGroup("Generation", "Generation", true, es); ExplainPropertyFloat("Deform", "ms", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->deform_counter), 3, es); ExplainPropertyFloat("Total", "ms", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->generation_counter), 3, es); ExplainCloseGroup("Generation", "Generation", true, es); ExplainPropertyFloat("Inlining", "ms", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->inlining_counter), 3, es); ExplainPropertyFloat("Optimization", "ms", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->optimization_counter), 3, es); ExplainPropertyFloat("Emission", "ms", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->emission_counter), 3, es); ExplainPropertyFloat("Total", "ms", 1000.0 * INSTR_TIME_GET_DOUBLE(total_time), 3, es); ExplainCloseGroup("Timing", "Timing", true, es); } } ExplainCloseGroup("JIT", "JIT", true, es); } /* * ExplainPrintSerialize - * Append information about query output volume to es->str. */ static void ExplainPrintSerialize(ExplainState *es, SerializeMetrics *metrics) { const char *format; /* We shouldn't get called for EXPLAIN_SERIALIZE_NONE */ if (es->serialize == EXPLAIN_SERIALIZE_TEXT) format = "text"; else { Assert(es->serialize == EXPLAIN_SERIALIZE_BINARY); format = "binary"; } ExplainOpenGroup("Serialization", "Serialization", true, es); if (es->format == EXPLAIN_FORMAT_TEXT) { ExplainIndentText(es); if (es->timing) appendStringInfo(es->str, "Serialization: time=%.3f ms output=" UINT64_FORMAT "kB format=%s\n", 1000.0 * INSTR_TIME_GET_DOUBLE(metrics->timeSpent), BYTES_TO_KILOBYTES(metrics->bytesSent), format); else appendStringInfo(es->str, "Serialization: output=" UINT64_FORMAT "kB format=%s\n", BYTES_TO_KILOBYTES(metrics->bytesSent), format); if (es->buffers && peek_buffer_usage(es, &metrics->bufferUsage)) { es->indent++; show_buffer_usage(es, &metrics->bufferUsage); es->indent--; } } else { if (es->timing) ExplainPropertyFloat("Time", "ms", 1000.0 * INSTR_TIME_GET_DOUBLE(metrics->timeSpent), 3, es); ExplainPropertyUInteger("Output Volume", "kB", BYTES_TO_KILOBYTES(metrics->bytesSent), es); ExplainPropertyText("Format", format, es); if (es->buffers) show_buffer_usage(es, &metrics->bufferUsage); } ExplainCloseGroup("Serialization", "Serialization", true, es); } /* * ExplainQueryText - * add a "Query Text" node that contains the actual text of the query * * The caller should have set up the options fields of *es, as well as * initializing the output buffer es->str. * */ void ExplainQueryText(ExplainState *es, QueryDesc *queryDesc) { if (queryDesc->sourceText) ExplainPropertyText("Query Text", queryDesc->sourceText, es); } /* * ExplainQueryParameters - * add a "Query Parameters" node that describes the parameters of the query * * The caller should have set up the options fields of *es, as well as * initializing the output buffer es->str. * */ void ExplainQueryParameters(ExplainState *es, ParamListInfo params, int maxlen) { char *str; /* This check is consistent with errdetail_params() */ if (params == NULL || params->numParams <= 0 || maxlen == 0) return; str = BuildParamLogString(params, NULL, maxlen); if (str && str[0] != '\0') ExplainPropertyText("Query Parameters", str, es); } /* * report_triggers - * report execution stats for a single relation's triggers */ static void report_triggers(ResultRelInfo *rInfo, bool show_relname, ExplainState *es) { int nt; if (!rInfo->ri_TrigDesc || !rInfo->ri_TrigInstrument) return; for (nt = 0; nt < rInfo->ri_TrigDesc->numtriggers; nt++) { Trigger *trig = rInfo->ri_TrigDesc->triggers + nt; TriggerInstrumentation *tginstr = rInfo->ri_TrigInstrument + nt; char *relname; char *conname = NULL; /* * We ignore triggers that were never invoked; they likely aren't * relevant to the current query type. */ if (tginstr->firings == 0) continue; ExplainOpenGroup("Trigger", NULL, true, es); relname = RelationGetRelationName(rInfo->ri_RelationDesc); if (OidIsValid(trig->tgconstraint)) conname = get_constraint_name(trig->tgconstraint); /* * In text format, we avoid printing both the trigger name and the * constraint name unless VERBOSE is specified. In non-text formats * we just print everything. */ if (es->format == EXPLAIN_FORMAT_TEXT) { if (es->verbose || conname == NULL) appendStringInfo(es->str, "Trigger %s", trig->tgname); else appendStringInfoString(es->str, "Trigger"); if (conname) appendStringInfo(es->str, " for constraint %s", conname); if (show_relname) appendStringInfo(es->str, " on %s", relname); if (es->timing) appendStringInfo(es->str, ": time=%.3f calls=%" PRId64 "\n", INSTR_TIME_GET_MILLISEC(tginstr->instr.total), tginstr->firings); else appendStringInfo(es->str, ": calls=%" PRId64 "\n", tginstr->firings); } else { ExplainPropertyText("Trigger Name", trig->tgname, es); if (conname) ExplainPropertyText("Constraint Name", conname, es); ExplainPropertyText("Relation", relname, es); if (es->timing) ExplainPropertyFloat("Time", "ms", INSTR_TIME_GET_MILLISEC(tginstr->instr.total), 3, es); ExplainPropertyInteger("Calls", NULL, tginstr->firings, es); } if (conname) pfree(conname); ExplainCloseGroup("Trigger", NULL, true, es); } } /* Compute elapsed time in seconds since given timestamp */ static double elapsed_time(instr_time *starttime) { instr_time endtime; INSTR_TIME_SET_CURRENT(endtime); INSTR_TIME_SUBTRACT(endtime, *starttime); return INSTR_TIME_GET_DOUBLE(endtime); } /* * ExplainPreScanNode - * Prescan the planstate tree to identify which RTEs are referenced * * Adds the relid of each referenced RTE to *rels_used. The result controls * which RTEs are assigned aliases by select_rtable_names_for_explain. * This ensures that we don't confusingly assign un-suffixed aliases to RTEs * that never appear in the EXPLAIN output (such as inheritance parents). */ static bool ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used) { Plan *plan = planstate->plan; switch (nodeTag(plan)) { case T_SeqScan: case T_SampleScan: case T_IndexScan: case T_IndexOnlyScan: case T_BitmapHeapScan: case T_TidScan: case T_TidRangeScan: case T_SubqueryScan: case T_FunctionScan: case T_TableFuncScan: case T_ValuesScan: case T_CteScan: case T_NamedTuplestoreScan: case T_WorkTableScan: *rels_used = bms_add_member(*rels_used, ((Scan *) plan)->scanrelid); break; case T_ForeignScan: *rels_used = bms_add_members(*rels_used, ((ForeignScan *) plan)->fs_base_relids); break; case T_CustomScan: *rels_used = bms_add_members(*rels_used, ((CustomScan *) plan)->custom_relids); break; case T_ModifyTable: *rels_used = bms_add_member(*rels_used, ((ModifyTable *) plan)->nominalRelation); if (((ModifyTable *) plan)->exclRelRTI) *rels_used = bms_add_member(*rels_used, ((ModifyTable *) plan)->exclRelRTI); /* Ensure Vars used in RETURNING will have refnames */ if (plan->targetlist) *rels_used = bms_add_member(*rels_used, linitial_int(((ModifyTable *) plan)->resultRelations)); break; case T_Append: *rels_used = bms_add_members(*rels_used, ((Append *) plan)->apprelids); break; case T_MergeAppend: *rels_used = bms_add_members(*rels_used, ((MergeAppend *) plan)->apprelids); break; case T_Result: *rels_used = bms_add_members(*rels_used, ((Result *) plan)->relids); break; default: break; } return planstate_tree_walker(planstate, ExplainPreScanNode, rels_used); } /* * plan_is_disabled * Checks if the given plan node type was disabled during query planning. * This is evident by the disabled_nodes field being higher than the sum of * the disabled_nodes field from the plan's children. */ static bool plan_is_disabled(Plan *plan) { int child_disabled_nodes; /* The node is certainly not disabled if this is zero */ if (plan->disabled_nodes == 0) return false; child_disabled_nodes = 0; /* * Handle special nodes first. Children of BitmapOrs and BitmapAnds can't * be disabled, so no need to handle those specifically. */ if (IsA(plan, Append)) { ListCell *lc; Append *aplan = (Append *) plan; /* * Sum the Append childrens' disabled_nodes. This purposefully * includes any run-time pruned children. Ignoring those could give * us the incorrect number of disabled nodes. */ foreach(lc, aplan->appendplans) { Plan *subplan = lfirst(lc); child_disabled_nodes += subplan->disabled_nodes; } } else if (IsA(plan, MergeAppend)) { ListCell *lc; MergeAppend *maplan = (MergeAppend *) plan; /* * Sum the MergeAppend childrens' disabled_nodes. This purposefully * includes any run-time pruned children. Ignoring those could give * us the incorrect number of disabled nodes. */ foreach(lc, maplan->mergeplans) { Plan *subplan = lfirst(lc); child_disabled_nodes += subplan->disabled_nodes; } } else if (IsA(plan, SubqueryScan)) child_disabled_nodes += ((SubqueryScan *) plan)->subplan->disabled_nodes; else if (IsA(plan, CustomScan)) { ListCell *lc; CustomScan *cplan = (CustomScan *) plan; foreach(lc, cplan->custom_plans) { Plan *subplan = lfirst(lc); child_disabled_nodes += subplan->disabled_nodes; } } else { /* * Else, sum up disabled_nodes from the plan's inner and outer side. */ if (outerPlan(plan)) child_disabled_nodes += outerPlan(plan)->disabled_nodes; if (innerPlan(plan)) child_disabled_nodes += innerPlan(plan)->disabled_nodes; } /* * It's disabled if the plan's disabled_nodes is higher than the sum of * its child's plan disabled_nodes. */ if (plan->disabled_nodes > child_disabled_nodes) return true; return false; } /* * ExplainNode - * Appends a description of a plan tree to es->str * * planstate points to the executor state node for the current plan node. * We need to work from a PlanState node, not just a Plan node, in order to * get at the instrumentation data (if any) as well as the list of subplans. * * ancestors is a list of parent Plan and SubPlan nodes, most-closely-nested * first. These are needed in order to interpret PARAM_EXEC Params. * * relationship describes the relationship of this plan node to its parent * (eg, "Outer", "Inner"); it can be null at top level. plan_name is an * optional name to be attached to the node. * * In text format, es->indent is controlled in this function since we only * want it to change at plan-node boundaries (but a few subroutines will * transiently increment it). In non-text formats, es->indent corresponds * to the nesting depth of logical output groups, and therefore is controlled * by ExplainOpenGroup/ExplainCloseGroup. */ static void ExplainNode(PlanState *planstate, List *ancestors, const char *relationship, const char *plan_name, ExplainState *es) { Plan *plan = planstate->plan; const char *pname; /* node type name for text output */ const char *sname; /* node type name for non-text output */ const char *strategy = NULL; const char *partialmode = NULL; const char *operation = NULL; const char *custom_name = NULL; ExplainWorkersState *save_workers_state = es->workers_state; int save_indent = es->indent; bool haschildren; bool isdisabled; /* * Prepare per-worker output buffers, if needed. We'll append the data in * these to the main output string further down. */ if (planstate->worker_instrument && es->analyze && !es->hide_workers) es->workers_state = ExplainCreateWorkersState(planstate->worker_instrument->num_workers); else es->workers_state = NULL; /* Identify plan node type, and print generic details */ switch (nodeTag(plan)) { case T_Result: pname = sname = "Result"; break; case T_ProjectSet: pname = sname = "ProjectSet"; break; case T_ModifyTable: sname = "ModifyTable"; switch (((ModifyTable *) plan)->operation) { case CMD_INSERT: pname = operation = "Insert"; break; case CMD_UPDATE: pname = operation = "Update"; break; case CMD_DELETE: pname = operation = "Delete"; break; case CMD_MERGE: pname = operation = "Merge"; break; default: pname = "???"; break; } break; case T_Append: pname = sname = "Append"; break; case T_MergeAppend: pname = sname = "Merge Append"; break; case T_RecursiveUnion: pname = sname = "Recursive Union"; break; case T_BitmapAnd: pname = sname = "BitmapAnd"; break; case T_BitmapOr: pname = sname = "BitmapOr"; break; case T_NestLoop: pname = sname = "Nested Loop"; break; case T_MergeJoin: pname = "Merge"; /* "Join" gets added by jointype switch */ sname = "Merge Join"; break; case T_HashJoin: pname = "Hash"; /* "Join" gets added by jointype switch */ sname = "Hash Join"; break; case T_SeqScan: pname = sname = "Seq Scan"; break; case T_SampleScan: pname = sname = "Sample Scan"; break; case T_Gather: pname = sname = "Gather"; break; case T_GatherMerge: pname = sname = "Gather Merge"; break; case T_IndexScan: pname = sname = "Index Scan"; break; case T_IndexOnlyScan: pname = sname = "Index Only Scan"; break; case T_BitmapIndexScan: pname = sname = "Bitmap Index Scan"; break; case T_BitmapHeapScan: pname = sname = "Bitmap Heap Scan"; break; case T_TidScan: pname = sname = "Tid Scan"; break; case T_TidRangeScan: pname = sname = "Tid Range Scan"; break; case T_SubqueryScan: pname = sname = "Subquery Scan"; break; case T_FunctionScan: pname = sname = "Function Scan"; break; case T_TableFuncScan: pname = sname = "Table Function Scan"; break; case T_ValuesScan: pname = sname = "Values Scan"; break; case T_CteScan: pname = sname = "CTE Scan"; break; case T_NamedTuplestoreScan: pname = sname = "Named Tuplestore Scan"; break; case T_WorkTableScan: pname = sname = "WorkTable Scan"; break; case T_ForeignScan: sname = "Foreign Scan"; switch (((ForeignScan *) plan)->operation) { case CMD_SELECT: pname = "Foreign Scan"; operation = "Select"; break; case CMD_INSERT: pname = "Foreign Insert"; operation = "Insert"; break; case CMD_UPDATE: pname = "Foreign Update"; operation = "Update"; break; case CMD_DELETE: pname = "Foreign Delete"; operation = "Delete"; break; default: pname = "???"; break; } break; case T_CustomScan: sname = "Custom Scan"; custom_name = ((CustomScan *) plan)->methods->CustomName; if (custom_name) pname = psprintf("Custom Scan (%s)", custom_name); else pname = sname; break; case T_Material: pname = sname = "Materialize"; break; case T_Memoize: pname = sname = "Memoize"; break; case T_Sort: pname = sname = "Sort"; break; case T_IncrementalSort: pname = sname = "Incremental Sort"; break; case T_Group: pname = sname = "Group"; break; case T_Agg: { Agg *agg = (Agg *) plan; sname = "Aggregate"; switch (agg->aggstrategy) { case AGG_PLAIN: pname = "Aggregate"; strategy = "Plain"; break; case AGG_SORTED: pname = "GroupAggregate"; strategy = "Sorted"; break; case AGG_HASHED: pname = "HashAggregate"; strategy = "Hashed"; break; case AGG_MIXED: pname = "MixedAggregate"; strategy = "Mixed"; break; default: pname = "Aggregate ???"; strategy = "???"; break; } if (DO_AGGSPLIT_SKIPFINAL(agg->aggsplit)) { partialmode = "Partial"; pname = psprintf("%s %s", partialmode, pname); } else if (DO_AGGSPLIT_COMBINE(agg->aggsplit)) { partialmode = "Finalize"; pname = psprintf("%s %s", partialmode, pname); } else partialmode = "Simple"; } break; case T_WindowAgg: pname = sname = "WindowAgg"; break; case T_Unique: pname = sname = "Unique"; break; case T_SetOp: sname = "SetOp"; switch (((SetOp *) plan)->strategy) { case SETOP_SORTED: pname = "SetOp"; strategy = "Sorted"; break; case SETOP_HASHED: pname = "HashSetOp"; strategy = "Hashed"; break; default: pname = "SetOp ???"; strategy = "???"; break; } break; case T_LockRows: pname = sname = "LockRows"; break; case T_Limit: pname = sname = "Limit"; break; case T_Hash: pname = sname = "Hash"; break; default: pname = sname = "???"; break; } ExplainOpenGroup("Plan", relationship ? NULL : "Plan", true, es); if (es->format == EXPLAIN_FORMAT_TEXT) { if (plan_name) { ExplainIndentText(es); appendStringInfo(es->str, "%s\n", plan_name); es->indent++; } if (es->indent) { ExplainIndentText(es); appendStringInfoString(es->str, "-> "); es->indent += 2; } if (plan->parallel_aware) appendStringInfoString(es->str, "Parallel "); if (plan->async_capable) appendStringInfoString(es->str, "Async "); appendStringInfoString(es->str, pname); es->indent++; } else { ExplainPropertyText("Node Type", sname, es); if (strategy) ExplainPropertyText("Strategy", strategy, es); if (partialmode) ExplainPropertyText("Partial Mode", partialmode, es); if (operation) ExplainPropertyText("Operation", operation, es); if (relationship) ExplainPropertyText("Parent Relationship", relationship, es); if (plan_name) ExplainPropertyText("Subplan Name", plan_name, es); if (custom_name) ExplainPropertyText("Custom Plan Provider", custom_name, es); ExplainPropertyBool("Parallel Aware", plan->parallel_aware, es); ExplainPropertyBool("Async Capable", plan->async_capable, es); } switch (nodeTag(plan)) { case T_SeqScan: case T_SampleScan: case T_BitmapHeapScan: case T_TidScan: case T_TidRangeScan: case T_SubqueryScan: case T_FunctionScan: case T_TableFuncScan: case T_ValuesScan: case T_CteScan: case T_WorkTableScan: ExplainScanTarget((Scan *) plan, es); break; case T_ForeignScan: case T_CustomScan: if (((Scan *) plan)->scanrelid > 0) ExplainScanTarget((Scan *) plan, es); break; case T_IndexScan: { IndexScan *indexscan = (IndexScan *) plan; ExplainIndexScanDetails(indexscan->indexid, indexscan->indexorderdir, es); ExplainScanTarget((Scan *) indexscan, es); } break; case T_IndexOnlyScan: { IndexOnlyScan *indexonlyscan = (IndexOnlyScan *) plan; ExplainIndexScanDetails(indexonlyscan->indexid, indexonlyscan->indexorderdir, es); ExplainScanTarget((Scan *) indexonlyscan, es); } break; case T_BitmapIndexScan: { BitmapIndexScan *bitmapindexscan = (BitmapIndexScan *) plan; const char *indexname = explain_get_index_name(bitmapindexscan->indexid); if (es->format == EXPLAIN_FORMAT_TEXT) appendStringInfo(es->str, " on %s", quote_identifier(indexname)); else ExplainPropertyText("Index Name", indexname, es); } break; case T_ModifyTable: ExplainModifyTarget((ModifyTable *) plan, es); break; case T_NestLoop: case T_MergeJoin: case T_HashJoin: { const char *jointype; switch (((Join *) plan)->jointype) { case JOIN_INNER: jointype = "Inner"; break; case JOIN_LEFT: jointype = "Left"; break; case JOIN_FULL: jointype = "Full"; break; case JOIN_RIGHT: jointype = "Right"; break; case JOIN_SEMI: jointype = "Semi"; break; case JOIN_ANTI: jointype = "Anti"; break; case JOIN_RIGHT_SEMI: jointype = "Right Semi"; break; case JOIN_RIGHT_ANTI: jointype = "Right Anti"; break; default: jointype = "???"; break; } if (es->format == EXPLAIN_FORMAT_TEXT) { /* * For historical reasons, the join type is interpolated * into the node type name... */ if (((Join *) plan)->jointype != JOIN_INNER) appendStringInfo(es->str, " %s Join", jointype); else if (!IsA(plan, NestLoop)) appendStringInfoString(es->str, " Join"); } else ExplainPropertyText("Join Type", jointype, es); } break; case T_SetOp: { const char *setopcmd; switch (((SetOp *) plan)->cmd) { case SETOPCMD_INTERSECT: setopcmd = "Intersect"; break; case SETOPCMD_INTERSECT_ALL: setopcmd = "Intersect All"; break; case SETOPCMD_EXCEPT: setopcmd = "Except"; break; case SETOPCMD_EXCEPT_ALL: setopcmd = "Except All"; break; default: setopcmd = "???"; break; } if (es->format == EXPLAIN_FORMAT_TEXT) appendStringInfo(es->str, " %s", setopcmd); else ExplainPropertyText("Command", setopcmd, es); } break; default: break; } if (es->costs) { if (es->format == EXPLAIN_FORMAT_TEXT) { appendStringInfo(es->str, " (cost=%.2f..%.2f rows=%.0f width=%d)", plan->startup_cost, plan->total_cost, plan->plan_rows, plan->plan_width); } else { ExplainPropertyFloat("Startup Cost", NULL, plan->startup_cost, 2, es); ExplainPropertyFloat("Total Cost", NULL, plan->total_cost, 2, es); ExplainPropertyFloat("Plan Rows", NULL, plan->plan_rows, 0, es); ExplainPropertyInteger("Plan Width", NULL, plan->plan_width, es); } } /* * We have to forcibly clean up the instrumentation state because we * haven't done ExecutorEnd yet. This is pretty grotty ... * * Note: contrib/auto_explain could cause instrumentation to be set up * even though we didn't ask for it here. Be careful not to print any * instrumentation results the user didn't ask for. But we do the * InstrEndLoop call anyway, if possible, to reduce the number of cases * auto_explain has to contend with. */ if (planstate->instrument) InstrEndLoop(planstate->instrument); if (es->analyze && planstate->instrument && planstate->instrument->nloops > 0) { NodeInstrumentation *instr = planstate->instrument; double nloops = instr->nloops; double startup_ms = INSTR_TIME_GET_MILLISEC(instr->startup) / nloops; double total_ms = INSTR_TIME_GET_MILLISEC(instr->instr.total) / nloops; double rows = instr->ntuples / nloops; if (es->format == EXPLAIN_FORMAT_TEXT) { appendStringInfoString(es->str, " (actual "); if (es->timing) appendStringInfo(es->str, "time=%.3f..%.3f ", startup_ms, total_ms); appendStringInfo(es->str, "rows=%.2f loops=%.0f)", rows, nloops); } else { if (es->timing) { ExplainPropertyFloat("Actual Startup Time", "ms", startup_ms, 3, es); ExplainPropertyFloat("Actual Total Time", "ms", total_ms, 3, es); } ExplainPropertyFloat("Actual Rows", NULL, rows, 2, es); ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es); } } else if (es->analyze) { if (es->format == EXPLAIN_FORMAT_TEXT) appendStringInfoString(es->str, " (never executed)"); else { if (es->timing) { ExplainPropertyFloat("Actual Startup Time", "ms", 0.0, 3, es); ExplainPropertyFloat("Actual Total Time", "ms", 0.0, 3, es); } ExplainPropertyFloat("Actual Rows", NULL, 0.0, 0, es); ExplainPropertyFloat("Actual Loops", NULL, 0.0, 0, es); } } /* in text format, first line ends here */ if (es->format == EXPLAIN_FORMAT_TEXT) appendStringInfoChar(es->str, '\n'); isdisabled = plan_is_disabled(plan); if (es->format != EXPLAIN_FORMAT_TEXT || isdisabled) ExplainPropertyBool("Disabled", isdisabled, es); /* prepare per-worker general execution details */ if (es->workers_state && es->verbose) { WorkerNodeInstrumentation *w = planstate->worker_instrument; for (int n = 0; n < w->num_workers; n++) { NodeInstrumentation *instrument = &w->instrument[n]; double nloops = instrument->nloops; double startup_ms; double total_ms; double rows; if (nloops <= 0) continue; startup_ms = INSTR_TIME_GET_MILLISEC(instrument->startup) / nloops; total_ms = INSTR_TIME_GET_MILLISEC(instrument->instr.total) / nloops; rows = instrument->ntuples / nloops; ExplainOpenWorker(n, es); if (es->format == EXPLAIN_FORMAT_TEXT) { ExplainIndentText(es); appendStringInfoString(es->str, "actual "); if (es->timing) appendStringInfo(es->str, "time=%.3f..%.3f ", startup_ms, total_ms); appendStringInfo(es->str, "rows=%.2f loops=%.0f\n", rows, nloops); } else { if (es->timing) { ExplainPropertyFloat("Actual Startup Time", "ms", startup_ms, 3, es); ExplainPropertyFloat("Actual Total Time", "ms", total_ms, 3, es); } ExplainPropertyFloat("Actual Rows", NULL, rows, 2, es); ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es); } ExplainCloseWorker(n, es); } } /* target list */ if (es->verbose) show_plan_tlist(planstate, ancestors, es); /* unique join */ switch (nodeTag(plan)) { case T_NestLoop: case T_MergeJoin: case T_HashJoin: /* try not to be too chatty about this in text mode */ if (es->format != EXPLAIN_FORMAT_TEXT || (es->verbose && ((Join *) plan)->inner_unique)) ExplainPropertyBool("Inner Unique", ((Join *) plan)->inner_unique, es); break; default: break; } /* quals, sort keys, etc */ switch (nodeTag(plan)) { case T_IndexScan: show_scan_qual(((IndexScan *) plan)->indexqualorig, "Index Cond", planstate, ancestors, es); if (((IndexScan *) plan)->indexqualorig) show_instrumentation_count("Rows Removed by Index Recheck", 2, planstate, es); show_scan_qual(((IndexScan *) plan)->indexorderbyorig, "Order By", planstate, ancestors, es); show_scan_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); show_indexsearches_info(planstate, es); break; case T_IndexOnlyScan: show_scan_qual(((IndexOnlyScan *) plan)->indexqual, "Index Cond", planstate, ancestors, es); if (((IndexOnlyScan *) plan)->recheckqual) show_instrumentation_count("Rows Removed by Index Recheck", 2, planstate, es); show_scan_qual(((IndexOnlyScan *) plan)->indexorderby, "Order By", planstate, ancestors, es); show_scan_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); if (es->analyze) ExplainPropertyFloat("Heap Fetches", NULL, planstate->instrument->ntuples2, 0, es); show_indexsearches_info(planstate, es); break; case T_BitmapIndexScan: show_scan_qual(((BitmapIndexScan *) plan)->indexqualorig, "Index Cond", planstate, ancestors, es); show_indexsearches_info(planstate, es); break; case T_BitmapHeapScan: show_scan_qual(((BitmapHeapScan *) plan)->bitmapqualorig, "Recheck Cond", planstate, ancestors, es); if (((BitmapHeapScan *) plan)->bitmapqualorig) show_instrumentation_count("Rows Removed by Index Recheck", 2, planstate, es); show_scan_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); show_tidbitmap_info((BitmapHeapScanState *) planstate, es); show_scan_io_usage((ScanState *) planstate, es); break; case T_SampleScan: show_tablesample(((SampleScan *) plan)->tablesample, planstate, ancestors, es); /* fall through to print additional fields the same as SeqScan */ pg_fallthrough; case T_SeqScan: case T_ValuesScan: case T_CteScan: case T_NamedTuplestoreScan: case T_WorkTableScan: case T_SubqueryScan: show_scan_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); if (IsA(plan, CteScan)) show_ctescan_info(castNode(CteScanState, planstate), es); show_scan_io_usage((ScanState *) planstate, es); break; case T_Gather: { Gather *gather = (Gather *) plan; show_scan_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); ExplainPropertyInteger("Workers Planned", NULL, gather->num_workers, es); if (es->analyze) { int nworkers; nworkers = ((GatherState *) planstate)->nworkers_launched; ExplainPropertyInteger("Workers Launched", NULL, nworkers, es); } if (gather->single_copy || es->format != EXPLAIN_FORMAT_TEXT) ExplainPropertyBool("Single Copy", gather->single_copy, es); } break; case T_GatherMerge: { GatherMerge *gm = (GatherMerge *) plan; show_scan_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); ExplainPropertyInteger("Workers Planned", NULL, gm->num_workers, es); if (es->analyze) { int nworkers; nworkers = ((GatherMergeState *) planstate)->nworkers_launched; ExplainPropertyInteger("Workers Launched", NULL, nworkers, es); } } break; case T_FunctionScan: if (es->verbose) { List *fexprs = NIL; ListCell *lc; foreach(lc, ((FunctionScan *) plan)->functions) { RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc); fexprs = lappend(fexprs, rtfunc->funcexpr); } /* We rely on show_expression to insert commas as needed */ show_expression((Node *) fexprs, "Function Call", planstate, ancestors, es->verbose, es); } show_scan_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); break; case T_TableFuncScan: if (es->verbose) { TableFunc *tablefunc = ((TableFuncScan *) plan)->tablefunc; show_expression((Node *) tablefunc, "Table Function Call", planstate, ancestors, es->verbose, es); } show_scan_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); show_table_func_scan_info(castNode(TableFuncScanState, planstate), es); break; case T_TidScan: { /* * The tidquals list has OR semantics, so be sure to show it * as an OR condition. */ List *tidquals = ((TidScan *) plan)->tidquals; if (list_length(tidquals) > 1) tidquals = list_make1(make_orclause(tidquals)); show_scan_qual(tidquals, "TID Cond", planstate, ancestors, es); show_scan_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); } break; case T_TidRangeScan: { /* * The tidrangequals list has AND semantics, so be sure to * show it as an AND condition. */ List *tidquals = ((TidRangeScan *) plan)->tidrangequals; if (list_length(tidquals) > 1) tidquals = list_make1(make_andclause(tidquals)); show_scan_qual(tidquals, "TID Cond", planstate, ancestors, es); show_scan_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); show_scan_io_usage((ScanState *) planstate, es); } break; case T_ForeignScan: show_scan_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); show_foreignscan_info((ForeignScanState *) planstate, es); break; case T_CustomScan: { CustomScanState *css = (CustomScanState *) planstate; show_scan_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); if (css->methods->ExplainCustomScan) css->methods->ExplainCustomScan(css, ancestors, es); } break; case T_NestLoop: show_upper_qual(((NestLoop *) plan)->join.joinqual, "Join Filter", planstate, ancestors, es); if (((NestLoop *) plan)->join.joinqual) show_instrumentation_count("Rows Removed by Join Filter", 1, planstate, es); show_upper_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 2, planstate, es); break; case T_MergeJoin: show_upper_qual(((MergeJoin *) plan)->mergeclauses, "Merge Cond", planstate, ancestors, es); show_upper_qual(((MergeJoin *) plan)->join.joinqual, "Join Filter", planstate, ancestors, es); if (((MergeJoin *) plan)->join.joinqual) show_instrumentation_count("Rows Removed by Join Filter", 1, planstate, es); show_upper_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 2, planstate, es); break; case T_HashJoin: show_upper_qual(((HashJoin *) plan)->hashclauses, "Hash Cond", planstate, ancestors, es); show_upper_qual(((HashJoin *) plan)->join.joinqual, "Join Filter", planstate, ancestors, es); if (((HashJoin *) plan)->join.joinqual) show_instrumentation_count("Rows Removed by Join Filter", 1, planstate, es); show_upper_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 2, planstate, es); break; case T_Agg: show_agg_keys(castNode(AggState, planstate), ancestors, es); show_upper_qual(plan->qual, "Filter", planstate, ancestors, es); show_hashagg_info((AggState *) planstate, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); break; case T_WindowAgg: show_window_def(castNode(WindowAggState, planstate), ancestors, es); show_upper_qual(((WindowAgg *) plan)->runConditionOrig, "Run Condition", planstate, ancestors, es); show_upper_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); show_windowagg_info(castNode(WindowAggState, planstate), es); break; case T_Group: show_group_keys(castNode(GroupState, planstate), ancestors, es); show_upper_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); break; case T_Sort: show_sort_keys(castNode(SortState, planstate), ancestors, es); show_sort_info(castNode(SortState, planstate), es); break; case T_IncrementalSort: show_incremental_sort_keys(castNode(IncrementalSortState, planstate), ancestors, es); show_incremental_sort_info(castNode(IncrementalSortState, planstate), es); break; case T_MergeAppend: show_merge_append_keys(castNode(MergeAppendState, planstate), ancestors, es); break; case T_Result: show_result_replacement_info(castNode(Result, plan), es); show_upper_qual((List *) ((Result *) plan)->resconstantqual, "One-Time Filter", planstate, ancestors, es); show_upper_qual(plan->qual, "Filter", planstate, ancestors, es); if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); break; case T_ModifyTable: show_modifytable_info(castNode(ModifyTableState, planstate), ancestors, es); break; case T_Hash: show_hash_info(castNode(HashState, planstate), es); break; case T_Material: show_material_info(castNode(MaterialState, planstate), es); break; case T_Memoize: show_memoize_info(castNode(MemoizeState, planstate), ancestors, es); break; case T_RecursiveUnion: show_recursive_union_info(castNode(RecursiveUnionState, planstate), es); break; default: break; } /* * Prepare per-worker JIT instrumentation. As with the overall JIT * summary, this is printed only if printing costs is enabled. */ if (es->workers_state && es->costs && es->verbose) { SharedJitInstrumentation *w = planstate->worker_jit_instrument; if (w) { for (int n = 0; n < w->num_workers; n++) { ExplainOpenWorker(n, es); ExplainPrintJIT(es, planstate->state->es_jit_flags, &w->jit_instr[n]); ExplainCloseWorker(n, es); } } } /* Show buffer/WAL usage */ if (es->buffers && planstate->instrument) show_buffer_usage(es, &planstate->instrument->instr.bufusage); if (es->wal && planstate->instrument) show_wal_usage(es, &planstate->instrument->instr.walusage); /* Prepare per-worker buffer/WAL usage */ if (es->workers_state && (es->buffers || es->wal) && es->verbose) { WorkerNodeInstrumentation *w = planstate->worker_instrument; for (int n = 0; n < w->num_workers; n++) { NodeInstrumentation *instrument = &w->instrument[n]; double nloops = instrument->nloops; if (nloops <= 0) continue; ExplainOpenWorker(n, es); if (es->buffers) show_buffer_usage(es, &instrument->instr.bufusage); if (es->wal) show_wal_usage(es, &instrument->instr.walusage); ExplainCloseWorker(n, es); } } /* Show per-worker details for this plan node, then pop that stack */ if (es->workers_state) ExplainFlushWorkersState(es); es->workers_state = save_workers_state; /* Allow plugins to print additional information */ if (explain_per_node_hook) (*explain_per_node_hook) (planstate, ancestors, relationship, plan_name, es); /* * If partition pruning was done during executor initialization, the * number of child plans we'll display below will be less than the number * of subplans that was specified in the plan. To make this a bit less * mysterious, emit an indication that this happened. Note that this * field is emitted now because we want it to be a property of the parent * node; it *cannot* be emitted within the Plans sub-node we'll open next. */ switch (nodeTag(plan)) { case T_Append: ExplainMissingMembers(((AppendState *) planstate)->as_nplans, list_length(((Append *) plan)->appendplans), es); break; case T_MergeAppend: ExplainMissingMembers(((MergeAppendState *) planstate)->ms_nplans, list_length(((MergeAppend *) plan)->mergeplans), es); break; default: break; } /* Get ready to display the child plans */ haschildren = planstate->initPlan || outerPlanState(planstate) || innerPlanState(planstate) || IsA(plan, Append) || IsA(plan, MergeAppend) || IsA(plan, BitmapAnd) || IsA(plan, BitmapOr) || IsA(plan, SubqueryScan) || (IsA(planstate, CustomScanState) && ((CustomScanState *) planstate)->custom_ps != NIL) || planstate->subPlan; if (haschildren) { ExplainOpenGroup("Plans", "Plans", false, es); /* Pass current Plan as head of ancestors list for children */ ancestors = lcons(plan, ancestors); } /* initPlan-s */ if (planstate->initPlan) ExplainSubPlans(planstate->initPlan, ancestors, "InitPlan", es); /* lefttree */ if (outerPlanState(planstate)) ExplainNode(outerPlanState(planstate), ancestors, "Outer", NULL, es); /* righttree */ if (innerPlanState(planstate)) ExplainNode(innerPlanState(planstate), ancestors, "Inner", NULL, es); /* special child plans */ switch (nodeTag(plan)) { case T_Append: ExplainMemberNodes(((AppendState *) planstate)->appendplans, ((AppendState *) planstate)->as_nplans, ancestors, es); break; case T_MergeAppend: ExplainMemberNodes(((MergeAppendState *) planstate)->mergeplans, ((MergeAppendState *) planstate)->ms_nplans, ancestors, es); break; case T_BitmapAnd: ExplainMemberNodes(((BitmapAndState *) planstate)->bitmapplans, ((BitmapAndState *) planstate)->nplans, ancestors, es); break; case T_BitmapOr: ExplainMemberNodes(((BitmapOrState *) planstate)->bitmapplans, ((BitmapOrState *) planstate)->nplans, ancestors, es); break; case T_SubqueryScan: ExplainNode(((SubqueryScanState *) planstate)->subplan, ancestors, "Subquery", NULL, es); break; case T_CustomScan: ExplainCustomChildren((CustomScanState *) planstate, ancestors, es); break; default: break; } /* subPlan-s */ if (planstate->subPlan) ExplainSubPlans(planstate->subPlan, ancestors, "SubPlan", es); /* end of child plans */ if (haschildren) { ancestors = list_delete_first(ancestors); ExplainCloseGroup("Plans", "Plans", false, es); } /* in text format, undo whatever indentation we added */ if (es->format == EXPLAIN_FORMAT_TEXT) es->indent = save_indent; ExplainCloseGroup("Plan", relationship ? NULL : "Plan", true, es); } /* * Show the targetlist of a plan node */ static void show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es) { Plan *plan = planstate->plan; List *context; List *result = NIL; bool useprefix; ListCell *lc; /* No work if empty tlist (this occurs eg in bitmap indexscans) */ if (plan->targetlist == NIL) return; /* The tlist of an Append isn't real helpful, so suppress it */ if (IsA(plan, Append)) return; /* Likewise for MergeAppend and RecursiveUnion */ if (IsA(plan, MergeAppend)) return; if (IsA(plan, RecursiveUnion)) return; /* * Likewise for ForeignScan that executes a direct INSERT/UPDATE/DELETE * * Note: the tlist for a ForeignScan that executes a direct INSERT/UPDATE * might contain subplan output expressions that are confusing in this * context. The tlist for a ForeignScan that executes a direct UPDATE/ * DELETE always contains "junk" target columns to identify the exact row * to update or delete, which would be confusing in this context. So, we * suppress it in all the cases. */ if (IsA(plan, ForeignScan) && ((ForeignScan *) plan)->operation != CMD_SELECT) return; /* Set up deparsing context */ context = set_deparse_context_plan(es->deparse_cxt, plan, ancestors); useprefix = es->rtable_size > 1; /* Deparse each result column (we now include resjunk ones) */ foreach(lc, plan->targetlist) { TargetEntry *tle = (TargetEntry *) lfirst(lc); result = lappend(result, deparse_expression((Node *) tle->expr, context, useprefix, false)); } /* Print results */ ExplainPropertyList("Output", result, es); } /* * Show a generic expression */ static void show_expression(Node *node, const char *qlabel, PlanState *planstate, List *ancestors, bool useprefix, ExplainState *es) { List *context; char *exprstr; /* Set up deparsing context */ context = set_deparse_context_plan(es->deparse_cxt, planstate->plan, ancestors); /* Deparse the expression */ exprstr = deparse_expression(node, context, useprefix, false); /* And add to es->str */ ExplainPropertyText(qlabel, exprstr, es); } /* * Show a qualifier expression (which is a List with implicit AND semantics) */ static void show_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, bool useprefix, ExplainState *es) { Node *node; /* No work if empty qual */ if (qual == NIL) return; /* Convert AND list to explicit AND */ node = (Node *) make_ands_explicit(qual); /* And show it */ show_expression(node, qlabel, planstate, ancestors, useprefix, es); } /* * Show a qualifier expression for a scan plan node */ static void show_scan_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, ExplainState *es) { bool useprefix; useprefix = (IsA(planstate->plan, SubqueryScan) || es->verbose); show_qual(qual, qlabel, planstate, ancestors, useprefix, es); } /* * Show a qualifier expression for an upper-level plan node */ static void show_upper_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, ExplainState *es) { bool useprefix; useprefix = (es->rtable_size > 1 || es->verbose); show_qual(qual, qlabel, planstate, ancestors, useprefix, es); } /* * Show the sort keys for a Sort node. */ static void show_sort_keys(SortState *sortstate, List *ancestors, ExplainState *es) { Sort *plan = (Sort *) sortstate->ss.ps.plan; show_sort_group_keys((PlanState *) sortstate, "Sort Key", plan->numCols, 0, plan->sortColIdx, plan->sortOperators, plan->collations, plan->nullsFirst, ancestors, es); } /* * Show the sort keys for an IncrementalSort node. */ static void show_incremental_sort_keys(IncrementalSortState *incrsortstate, List *ancestors, ExplainState *es) { IncrementalSort *plan = (IncrementalSort *) incrsortstate->ss.ps.plan; show_sort_group_keys((PlanState *) incrsortstate, "Sort Key", plan->sort.numCols, plan->nPresortedCols, plan->sort.sortColIdx, plan->sort.sortOperators, plan->sort.collations, plan->sort.nullsFirst, ancestors, es); } /* * Likewise, for a MergeAppend node. */ static void show_merge_append_keys(MergeAppendState *mstate, List *ancestors, ExplainState *es) { MergeAppend *plan = (MergeAppend *) mstate->ps.plan; show_sort_group_keys((PlanState *) mstate, "Sort Key", plan->numCols, 0, plan->sortColIdx, plan->sortOperators, plan->collations, plan->nullsFirst, ancestors, es); } /* * Show the grouping keys for an Agg node. */ static void show_agg_keys(AggState *astate, List *ancestors, ExplainState *es) { Agg *plan = (Agg *) astate->ss.ps.plan; if (plan->numCols > 0 || plan->groupingSets) { /* The key columns refer to the tlist of the child plan */ ancestors = lcons(plan, ancestors); if (plan->groupingSets) show_grouping_sets(outerPlanState(astate), plan, ancestors, es); else show_sort_group_keys(outerPlanState(astate), "Group Key", plan->numCols, 0, plan->grpColIdx, NULL, NULL, NULL, ancestors, es); ancestors = list_delete_first(ancestors); } } static void show_grouping_sets(PlanState *planstate, Agg *agg, List *ancestors, ExplainState *es) { List *context; bool useprefix; ListCell *lc; /* Set up deparsing context */ context = set_deparse_context_plan(es->deparse_cxt, planstate->plan, ancestors); useprefix = (es->rtable_size > 1 || es->verbose); ExplainOpenGroup("Grouping Sets", "Grouping Sets", false, es); show_grouping_set_keys(planstate, agg, NULL, context, useprefix, ancestors, es); foreach(lc, agg->chain) { Agg *aggnode = lfirst(lc); Sort *sortnode = (Sort *) aggnode->plan.lefttree; show_grouping_set_keys(planstate, aggnode, sortnode, context, useprefix, ancestors, es); } ExplainCloseGroup("Grouping Sets", "Grouping Sets", false, es); } static void show_grouping_set_keys(PlanState *planstate, Agg *aggnode, Sort *sortnode, List *context, bool useprefix, List *ancestors, ExplainState *es) { Plan *plan = planstate->plan; char *exprstr; ListCell *lc; List *gsets = aggnode->groupingSets; AttrNumber *keycols = aggnode->grpColIdx; const char *keyname; const char *keysetname; if (aggnode->aggstrategy == AGG_HASHED || aggnode->aggstrategy == AGG_MIXED) { keyname = "Hash Key"; keysetname = "Hash Keys"; } else { keyname = "Group Key"; keysetname = "Group Keys"; } ExplainOpenGroup("Grouping Set", NULL, true, es); if (sortnode) { show_sort_group_keys(planstate, "Sort Key", sortnode->numCols, 0, sortnode->sortColIdx, sortnode->sortOperators, sortnode->collations, sortnode->nullsFirst, ancestors, es); if (es->format == EXPLAIN_FORMAT_TEXT) es->indent++; } ExplainOpenGroup(keysetname, keysetname, false, es); foreach(lc, gsets) { List *result = NIL; ListCell *lc2; foreach(lc2, (List *) lfirst(lc)) { Index i = lfirst_int(lc2); AttrNumber keyresno = keycols[i]; TargetEntry *target = get_tle_by_resno(plan->targetlist, keyresno); if (!target) elog(ERROR, "no tlist entry for key %d", keyresno); /* Deparse the expression, showing any top-level cast */ exprstr = deparse_expression((Node *) target->expr, context, useprefix, true); result = lappend(result, exprstr); } if (!result && es->format == EXPLAIN_FORMAT_TEXT) ExplainPropertyText(keyname, "()", es); else ExplainPropertyListNested(keyname, result, es); } ExplainCloseGroup(keysetname, keysetname, false, es); if (sortnode && es->format == EXPLAIN_FORMAT_TEXT) es->indent--; ExplainCloseGroup("Grouping Set", NULL, true, es); } /* * Show the grouping keys for a Group node. */ static void show_group_keys(GroupState *gstate, List *ancestors, ExplainState *es) { Group *plan = (Group *) gstate->ss.ps.plan; /* The key columns refer to the tlist of the child plan */ ancestors = lcons(plan, ancestors); show_sort_group_keys(outerPlanState(gstate), "Group Key", plan->numCols, 0, plan->grpColIdx, NULL, NULL, NULL, ancestors, es); ancestors = list_delete_first(ancestors); } /* * Common code to show sort/group keys, which are represented in plan nodes * as arrays of targetlist indexes. If it's a sort key rather than a group * key, also pass sort operators/collations/nullsFirst arrays. */ static void show_sort_group_keys(PlanState *planstate, const char *qlabel, int nkeys, int nPresortedKeys, AttrNumber *keycols, Oid *sortOperators, Oid *collations, bool *nullsFirst, List *ancestors, ExplainState *es) { Plan *plan = planstate->plan; List *context; List *result = NIL; List *resultPresorted = NIL; StringInfoData sortkeybuf; bool useprefix; int keyno; if (nkeys <= 0) return; initStringInfo(&sortkeybuf); /* Set up deparsing context */ context = set_deparse_context_plan(es->deparse_cxt, plan, ancestors); useprefix = (es->rtable_size > 1 || es->verbose); for (keyno = 0; keyno < nkeys; keyno++) { /* find key expression in tlist */ AttrNumber keyresno = keycols[keyno]; TargetEntry *target = get_tle_by_resno(plan->targetlist, keyresno); char *exprstr; if (!target) elog(ERROR, "no tlist entry for key %d", keyresno); /* Deparse the expression, showing any top-level cast */ exprstr = deparse_expression((Node *) target->expr, context, useprefix, true); resetStringInfo(&sortkeybuf); appendStringInfoString(&sortkeybuf, exprstr); /* Append sort order information, if relevant */ if (sortOperators != NULL) show_sortorder_options(&sortkeybuf, (Node *) target->expr, sortOperators[keyno], collations[keyno], nullsFirst[keyno]); /* Emit one property-list item per sort key */ result = lappend(result, pstrdup(sortkeybuf.data)); if (keyno < nPresortedKeys) resultPresorted = lappend(resultPresorted, exprstr); } ExplainPropertyList(qlabel, result, es); if (nPresortedKeys > 0) ExplainPropertyList("Presorted Key", resultPresorted, es); } /* * Append nondefault characteristics of the sort ordering of a column to buf * (collation, direction, NULLS FIRST/LAST) */ static void show_sortorder_options(StringInfo buf, Node *sortexpr, Oid sortOperator, Oid collation, bool nullsFirst) { Oid sortcoltype = exprType(sortexpr); bool reverse = false; TypeCacheEntry *typentry; typentry = lookup_type_cache(sortcoltype, TYPECACHE_LT_OPR | TYPECACHE_GT_OPR); /* * Print COLLATE if it's not default for the column's type. There are * some cases where this is redundant, eg if expression is a column whose * declared collation is that collation, but it's hard to distinguish that * here (and arguably, printing COLLATE explicitly is a good idea anyway * in such cases). */ if (OidIsValid(collation) && collation != get_typcollation(sortcoltype)) { char *collname = get_collation_name(collation); if (collname == NULL) elog(ERROR, "cache lookup failed for collation %u", collation); appendStringInfo(buf, " COLLATE %s", quote_identifier(collname)); } /* Print direction if not ASC, or USING if non-default sort operator */ if (sortOperator == typentry->gt_opr) { appendStringInfoString(buf, " DESC"); reverse = true; } else if (sortOperator != typentry->lt_opr) { char *opname = get_opname(sortOperator); if (opname == NULL) elog(ERROR, "cache lookup failed for operator %u", sortOperator); appendStringInfo(buf, " USING %s", opname); /* Determine whether operator would be considered ASC or DESC */ (void) get_equality_op_for_ordering_op(sortOperator, &reverse); } /* Add NULLS FIRST/LAST only if it wouldn't be default */ if (nullsFirst && !reverse) { appendStringInfoString(buf, " NULLS FIRST"); } else if (!nullsFirst && reverse) { appendStringInfoString(buf, " NULLS LAST"); } } /* * Show the window definition for a WindowAgg node. */ static void show_window_def(WindowAggState *planstate, List *ancestors, ExplainState *es) { WindowAgg *wagg = (WindowAgg *) planstate->ss.ps.plan; StringInfoData wbuf; bool needspace = false; initStringInfo(&wbuf); appendStringInfo(&wbuf, "%s AS (", quote_identifier(wagg->winname)); /* The key columns refer to the tlist of the child plan */ ancestors = lcons(wagg, ancestors); if (wagg->partNumCols > 0) { appendStringInfoString(&wbuf, "PARTITION BY "); show_window_keys(&wbuf, outerPlanState(planstate), wagg->partNumCols, wagg->partColIdx, ancestors, es); needspace = true; } if (wagg->ordNumCols > 0) { if (needspace) appendStringInfoChar(&wbuf, ' '); appendStringInfoString(&wbuf, "ORDER BY "); show_window_keys(&wbuf, outerPlanState(planstate), wagg->ordNumCols, wagg->ordColIdx, ancestors, es); needspace = true; } ancestors = list_delete_first(ancestors); if (wagg->frameOptions & FRAMEOPTION_NONDEFAULT) { List *context; bool useprefix; char *framestr; /* Set up deparsing context for possible frame expressions */ context = set_deparse_context_plan(es->deparse_cxt, (Plan *) wagg, ancestors); useprefix = (es->rtable_size > 1 || es->verbose); framestr = get_window_frame_options_for_explain(wagg->frameOptions, wagg->startOffset, wagg->endOffset, context, useprefix); if (needspace) appendStringInfoChar(&wbuf, ' '); appendStringInfoString(&wbuf, framestr); pfree(framestr); } appendStringInfoChar(&wbuf, ')'); ExplainPropertyText("Window", wbuf.data, es); pfree(wbuf.data); } /* * Append the keys of a window's PARTITION BY or ORDER BY clause to buf. * We can't use show_sort_group_keys for this because that's too opinionated * about how the result will be displayed. * Note that the "planstate" node should be the WindowAgg's child. */ static void show_window_keys(StringInfo buf, PlanState *planstate, int nkeys, AttrNumber *keycols, List *ancestors, ExplainState *es) { Plan *plan = planstate->plan; List *context; bool useprefix; /* Set up deparsing context */ context = set_deparse_context_plan(es->deparse_cxt, plan, ancestors); useprefix = (es->rtable_size > 1 || es->verbose); for (int keyno = 0; keyno < nkeys; keyno++) { /* find key expression in tlist */ AttrNumber keyresno = keycols[keyno]; TargetEntry *target = get_tle_by_resno(plan->targetlist, keyresno); char *exprstr; if (!target) elog(ERROR, "no tlist entry for key %d", keyresno); /* Deparse the expression, showing any top-level cast */ exprstr = deparse_expression((Node *) target->expr, context, useprefix, true); if (keyno > 0) appendStringInfoString(buf, ", "); appendStringInfoString(buf, exprstr); pfree(exprstr); /* * We don't attempt to provide sort order information because * WindowAgg carries equality operators not comparison operators; * compare show_agg_keys. */ } } /* * Show information on storage method and maximum memory/disk space used. */ static void show_storage_info(char *maxStorageType, int64 maxSpaceUsed, ExplainState *es) { int64 maxSpaceUsedKB = BYTES_TO_KILOBYTES(maxSpaceUsed); if (es->format != EXPLAIN_FORMAT_TEXT) { ExplainPropertyText("Storage", maxStorageType, es); ExplainPropertyInteger("Maximum Storage", "kB", maxSpaceUsedKB, es); } else { ExplainIndentText(es); appendStringInfo(es->str, "Storage: %s Maximum Storage: " INT64_FORMAT "kB\n", maxStorageType, maxSpaceUsedKB); } } /* * Show TABLESAMPLE properties */ static void show_tablesample(TableSampleClause *tsc, PlanState *planstate, List *ancestors, ExplainState *es) { List *context; bool useprefix; char *method_name; List *params = NIL; char *repeatable; ListCell *lc; /* Set up deparsing context */ context = set_deparse_context_plan(es->deparse_cxt, planstate->plan, ancestors); useprefix = es->rtable_size > 1; /* Get the tablesample method name */ method_name = get_func_name(tsc->tsmhandler); /* Deparse parameter expressions */ foreach(lc, tsc->args) { Node *arg = (Node *) lfirst(lc); params = lappend(params, deparse_expression(arg, context, useprefix, false)); } if (tsc->repeatable) repeatable = deparse_expression((Node *) tsc->repeatable, context, useprefix, false); else repeatable = NULL; /* Print results */ if (es->format == EXPLAIN_FORMAT_TEXT) { bool first = true; ExplainIndentText(es); appendStringInfo(es->str, "Sampling: %s (", method_name); foreach(lc, params) { if (!first) appendStringInfoString(es->str, ", "); appendStringInfoString(es->str, (const char *) lfirst(lc)); first = false; } appendStringInfoChar(es->str, ')'); if (repeatable) appendStringInfo(es->str, " REPEATABLE (%s)", repeatable); appendStringInfoChar(es->str, '\n'); } else { ExplainPropertyText("Sampling Method", method_name, es); ExplainPropertyList("Sampling Parameters", params, es); if (repeatable) ExplainPropertyText("Repeatable Seed", repeatable, es); } } /* * If it's EXPLAIN ANALYZE, show tuplesort stats for a sort node */ static void show_sort_info(SortState *sortstate, ExplainState *es) { if (!es->analyze) return; if (sortstate->sort_Done && sortstate->tuplesortstate != NULL) { Tuplesortstate *state = (Tuplesortstate *) sortstate->tuplesortstate; TuplesortInstrumentation stats; const char *sortMethod; const char *spaceType; int64 spaceUsed; tuplesort_get_stats(state, &stats); sortMethod = tuplesort_method_name(stats.sortMethod); spaceType = tuplesort_space_type_name(stats.spaceType); spaceUsed = stats.spaceUsed; if (es->format == EXPLAIN_FORMAT_TEXT) { ExplainIndentText(es); appendStringInfo(es->str, "Sort Method: %s %s: " INT64_FORMAT "kB\n", sortMethod, spaceType, spaceUsed); } else { ExplainPropertyText("Sort Method", sortMethod, es); ExplainPropertyInteger("Sort Space Used", "kB", spaceUsed, es); ExplainPropertyText("Sort Space Type", spaceType, es); } } /* * You might think we should just skip this stanza entirely when * es->hide_workers is true, but then we'd get no sort-method output at * all. We have to make it look like worker 0's data is top-level data. * This is easily done by just skipping the OpenWorker/CloseWorker calls. * Currently, we don't worry about the possibility that there are multiple * workers in such a case; if there are, duplicate output fields will be * emitted. */ if (sortstate->shared_info != NULL) { int n; for (n = 0; n < sortstate->shared_info->num_workers; n++) { TuplesortInstrumentation *sinstrument; const char *sortMethod; const char *spaceType; int64 spaceUsed; sinstrument = &sortstate->shared_info->sinstrument[n]; if (sinstrument->sortMethod == SORT_TYPE_STILL_IN_PROGRESS) continue; /* ignore any unfilled slots */ sortMethod = tuplesort_method_name(sinstrument->sortMethod); spaceType = tuplesort_space_type_name(sinstrument->spaceType); spaceUsed = sinstrument->spaceUsed; if (es->workers_state) ExplainOpenWorker(n, es); if (es->format == EXPLAIN_FORMAT_TEXT) { ExplainIndentText(es); appendStringInfo(es->str, "Sort Method: %s %s: " INT64_FORMAT "kB\n", sortMethod, spaceType, spaceUsed); } else { ExplainPropertyText("Sort Method", sortMethod, es); ExplainPropertyInteger("Sort Space Used", "kB", spaceUsed, es); ExplainPropertyText("Sort Space Type", spaceType, es); } if (es->workers_state) ExplainCloseWorker(n, es); } } } /* * Incremental sort nodes sort in (a potentially very large number of) batches, * so EXPLAIN ANALYZE needs to roll up the tuplesort stats from each batch into * an intelligible summary. * * This function is used for both a non-parallel node and each worker in a * parallel incremental sort node. */ static void show_incremental_sort_group_info(IncrementalSortGroupInfo *groupInfo, const char *groupLabel, bool indent, ExplainState *es) { ListCell *methodCell; List *methodNames = NIL; /* Generate a list of sort methods used across all groups. */ for (int bit = 0; bit < NUM_TUPLESORTMETHODS; bit++) { TuplesortMethod sortMethod = (1 << bit); if (groupInfo->sortMethods & sortMethod) { const char *methodName = tuplesort_method_name(sortMethod); methodNames = lappend(methodNames, unconstify(char *, methodName)); } } if (es->format == EXPLAIN_FORMAT_TEXT) { if (indent) appendStringInfoSpaces(es->str, es->indent * 2); appendStringInfo(es->str, "%s Groups: " INT64_FORMAT " Sort Method", groupLabel, groupInfo->groupCount); /* plural/singular based on methodNames size */ if (list_length(methodNames) > 1) appendStringInfoString(es->str, "s: "); else appendStringInfoString(es->str, ": "); foreach(methodCell, methodNames) { appendStringInfoString(es->str, (char *) methodCell->ptr_value); if (foreach_current_index(methodCell) < list_length(methodNames) - 1) appendStringInfoString(es->str, ", "); } if (groupInfo->maxMemorySpaceUsed > 0) { int64 avgSpace = groupInfo->totalMemorySpaceUsed / groupInfo->groupCount; const char *spaceTypeName; spaceTypeName = tuplesort_space_type_name(SORT_SPACE_TYPE_MEMORY); appendStringInfo(es->str, " Average %s: " INT64_FORMAT "kB Peak %s: " INT64_FORMAT "kB", spaceTypeName, avgSpace, spaceTypeName, groupInfo->maxMemorySpaceUsed); } if (groupInfo->maxDiskSpaceUsed > 0) { int64 avgSpace = groupInfo->totalDiskSpaceUsed / groupInfo->groupCount; const char *spaceTypeName; spaceTypeName = tuplesort_space_type_name(SORT_SPACE_TYPE_DISK); appendStringInfo(es->str, " Average %s: " INT64_FORMAT "kB Peak %s: " INT64_FORMAT "kB", spaceTypeName, avgSpace, spaceTypeName, groupInfo->maxDiskSpaceUsed); } } else { StringInfoData groupName; initStringInfo(&groupName); appendStringInfo(&groupName, "%s Groups", groupLabel); ExplainOpenGroup("Incremental Sort Groups", groupName.data, true, es); ExplainPropertyInteger("Group Count", NULL, groupInfo->groupCount, es); ExplainPropertyList("Sort Methods Used", methodNames, es); if (groupInfo->maxMemorySpaceUsed > 0) { int64 avgSpace = groupInfo->totalMemorySpaceUsed / groupInfo->groupCount; const char *spaceTypeName; StringInfoData memoryName; spaceTypeName = tuplesort_space_type_name(SORT_SPACE_TYPE_MEMORY); initStringInfo(&memoryName); appendStringInfo(&memoryName, "Sort Space %s", spaceTypeName); ExplainOpenGroup("Sort Space", memoryName.data, true, es); ExplainPropertyInteger("Average Sort Space Used", "kB", avgSpace, es); ExplainPropertyInteger("Peak Sort Space Used", "kB", groupInfo->maxMemorySpaceUsed, es); ExplainCloseGroup("Sort Space", memoryName.data, true, es); } if (groupInfo->maxDiskSpaceUsed > 0) { int64 avgSpace = groupInfo->totalDiskSpaceUsed / groupInfo->groupCount; const char *spaceTypeName; StringInfoData diskName; spaceTypeName = tuplesort_space_type_name(SORT_SPACE_TYPE_DISK); initStringInfo(&diskName); appendStringInfo(&diskName, "Sort Space %s", spaceTypeName); ExplainOpenGroup("Sort Space", diskName.data, true, es); ExplainPropertyInteger("Average Sort Space Used", "kB", avgSpace, es); ExplainPropertyInteger("Peak Sort Space Used", "kB", groupInfo->maxDiskSpaceUsed, es); ExplainCloseGroup("Sort Space", diskName.data, true, es); } ExplainCloseGroup("Incremental Sort Groups", groupName.data, true, es); } } /* * If it's EXPLAIN ANALYZE, show tuplesort stats for an incremental sort node */ static void show_incremental_sort_info(IncrementalSortState *incrsortstate, ExplainState *es) { IncrementalSort *plan = (IncrementalSort *) incrsortstate->ss.ps.plan; IncrementalSortGroupInfo *fullsortGroupInfo; IncrementalSortGroupInfo *prefixsortGroupInfo; fullsortGroupInfo = &incrsortstate->incsort_info.fullsortGroupInfo; if (es->costs) ExplainPropertyFloat("Estimated Groups", NULL, plan->numGroups, 0, es); if (!es->analyze) return; /* * Since we never have any prefix groups unless we've first sorted a full * groups and transitioned modes (copying the tuples into a prefix group), * we don't need to do anything if there were 0 full groups. * * We still have to continue after this block if there are no full groups, * though, since it's possible that we have workers that did real work * even if the leader didn't participate. */ if (fullsortGroupInfo->groupCount > 0) { show_incremental_sort_group_info(fullsortGroupInfo, "Full-sort", true, es); prefixsortGroupInfo = &incrsortstate->incsort_info.prefixsortGroupInfo; if (prefixsortGroupInfo->groupCount > 0) { if (es->format == EXPLAIN_FORMAT_TEXT) appendStringInfoChar(es->str, '\n'); show_incremental_sort_group_info(prefixsortGroupInfo, "Pre-sorted", true, es); } if (es->format == EXPLAIN_FORMAT_TEXT) appendStringInfoChar(es->str, '\n'); } if (incrsortstate->shared_info != NULL) { int n; bool indent_first_line; for (n = 0; n < incrsortstate->shared_info->num_workers; n++) { IncrementalSortInfo *incsort_info = &incrsortstate->shared_info->sinfo[n]; /* * If a worker hasn't processed any sort groups at all, then * exclude it from output since it either didn't launch or didn't * contribute anything meaningful. */ fullsortGroupInfo = &incsort_info->fullsortGroupInfo; /* * Since we never have any prefix groups unless we've first sorted * a full groups and transitioned modes (copying the tuples into a * prefix group), we don't need to do anything if there were 0 * full groups. */ if (fullsortGroupInfo->groupCount == 0) continue; if (es->workers_state) ExplainOpenWorker(n, es); indent_first_line = es->workers_state == NULL || es->verbose; show_incremental_sort_group_info(fullsortGroupInfo, "Full-sort", indent_first_line, es); prefixsortGroupInfo = &incsort_info->prefixsortGroupInfo; if (prefixsortGroupInfo->groupCount > 0) { if (es->format == EXPLAIN_FORMAT_TEXT) appendStringInfoChar(es->str, '\n'); show_incremental_sort_group_info(prefixsortGroupInfo, "Pre-sorted", true, es); } if (es->format == EXPLAIN_FORMAT_TEXT) appendStringInfoChar(es->str, '\n'); if (es->workers_state) ExplainCloseWorker(n, es); } } } /* * Show information on hash buckets/batches. */ static void show_hash_info(HashState *hashstate, ExplainState *es) { HashInstrumentation hinstrument = {0}; /* * Collect stats from the local process, even when it's a parallel query. * In a parallel query, the leader process may or may not have run the * hash join, and even if it did it may not have built a hash table due to * timing (if it started late it might have seen no tuples in the outer * relation and skipped building the hash table). Therefore we have to be * prepared to get instrumentation data from all participants. */ if (hashstate->hinstrument) memcpy(&hinstrument, hashstate->hinstrument, sizeof(HashInstrumentation)); /* * Merge results from workers. In the parallel-oblivious case, the * results from all participants should be identical, except where * participants didn't run the join at all so have no data. In the * parallel-aware case, we need to consider all the results. Each worker * may have seen a different subset of batches and we want to report the * highest memory usage across all batches. We take the maxima of other * values too, for the same reasons as in ExecHashAccumInstrumentation. */ if (hashstate->shared_info) { SharedHashInfo *shared_info = hashstate->shared_info; int i; for (i = 0; i < shared_info->num_workers; ++i) { HashInstrumentation *worker_hi = &shared_info->hinstrument[i]; hinstrument.nbuckets = Max(hinstrument.nbuckets, worker_hi->nbuckets); hinstrument.nbuckets_original = Max(hinstrument.nbuckets_original, worker_hi->nbuckets_original); hinstrument.nbatch = Max(hinstrument.nbatch, worker_hi->nbatch); hinstrument.nbatch_original = Max(hinstrument.nbatch_original, worker_hi->nbatch_original); hinstrument.space_peak = Max(hinstrument.space_peak, worker_hi->space_peak); } } if (hinstrument.nbatch > 0) { uint64 spacePeakKb = BYTES_TO_KILOBYTES(hinstrument.space_peak); if (es->format != EXPLAIN_FORMAT_TEXT) { ExplainPropertyInteger("Hash Buckets", NULL, hinstrument.nbuckets, es); ExplainPropertyInteger("Original Hash Buckets", NULL, hinstrument.nbuckets_original, es); ExplainPropertyInteger("Hash Batches", NULL, hinstrument.nbatch, es); ExplainPropertyInteger("Original Hash Batches", NULL, hinstrument.nbatch_original, es); ExplainPropertyUInteger("Peak Memory Usage", "kB", spacePeakKb, es); } else if (hinstrument.nbatch_original != hinstrument.nbatch || hinstrument.nbuckets_original != hinstrument.nbuckets) { ExplainIndentText(es); appendStringInfo(es->str, "Buckets: %d (originally %d) Batches: %d (originally %d) Memory Usage: " UINT64_FORMAT "kB\n", hinstrument.nbuckets, hinstrument.nbuckets_original, hinstrument.nbatch, hinstrument.nbatch_original, spacePeakKb); } else { ExplainIndentText(es); appendStringInfo(es->str, "Buckets: %d Batches: %d Memory Usage: " UINT64_FORMAT "kB\n", hinstrument.nbuckets, hinstrument.nbatch, spacePeakKb); } } } /* * Show information on material node, storage method and maximum memory/disk * space used. */ static void show_material_info(MaterialState *mstate, ExplainState *es) { char *maxStorageType; int64 maxSpaceUsed; Tuplestorestate *tupstore = mstate->tuplestorestate; /* * Nothing to show if ANALYZE option wasn't used or if execution didn't * get as far as creating the tuplestore. */ if (!es->analyze || tupstore == NULL) return; tuplestore_get_stats(tupstore, &maxStorageType, &maxSpaceUsed); show_storage_info(maxStorageType, maxSpaceUsed, es); } /* * Show information on WindowAgg node, storage method and maximum memory/disk * space used. */ static void show_windowagg_info(WindowAggState *winstate, ExplainState *es) { char *maxStorageType; int64 maxSpaceUsed; Tuplestorestate *tupstore = winstate->buffer; /* * Nothing to show if ANALYZE option wasn't used or if execution didn't * get as far as creating the tuplestore. */ if (!es->analyze || tupstore == NULL) return; tuplestore_get_stats(tupstore, &maxStorageType, &maxSpaceUsed); show_storage_info(maxStorageType, maxSpaceUsed, es); } /* * Show information on CTE Scan node, storage method and maximum memory/disk * space used. */ static void show_ctescan_info(CteScanState *ctescanstate, ExplainState *es) { char *maxStorageType; int64 maxSpaceUsed; Tuplestorestate *tupstore = ctescanstate->leader->cte_table; if (!es->analyze || tupstore == NULL) return; tuplestore_get_stats(tupstore, &maxStorageType, &maxSpaceUsed); show_storage_info(maxStorageType, maxSpaceUsed, es); } /* * Show information on Table Function Scan node, storage method and maximum * memory/disk space used. */ static void show_table_func_scan_info(TableFuncScanState *tscanstate, ExplainState *es) { char *maxStorageType; int64 maxSpaceUsed; Tuplestorestate *tupstore = tscanstate->tupstore; if (!es->analyze || tupstore == NULL) return; tuplestore_get_stats(tupstore, &maxStorageType, &maxSpaceUsed); show_storage_info(maxStorageType, maxSpaceUsed, es); } /* * Show information on Recursive Union node, storage method and maximum * memory/disk space used. */ static void show_recursive_union_info(RecursiveUnionState *rstate, ExplainState *es) { char *maxStorageType, *tempStorageType; int64 maxSpaceUsed, tempSpaceUsed; if (!es->analyze) return; /* * Recursive union node uses two tuplestores. We employ the storage type * from one of them which consumed more memory/disk than the other. The * storage size is sum of the two. */ tuplestore_get_stats(rstate->working_table, &tempStorageType, &tempSpaceUsed); tuplestore_get_stats(rstate->intermediate_table, &maxStorageType, &maxSpaceUsed); if (tempSpaceUsed > maxSpaceUsed) maxStorageType = tempStorageType; maxSpaceUsed += tempSpaceUsed; show_storage_info(maxStorageType, maxSpaceUsed, es); } /* * Show information on memoize hits/misses/evictions and memory usage. */ static void show_memoize_info(MemoizeState *mstate, List *ancestors, ExplainState *es) { Plan *plan = ((PlanState *) mstate)->plan; Memoize *mplan = (Memoize *) plan; ListCell *lc; List *context; StringInfoData keystr; char *separator = ""; bool useprefix; int64 memPeakKb; initStringInfo(&keystr); /* * It's hard to imagine having a memoize node with fewer than 2 RTEs, but * let's just keep the same useprefix logic as elsewhere in this file. */ useprefix = es->rtable_size > 1 || es->verbose; /* Set up deparsing context */ context = set_deparse_context_plan(es->deparse_cxt, plan, ancestors); foreach(lc, mplan->param_exprs) { Node *expr = (Node *) lfirst(lc); appendStringInfoString(&keystr, separator); appendStringInfoString(&keystr, deparse_expression(expr, context, useprefix, false)); separator = ", "; } ExplainPropertyText("Cache Key", keystr.data, es); ExplainPropertyText("Cache Mode", mstate->binary_mode ? "binary" : "logical", es); pfree(keystr.data); if (es->costs) { if (es->format == EXPLAIN_FORMAT_TEXT) { ExplainIndentText(es); appendStringInfo(es->str, "Estimates: capacity=%u distinct keys=%.0f lookups=%.0f hit percent=%.2f%%\n", mplan->est_entries, mplan->est_unique_keys, mplan->est_calls, mplan->est_hit_ratio * 100.0); } else { ExplainPropertyUInteger("Estimated Capacity", NULL, mplan->est_entries, es); ExplainPropertyFloat("Estimated Distinct Lookup Keys", NULL, mplan->est_unique_keys, 0, es); ExplainPropertyFloat("Estimated Lookups", NULL, mplan->est_calls, 0, es); ExplainPropertyFloat("Estimated Hit Percent", NULL, mplan->est_hit_ratio * 100.0, 2, es); } } if (!es->analyze) return; if (mstate->stats.cache_misses > 0) { /* * mem_peak is only set when we freed memory, so we must use mem_used * when mem_peak is 0. */ if (mstate->stats.mem_peak > 0) memPeakKb = BYTES_TO_KILOBYTES(mstate->stats.mem_peak); else memPeakKb = BYTES_TO_KILOBYTES(mstate->mem_used); if (es->format != EXPLAIN_FORMAT_TEXT) { ExplainPropertyInteger("Cache Hits", NULL, mstate->stats.cache_hits, es); ExplainPropertyInteger("Cache Misses", NULL, mstate->stats.cache_misses, es); ExplainPropertyInteger("Cache Evictions", NULL, mstate->stats.cache_evictions, es); ExplainPropertyInteger("Cache Overflows", NULL, mstate->stats.cache_overflows, es); ExplainPropertyInteger("Peak Memory Usage", "kB", memPeakKb, es); } else { ExplainIndentText(es); appendStringInfo(es->str, "Hits: " UINT64_FORMAT " Misses: " UINT64_FORMAT " Evictions: " UINT64_FORMAT " Overflows: " UINT64_FORMAT " Memory Usage: " INT64_FORMAT "kB\n", mstate->stats.cache_hits, mstate->stats.cache_misses, mstate->stats.cache_evictions, mstate->stats.cache_overflows, memPeakKb); } } if (mstate->shared_info == NULL) return; /* Show details from parallel workers */ for (int n = 0; n < mstate->shared_info->num_workers; n++) { MemoizeInstrumentation *si; si = &mstate->shared_info->sinstrument[n]; /* * Skip workers that didn't do any work. We needn't bother checking * for cache hits as a miss will always occur before a cache hit. */ if (si->cache_misses == 0) continue; if (es->workers_state) ExplainOpenWorker(n, es); /* * Since the worker's MemoizeState.mem_used field is unavailable to * us, ExecEndMemoize will have set the * MemoizeInstrumentation.mem_peak field for us. No need to do the * zero checks like we did for the serial case above. */ memPeakKb = BYTES_TO_KILOBYTES(si->mem_peak); if (es->format == EXPLAIN_FORMAT_TEXT) { ExplainIndentText(es); appendStringInfo(es->str, "Hits: " UINT64_FORMAT " Misses: " UINT64_FORMAT " Evictions: " UINT64_FORMAT " Overflows: " UINT64_FORMAT " Memory Usage: " INT64_FORMAT "kB\n", si->cache_hits, si->cache_misses, si->cache_evictions, si->cache_overflows, memPeakKb); } else { ExplainPropertyInteger("Cache Hits", NULL, si->cache_hits, es); ExplainPropertyInteger("Cache Misses", NULL, si->cache_misses, es); ExplainPropertyInteger("Cache Evictions", NULL, si->cache_evictions, es); ExplainPropertyInteger("Cache Overflows", NULL, si->cache_overflows, es); ExplainPropertyInteger("Peak Memory Usage", "kB", memPeakKb, es); } if (es->workers_state) ExplainCloseWorker(n, es); } } /* * Show information on hash aggregate memory usage and batches. */ static void show_hashagg_info(AggState *aggstate, ExplainState *es) { Agg *agg = (Agg *) aggstate->ss.ps.plan; int64 memPeakKb = BYTES_TO_KILOBYTES(aggstate->hash_mem_peak); if (agg->aggstrategy != AGG_HASHED && agg->aggstrategy != AGG_MIXED) return; if (es->format != EXPLAIN_FORMAT_TEXT) { if (es->costs) ExplainPropertyInteger("Planned Partitions", NULL, aggstate->hash_planned_partitions, es); /* * During parallel query the leader may have not helped out. We * detect this by checking how much memory it used. If we find it * didn't do any work then we don't show its properties. */ if (es->analyze && aggstate->hash_mem_peak > 0) { ExplainPropertyInteger("HashAgg Batches", NULL, aggstate->hash_batches_used, es); ExplainPropertyInteger("Peak Memory Usage", "kB", memPeakKb, es); ExplainPropertyInteger("Disk Usage", "kB", aggstate->hash_disk_used, es); } } else { bool gotone = false; if (es->costs && aggstate->hash_planned_partitions > 0) { ExplainIndentText(es); appendStringInfo(es->str, "Planned Partitions: %d", aggstate->hash_planned_partitions); gotone = true; } /* * During parallel query the leader may have not helped out. We * detect this by checking how much memory it used. If we find it * didn't do any work then we don't show its properties. */ if (es->analyze && aggstate->hash_mem_peak > 0) { if (!gotone) ExplainIndentText(es); else appendStringInfoSpaces(es->str, 2); appendStringInfo(es->str, "Batches: %d Memory Usage: " INT64_FORMAT "kB", aggstate->hash_batches_used, memPeakKb); gotone = true; /* Only display disk usage if we spilled to disk */ if (aggstate->hash_batches_used > 1) { appendStringInfo(es->str, " Disk Usage: " UINT64_FORMAT "kB", aggstate->hash_disk_used); } } if (gotone) appendStringInfoChar(es->str, '\n'); } /* Display stats for each parallel worker */ if (es->analyze && aggstate->shared_info != NULL) { for (int n = 0; n < aggstate->shared_info->num_workers; n++) { AggregateInstrumentation *sinstrument; uint64 hash_disk_used; int hash_batches_used; sinstrument = &aggstate->shared_info->sinstrument[n]; /* Skip workers that didn't do anything */ if (sinstrument->hash_mem_peak == 0) continue; hash_disk_used = sinstrument->hash_disk_used; hash_batches_used = sinstrument->hash_batches_used; memPeakKb = BYTES_TO_KILOBYTES(sinstrument->hash_mem_peak); if (es->workers_state) ExplainOpenWorker(n, es); if (es->format == EXPLAIN_FORMAT_TEXT) { ExplainIndentText(es); appendStringInfo(es->str, "Batches: %d Memory Usage: " INT64_FORMAT "kB", hash_batches_used, memPeakKb); /* Only display disk usage if we spilled to disk */ if (hash_batches_used > 1) appendStringInfo(es->str, " Disk Usage: " UINT64_FORMAT "kB", hash_disk_used); appendStringInfoChar(es->str, '\n'); } else { ExplainPropertyInteger("HashAgg Batches", NULL, hash_batches_used, es); ExplainPropertyInteger("Peak Memory Usage", "kB", memPeakKb, es); ExplainPropertyInteger("Disk Usage", "kB", hash_disk_used, es); } if (es->workers_state) ExplainCloseWorker(n, es); } } } /* * Show the total number of index searches for a * IndexScan/IndexOnlyScan/BitmapIndexScan node */ static void show_indexsearches_info(PlanState *planstate, ExplainState *es) { Plan *plan = planstate->plan; SharedIndexScanInstrumentation *SharedInfo = NULL; uint64 nsearches = 0; if (!es->analyze) return; /* Initialize counters with stats from the local process first */ switch (nodeTag(plan)) { case T_IndexScan: { IndexScanState *indexstate = ((IndexScanState *) planstate); nsearches = indexstate->iss_Instrument->nsearches; SharedInfo = indexstate->iss_SharedInfo; break; } case T_IndexOnlyScan: { IndexOnlyScanState *indexstate = ((IndexOnlyScanState *) planstate); nsearches = indexstate->ioss_Instrument->nsearches; SharedInfo = indexstate->ioss_SharedInfo; break; } case T_BitmapIndexScan: { BitmapIndexScanState *indexstate = ((BitmapIndexScanState *) planstate); nsearches = indexstate->biss_Instrument->nsearches; SharedInfo = indexstate->biss_SharedInfo; break; } default: break; } /* Next get the sum of the counters set within each and every process */ if (SharedInfo) { for (int i = 0; i < SharedInfo->num_workers; ++i) { IndexScanInstrumentation *winstrument = &SharedInfo->winstrument[i]; nsearches += winstrument->nsearches; } } ExplainPropertyUInteger("Index Searches", NULL, nsearches, es); } /* * Show exact/lossy pages for a BitmapHeapScan node */ static void show_tidbitmap_info(BitmapHeapScanState *planstate, ExplainState *es) { if (!es->analyze) return; if (es->format != EXPLAIN_FORMAT_TEXT) { ExplainPropertyUInteger("Exact Heap Blocks", NULL, planstate->stats.exact_pages, es); ExplainPropertyUInteger("Lossy Heap Blocks", NULL, planstate->stats.lossy_pages, es); } else { if (planstate->stats.exact_pages > 0 || planstate->stats.lossy_pages > 0) { ExplainIndentText(es); appendStringInfoString(es->str, "Heap Blocks:"); if (planstate->stats.exact_pages > 0) appendStringInfo(es->str, " exact=" UINT64_FORMAT, planstate->stats.exact_pages); if (planstate->stats.lossy_pages > 0) appendStringInfo(es->str, " lossy=" UINT64_FORMAT, planstate->stats.lossy_pages); appendStringInfoChar(es->str, '\n'); } } /* Display stats for each parallel worker */ if (planstate->sinstrument != NULL) { for (int n = 0; n < planstate->sinstrument->num_workers; n++) { BitmapHeapScanInstrumentation *si = &planstate->sinstrument->sinstrument[n]; if (si->exact_pages == 0 && si->lossy_pages == 0) continue; if (es->workers_state) ExplainOpenWorker(n, es); if (es->format == EXPLAIN_FORMAT_TEXT) { ExplainIndentText(es); appendStringInfoString(es->str, "Heap Blocks:"); if (si->exact_pages > 0) appendStringInfo(es->str, " exact=" UINT64_FORMAT, si->exact_pages); if (si->lossy_pages > 0) appendStringInfo(es->str, " lossy=" UINT64_FORMAT, si->lossy_pages); appendStringInfoChar(es->str, '\n'); } else { ExplainPropertyUInteger("Exact Heap Blocks", NULL, si->exact_pages, es); ExplainPropertyUInteger("Lossy Heap Blocks", NULL, si->lossy_pages, es); } if (es->workers_state) ExplainCloseWorker(n, es); } } } /* * Print I/O stats - prefetching and I/O performed * * This prints two types of stats - "prefetch" about the prefetching done by * ReadStream, and "I/O" issued by the stream. The prefetch stats are based * on buffers pulled from the stream (even if no I/O is needed). The I/O * information is related to I/O requests issued by the stream. * * The prefetch stats are printed if any buffer was pulled from the stream. * For the I/O stats it depend on the output format. In non-text formats the * information is printed if prefetch stats were printed. In text format it * gets printed only if there were any I/O requests. */ static void print_io_usage(ExplainState *es, IOStats *stats) { /* don't print prefetch stats if there's nothing to report */ if (stats->prefetch_count > 0) { if (es->format == EXPLAIN_FORMAT_TEXT) { /* prefetch distance info */ ExplainIndentText(es); appendStringInfo(es->str, "Prefetch: avg=%.2f max=%d capacity=%d\n", (stats->distance_sum * 1.0 / stats->prefetch_count), stats->distance_max, stats->distance_capacity); /* prefetch I/O info (only if there were actual I/Os) */ if (stats->io_count > 0) { ExplainIndentText(es); appendStringInfo(es->str, "I/O: count=%" PRIu64 " waits=%" PRIu64 " size=%.2f in-progress=%.2f\n", stats->io_count, stats->wait_count, (stats->io_nblocks * 1.0 / stats->io_count), (stats->io_in_progress * 1.0 / stats->io_count)); } } else { ExplainPropertyFloat("Average Prefetch Distance", NULL, (stats->distance_sum * 1.0 / stats->prefetch_count), 3, es); ExplainPropertyInteger("Max Prefetch Distance", NULL, stats->distance_max, es); ExplainPropertyInteger("Prefetch Capacity", NULL, stats->distance_capacity, es); ExplainPropertyUInteger("I/O Count", NULL, stats->io_count, es); ExplainPropertyUInteger("I/O Waits", NULL, stats->wait_count, es); ExplainPropertyFloat("Average I/O Size", NULL, (stats->io_nblocks * 1.0 / Max(1, stats->io_count)), 3, es); ExplainPropertyFloat("Average I/Os In Progress", NULL, (stats->io_in_progress * 1.0 / Max(1, stats->io_count)), 3, es); } } } /* * Show information about prefetch and I/O in a scan node. */ static void show_scan_io_usage(ScanState *planstate, ExplainState *es) { Plan *plan = planstate->ps.plan; IOStats stats = {0}; if (!es->io) return; /* * Initialize counters with stats from the local process first. * * The scan descriptor may not exist, e.g. if the scan did not start, or * because of debug_parallel_query=regress. We still want to collect data * from workers. */ if (planstate->ss_currentScanDesc && planstate->ss_currentScanDesc->rs_instrument) { stats = planstate->ss_currentScanDesc->rs_instrument->io; } /* * Accumulate data from parallel workers (if any). */ switch (nodeTag(plan)) { case T_BitmapHeapScan: { SharedBitmapHeapInstrumentation *sinstrument = ((BitmapHeapScanState *) planstate)->sinstrument; if (sinstrument) { for (int i = 0; i < sinstrument->num_workers; ++i) { BitmapHeapScanInstrumentation *winstrument = &sinstrument->sinstrument[i]; AccumulateIOStats(&stats, &winstrument->stats.io); if (!es->workers_state) continue; ExplainOpenWorker(i, es); print_io_usage(es, &winstrument->stats.io); ExplainCloseWorker(i, es); } } break; } case T_SeqScan: { SharedSeqScanInstrumentation *sinstrument = ((SeqScanState *) planstate)->sinstrument; if (sinstrument) { for (int i = 0; i < sinstrument->num_workers; ++i) { SeqScanInstrumentation *winstrument = &sinstrument->sinstrument[i]; AccumulateIOStats(&stats, &winstrument->stats.io); if (!es->workers_state) continue; ExplainOpenWorker(i, es); print_io_usage(es, &winstrument->stats.io); ExplainCloseWorker(i, es); } } break; } case T_TidRangeScan: { SharedTidRangeScanInstrumentation *sinstrument = ((TidRangeScanState *) planstate)->trss_sinstrument; if (sinstrument) { for (int i = 0; i < sinstrument->num_workers; ++i) { TidRangeScanInstrumentation *winstrument = &sinstrument->sinstrument[i]; AccumulateIOStats(&stats, &winstrument->stats.io); if (!es->workers_state) continue; ExplainOpenWorker(i, es); print_io_usage(es, &winstrument->stats.io); ExplainCloseWorker(i, es); } } break; } default: /* ignore other plans */ return; } print_io_usage(es, &stats); } /* * If it's EXPLAIN ANALYZE, show instrumentation information for a plan node * * "which" identifies which instrumentation counter to print */ static void show_instrumentation_count(const char *qlabel, int which, PlanState *planstate, ExplainState *es) { double nfiltered; double nloops; if (!es->analyze || !planstate->instrument) return; if (which == 2) nfiltered = planstate->instrument->nfiltered2; else nfiltered = planstate->instrument->nfiltered1; nloops = planstate->instrument->nloops; /* In text mode, suppress zero counts; they're not interesting enough */ if (nfiltered > 0 || es->format != EXPLAIN_FORMAT_TEXT) { if (nloops > 0) ExplainPropertyFloat(qlabel, NULL, nfiltered / nloops, 0, es); else ExplainPropertyFloat(qlabel, NULL, 0.0, 0, es); } } /* * Show extra information for a ForeignScan node. */ static void show_foreignscan_info(ForeignScanState *fsstate, ExplainState *es) { FdwRoutine *fdwroutine = fsstate->fdwroutine; /* Let the FDW emit whatever fields it wants */ if (((ForeignScan *) fsstate->ss.ps.plan)->operation != CMD_SELECT) { if (fdwroutine->ExplainDirectModify != NULL) fdwroutine->ExplainDirectModify(fsstate, es); } else { if (fdwroutine->ExplainForeignScan != NULL) fdwroutine->ExplainForeignScan(fsstate, es); } } /* * Fetch the name of an index in an EXPLAIN * * We allow plugins to get control here so that plans involving hypothetical * indexes can be explained. * * Note: names returned by this function should be "raw"; the caller will * apply quoting if needed. Formerly the convention was to do quoting here, * but we don't want that in non-text output formats. */ static const char * explain_get_index_name(Oid indexId) { const char *result; if (explain_get_index_name_hook) result = (*explain_get_index_name_hook) (indexId); else result = NULL; if (result == NULL) { /* default behavior: look it up in the catalogs */ result = get_rel_name(indexId); if (result == NULL) elog(ERROR, "cache lookup failed for index %u", indexId); } return result; } /* * Return whether show_buffer_usage would have anything to print, if given * the same 'usage' data. Note that when the format is anything other than * text, we print even if the counters are all zeroes. */ static bool peek_buffer_usage(ExplainState *es, const BufferUsage *usage) { bool has_shared; bool has_local; bool has_temp; bool has_shared_timing; bool has_local_timing; bool has_temp_timing; if (usage == NULL) return false; if (es->format != EXPLAIN_FORMAT_TEXT) return true; has_shared = (usage->shared_blks_hit > 0 || usage->shared_blks_read > 0 || usage->shared_blks_dirtied > 0 || usage->shared_blks_written > 0); has_local = (usage->local_blks_hit > 0 || usage->local_blks_read > 0 || usage->local_blks_dirtied > 0 || usage->local_blks_written > 0); has_temp = (usage->temp_blks_read > 0 || usage->temp_blks_written > 0); has_shared_timing = (!INSTR_TIME_IS_ZERO(usage->shared_blk_read_time) || !INSTR_TIME_IS_ZERO(usage->shared_blk_write_time)); has_local_timing = (!INSTR_TIME_IS_ZERO(usage->local_blk_read_time) || !INSTR_TIME_IS_ZERO(usage->local_blk_write_time)); has_temp_timing = (!INSTR_TIME_IS_ZERO(usage->temp_blk_read_time) || !INSTR_TIME_IS_ZERO(usage->temp_blk_write_time)); return has_shared || has_local || has_temp || has_shared_timing || has_local_timing || has_temp_timing; } /* * Show buffer usage details. This better be sync with peek_buffer_usage. */ static void show_buffer_usage(ExplainState *es, const BufferUsage *usage) { if (es->format == EXPLAIN_FORMAT_TEXT) { bool has_shared = (usage->shared_blks_hit > 0 || usage->shared_blks_read > 0 || usage->shared_blks_dirtied > 0 || usage->shared_blks_written > 0); bool has_local = (usage->local_blks_hit > 0 || usage->local_blks_read > 0 || usage->local_blks_dirtied > 0 || usage->local_blks_written > 0); bool has_temp = (usage->temp_blks_read > 0 || usage->temp_blks_written > 0); bool has_shared_timing = (!INSTR_TIME_IS_ZERO(usage->shared_blk_read_time) || !INSTR_TIME_IS_ZERO(usage->shared_blk_write_time)); bool has_local_timing = (!INSTR_TIME_IS_ZERO(usage->local_blk_read_time) || !INSTR_TIME_IS_ZERO(usage->local_blk_write_time)); bool has_temp_timing = (!INSTR_TIME_IS_ZERO(usage->temp_blk_read_time) || !INSTR_TIME_IS_ZERO(usage->temp_blk_write_time)); /* Show only positive counter values. */ if (has_shared || has_local || has_temp) { ExplainIndentText(es); appendStringInfoString(es->str, "Buffers:"); if (has_shared) { appendStringInfoString(es->str, " shared"); if (usage->shared_blks_hit > 0) appendStringInfo(es->str, " hit=%" PRId64, usage->shared_blks_hit); if (usage->shared_blks_read > 0) appendStringInfo(es->str, " read=%" PRId64, usage->shared_blks_read); if (usage->shared_blks_dirtied > 0) appendStringInfo(es->str, " dirtied=%" PRId64, usage->shared_blks_dirtied); if (usage->shared_blks_written > 0) appendStringInfo(es->str, " written=%" PRId64, usage->shared_blks_written); if (has_local || has_temp) appendStringInfoChar(es->str, ','); } if (has_local) { appendStringInfoString(es->str, " local"); if (usage->local_blks_hit > 0) appendStringInfo(es->str, " hit=%" PRId64, usage->local_blks_hit); if (usage->local_blks_read > 0) appendStringInfo(es->str, " read=%" PRId64, usage->local_blks_read); if (usage->local_blks_dirtied > 0) appendStringInfo(es->str, " dirtied=%" PRId64, usage->local_blks_dirtied); if (usage->local_blks_written > 0) appendStringInfo(es->str, " written=%" PRId64, usage->local_blks_written); if (has_temp) appendStringInfoChar(es->str, ','); } if (has_temp) { appendStringInfoString(es->str, " temp"); if (usage->temp_blks_read > 0) appendStringInfo(es->str, " read=%" PRId64, usage->temp_blks_read); if (usage->temp_blks_written > 0) appendStringInfo(es->str, " written=%" PRId64, usage->temp_blks_written); } appendStringInfoChar(es->str, '\n'); } /* As above, show only positive counter values. */ if (has_shared_timing || has_local_timing || has_temp_timing) { ExplainIndentText(es); appendStringInfoString(es->str, "I/O Timings:"); if (has_shared_timing) { appendStringInfoString(es->str, " shared"); if (!INSTR_TIME_IS_ZERO(usage->shared_blk_read_time)) appendStringInfo(es->str, " read=%0.3f", INSTR_TIME_GET_MILLISEC(usage->shared_blk_read_time)); if (!INSTR_TIME_IS_ZERO(usage->shared_blk_write_time)) appendStringInfo(es->str, " write=%0.3f", INSTR_TIME_GET_MILLISEC(usage->shared_blk_write_time)); if (has_local_timing || has_temp_timing) appendStringInfoChar(es->str, ','); } if (has_local_timing) { appendStringInfoString(es->str, " local"); if (!INSTR_TIME_IS_ZERO(usage->local_blk_read_time)) appendStringInfo(es->str, " read=%0.3f", INSTR_TIME_GET_MILLISEC(usage->local_blk_read_time)); if (!INSTR_TIME_IS_ZERO(usage->local_blk_write_time)) appendStringInfo(es->str, " write=%0.3f", INSTR_TIME_GET_MILLISEC(usage->local_blk_write_time)); if (has_temp_timing) appendStringInfoChar(es->str, ','); } if (has_temp_timing) { appendStringInfoString(es->str, " temp"); if (!INSTR_TIME_IS_ZERO(usage->temp_blk_read_time)) appendStringInfo(es->str, " read=%0.3f", INSTR_TIME_GET_MILLISEC(usage->temp_blk_read_time)); if (!INSTR_TIME_IS_ZERO(usage->temp_blk_write_time)) appendStringInfo(es->str, " write=%0.3f", INSTR_TIME_GET_MILLISEC(usage->temp_blk_write_time)); } appendStringInfoChar(es->str, '\n'); } } else { ExplainPropertyInteger("Shared Hit Blocks", NULL, usage->shared_blks_hit, es); ExplainPropertyInteger("Shared Read Blocks", NULL, usage->shared_blks_read, es); ExplainPropertyInteger("Shared Dirtied Blocks", NULL, usage->shared_blks_dirtied, es); ExplainPropertyInteger("Shared Written Blocks", NULL, usage->shared_blks_written, es); ExplainPropertyInteger("Local Hit Blocks", NULL, usage->local_blks_hit, es); ExplainPropertyInteger("Local Read Blocks", NULL, usage->local_blks_read, es); ExplainPropertyInteger("Local Dirtied Blocks", NULL, usage->local_blks_dirtied, es); ExplainPropertyInteger("Local Written Blocks", NULL, usage->local_blks_written, es); ExplainPropertyInteger("Temp Read Blocks", NULL, usage->temp_blks_read, es); ExplainPropertyInteger("Temp Written Blocks", NULL, usage->temp_blks_written, es); if (track_io_timing) { ExplainPropertyFloat("Shared I/O Read Time", "ms", INSTR_TIME_GET_MILLISEC(usage->shared_blk_read_time), 3, es); ExplainPropertyFloat("Shared I/O Write Time", "ms", INSTR_TIME_GET_MILLISEC(usage->shared_blk_write_time), 3, es); ExplainPropertyFloat("Local I/O Read Time", "ms", INSTR_TIME_GET_MILLISEC(usage->local_blk_read_time), 3, es); ExplainPropertyFloat("Local I/O Write Time", "ms", INSTR_TIME_GET_MILLISEC(usage->local_blk_write_time), 3, es); ExplainPropertyFloat("Temp I/O Read Time", "ms", INSTR_TIME_GET_MILLISEC(usage->temp_blk_read_time), 3, es); ExplainPropertyFloat("Temp I/O Write Time", "ms", INSTR_TIME_GET_MILLISEC(usage->temp_blk_write_time), 3, es); } } } /* * Show WAL usage details. */ static void show_wal_usage(ExplainState *es, const WalUsage *usage) { if (es->format == EXPLAIN_FORMAT_TEXT) { /* Show only positive counter values. */ if ((usage->wal_records > 0) || (usage->wal_fpi > 0) || (usage->wal_bytes > 0) || (usage->wal_buffers_full > 0) || (usage->wal_fpi_bytes > 0)) { ExplainIndentText(es); appendStringInfoString(es->str, "WAL:"); if (usage->wal_records > 0) appendStringInfo(es->str, " records=%" PRId64, usage->wal_records); if (usage->wal_fpi > 0) appendStringInfo(es->str, " fpi=%" PRId64, usage->wal_fpi); if (usage->wal_bytes > 0) appendStringInfo(es->str, " bytes=%" PRIu64, usage->wal_bytes); if (usage->wal_fpi_bytes > 0) appendStringInfo(es->str, " fpi bytes=%" PRIu64, usage->wal_fpi_bytes); if (usage->wal_buffers_full > 0) appendStringInfo(es->str, " buffers full=%" PRId64, usage->wal_buffers_full); appendStringInfoChar(es->str, '\n'); } } else { ExplainPropertyInteger("WAL Records", NULL, usage->wal_records, es); ExplainPropertyInteger("WAL FPI", NULL, usage->wal_fpi, es); ExplainPropertyUInteger("WAL Bytes", NULL, usage->wal_bytes, es); ExplainPropertyUInteger("WAL FPI Bytes", NULL, usage->wal_fpi_bytes, es); ExplainPropertyInteger("WAL Buffers Full", NULL, usage->wal_buffers_full, es); } } /* * Show memory usage details. */ static void show_memory_counters(ExplainState *es, const MemoryContextCounters *mem_counters) { int64 memUsedkB = BYTES_TO_KILOBYTES(mem_counters->totalspace - mem_counters->freespace); int64 memAllocatedkB = BYTES_TO_KILOBYTES(mem_counters->totalspace); if (es->format == EXPLAIN_FORMAT_TEXT) { ExplainIndentText(es); appendStringInfo(es->str, "Memory: used=" INT64_FORMAT "kB allocated=" INT64_FORMAT "kB", memUsedkB, memAllocatedkB); appendStringInfoChar(es->str, '\n'); } else { ExplainPropertyInteger("Memory Used", "kB", memUsedkB, es); ExplainPropertyInteger("Memory Allocated", "kB", memAllocatedkB, es); } } /* * Add some additional details about an IndexScan or IndexOnlyScan */ static void ExplainIndexScanDetails(Oid indexid, ScanDirection indexorderdir, ExplainState *es) { const char *indexname = explain_get_index_name(indexid); if (es->format == EXPLAIN_FORMAT_TEXT) { if (ScanDirectionIsBackward(indexorderdir)) appendStringInfoString(es->str, " Backward"); appendStringInfo(es->str, " using %s", quote_identifier(indexname)); } else { const char *scandir; switch (indexorderdir) { case BackwardScanDirection: scandir = "Backward"; break; case ForwardScanDirection: scandir = "Forward"; break; default: scandir = "???"; break; } ExplainPropertyText("Scan Direction", scandir, es); ExplainPropertyText("Index Name", indexname, es); } } /* * Show the target of a Scan node */ static void ExplainScanTarget(Scan *plan, ExplainState *es) { ExplainTargetRel((Plan *) plan, plan->scanrelid, es); } /* * Show the target of a ModifyTable node * * Here we show the nominal target (ie, the relation that was named in the * original query). If the actual target(s) is/are different, we'll show them * in show_modifytable_info(). */ static void ExplainModifyTarget(ModifyTable *plan, ExplainState *es) { ExplainTargetRel((Plan *) plan, plan->nominalRelation, es); } /* * Show the target relation of a scan or modify node */ static void ExplainTargetRel(Plan *plan, Index rti, ExplainState *es) { char *objectname = NULL; char *namespace = NULL; const char *objecttag = NULL; RangeTblEntry *rte; char *refname; rte = rt_fetch(rti, es->rtable); refname = (char *) list_nth(es->rtable_names, rti - 1); if (refname == NULL) refname = rte->eref->aliasname; switch (nodeTag(plan)) { case T_SeqScan: case T_SampleScan: case T_IndexScan: case T_IndexOnlyScan: case T_BitmapHeapScan: case T_TidScan: case T_TidRangeScan: case T_ForeignScan: case T_CustomScan: case T_ModifyTable: /* Assert it's on a real relation */ Assert(rte->rtekind == RTE_RELATION); objectname = get_rel_name(rte->relid); if (es->verbose) namespace = get_namespace_name_or_temp(get_rel_namespace(rte->relid)); objecttag = "Relation Name"; break; case T_FunctionScan: { FunctionScan *fscan = (FunctionScan *) plan; /* Assert it's on a RangeFunction */ Assert(rte->rtekind == RTE_FUNCTION); /* * If the expression is still a function call of a single * function, we can get the real name of the function. * Otherwise, punt. (Even if it was a single function call * originally, the optimizer could have simplified it away.) */ if (list_length(fscan->functions) == 1) { RangeTblFunction *rtfunc = (RangeTblFunction *) linitial(fscan->functions); if (IsA(rtfunc->funcexpr, FuncExpr)) { FuncExpr *funcexpr = (FuncExpr *) rtfunc->funcexpr; Oid funcid = funcexpr->funcid; objectname = get_func_name(funcid); if (es->verbose) namespace = get_namespace_name_or_temp(get_func_namespace(funcid)); } } objecttag = "Function Name"; } break; case T_TableFuncScan: { TableFunc *tablefunc = ((TableFuncScan *) plan)->tablefunc; Assert(rte->rtekind == RTE_TABLEFUNC); switch (tablefunc->functype) { case TFT_XMLTABLE: objectname = "xmltable"; break; case TFT_JSON_TABLE: objectname = "json_table"; break; default: elog(ERROR, "invalid TableFunc type %d", (int) tablefunc->functype); } objecttag = "Table Function Name"; } break; case T_ValuesScan: Assert(rte->rtekind == RTE_VALUES); break; case T_CteScan: /* Assert it's on a non-self-reference CTE */ Assert(rte->rtekind == RTE_CTE); Assert(!rte->self_reference); objectname = rte->ctename; objecttag = "CTE Name"; break; case T_NamedTuplestoreScan: Assert(rte->rtekind == RTE_NAMEDTUPLESTORE); objectname = rte->enrname; objecttag = "Tuplestore Name"; break; case T_WorkTableScan: /* Assert it's on a self-reference CTE */ Assert(rte->rtekind == RTE_CTE); Assert(rte->self_reference); objectname = rte->ctename; objecttag = "CTE Name"; break; default: break; } if (es->format == EXPLAIN_FORMAT_TEXT) { appendStringInfoString(es->str, " on"); if (namespace != NULL) appendStringInfo(es->str, " %s.%s", quote_identifier(namespace), quote_identifier(objectname)); else if (objectname != NULL) appendStringInfo(es->str, " %s", quote_identifier(objectname)); if (objectname == NULL || strcmp(refname, objectname) != 0) appendStringInfo(es->str, " %s", quote_identifier(refname)); } else { if (objecttag != NULL && objectname != NULL) ExplainPropertyText(objecttag, objectname, es); if (namespace != NULL) ExplainPropertyText("Schema", namespace, es); ExplainPropertyText("Alias", refname, es); } } /* * Show extra information for a ModifyTable node * * We have three objectives here. First, if there's more than one target * table or it's different from the nominal target, identify the actual * target(s). Second, give FDWs a chance to display extra info about foreign * targets. Third, show information about ON CONFLICT. */ static void show_modifytable_info(ModifyTableState *mtstate, List *ancestors, ExplainState *es) { ModifyTable *node = (ModifyTable *) mtstate->ps.plan; const char *operation; const char *foperation; bool labeltargets; int j; List *idxNames = NIL; ListCell *lst; switch (node->operation) { case CMD_INSERT: operation = "Insert"; foperation = "Foreign Insert"; break; case CMD_UPDATE: operation = "Update"; foperation = "Foreign Update"; break; case CMD_DELETE: operation = "Delete"; foperation = "Foreign Delete"; break; case CMD_MERGE: operation = "Merge"; /* XXX unsupported for now, but avoid compiler noise */ foperation = "Foreign Merge"; break; default: operation = "???"; foperation = "Foreign ???"; break; } /* * Should we explicitly label target relations? * * If there's only one target relation, do not list it if it's the * relation named in the query, or if it has been pruned. (Normally * mtstate->resultRelInfo doesn't include pruned relations, but a single * pruned target relation may be present, if all other target relations * have been pruned. See ExecInitModifyTable().) */ labeltargets = (mtstate->mt_nrels > 1 || (mtstate->mt_nrels == 1 && mtstate->resultRelInfo[0].ri_RangeTableIndex != node->nominalRelation && bms_is_member(mtstate->resultRelInfo[0].ri_RangeTableIndex, mtstate->ps.state->es_unpruned_relids))); if (labeltargets) ExplainOpenGroup("Target Tables", "Target Tables", false, es); for (j = 0; j < mtstate->mt_nrels; j++) { ResultRelInfo *resultRelInfo = mtstate->resultRelInfo + j; FdwRoutine *fdwroutine = resultRelInfo->ri_FdwRoutine; if (labeltargets) { /* Open a group for this target */ ExplainOpenGroup("Target Table", NULL, true, es); /* * In text mode, decorate each target with operation type, so that * ExplainTargetRel's output of " on foo" will read nicely. */ if (es->format == EXPLAIN_FORMAT_TEXT) { ExplainIndentText(es); appendStringInfoString(es->str, fdwroutine ? foperation : operation); } /* Identify target */ ExplainTargetRel((Plan *) node, resultRelInfo->ri_RangeTableIndex, es); if (es->format == EXPLAIN_FORMAT_TEXT) { appendStringInfoChar(es->str, '\n'); es->indent++; } } /* Give FDW a chance if needed */ if (!resultRelInfo->ri_usesFdwDirectModify && fdwroutine != NULL && fdwroutine->ExplainForeignModify != NULL) { List *fdw_private = (List *) list_nth(mtstate->mt_fdwPrivLists, j); fdwroutine->ExplainForeignModify(mtstate, resultRelInfo, fdw_private, j, es); } if (labeltargets) { /* Undo the indentation we added in text format */ if (es->format == EXPLAIN_FORMAT_TEXT) es->indent--; /* Close the group */ ExplainCloseGroup("Target Table", NULL, true, es); } } /* Gather names of ON CONFLICT arbiter indexes */ foreach(lst, node->arbiterIndexes) { char *indexname = get_rel_name(lfirst_oid(lst)); idxNames = lappend(idxNames, indexname); } if (node->onConflictAction != ONCONFLICT_NONE) { const char *resolution = NULL; if (node->onConflictAction == ONCONFLICT_NOTHING) resolution = "NOTHING"; else if (node->onConflictAction == ONCONFLICT_UPDATE) resolution = "UPDATE"; else { Assert(node->onConflictAction == ONCONFLICT_SELECT); switch (node->onConflictLockStrength) { case LCS_NONE: resolution = "SELECT"; break; case LCS_FORKEYSHARE: resolution = "SELECT FOR KEY SHARE"; break; case LCS_FORSHARE: resolution = "SELECT FOR SHARE"; break; case LCS_FORNOKEYUPDATE: resolution = "SELECT FOR NO KEY UPDATE"; break; case LCS_FORUPDATE: resolution = "SELECT FOR UPDATE"; break; } } ExplainPropertyText("Conflict Resolution", resolution, es); /* * Don't display arbiter indexes at all when DO NOTHING variant * implicitly ignores all conflicts */ if (idxNames) ExplainPropertyList("Conflict Arbiter Indexes", idxNames, es); /* ON CONFLICT DO SELECT/UPDATE WHERE qual is specially displayed */ if (node->onConflictWhere) { show_upper_qual((List *) node->onConflictWhere, "Conflict Filter", &mtstate->ps, ancestors, es); show_instrumentation_count("Rows Removed by Conflict Filter", 1, &mtstate->ps, es); } /* EXPLAIN ANALYZE display of actual outcome for each tuple proposed */ if (es->analyze && mtstate->ps.instrument) { double total; double insert_path; double other_path; InstrEndLoop(outerPlanState(mtstate)->instrument); /* count the number of source rows */ total = outerPlanState(mtstate)->instrument->ntuples; other_path = mtstate->ps.instrument->ntuples2; insert_path = total - other_path; ExplainPropertyFloat("Tuples Inserted", NULL, insert_path, 0, es); ExplainPropertyFloat("Conflicting Tuples", NULL, other_path, 0, es); } } else if (node->operation == CMD_MERGE) { /* EXPLAIN ANALYZE display of tuples processed */ if (es->analyze && mtstate->ps.instrument) { double total; double insert_path; double update_path; double delete_path; double skipped_path; InstrEndLoop(outerPlanState(mtstate)->instrument); /* count the number of source rows */ total = outerPlanState(mtstate)->instrument->ntuples; insert_path = mtstate->mt_merge_inserted; update_path = mtstate->mt_merge_updated; delete_path = mtstate->mt_merge_deleted; skipped_path = total - insert_path - update_path - delete_path; Assert(skipped_path >= 0); if (es->format == EXPLAIN_FORMAT_TEXT) { if (total > 0) { ExplainIndentText(es); appendStringInfoString(es->str, "Tuples:"); if (insert_path > 0) appendStringInfo(es->str, " inserted=%.0f", insert_path); if (update_path > 0) appendStringInfo(es->str, " updated=%.0f", update_path); if (delete_path > 0) appendStringInfo(es->str, " deleted=%.0f", delete_path); if (skipped_path > 0) appendStringInfo(es->str, " skipped=%.0f", skipped_path); appendStringInfoChar(es->str, '\n'); } } else { ExplainPropertyFloat("Tuples Inserted", NULL, insert_path, 0, es); ExplainPropertyFloat("Tuples Updated", NULL, update_path, 0, es); ExplainPropertyFloat("Tuples Deleted", NULL, delete_path, 0, es); ExplainPropertyFloat("Tuples Skipped", NULL, skipped_path, 0, es); } } } if (labeltargets) ExplainCloseGroup("Target Tables", "Target Tables", false, es); } /* * Explain what a "Result" node replaced. */ static void show_result_replacement_info(Result *result, ExplainState *es) { StringInfoData buf; int nrels = 0; int rti = -1; bool found_non_result = false; char *replacement_type = "???"; /* If the Result node has a subplan, it didn't replace anything. */ if (result->plan.lefttree != NULL) return; /* Gating result nodes should have a subplan, and we don't. */ Assert(result->result_type != RESULT_TYPE_GATING); switch (result->result_type) { case RESULT_TYPE_GATING: replacement_type = "Gating"; break; case RESULT_TYPE_SCAN: replacement_type = "Scan"; break; case RESULT_TYPE_JOIN: replacement_type = "Join"; break; case RESULT_TYPE_UPPER: /* a small white lie */ replacement_type = "Aggregate"; break; case RESULT_TYPE_MINMAX: replacement_type = "MinMaxAggregate"; break; } /* * Build up a comma-separated list of user-facing names for the range * table entries in the relids set. */ initStringInfo(&buf); while ((rti = bms_next_member(result->relids, rti)) >= 0) { RangeTblEntry *rte = rt_fetch(rti, es->rtable); char *refname; /* * add_outer_joins_to_relids will add join RTIs to the relids set of a * join; if that join is then replaced with a Result node, we may see * such RTIs here. But we want to completely ignore those here, * because "a LEFT JOIN b ON whatever" is a join between a and b, not * a join between a, b, and an unnamed join. */ if (rte->rtekind == RTE_JOIN) continue; /* Count the number of rels that aren't ignored completely. */ ++nrels; /* Work out what reference name to use and add it to the string. */ refname = (char *) list_nth(es->rtable_names, rti - 1); if (refname == NULL) refname = rte->eref->aliasname; if (buf.len > 0) appendStringInfoString(&buf, ", "); appendStringInfoString(&buf, refname); /* Keep track of whether we see anything other than RTE_RESULT. */ if (rte->rtekind != RTE_RESULT) found_non_result = true; } /* * If this Result node is because of a single RTE that is RTE_RESULT, it * is not really replacing anything at all, because there's no other * method for implementing a scan of such an RTE, so we don't display the * Replaces line in such cases. */ if (nrels <= 1 && !found_non_result && result->result_type == RESULT_TYPE_SCAN) return; /* Say what we replaced, with list of rels if available. */ if (buf.len == 0) ExplainPropertyText("Replaces", replacement_type, es); else { char *s = psprintf("%s on %s", replacement_type, buf.data); ExplainPropertyText("Replaces", s, es); } } /* * Explain the constituent plans of an Append, MergeAppend, * BitmapAnd, or BitmapOr node. * * The ancestors list should already contain the immediate parent of these * plans. */ static void ExplainMemberNodes(PlanState **planstates, int nplans, List *ancestors, ExplainState *es) { int j; for (j = 0; j < nplans; j++) ExplainNode(planstates[j], ancestors, "Member", NULL, es); } /* * Report about any pruned subnodes of an Append or MergeAppend node. * * nplans indicates the number of live subplans. * nchildren indicates the original number of subnodes in the Plan; * some of these may have been pruned by the run-time pruning code. */ static void ExplainMissingMembers(int nplans, int nchildren, ExplainState *es) { if (nplans < nchildren || es->format != EXPLAIN_FORMAT_TEXT) ExplainPropertyInteger("Subplans Removed", NULL, nchildren - nplans, es); } /* * Explain a list of SubPlans (or initPlans, which also use SubPlan nodes). * * The ancestors list should already contain the immediate parent of these * SubPlans. */ static void ExplainSubPlans(List *plans, List *ancestors, const char *relationship, ExplainState *es) { ListCell *lst; foreach(lst, plans) { SubPlanState *sps = (SubPlanState *) lfirst(lst); SubPlan *sp = sps->subplan; char *cooked_plan_name; /* * There can be multiple SubPlan nodes referencing the same physical * subplan (same plan_id, which is its index in PlannedStmt.subplans). * We should print a subplan only once, so track which ones we already * printed. This state must be global across the plan tree, since the * duplicate nodes could be in different plan nodes, eg both a bitmap * indexscan's indexqual and its parent heapscan's recheck qual. (We * do not worry too much about which plan node we show the subplan as * attached to in such cases.) */ if (bms_is_member(sp->plan_id, es->printed_subplans)) continue; es->printed_subplans = bms_add_member(es->printed_subplans, sp->plan_id); /* * Treat the SubPlan node as an ancestor of the plan node(s) within * it, so that ruleutils.c can find the referents of subplan * parameters. */ ancestors = lcons(sp, ancestors); /* * The plan has a name like exists_1 or rowcompare_2, but here we want * to prefix that with CTE, InitPlan, or SubPlan, as appropriate, for * display purposes. */ if (sp->subLinkType == CTE_SUBLINK) cooked_plan_name = psprintf("CTE %s", sp->plan_name); else if (sp->isInitPlan) cooked_plan_name = psprintf("InitPlan %s", sp->plan_name); else cooked_plan_name = psprintf("SubPlan %s", sp->plan_name); ExplainNode(sps->planstate, ancestors, relationship, cooked_plan_name, es); ancestors = list_delete_first(ancestors); } } /* * Explain a list of children of a CustomScan. */ static void ExplainCustomChildren(CustomScanState *css, List *ancestors, ExplainState *es) { ListCell *cell; const char *label = (list_length(css->custom_ps) != 1 ? "children" : "child"); foreach(cell, css->custom_ps) ExplainNode((PlanState *) lfirst(cell), ancestors, label, NULL, es); } /* * Create a per-plan-node workspace for collecting per-worker data. * * Output related to each worker will be temporarily "set aside" into a * separate buffer, which we'll merge into the main output stream once * we've processed all data for the plan node. This makes it feasible to * generate a coherent sub-group of fields for each worker, even though the * code that produces the fields is in several different places in this file. * Formatting of such a set-aside field group is managed by * ExplainOpenSetAsideGroup and ExplainSaveGroup/ExplainRestoreGroup. */ static ExplainWorkersState * ExplainCreateWorkersState(int num_workers) { ExplainWorkersState *wstate; wstate = palloc_object(ExplainWorkersState); wstate->num_workers = num_workers; wstate->worker_inited = (bool *) palloc0(num_workers * sizeof(bool)); wstate->worker_str = (StringInfoData *) palloc0(num_workers * sizeof(StringInfoData)); wstate->worker_state_save = (int *) palloc(num_workers * sizeof(int)); return wstate; } /* * Begin or resume output into the set-aside group for worker N. */ static void ExplainOpenWorker(int n, ExplainState *es) { ExplainWorkersState *wstate = es->workers_state; Assert(wstate); Assert(n >= 0 && n < wstate->num_workers); /* Save prior output buffer pointer */ wstate->prev_str = es->str; if (!wstate->worker_inited[n]) { /* First time through, so create the buffer for this worker */ initStringInfo(&wstate->worker_str[n]); es->str = &wstate->worker_str[n]; /* * Push suitable initial formatting state for this worker's field * group. We allow one extra logical nesting level, since this group * will eventually be wrapped in an outer "Workers" group. */ ExplainOpenSetAsideGroup("Worker", NULL, true, 2, es); /* * In non-TEXT formats we always emit a "Worker Number" field, even if * there's no other data for this worker. */ if (es->format != EXPLAIN_FORMAT_TEXT) ExplainPropertyInteger("Worker Number", NULL, n, es); wstate->worker_inited[n] = true; } else { /* Resuming output for a worker we've already emitted some data for */ es->str = &wstate->worker_str[n]; /* Restore formatting state saved by last ExplainCloseWorker() */ ExplainRestoreGroup(es, 2, &wstate->worker_state_save[n]); } /* * In TEXT format, prefix the first output line for this worker with * "Worker N:". Then, any additional lines should be indented one more * stop than the "Worker N" line is. */ if (es->format == EXPLAIN_FORMAT_TEXT) { if (es->str->len == 0) { ExplainIndentText(es); appendStringInfo(es->str, "Worker %d: ", n); } es->indent++; } } /* * End output for worker N --- must pair with previous ExplainOpenWorker call */ static void ExplainCloseWorker(int n, ExplainState *es) { ExplainWorkersState *wstate = es->workers_state; Assert(wstate); Assert(n >= 0 && n < wstate->num_workers); Assert(wstate->worker_inited[n]); /* * Save formatting state in case we do another ExplainOpenWorker(), then * pop the formatting stack. */ ExplainSaveGroup(es, 2, &wstate->worker_state_save[n]); /* * In TEXT format, if we didn't actually produce any output line(s) then * truncate off the partial line emitted by ExplainOpenWorker. (This is * to avoid bogus output if, say, show_buffer_usage chooses not to print * anything for the worker.) Also fix up the indent level. */ if (es->format == EXPLAIN_FORMAT_TEXT) { while (es->str->len > 0 && es->str->data[es->str->len - 1] != '\n') es->str->data[--(es->str->len)] = '\0'; es->indent--; } /* Restore prior output buffer pointer */ es->str = wstate->prev_str; } /* * Print per-worker info for current node, then free the ExplainWorkersState. */ static void ExplainFlushWorkersState(ExplainState *es) { ExplainWorkersState *wstate = es->workers_state; ExplainOpenGroup("Workers", "Workers", false, es); for (int i = 0; i < wstate->num_workers; i++) { if (wstate->worker_inited[i]) { /* This must match previous ExplainOpenSetAsideGroup call */ ExplainOpenGroup("Worker", NULL, true, es); appendStringInfoString(es->str, wstate->worker_str[i].data); ExplainCloseGroup("Worker", NULL, true, es); pfree(wstate->worker_str[i].data); } } ExplainCloseGroup("Workers", "Workers", false, es); pfree(wstate->worker_inited); pfree(wstate->worker_str); pfree(wstate->worker_state_save); pfree(wstate); }