PostgreSQL Source Code  git master
explain.c File Reference
#include "postgres.h"
#include "access/xact.h"
#include "catalog/pg_type.h"
#include "commands/createas.h"
#include "commands/defrem.h"
#include "commands/prepare.h"
#include "executor/nodeHash.h"
#include "foreign/fdwapi.h"
#include "jit/jit.h"
#include "nodes/extensible.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.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/typcache.h"
#include "utils/xml.h"
Include dependency graph for explain.c:

Go to the source code of this file.

Macros

#define X_OPENING   0
 
#define X_CLOSING   1
 
#define X_CLOSE_IMMEDIATE   2
 
#define X_NOWHITESPACE   4
 

Functions

static void ExplainOneQuery (Query *query, int cursorOptions, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv)
 
static void ExplainPrintJIT (ExplainState *es, int jit_flags, JitInstrumentation *ji)
 
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_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_hashagg_info (AggState *hashstate, ExplainState *es)
 
static void show_tidbitmap_info (BitmapHeapScanState *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 void show_eval_params (Bitmapset *bms_params, ExplainState *es)
 
static const char * explain_get_index_name (Oid indexId)
 
static void show_buffer_usage (ExplainState *es, const BufferUsage *usage)
 
static void show_wal_usage (ExplainState *es, const WalUsage *usage)
 
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 ExplainWorkersStateExplainCreateWorkersState (int num_workers)
 
static void ExplainOpenWorker (int n, ExplainState *es)
 
static void ExplainCloseWorker (int n, ExplainState *es)
 
static void ExplainFlushWorkersState (ExplainState *es)
 
static void ExplainProperty (const char *qlabel, const char *unit, const char *value, bool numeric, ExplainState *es)
 
static void ExplainOpenSetAsideGroup (const char *objtype, const char *labelname, bool labeled, int depth, ExplainState *es)
 
static void ExplainSaveGroup (ExplainState *es, int depth, int *state_save)
 
static void ExplainRestoreGroup (ExplainState *es, int depth, int *state_save)
 
static void ExplainDummyGroup (const char *objtype, const char *labelname, ExplainState *es)
 
static void ExplainXMLTag (const char *tagname, int flags, ExplainState *es)
 
static void ExplainIndentText (ExplainState *es)
 
static void ExplainJSONLineEnding (ExplainState *es)
 
static void ExplainYAMLLineStarting (ExplainState *es)
 
static void escape_yaml (StringInfo buf, const char *str)
 
void ExplainQuery (ParseState *pstate, ExplainStmt *stmt, ParamListInfo params, DestReceiver *dest)
 
ExplainStateNewExplainState (void)
 
TupleDesc ExplainResultDesc (ExplainStmt *stmt)
 
void ExplainOneUtility (Node *utilityStmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv)
 
void ExplainOnePlan (PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv, const instr_time *planduration, const BufferUsage *bufusage)
 
static void ExplainPrintSettings (ExplainState *es)
 
void ExplainPrintPlan (ExplainState *es, QueryDesc *queryDesc)
 
void ExplainPrintTriggers (ExplainState *es, QueryDesc *queryDesc)
 
void ExplainPrintJITSummary (ExplainState *es, QueryDesc *queryDesc)
 
void ExplainQueryText (ExplainState *es, QueryDesc *queryDesc)
 
static void show_incremental_sort_group_info (IncrementalSortGroupInfo *groupInfo, const char *groupLabel, bool indent, ExplainState *es)
 
void ExplainPropertyList (const char *qlabel, List *data, ExplainState *es)
 
void ExplainPropertyListNested (const char *qlabel, List *data, ExplainState *es)
 
void ExplainPropertyText (const char *qlabel, const char *value, ExplainState *es)
 
void ExplainPropertyInteger (const char *qlabel, const char *unit, int64 value, ExplainState *es)
 
void ExplainPropertyUInteger (const char *qlabel, const char *unit, uint64 value, ExplainState *es)
 
void ExplainPropertyFloat (const char *qlabel, const char *unit, double value, int ndigits, ExplainState *es)
 
void ExplainPropertyBool (const char *qlabel, bool value, ExplainState *es)
 
void ExplainOpenGroup (const char *objtype, const char *labelname, bool labeled, ExplainState *es)
 
void ExplainCloseGroup (const char *objtype, const char *labelname, bool labeled, ExplainState *es)
 
void ExplainBeginOutput (ExplainState *es)
 
void ExplainEndOutput (ExplainState *es)
 
void ExplainSeparatePlans (ExplainState *es)
 

Variables

ExplainOneQuery_hook_type ExplainOneQuery_hook = NULL
 
explain_get_index_name_hook_type explain_get_index_name_hook = NULL
 

Macro Definition Documentation

◆ X_CLOSE_IMMEDIATE

#define X_CLOSE_IMMEDIATE   2

Definition at line 53 of file explain.c.

Referenced by ExplainDummyGroup(), and ExplainXMLTag().

◆ X_CLOSING

#define X_CLOSING   1

Definition at line 52 of file explain.c.

Referenced by ExplainCloseGroup(), ExplainProperty(), ExplainPropertyList(), and ExplainXMLTag().

◆ X_NOWHITESPACE

#define X_NOWHITESPACE   4

Definition at line 54 of file explain.c.

Referenced by ExplainProperty(), and ExplainXMLTag().

◆ X_OPENING

#define X_OPENING   0

Definition at line 51 of file explain.c.

Referenced by ExplainOpenGroup(), ExplainProperty(), and ExplainPropertyList().

Function Documentation

◆ elapsed_time()

static double elapsed_time ( instr_time starttime)
static

Definition at line 1028 of file explain.c.

References INSTR_TIME_GET_DOUBLE, INSTR_TIME_SET_CURRENT, and INSTR_TIME_SUBTRACT.

Referenced by ExplainOnePlan(), and IsCheckpointOnSchedule().

1029 {
1030  instr_time endtime;
1031 
1032  INSTR_TIME_SET_CURRENT(endtime);
1033  INSTR_TIME_SUBTRACT(endtime, *starttime);
1034  return INSTR_TIME_GET_DOUBLE(endtime);
1035 }
struct timeval instr_time
Definition: instr_time.h:150
#define INSTR_TIME_GET_DOUBLE(t)
Definition: instr_time.h:199
#define INSTR_TIME_SUBTRACT(x, y)
Definition: instr_time.h:170
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:156

◆ escape_yaml()

static void escape_yaml ( StringInfo  buf,
const char *  str 
)
static

Definition at line 4725 of file explain.c.

References escape_json().

Referenced by ExplainDummyGroup(), ExplainProperty(), ExplainPropertyList(), and ExplainPropertyListNested().

4726 {
4727  escape_json(buf, str);
4728 }
void escape_json(StringInfo buf, const char *str)
Definition: json.c:1279

◆ explain_get_index_name()

static const char * explain_get_index_name ( Oid  indexId)
static

Definition at line 3282 of file explain.c.

References elog, ERROR, explain_get_index_name_hook, and get_rel_name().

Referenced by ExplainIndexScanDetails(), and ExplainNode().

3283 {
3284  const char *result;
3285 
3287  result = (*explain_get_index_name_hook) (indexId);
3288  else
3289  result = NULL;
3290  if (result == NULL)
3291  {
3292  /* default behavior: look it up in the catalogs */
3293  result = get_rel_name(indexId);
3294  if (result == NULL)
3295  elog(ERROR, "cache lookup failed for index %u", indexId);
3296  }
3297  return result;
3298 }
#define ERROR
Definition: elog.h:43
explain_get_index_name_hook_type explain_get_index_name_hook
Definition: explain.c:47
#define elog(elevel,...)
Definition: elog.h:214
char * get_rel_name(Oid relid)
Definition: lsyscache.c:1840

◆ ExplainBeginOutput()

void ExplainBeginOutput ( ExplainState es)

Definition at line 4549 of file explain.c.

References appendStringInfoChar(), appendStringInfoString(), EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainState::format, ExplainState::grouping_stack, ExplainState::indent, lcons_int(), and ExplainState::str.

Referenced by explain_ExecutorEnd(), and ExplainQuery().

4550 {
4551  switch (es->format)
4552  {
4553  case EXPLAIN_FORMAT_TEXT:
4554  /* nothing to do */
4555  break;
4556 
4557  case EXPLAIN_FORMAT_XML:
4559  "<explain xmlns=\"http://www.postgresql.org/2009/explain\">\n");
4560  es->indent++;
4561  break;
4562 
4563  case EXPLAIN_FORMAT_JSON:
4564  /* top-level structure is an array of plans */
4565  appendStringInfoChar(es->str, '[');
4566  es->grouping_stack = lcons_int(0, es->grouping_stack);
4567  es->indent++;
4568  break;
4569 
4570  case EXPLAIN_FORMAT_YAML:
4571  es->grouping_stack = lcons_int(0, es->grouping_stack);
4572  break;
4573  }
4574 }
List * lcons_int(int datum, List *list)
Definition: list.c:471
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
List * grouping_stack
Definition: explain.h:52
int indent
Definition: explain.h:51
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
ExplainFormat format
Definition: explain.h:49
StringInfo str
Definition: explain.h:39

◆ ExplainCloseGroup()

void ExplainCloseGroup ( const char *  objtype,
const char *  labelname,
bool  labeled,
ExplainState es 
)

Definition at line 4356 of file explain.c.

References appendStringInfoChar(), appendStringInfoSpaces(), EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainXMLTag(), ExplainState::format, ExplainState::grouping_stack, ExplainState::indent, list_delete_first(), ExplainState::str, and X_CLOSING.

Referenced by ExplainFlushWorkersState(), ExplainNode(), ExplainOnePlan(), ExplainPrintJIT(), ExplainPrintSettings(), ExplainPrintTriggers(), report_triggers(), show_grouping_set_keys(), show_grouping_sets(), show_incremental_sort_group_info(), and show_modifytable_info().

4358 {
4359  switch (es->format)
4360  {
4361  case EXPLAIN_FORMAT_TEXT:
4362  /* nothing to do */
4363  break;
4364 
4365  case EXPLAIN_FORMAT_XML:
4366  es->indent--;
4367  ExplainXMLTag(objtype, X_CLOSING, es);
4368  break;
4369 
4370  case EXPLAIN_FORMAT_JSON:
4371  es->indent--;
4372  appendStringInfoChar(es->str, '\n');
4373  appendStringInfoSpaces(es->str, 2 * es->indent);
4374  appendStringInfoChar(es->str, labeled ? '}' : ']');
4376  break;
4377 
4378  case EXPLAIN_FORMAT_YAML:
4379  es->indent--;
4381  break;
4382  }
4383 }
static void ExplainXMLTag(const char *tagname, int flags, ExplainState *es)
Definition: explain.c:4638
#define X_CLOSING
Definition: explain.c:52
List * grouping_stack
Definition: explain.h:52
int indent
Definition: explain.h:51
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
void appendStringInfoSpaces(StringInfo str, int count)
Definition: stringinfo.c:206
ExplainFormat format
Definition: explain.h:49
StringInfo str
Definition: explain.h:39
List * list_delete_first(List *list)
Definition: list.c:860

◆ ExplainCloseWorker()

static void ExplainCloseWorker ( int  n,
ExplainState es 
)
static

Definition at line 3986 of file explain.c.

References Assert, StringInfoData::data, EXPLAIN_FORMAT_TEXT, ExplainSaveGroup(), ExplainState::format, ExplainState::indent, StringInfoData::len, ExplainWorkersState::prev_str, ExplainState::str, ExplainWorkersState::worker_inited, ExplainWorkersState::worker_state_save, and ExplainState::workers_state.

Referenced by ExplainNode(), show_hashagg_info(), show_incremental_sort_info(), and show_sort_info().

3987 {
3988  ExplainWorkersState *wstate = es->workers_state;
3989 
3990  Assert(wstate);
3991  Assert(n >= 0 && n < wstate->num_workers);
3992  Assert(wstate->worker_inited[n]);
3993 
3994  /*
3995  * Save formatting state in case we do another ExplainOpenWorker(), then
3996  * pop the formatting stack.
3997  */
3998  ExplainSaveGroup(es, 2, &wstate->worker_state_save[n]);
3999 
4000  /*
4001  * In TEXT format, if we didn't actually produce any output line(s) then
4002  * truncate off the partial line emitted by ExplainOpenWorker. (This is
4003  * to avoid bogus output if, say, show_buffer_usage chooses not to print
4004  * anything for the worker.) Also fix up the indent level.
4005  */
4006  if (es->format == EXPLAIN_FORMAT_TEXT)
4007  {
4008  while (es->str->len > 0 && es->str->data[es->str->len - 1] != '\n')
4009  es->str->data[--(es->str->len)] = '\0';
4010 
4011  es->indent--;
4012  }
4013 
4014  /* Restore prior output buffer pointer */
4015  es->str = wstate->prev_str;
4016 }
int * worker_state_save
Definition: explain.h:33
int indent
Definition: explain.h:51
bool * worker_inited
Definition: explain.h:31
#define Assert(condition)
Definition: c.h:745
ExplainWorkersState * workers_state
Definition: explain.h:61
ExplainFormat format
Definition: explain.h:49
StringInfo prev_str
Definition: explain.h:34
static void ExplainSaveGroup(ExplainState *es, int depth, int *state_save)
Definition: explain.c:4442
StringInfo str
Definition: explain.h:39

◆ ExplainCreateWorkersState()

static ExplainWorkersState * ExplainCreateWorkersState ( int  num_workers)
static

Definition at line 3907 of file explain.c.

References ExplainWorkersState::num_workers, palloc(), palloc0(), ExplainWorkersState::worker_inited, ExplainWorkersState::worker_state_save, and ExplainWorkersState::worker_str.

Referenced by ExplainNode().

3908 {
3909  ExplainWorkersState *wstate;
3910 
3911  wstate = (ExplainWorkersState *) palloc(sizeof(ExplainWorkersState));
3912  wstate->num_workers = num_workers;
3913  wstate->worker_inited = (bool *) palloc0(num_workers * sizeof(bool));
3914  wstate->worker_str = (StringInfoData *)
3915  palloc0(num_workers * sizeof(StringInfoData));
3916  wstate->worker_state_save = (int *) palloc(num_workers * sizeof(int));
3917  return wstate;
3918 }
int * worker_state_save
Definition: explain.h:33
StringInfoData * worker_str
Definition: explain.h:32
void * palloc0(Size size)
Definition: mcxt.c:980
bool * worker_inited
Definition: explain.h:31
void * palloc(Size size)
Definition: mcxt.c:949

◆ ExplainCustomChildren()

static void ExplainCustomChildren ( CustomScanState css,
List ancestors,
ExplainState es 
)
static

Definition at line 3885 of file explain.c.

References CustomScanState::custom_ps, ExplainNode(), label, lfirst, and list_length().

Referenced by ExplainNode().

3886 {
3887  ListCell *cell;
3888  const char *label =
3889  (list_length(css->custom_ps) != 1 ? "children" : "child");
3890 
3891  foreach(cell, css->custom_ps)
3892  ExplainNode((PlanState *) lfirst(cell), ancestors, label, NULL, es);
3893 }
List * custom_ps
Definition: execnodes.h:1822
static void ExplainNode(PlanState *planstate, List *ancestors, const char *relationship, const char *plan_name, ExplainState *es)
Definition: explain.c:1121
static char * label
#define lfirst(lc)
Definition: pg_list.h:190
static int list_length(const List *l)
Definition: pg_list.h:169

◆ ExplainDummyGroup()

static void ExplainDummyGroup ( const char *  objtype,
const char *  labelname,
ExplainState es 
)
static

Definition at line 4503 of file explain.c.

References appendStringInfoSpaces(), appendStringInfoString(), escape_json(), escape_yaml(), EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainJSONLineEnding(), ExplainXMLTag(), ExplainYAMLLineStarting(), ExplainState::format, ExplainState::indent, ExplainState::str, and X_CLOSE_IMMEDIATE.

Referenced by ExplainOneUtility().

4504 {
4505  switch (es->format)
4506  {
4507  case EXPLAIN_FORMAT_TEXT:
4508  /* nothing to do */
4509  break;
4510 
4511  case EXPLAIN_FORMAT_XML:
4512  ExplainXMLTag(objtype, X_CLOSE_IMMEDIATE, es);
4513  break;
4514 
4515  case EXPLAIN_FORMAT_JSON:
4517  appendStringInfoSpaces(es->str, 2 * es->indent);
4518  if (labelname)
4519  {
4520  escape_json(es->str, labelname);
4521  appendStringInfoString(es->str, ": ");
4522  }
4523  escape_json(es->str, objtype);
4524  break;
4525 
4526  case EXPLAIN_FORMAT_YAML:
4528  if (labelname)
4529  {
4530  escape_yaml(es->str, labelname);
4531  appendStringInfoString(es->str, ": ");
4532  }
4533  else
4534  {
4535  appendStringInfoString(es->str, "- ");
4536  }
4537  escape_yaml(es->str, objtype);
4538  break;
4539  }
4540 }
void escape_json(StringInfo buf, const char *str)
Definition: json.c:1279
static void ExplainXMLTag(const char *tagname, int flags, ExplainState *es)
Definition: explain.c:4638
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
static void ExplainYAMLLineStarting(ExplainState *es)
Definition: explain.c:4700
int indent
Definition: explain.h:51
static void escape_yaml(StringInfo buf, const char *str)
Definition: explain.c:4725
void appendStringInfoSpaces(StringInfo str, int count)
Definition: stringinfo.c:206
static void ExplainJSONLineEnding(ExplainState *es)
Definition: explain.c:4680
ExplainFormat format
Definition: explain.h:49
#define X_CLOSE_IMMEDIATE
Definition: explain.c:53
StringInfo str
Definition: explain.h:39

◆ ExplainEndOutput()

void ExplainEndOutput ( ExplainState es)

Definition at line 4580 of file explain.c.

References appendStringInfoString(), EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainState::format, ExplainState::grouping_stack, ExplainState::indent, list_delete_first(), and ExplainState::str.

Referenced by explain_ExecutorEnd(), and ExplainQuery().

4581 {
4582  switch (es->format)
4583  {
4584  case EXPLAIN_FORMAT_TEXT:
4585  /* nothing to do */
4586  break;
4587 
4588  case EXPLAIN_FORMAT_XML:
4589  es->indent--;
4590  appendStringInfoString(es->str, "</explain>");
4591  break;
4592 
4593  case EXPLAIN_FORMAT_JSON:
4594  es->indent--;
4595  appendStringInfoString(es->str, "\n]");
4597  break;
4598 
4599  case EXPLAIN_FORMAT_YAML:
4601  break;
4602  }
4603 }
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
List * grouping_stack
Definition: explain.h:52
int indent
Definition: explain.h:51
ExplainFormat format
Definition: explain.h:49
StringInfo str
Definition: explain.h:39
List * list_delete_first(List *list)
Definition: list.c:860

◆ ExplainFlushWorkersState()

static void ExplainFlushWorkersState ( ExplainState es)
static

Definition at line 4022 of file explain.c.

References appendStringInfoString(), StringInfoData::data, ExplainCloseGroup(), ExplainOpenGroup(), i, ExplainWorkersState::num_workers, pfree(), ExplainState::str, ExplainWorkersState::worker_inited, ExplainWorkersState::worker_state_save, ExplainWorkersState::worker_str, and ExplainState::workers_state.

Referenced by ExplainNode().

4023 {
4024  ExplainWorkersState *wstate = es->workers_state;
4025 
4026  ExplainOpenGroup("Workers", "Workers", false, es);
4027  for (int i = 0; i < wstate->num_workers; i++)
4028  {
4029  if (wstate->worker_inited[i])
4030  {
4031  /* This must match previous ExplainOpenSetAsideGroup call */
4032  ExplainOpenGroup("Worker", NULL, true, es);
4033  appendStringInfoString(es->str, wstate->worker_str[i].data);
4034  ExplainCloseGroup("Worker", NULL, true, es);
4035 
4036  pfree(wstate->worker_str[i].data);
4037  }
4038  }
4039  ExplainCloseGroup("Workers", "Workers", false, es);
4040 
4041  pfree(wstate->worker_inited);
4042  pfree(wstate->worker_str);
4043  pfree(wstate->worker_state_save);
4044  pfree(wstate);
4045 }
int * worker_state_save
Definition: explain.h:33
void pfree(void *pointer)
Definition: mcxt.c:1056
StringInfoData * worker_str
Definition: explain.h:32
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
bool * worker_inited
Definition: explain.h:31
ExplainWorkersState * workers_state
Definition: explain.h:61
int i
void ExplainCloseGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4356
void ExplainOpenGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4293
StringInfo str
Definition: explain.h:39

◆ ExplainIndentText()

static void ExplainIndentText ( ExplainState es)
static

◆ ExplainIndexScanDetails()

static void ExplainIndexScanDetails ( Oid  indexid,
ScanDirection  indexorderdir,
ExplainState es 
)
static

Definition at line 3466 of file explain.c.

References appendStringInfo(), appendStringInfoString(), BackwardScanDirection, EXPLAIN_FORMAT_TEXT, explain_get_index_name(), ExplainPropertyText(), ExplainState::format, ForwardScanDirection, NoMovementScanDirection, quote_identifier(), ScanDirectionIsBackward, and ExplainState::str.

Referenced by ExplainNode().

3468 {
3469  const char *indexname = explain_get_index_name(indexid);
3470 
3471  if (es->format == EXPLAIN_FORMAT_TEXT)
3472  {
3473  if (ScanDirectionIsBackward(indexorderdir))
3474  appendStringInfoString(es->str, " Backward");
3475  appendStringInfo(es->str, " using %s", quote_identifier(indexname));
3476  }
3477  else
3478  {
3479  const char *scandir;
3480 
3481  switch (indexorderdir)
3482  {
3483  case BackwardScanDirection:
3484  scandir = "Backward";
3485  break;
3487  scandir = "NoMovement";
3488  break;
3489  case ForwardScanDirection:
3490  scandir = "Forward";
3491  break;
3492  default:
3493  scandir = "???";
3494  break;
3495  }
3496  ExplainPropertyText("Scan Direction", scandir, es);
3497  ExplainPropertyText("Index Name", indexname, es);
3498  }
3499 }
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:10727
#define ScanDirectionIsBackward(direction)
Definition: sdir.h:41
void ExplainPropertyText(const char *qlabel, const char *value, ExplainState *es)
Definition: explain.c:4228
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
ExplainFormat format
Definition: explain.h:49
static const char * explain_get_index_name(Oid indexId)
Definition: explain.c:3282
StringInfo str
Definition: explain.h:39

◆ ExplainJSONLineEnding()

static void ExplainJSONLineEnding ( ExplainState es)
static

Definition at line 4680 of file explain.c.

References appendStringInfoChar(), Assert, EXPLAIN_FORMAT_JSON, ExplainState::format, ExplainState::grouping_stack, linitial_int, and ExplainState::str.

Referenced by ExplainDummyGroup(), ExplainOpenGroup(), ExplainProperty(), ExplainPropertyList(), and ExplainPropertyListNested().

4681 {
4683  if (linitial_int(es->grouping_stack) != 0)
4684  appendStringInfoChar(es->str, ',');
4685  else
4686  linitial_int(es->grouping_stack) = 1;
4687  appendStringInfoChar(es->str, '\n');
4688 }
#define linitial_int(l)
Definition: pg_list.h:196
List * grouping_stack
Definition: explain.h:52
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
#define Assert(condition)
Definition: c.h:745
ExplainFormat format
Definition: explain.h:49
StringInfo str
Definition: explain.h:39

◆ ExplainMemberNodes()

static void ExplainMemberNodes ( PlanState **  planstates,
int  nplans,
List ancestors,
ExplainState es 
)
static

Definition at line 3810 of file explain.c.

References ExplainNode().

Referenced by ExplainNode().

3812 {
3813  int j;
3814 
3815  for (j = 0; j < nplans; j++)
3816  ExplainNode(planstates[j], ancestors,
3817  "Member", NULL, es);
3818 }
static void ExplainNode(PlanState *planstate, List *ancestors, const char *relationship, const char *plan_name, ExplainState *es)
Definition: explain.c:1121

◆ ExplainMissingMembers()

static void ExplainMissingMembers ( int  nplans,
int  nchildren,
ExplainState es 
)
static

Definition at line 3828 of file explain.c.

References EXPLAIN_FORMAT_TEXT, ExplainPropertyInteger(), and format.

Referenced by ExplainNode().

3829 {
3830  if (nplans < nchildren || es->format != EXPLAIN_FORMAT_TEXT)
3831  ExplainPropertyInteger("Subplans Removed", NULL,
3832  nchildren - nplans, es);
3833 }
void ExplainPropertyInteger(const char *qlabel, const char *unit, int64 value, ExplainState *es)
Definition: explain.c:4237
static char format

◆ ExplainModifyTarget()

static void ExplainModifyTarget ( ModifyTable plan,
ExplainState es 
)
static

Definition at line 3518 of file explain.c.

References ExplainTargetRel().

Referenced by ExplainNode().

3519 {
3520  ExplainTargetRel((Plan *) plan, plan->nominalRelation, es);
3521 }
static void ExplainTargetRel(Plan *plan, Index rti, ExplainState *es)
Definition: explain.c:3527

◆ ExplainNode()

static void ExplainNode ( PlanState planstate,
List ancestors,
const char *  relationship,
const char *  plan_name,
ExplainState es 
)
static

Definition at line 1121 of file explain.c.

References AGG_HASHED, AGG_MIXED, AGG_PLAIN, AGG_SORTED, Agg::aggsplit, Agg::aggstrategy, ExplainState::analyze, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), ExplainState::buffers, Instrumentation::bufusage, castNode, CMD_DELETE, CMD_INSERT, CMD_SELECT, CMD_UPDATE, ExplainState::costs, DO_AGGSPLIT_COMBINE, DO_AGGSPLIT_SKIPFINAL, EState::es_jit_flags, EXPLAIN_FORMAT_TEXT, explain_get_index_name(), ExplainCloseGroup(), ExplainCloseWorker(), ExplainCreateWorkersState(), ExplainCustomChildren(), CustomExecMethods::ExplainCustomScan, ExplainFlushWorkersState(), ExplainIndentText(), ExplainIndexScanDetails(), ExplainMemberNodes(), ExplainMissingMembers(), ExplainModifyTarget(), ExplainOpenGroup(), ExplainOpenWorker(), ExplainPrintJIT(), ExplainPropertyBool(), ExplainPropertyFloat(), ExplainPropertyInteger(), ExplainPropertyText(), ExplainScanTarget(), ExplainSubPlans(), ExplainState::format, RangeTblFunction::funcexpr, functions, ExplainState::hide_workers, ExplainState::indent, IndexScan::indexid, IndexOnlyScan::indexid, BitmapIndexScan::indexid, IndexScan::indexorderdir, IndexOnlyScan::indexorderdir, Gather::initParam, GatherMerge::initParam, PlanState::initPlan, innerPlanState, InstrEndLoop(), WorkerInstrumentation::instrument, PlanState::instrument, IsA, SharedJitInstrumentation::jit_instr, JOIN_ANTI, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, JOIN_SEMI, lappend(), lcons(), lfirst, list_delete_first(), list_length(), list_make1, make_orclause(), CustomScanState::methods, NIL, Instrumentation::nloops, nodeTag, Instrumentation::ntuples, Instrumentation::ntuples2, SharedJitInstrumentation::num_workers, WorkerInstrumentation::num_workers, Gather::num_workers, GatherMerge::num_workers, outerPlanState, Plan::parallel_aware, PlanState::plan, Plan::plan_rows, Plan::plan_width, psprintf(), quote_identifier(), SETOP_HASHED, SETOP_SORTED, SETOPCMD_EXCEPT, SETOPCMD_EXCEPT_ALL, SETOPCMD_INTERSECT, SETOPCMD_INTERSECT_ALL, show_agg_keys(), show_buffer_usage(), show_eval_params(), show_expression(), show_foreignscan_info(), show_group_keys(), show_hash_info(), show_hashagg_info(), show_incremental_sort_info(), show_incremental_sort_keys(), show_instrumentation_count(), show_merge_append_keys(), show_modifytable_info(), show_plan_tlist(), show_scan_qual(), show_sort_info(), show_sort_keys(), show_tablesample(), show_tidbitmap_info(), show_upper_qual(), show_wal_usage(), Gather::single_copy, Instrumentation::startup, Plan::startup_cost, PlanState::state, ExplainState::str, PlanState::subPlan, T_Agg, T_Append, T_BitmapAnd, T_BitmapHeapScan, T_BitmapIndexScan, T_BitmapOr, T_CteScan, T_CustomScan, T_ForeignScan, T_FunctionScan, T_Gather, T_GatherMerge, T_Group, T_Hash, T_HashJoin, T_IncrementalSort, T_IndexOnlyScan, T_IndexScan, T_Limit, T_LockRows, T_Material, T_MergeAppend, T_MergeJoin, T_ModifyTable, T_NamedTuplestoreScan, T_NestLoop, T_ProjectSet, T_RecursiveUnion, T_Result, T_SampleScan, T_SeqScan, T_SetOp, T_Sort, T_SubqueryScan, T_TableFuncScan, T_TidScan, T_Unique, T_ValuesScan, T_WindowAgg, T_WorkTableScan, ExplainState::timing, Instrumentation::total, Plan::total_cost, ExplainState::verbose, ExplainState::wal, Instrumentation::walusage, PlanState::worker_instrument, PlanState::worker_jit_instrument, and ExplainState::workers_state.

Referenced by ExplainCustomChildren(), ExplainMemberNodes(), ExplainPrintPlan(), and ExplainSubPlans().

1124 {
1125  Plan *plan = planstate->plan;
1126  const char *pname; /* node type name for text output */
1127  const char *sname; /* node type name for non-text output */
1128  const char *strategy = NULL;
1129  const char *partialmode = NULL;
1130  const char *operation = NULL;
1131  const char *custom_name = NULL;
1132  ExplainWorkersState *save_workers_state = es->workers_state;
1133  int save_indent = es->indent;
1134  bool haschildren;
1135 
1136  /*
1137  * Prepare per-worker output buffers, if needed. We'll append the data in
1138  * these to the main output string further down.
1139  */
1140  if (planstate->worker_instrument && es->analyze && !es->hide_workers)
1142  else
1143  es->workers_state = NULL;
1144 
1145  /* Identify plan node type, and print generic details */
1146  switch (nodeTag(plan))
1147  {
1148  case T_Result:
1149  pname = sname = "Result";
1150  break;
1151  case T_ProjectSet:
1152  pname = sname = "ProjectSet";
1153  break;
1154  case T_ModifyTable:
1155  sname = "ModifyTable";
1156  switch (((ModifyTable *) plan)->operation)
1157  {
1158  case CMD_INSERT:
1159  pname = operation = "Insert";
1160  break;
1161  case CMD_UPDATE:
1162  pname = operation = "Update";
1163  break;
1164  case CMD_DELETE:
1165  pname = operation = "Delete";
1166  break;
1167  default:
1168  pname = "???";
1169  break;
1170  }
1171  break;
1172  case T_Append:
1173  pname = sname = "Append";
1174  break;
1175  case T_MergeAppend:
1176  pname = sname = "Merge Append";
1177  break;
1178  case T_RecursiveUnion:
1179  pname = sname = "Recursive Union";
1180  break;
1181  case T_BitmapAnd:
1182  pname = sname = "BitmapAnd";
1183  break;
1184  case T_BitmapOr:
1185  pname = sname = "BitmapOr";
1186  break;
1187  case T_NestLoop:
1188  pname = sname = "Nested Loop";
1189  break;
1190  case T_MergeJoin:
1191  pname = "Merge"; /* "Join" gets added by jointype switch */
1192  sname = "Merge Join";
1193  break;
1194  case T_HashJoin:
1195  pname = "Hash"; /* "Join" gets added by jointype switch */
1196  sname = "Hash Join";
1197  break;
1198  case T_SeqScan:
1199  pname = sname = "Seq Scan";
1200  break;
1201  case T_SampleScan:
1202  pname = sname = "Sample Scan";
1203  break;
1204  case T_Gather:
1205  pname = sname = "Gather";
1206  break;
1207  case T_GatherMerge:
1208  pname = sname = "Gather Merge";
1209  break;
1210  case T_IndexScan:
1211  pname = sname = "Index Scan";
1212  break;
1213  case T_IndexOnlyScan:
1214  pname = sname = "Index Only Scan";
1215  break;
1216  case T_BitmapIndexScan:
1217  pname = sname = "Bitmap Index Scan";
1218  break;
1219  case T_BitmapHeapScan:
1220  pname = sname = "Bitmap Heap Scan";
1221  break;
1222  case T_TidScan:
1223  pname = sname = "Tid Scan";
1224  break;
1225  case T_SubqueryScan:
1226  pname = sname = "Subquery Scan";
1227  break;
1228  case T_FunctionScan:
1229  pname = sname = "Function Scan";
1230  break;
1231  case T_TableFuncScan:
1232  pname = sname = "Table Function Scan";
1233  break;
1234  case T_ValuesScan:
1235  pname = sname = "Values Scan";
1236  break;
1237  case T_CteScan:
1238  pname = sname = "CTE Scan";
1239  break;
1240  case T_NamedTuplestoreScan:
1241  pname = sname = "Named Tuplestore Scan";
1242  break;
1243  case T_WorkTableScan:
1244  pname = sname = "WorkTable Scan";
1245  break;
1246  case T_ForeignScan:
1247  sname = "Foreign Scan";
1248  switch (((ForeignScan *) plan)->operation)
1249  {
1250  case CMD_SELECT:
1251  pname = "Foreign Scan";
1252  operation = "Select";
1253  break;
1254  case CMD_INSERT:
1255  pname = "Foreign Insert";
1256  operation = "Insert";
1257  break;
1258  case CMD_UPDATE:
1259  pname = "Foreign Update";
1260  operation = "Update";
1261  break;
1262  case CMD_DELETE:
1263  pname = "Foreign Delete";
1264  operation = "Delete";
1265  break;
1266  default:
1267  pname = "???";
1268  break;
1269  }
1270  break;
1271  case T_CustomScan:
1272  sname = "Custom Scan";
1273  custom_name = ((CustomScan *) plan)->methods->CustomName;
1274  if (custom_name)
1275  pname = psprintf("Custom Scan (%s)", custom_name);
1276  else
1277  pname = sname;
1278  break;
1279  case T_Material:
1280  pname = sname = "Materialize";
1281  break;
1282  case T_Sort:
1283  pname = sname = "Sort";
1284  break;
1285  case T_IncrementalSort:
1286  pname = sname = "Incremental Sort";
1287  break;
1288  case T_Group:
1289  pname = sname = "Group";
1290  break;
1291  case T_Agg:
1292  {
1293  Agg *agg = (Agg *) plan;
1294 
1295  sname = "Aggregate";
1296  switch (agg->aggstrategy)
1297  {
1298  case AGG_PLAIN:
1299  pname = "Aggregate";
1300  strategy = "Plain";
1301  break;
1302  case AGG_SORTED:
1303  pname = "GroupAggregate";
1304  strategy = "Sorted";
1305  break;
1306  case AGG_HASHED:
1307  pname = "HashAggregate";
1308  strategy = "Hashed";
1309  break;
1310  case AGG_MIXED:
1311  pname = "MixedAggregate";
1312  strategy = "Mixed";
1313  break;
1314  default:
1315  pname = "Aggregate ???";
1316  strategy = "???";
1317  break;
1318  }
1319 
1320  if (DO_AGGSPLIT_SKIPFINAL(agg->aggsplit))
1321  {
1322  partialmode = "Partial";
1323  pname = psprintf("%s %s", partialmode, pname);
1324  }
1325  else if (DO_AGGSPLIT_COMBINE(agg->aggsplit))
1326  {
1327  partialmode = "Finalize";
1328  pname = psprintf("%s %s", partialmode, pname);
1329  }
1330  else
1331  partialmode = "Simple";
1332  }
1333  break;
1334  case T_WindowAgg:
1335  pname = sname = "WindowAgg";
1336  break;
1337  case T_Unique:
1338  pname = sname = "Unique";
1339  break;
1340  case T_SetOp:
1341  sname = "SetOp";
1342  switch (((SetOp *) plan)->strategy)
1343  {
1344  case SETOP_SORTED:
1345  pname = "SetOp";
1346  strategy = "Sorted";
1347  break;
1348  case SETOP_HASHED:
1349  pname = "HashSetOp";
1350  strategy = "Hashed";
1351  break;
1352  default:
1353  pname = "SetOp ???";
1354  strategy = "???";
1355  break;
1356  }
1357  break;
1358  case T_LockRows:
1359  pname = sname = "LockRows";
1360  break;
1361  case T_Limit:
1362  pname = sname = "Limit";
1363  break;
1364  case T_Hash:
1365  pname = sname = "Hash";
1366  break;
1367  default:
1368  pname = sname = "???";
1369  break;
1370  }
1371 
1372  ExplainOpenGroup("Plan",
1373  relationship ? NULL : "Plan",
1374  true, es);
1375 
1376  if (es->format == EXPLAIN_FORMAT_TEXT)
1377  {
1378  if (plan_name)
1379  {
1380  ExplainIndentText(es);
1381  appendStringInfo(es->str, "%s\n", plan_name);
1382  es->indent++;
1383  }
1384  if (es->indent)
1385  {
1386  ExplainIndentText(es);
1387  appendStringInfoString(es->str, "-> ");
1388  es->indent += 2;
1389  }
1390  if (plan->parallel_aware)
1391  appendStringInfoString(es->str, "Parallel ");
1392  appendStringInfoString(es->str, pname);
1393  es->indent++;
1394  }
1395  else
1396  {
1397  ExplainPropertyText("Node Type", sname, es);
1398  if (strategy)
1399  ExplainPropertyText("Strategy", strategy, es);
1400  if (partialmode)
1401  ExplainPropertyText("Partial Mode", partialmode, es);
1402  if (operation)
1403  ExplainPropertyText("Operation", operation, es);
1404  if (relationship)
1405  ExplainPropertyText("Parent Relationship", relationship, es);
1406  if (plan_name)
1407  ExplainPropertyText("Subplan Name", plan_name, es);
1408  if (custom_name)
1409  ExplainPropertyText("Custom Plan Provider", custom_name, es);
1410  ExplainPropertyBool("Parallel Aware", plan->parallel_aware, es);
1411  }
1412 
1413  switch (nodeTag(plan))
1414  {
1415  case T_SeqScan:
1416  case T_SampleScan:
1417  case T_BitmapHeapScan:
1418  case T_TidScan:
1419  case T_SubqueryScan:
1420  case T_FunctionScan:
1421  case T_TableFuncScan:
1422  case T_ValuesScan:
1423  case T_CteScan:
1424  case T_WorkTableScan:
1425  ExplainScanTarget((Scan *) plan, es);
1426  break;
1427  case T_ForeignScan:
1428  case T_CustomScan:
1429  if (((Scan *) plan)->scanrelid > 0)
1430  ExplainScanTarget((Scan *) plan, es);
1431  break;
1432  case T_IndexScan:
1433  {
1434  IndexScan *indexscan = (IndexScan *) plan;
1435 
1436  ExplainIndexScanDetails(indexscan->indexid,
1437  indexscan->indexorderdir,
1438  es);
1439  ExplainScanTarget((Scan *) indexscan, es);
1440  }
1441  break;
1442  case T_IndexOnlyScan:
1443  {
1444  IndexOnlyScan *indexonlyscan = (IndexOnlyScan *) plan;
1445 
1446  ExplainIndexScanDetails(indexonlyscan->indexid,
1447  indexonlyscan->indexorderdir,
1448  es);
1449  ExplainScanTarget((Scan *) indexonlyscan, es);
1450  }
1451  break;
1452  case T_BitmapIndexScan:
1453  {
1454  BitmapIndexScan *bitmapindexscan = (BitmapIndexScan *) plan;
1455  const char *indexname =
1456  explain_get_index_name(bitmapindexscan->indexid);
1457 
1458  if (es->format == EXPLAIN_FORMAT_TEXT)
1459  appendStringInfo(es->str, " on %s",
1460  quote_identifier(indexname));
1461  else
1462  ExplainPropertyText("Index Name", indexname, es);
1463  }
1464  break;
1465  case T_ModifyTable:
1466  ExplainModifyTarget((ModifyTable *) plan, es);
1467  break;
1468  case T_NestLoop:
1469  case T_MergeJoin:
1470  case T_HashJoin:
1471  {
1472  const char *jointype;
1473 
1474  switch (((Join *) plan)->jointype)
1475  {
1476  case JOIN_INNER:
1477  jointype = "Inner";
1478  break;
1479  case JOIN_LEFT:
1480  jointype = "Left";
1481  break;
1482  case JOIN_FULL:
1483  jointype = "Full";
1484  break;
1485  case JOIN_RIGHT:
1486  jointype = "Right";
1487  break;
1488  case JOIN_SEMI:
1489  jointype = "Semi";
1490  break;
1491  case JOIN_ANTI:
1492  jointype = "Anti";
1493  break;
1494  default:
1495  jointype = "???";
1496  break;
1497  }
1498  if (es->format == EXPLAIN_FORMAT_TEXT)
1499  {
1500  /*
1501  * For historical reasons, the join type is interpolated
1502  * into the node type name...
1503  */
1504  if (((Join *) plan)->jointype != JOIN_INNER)
1505  appendStringInfo(es->str, " %s Join", jointype);
1506  else if (!IsA(plan, NestLoop))
1507  appendStringInfoString(es->str, " Join");
1508  }
1509  else
1510  ExplainPropertyText("Join Type", jointype, es);
1511  }
1512  break;
1513  case T_SetOp:
1514  {
1515  const char *setopcmd;
1516 
1517  switch (((SetOp *) plan)->cmd)
1518  {
1519  case SETOPCMD_INTERSECT:
1520  setopcmd = "Intersect";
1521  break;
1523  setopcmd = "Intersect All";
1524  break;
1525  case SETOPCMD_EXCEPT:
1526  setopcmd = "Except";
1527  break;
1528  case SETOPCMD_EXCEPT_ALL:
1529  setopcmd = "Except All";
1530  break;
1531  default:
1532  setopcmd = "???";
1533  break;
1534  }
1535  if (es->format == EXPLAIN_FORMAT_TEXT)
1536  appendStringInfo(es->str, " %s", setopcmd);
1537  else
1538  ExplainPropertyText("Command", setopcmd, es);
1539  }
1540  break;
1541  default:
1542  break;
1543  }
1544 
1545  if (es->costs)
1546  {
1547  if (es->format == EXPLAIN_FORMAT_TEXT)
1548  {
1549  appendStringInfo(es->str, " (cost=%.2f..%.2f rows=%.0f width=%d)",
1550  plan->startup_cost, plan->total_cost,
1551  plan->plan_rows, plan->plan_width);
1552  }
1553  else
1554  {
1555  ExplainPropertyFloat("Startup Cost", NULL, plan->startup_cost,
1556  2, es);
1557  ExplainPropertyFloat("Total Cost", NULL, plan->total_cost,
1558  2, es);
1559  ExplainPropertyFloat("Plan Rows", NULL, plan->plan_rows,
1560  0, es);
1561  ExplainPropertyInteger("Plan Width", NULL, plan->plan_width,
1562  es);
1563  }
1564  }
1565 
1566  /*
1567  * We have to forcibly clean up the instrumentation state because we
1568  * haven't done ExecutorEnd yet. This is pretty grotty ...
1569  *
1570  * Note: contrib/auto_explain could cause instrumentation to be set up
1571  * even though we didn't ask for it here. Be careful not to print any
1572  * instrumentation results the user didn't ask for. But we do the
1573  * InstrEndLoop call anyway, if possible, to reduce the number of cases
1574  * auto_explain has to contend with.
1575  */
1576  if (planstate->instrument)
1577  InstrEndLoop(planstate->instrument);
1578 
1579  if (es->analyze &&
1580  planstate->instrument && planstate->instrument->nloops > 0)
1581  {
1582  double nloops = planstate->instrument->nloops;
1583  double startup_ms = 1000.0 * planstate->instrument->startup / nloops;
1584  double total_ms = 1000.0 * planstate->instrument->total / nloops;
1585  double rows = planstate->instrument->ntuples / nloops;
1586 
1587  if (es->format == EXPLAIN_FORMAT_TEXT)
1588  {
1589  if (es->timing)
1590  appendStringInfo(es->str,
1591  " (actual time=%.3f..%.3f rows=%.0f loops=%.0f)",
1592  startup_ms, total_ms, rows, nloops);
1593  else
1594  appendStringInfo(es->str,
1595  " (actual rows=%.0f loops=%.0f)",
1596  rows, nloops);
1597  }
1598  else
1599  {
1600  if (es->timing)
1601  {
1602  ExplainPropertyFloat("Actual Startup Time", "s", startup_ms,
1603  3, es);
1604  ExplainPropertyFloat("Actual Total Time", "s", total_ms,
1605  3, es);
1606  }
1607  ExplainPropertyFloat("Actual Rows", NULL, rows, 0, es);
1608  ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es);
1609  }
1610  }
1611  else if (es->analyze)
1612  {
1613  if (es->format == EXPLAIN_FORMAT_TEXT)
1614  appendStringInfoString(es->str, " (never executed)");
1615  else
1616  {
1617  if (es->timing)
1618  {
1619  ExplainPropertyFloat("Actual Startup Time", "ms", 0.0, 3, es);
1620  ExplainPropertyFloat("Actual Total Time", "ms", 0.0, 3, es);
1621  }
1622  ExplainPropertyFloat("Actual Rows", NULL, 0.0, 0, es);
1623  ExplainPropertyFloat("Actual Loops", NULL, 0.0, 0, es);
1624  }
1625  }
1626 
1627  /* in text format, first line ends here */
1628  if (es->format == EXPLAIN_FORMAT_TEXT)
1629  appendStringInfoChar(es->str, '\n');
1630 
1631  /* prepare per-worker general execution details */
1632  if (es->workers_state && es->verbose)
1633  {
1634  WorkerInstrumentation *w = planstate->worker_instrument;
1635 
1636  for (int n = 0; n < w->num_workers; n++)
1637  {
1638  Instrumentation *instrument = &w->instrument[n];
1639  double nloops = instrument->nloops;
1640  double startup_ms;
1641  double total_ms;
1642  double rows;
1643 
1644  if (nloops <= 0)
1645  continue;
1646  startup_ms = 1000.0 * instrument->startup / nloops;
1647  total_ms = 1000.0 * instrument->total / nloops;
1648  rows = instrument->ntuples / nloops;
1649 
1650  ExplainOpenWorker(n, es);
1651 
1652  if (es->format == EXPLAIN_FORMAT_TEXT)
1653  {
1654  ExplainIndentText(es);
1655  if (es->timing)
1656  appendStringInfo(es->str,
1657  "actual time=%.3f..%.3f rows=%.0f loops=%.0f\n",
1658  startup_ms, total_ms, rows, nloops);
1659  else
1660  appendStringInfo(es->str,
1661  "actual rows=%.0f loops=%.0f\n",
1662  rows, nloops);
1663  }
1664  else
1665  {
1666  if (es->timing)
1667  {
1668  ExplainPropertyFloat("Actual Startup Time", "ms",
1669  startup_ms, 3, es);
1670  ExplainPropertyFloat("Actual Total Time", "ms",
1671  total_ms, 3, es);
1672  }
1673  ExplainPropertyFloat("Actual Rows", NULL, rows, 0, es);
1674  ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es);
1675  }
1676 
1677  ExplainCloseWorker(n, es);
1678  }
1679  }
1680 
1681  /* target list */
1682  if (es->verbose)
1683  show_plan_tlist(planstate, ancestors, es);
1684 
1685  /* unique join */
1686  switch (nodeTag(plan))
1687  {
1688  case T_NestLoop:
1689  case T_MergeJoin:
1690  case T_HashJoin:
1691  /* try not to be too chatty about this in text mode */
1692  if (es->format != EXPLAIN_FORMAT_TEXT ||
1693  (es->verbose && ((Join *) plan)->inner_unique))
1694  ExplainPropertyBool("Inner Unique",
1695  ((Join *) plan)->inner_unique,
1696  es);
1697  break;
1698  default:
1699  break;
1700  }
1701 
1702  /* quals, sort keys, etc */
1703  switch (nodeTag(plan))
1704  {
1705  case T_IndexScan:
1706  show_scan_qual(((IndexScan *) plan)->indexqualorig,
1707  "Index Cond", planstate, ancestors, es);
1708  if (((IndexScan *) plan)->indexqualorig)
1709  show_instrumentation_count("Rows Removed by Index Recheck", 2,
1710  planstate, es);
1711  show_scan_qual(((IndexScan *) plan)->indexorderbyorig,
1712  "Order By", planstate, ancestors, es);
1713  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1714  if (plan->qual)
1715  show_instrumentation_count("Rows Removed by Filter", 1,
1716  planstate, es);
1717  break;
1718  case T_IndexOnlyScan:
1719  show_scan_qual(((IndexOnlyScan *) plan)->indexqual,
1720  "Index Cond", planstate, ancestors, es);
1721  if (((IndexOnlyScan *) plan)->indexqual)
1722  show_instrumentation_count("Rows Removed by Index Recheck", 2,
1723  planstate, es);
1724  show_scan_qual(((IndexOnlyScan *) plan)->indexorderby,
1725  "Order By", planstate, ancestors, es);
1726  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1727  if (plan->qual)
1728  show_instrumentation_count("Rows Removed by Filter", 1,
1729  planstate, es);
1730  if (es->analyze)
1731  ExplainPropertyFloat("Heap Fetches", NULL,
1732  planstate->instrument->ntuples2, 0, es);
1733  break;
1734  case T_BitmapIndexScan:
1735  show_scan_qual(((BitmapIndexScan *) plan)->indexqualorig,
1736  "Index Cond", planstate, ancestors, es);
1737  break;
1738  case T_BitmapHeapScan:
1739  show_scan_qual(((BitmapHeapScan *) plan)->bitmapqualorig,
1740  "Recheck Cond", planstate, ancestors, es);
1741  if (((BitmapHeapScan *) plan)->bitmapqualorig)
1742  show_instrumentation_count("Rows Removed by Index Recheck", 2,
1743  planstate, es);
1744  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1745  if (plan->qual)
1746  show_instrumentation_count("Rows Removed by Filter", 1,
1747  planstate, es);
1748  if (es->analyze)
1749  show_tidbitmap_info((BitmapHeapScanState *) planstate, es);
1750  break;
1751  case T_SampleScan:
1752  show_tablesample(((SampleScan *) plan)->tablesample,
1753  planstate, ancestors, es);
1754  /* fall through to print additional fields the same as SeqScan */
1755  /* FALLTHROUGH */
1756  case T_SeqScan:
1757  case T_ValuesScan:
1758  case T_CteScan:
1759  case T_NamedTuplestoreScan:
1760  case T_WorkTableScan:
1761  case T_SubqueryScan:
1762  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1763  if (plan->qual)
1764  show_instrumentation_count("Rows Removed by Filter", 1,
1765  planstate, es);
1766  break;
1767  case T_Gather:
1768  {
1769  Gather *gather = (Gather *) plan;
1770 
1771  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1772  if (plan->qual)
1773  show_instrumentation_count("Rows Removed by Filter", 1,
1774  planstate, es);
1775  ExplainPropertyInteger("Workers Planned", NULL,
1776  gather->num_workers, es);
1777 
1778  /* Show params evaluated at gather node */
1779  if (gather->initParam)
1780  show_eval_params(gather->initParam, es);
1781 
1782  if (es->analyze)
1783  {
1784  int nworkers;
1785 
1786  nworkers = ((GatherState *) planstate)->nworkers_launched;
1787  ExplainPropertyInteger("Workers Launched", NULL,
1788  nworkers, es);
1789  }
1790 
1791  if (gather->single_copy || es->format != EXPLAIN_FORMAT_TEXT)
1792  ExplainPropertyBool("Single Copy", gather->single_copy, es);
1793  }
1794  break;
1795  case T_GatherMerge:
1796  {
1797  GatherMerge *gm = (GatherMerge *) plan;
1798 
1799  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1800  if (plan->qual)
1801  show_instrumentation_count("Rows Removed by Filter", 1,
1802  planstate, es);
1803  ExplainPropertyInteger("Workers Planned", NULL,
1804  gm->num_workers, es);
1805 
1806  /* Show params evaluated at gather-merge node */
1807  if (gm->initParam)
1808  show_eval_params(gm->initParam, es);
1809 
1810  if (es->analyze)
1811  {
1812  int nworkers;
1813 
1814  nworkers = ((GatherMergeState *) planstate)->nworkers_launched;
1815  ExplainPropertyInteger("Workers Launched", NULL,
1816  nworkers, es);
1817  }
1818  }
1819  break;
1820  case T_FunctionScan:
1821  if (es->verbose)
1822  {
1823  List *fexprs = NIL;
1824  ListCell *lc;
1825 
1826  foreach(lc, ((FunctionScan *) plan)->functions)
1827  {
1828  RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
1829 
1830  fexprs = lappend(fexprs, rtfunc->funcexpr);
1831  }
1832  /* We rely on show_expression to insert commas as needed */
1833  show_expression((Node *) fexprs,
1834  "Function Call", planstate, ancestors,
1835  es->verbose, es);
1836  }
1837  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1838  if (plan->qual)
1839  show_instrumentation_count("Rows Removed by Filter", 1,
1840  planstate, es);
1841  break;
1842  case T_TableFuncScan:
1843  if (es->verbose)
1844  {
1845  TableFunc *tablefunc = ((TableFuncScan *) plan)->tablefunc;
1846 
1847  show_expression((Node *) tablefunc,
1848  "Table Function Call", planstate, ancestors,
1849  es->verbose, es);
1850  }
1851  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1852  if (plan->qual)
1853  show_instrumentation_count("Rows Removed by Filter", 1,
1854  planstate, es);
1855  break;
1856  case T_TidScan:
1857  {
1858  /*
1859  * The tidquals list has OR semantics, so be sure to show it
1860  * as an OR condition.
1861  */
1862  List *tidquals = ((TidScan *) plan)->tidquals;
1863 
1864  if (list_length(tidquals) > 1)
1865  tidquals = list_make1(make_orclause(tidquals));
1866  show_scan_qual(tidquals, "TID Cond", planstate, ancestors, es);
1867  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1868  if (plan->qual)
1869  show_instrumentation_count("Rows Removed by Filter", 1,
1870  planstate, es);
1871  }
1872  break;
1873  case T_ForeignScan:
1874  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1875  if (plan->qual)
1876  show_instrumentation_count("Rows Removed by Filter", 1,
1877  planstate, es);
1878  show_foreignscan_info((ForeignScanState *) planstate, es);
1879  break;
1880  case T_CustomScan:
1881  {
1882  CustomScanState *css = (CustomScanState *) planstate;
1883 
1884  show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
1885  if (plan->qual)
1886  show_instrumentation_count("Rows Removed by Filter", 1,
1887  planstate, es);
1888  if (css->methods->ExplainCustomScan)
1889  css->methods->ExplainCustomScan(css, ancestors, es);
1890  }
1891  break;
1892  case T_NestLoop:
1893  show_upper_qual(((NestLoop *) plan)->join.joinqual,
1894  "Join Filter", planstate, ancestors, es);
1895  if (((NestLoop *) plan)->join.joinqual)
1896  show_instrumentation_count("Rows Removed by Join Filter", 1,
1897  planstate, es);
1898  show_upper_qual(plan->qual, "Filter", planstate, ancestors, es);
1899  if (plan->qual)
1900  show_instrumentation_count("Rows Removed by Filter", 2,
1901  planstate, es);
1902  break;
1903  case T_MergeJoin:
1904  show_upper_qual(((MergeJoin *) plan)->mergeclauses,
1905  "Merge Cond", planstate, ancestors, es);
1906  show_upper_qual(((MergeJoin *) plan)->join.joinqual,
1907  "Join Filter", planstate, ancestors, es);
1908  if (((MergeJoin *) plan)->join.joinqual)
1909  show_instrumentation_count("Rows Removed by Join Filter", 1,
1910  planstate, es);
1911  show_upper_qual(plan->qual, "Filter", planstate, ancestors, es);
1912  if (plan->qual)
1913  show_instrumentation_count("Rows Removed by Filter", 2,
1914  planstate, es);
1915  break;
1916  case T_HashJoin:
1917  show_upper_qual(((HashJoin *) plan)->hashclauses,
1918  "Hash Cond", planstate, ancestors, es);
1919  show_upper_qual(((HashJoin *) plan)->join.joinqual,
1920  "Join Filter", planstate, ancestors, es);
1921  if (((HashJoin *) plan)->join.joinqual)
1922  show_instrumentation_count("Rows Removed by Join Filter", 1,
1923  planstate, es);
1924  show_upper_qual(plan->qual, "Filter", planstate, ancestors, es);
1925  if (plan->qual)
1926  show_instrumentation_count("Rows Removed by Filter", 2,
1927  planstate, es);
1928  break;
1929  case T_Agg:
1930  show_agg_keys(castNode(AggState, planstate), ancestors, es);
1931  show_upper_qual(plan->qual, "Filter", planstate, ancestors, es);
1932  show_hashagg_info((AggState *) planstate, es);
1933  if (plan->qual)
1934  show_instrumentation_count("Rows Removed by Filter", 1,
1935  planstate, es);
1936  break;
1937  case T_Group:
1938  show_group_keys(castNode(GroupState, planstate), ancestors, es);
1939  show_upper_qual(plan->qual, "Filter", planstate, ancestors, es);
1940  if (plan->qual)
1941  show_instrumentation_count("Rows Removed by Filter", 1,
1942  planstate, es);
1943  break;
1944  case T_Sort:
1945  show_sort_keys(castNode(SortState, planstate), ancestors, es);
1946  show_sort_info(castNode(SortState, planstate), es);
1947  break;
1948  case T_IncrementalSort:
1950  ancestors, es);
1952  es);
1953  break;
1954  case T_MergeAppend:
1956  ancestors, es);
1957  break;
1958  case T_Result:
1959  show_upper_qual((List *) ((Result *) plan)->resconstantqual,
1960  "One-Time Filter", planstate, ancestors, es);
1961  show_upper_qual(plan->qual, "Filter", planstate, ancestors, es);
1962  if (plan->qual)
1963  show_instrumentation_count("Rows Removed by Filter", 1,
1964  planstate, es);
1965  break;
1966  case T_ModifyTable:
1967  show_modifytable_info(castNode(ModifyTableState, planstate), ancestors,
1968  es);
1969  break;
1970  case T_Hash:
1971  show_hash_info(castNode(HashState, planstate), es);
1972  break;
1973  default:
1974  break;
1975  }
1976 
1977  /*
1978  * Prepare per-worker JIT instrumentation. As with the overall JIT
1979  * summary, this is printed only if printing costs is enabled.
1980  */
1981  if (es->workers_state && es->costs && es->verbose)
1982  {
1984 
1985  if (w)
1986  {
1987  for (int n = 0; n < w->num_workers; n++)
1988  {
1989  ExplainOpenWorker(n, es);
1990  ExplainPrintJIT(es, planstate->state->es_jit_flags,
1991  &w->jit_instr[n]);
1992  ExplainCloseWorker(n, es);
1993  }
1994  }
1995  }
1996 
1997  /* Show buffer/WAL usage */
1998  if (es->buffers && planstate->instrument)
1999  show_buffer_usage(es, &planstate->instrument->bufusage);
2000  if (es->wal && planstate->instrument)
2001  show_wal_usage(es, &planstate->instrument->walusage);
2002 
2003  /* Prepare per-worker buffer/WAL usage */
2004  if (es->workers_state && (es->buffers || es->wal) && es->verbose)
2005  {
2006  WorkerInstrumentation *w = planstate->worker_instrument;
2007 
2008  for (int n = 0; n < w->num_workers; n++)
2009  {
2010  Instrumentation *instrument = &w->instrument[n];
2011  double nloops = instrument->nloops;
2012 
2013  if (nloops <= 0)
2014  continue;
2015 
2016  ExplainOpenWorker(n, es);
2017  if (es->buffers)
2018  show_buffer_usage(es, &instrument->bufusage);
2019  if (es->wal)
2020  show_wal_usage(es, &instrument->walusage);
2021  ExplainCloseWorker(n, es);
2022  }
2023  }
2024 
2025  /* Show per-worker details for this plan node, then pop that stack */
2026  if (es->workers_state)
2028  es->workers_state = save_workers_state;
2029 
2030  /*
2031  * If partition pruning was done during executor initialization, the
2032  * number of child plans we'll display below will be less than the number
2033  * of subplans that was specified in the plan. To make this a bit less
2034  * mysterious, emit an indication that this happened. Note that this
2035  * field is emitted now because we want it to be a property of the parent
2036  * node; it *cannot* be emitted within the Plans sub-node we'll open next.
2037  */
2038  switch (nodeTag(plan))
2039  {
2040  case T_Append:
2041  ExplainMissingMembers(((AppendState *) planstate)->as_nplans,
2042  list_length(((Append *) plan)->appendplans),
2043  es);
2044  break;
2045  case T_MergeAppend:
2046  ExplainMissingMembers(((MergeAppendState *) planstate)->ms_nplans,
2047  list_length(((MergeAppend *) plan)->mergeplans),
2048  es);
2049  break;
2050  default:
2051  break;
2052  }
2053 
2054  /* Get ready to display the child plans */
2055  haschildren = planstate->initPlan ||
2056  outerPlanState(planstate) ||
2057  innerPlanState(planstate) ||
2058  IsA(plan, ModifyTable) ||
2059  IsA(plan, Append) ||
2060  IsA(plan, MergeAppend) ||
2061  IsA(plan, BitmapAnd) ||
2062  IsA(plan, BitmapOr) ||
2063  IsA(plan, SubqueryScan) ||
2064  (IsA(planstate, CustomScanState) &&
2065  ((CustomScanState *) planstate)->custom_ps != NIL) ||
2066  planstate->subPlan;
2067  if (haschildren)
2068  {
2069  ExplainOpenGroup("Plans", "Plans", false, es);
2070  /* Pass current Plan as head of ancestors list for children */
2071  ancestors = lcons(plan, ancestors);
2072  }
2073 
2074  /* initPlan-s */
2075  if (planstate->initPlan)
2076  ExplainSubPlans(planstate->initPlan, ancestors, "InitPlan", es);
2077 
2078  /* lefttree */
2079  if (outerPlanState(planstate))
2080  ExplainNode(outerPlanState(planstate), ancestors,
2081  "Outer", NULL, es);
2082 
2083  /* righttree */
2084  if (innerPlanState(planstate))
2085  ExplainNode(innerPlanState(planstate), ancestors,
2086  "Inner", NULL, es);
2087 
2088  /* special child plans */
2089  switch (nodeTag(plan))
2090  {
2091  case T_ModifyTable:
2092  ExplainMemberNodes(((ModifyTableState *) planstate)->mt_plans,
2093  ((ModifyTableState *) planstate)->mt_nplans,
2094  ancestors, es);
2095  break;
2096  case T_Append:
2097  ExplainMemberNodes(((AppendState *) planstate)->appendplans,
2098  ((AppendState *) planstate)->as_nplans,
2099  ancestors, es);
2100  break;
2101  case T_MergeAppend:
2102  ExplainMemberNodes(((MergeAppendState *) planstate)->mergeplans,
2103  ((MergeAppendState *) planstate)->ms_nplans,
2104  ancestors, es);
2105  break;
2106  case T_BitmapAnd:
2107  ExplainMemberNodes(((BitmapAndState *) planstate)->bitmapplans,
2108  ((BitmapAndState *) planstate)->nplans,
2109  ancestors, es);
2110  break;
2111  case T_BitmapOr:
2112  ExplainMemberNodes(((BitmapOrState *) planstate)->bitmapplans,
2113  ((BitmapOrState *) planstate)->nplans,
2114  ancestors, es);
2115  break;
2116  case T_SubqueryScan:
2117  ExplainNode(((SubqueryScanState *) planstate)->subplan, ancestors,
2118  "Subquery", NULL, es);
2119  break;
2120  case T_CustomScan:
2121  ExplainCustomChildren((CustomScanState *) planstate,
2122  ancestors, es);
2123  break;
2124  default:
2125  break;
2126  }
2127 
2128  /* subPlan-s */
2129  if (planstate->subPlan)
2130  ExplainSubPlans(planstate->subPlan, ancestors, "SubPlan", es);
2131 
2132  /* end of child plans */
2133  if (haschildren)
2134  {
2135  ancestors = list_delete_first(ancestors);
2136  ExplainCloseGroup("Plans", "Plans", false, es);
2137  }
2138 
2139  /* in text format, undo whatever indentation we added */
2140  if (es->format == EXPLAIN_FORMAT_TEXT)
2141  es->indent = save_indent;
2142 
2143  ExplainCloseGroup("Plan",
2144  relationship ? NULL : "Plan",
2145  true, es);
2146 }
#define NIL
Definition: pg_list.h:65
static ExplainWorkersState * ExplainCreateWorkersState(int num_workers)
Definition: explain.c:3907
Definition: nodes.h:79
void ExplainPropertyBool(const char *qlabel, bool value, ExplainState *es)
Definition: explain.c:4278
ScanDirection indexorderdir
Definition: plannodes.h:411
#define IsA(nodeptr, _type_)
Definition: nodes.h:580
Bitmapset * initParam
Definition: plannodes.h:910
WorkerInstrumentation * worker_instrument
Definition: execnodes.h:956
WalUsage walusage
Definition: instrument.h:75
void ExplainPropertyInteger(const char *qlabel, const char *unit, int64 value, ExplainState *es)
Definition: explain.c:4237
Definition: nodes.h:81
bool hide_workers
Definition: explain.h:59
Instrumentation * instrument
Definition: execnodes.h:955
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:10727
static void show_modifytable_info(ModifyTableState *mtstate, List *ancestors, ExplainState *es)
Definition: explain.c:3650
#define castNode(_type_, nodeptr)
Definition: nodes.h:598
void ExplainPropertyFloat(const char *qlabel, const char *unit, double value, int ndigits, ExplainState *es)
Definition: explain.c:4264
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
double startup
Definition: instrument.h:67
Definition: nodes.h:529
Definition: nodes.h:49
static void show_incremental_sort_info(IncrementalSortState *incrsortstate, ExplainState *es)
Definition: explain.c:2873
static void ExplainOpenWorker(int n, ExplainState *es)
Definition: explain.c:3924
static void ExplainCloseWorker(int n, ExplainState *es)
Definition: explain.c:3986
static void ExplainPrintJIT(ExplainState *es, int jit_flags, JitInstrumentation *ji)
Definition: explain.c:852
Definition: nodes.h:76
EState * state
Definition: execnodes.h:947
Expr * make_orclause(List *orclauses)
Definition: makefuncs.c:651
bool costs
Definition: explain.h:43
JitInstrumentation jit_instr[FLEXIBLE_ARRAY_MEMBER]
Definition: jit.h:51
static void show_scan_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, ExplainState *es)
Definition: explain.c:2254
#define DO_AGGSPLIT_COMBINE(as)
Definition: nodes.h:791
bool analyze
Definition: explain.h:42
static void show_sort_info(SortState *sortstate, ExplainState *es)
Definition: explain.c:2668
Oid indexid
Definition: plannodes.h:405
static void show_upper_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, ExplainState *es)
Definition: explain.c:2268
static void show_instrumentation_count(const char *qlabel, int which, PlanState *planstate, ExplainState *es)
Definition: explain.c:3202
void InstrEndLoop(Instrumentation *instr)
Definition: instrument.c:121
const struct CustomExecMethods * methods
Definition: execnodes.h:1824
#define list_make1(x1)
Definition: pg_list.h:227
void ExplainPropertyText(const char *qlabel, const char *value, ExplainState *es)
Definition: explain.c:4228
static void ExplainNode(PlanState *planstate, List *ancestors, const char *relationship, const char *plan_name, ExplainState *es)
Definition: explain.c:1121
AggStrategy aggstrategy
Definition: plannodes.h:819
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
Definition: nodes.h:46
bool single_copy
Definition: plannodes.h:889
Definition: nodes.h:78
#define outerPlanState(node)
Definition: execnodes.h:1039
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
int es_jit_flags
Definition: execnodes.h:600
static void show_tablesample(TableSampleClause *tsc, PlanState *planstate, List *ancestors, ExplainState *es)
Definition: explain.c:2602
ScanDirection indexorderdir
Definition: plannodes.h:438
double ntuples
Definition: instrument.h:69
int indent
Definition: explain.h:51
static void show_wal_usage(ExplainState *es, const WalUsage *usage)
Definition: explain.c:3428
static void show_tidbitmap_info(BitmapHeapScanState *planstate, ExplainState *es)
Definition: explain.c:3172
static void ExplainModifyTarget(ModifyTable *plan, ExplainState *es)
Definition: explain.c:3518
static void ExplainMissingMembers(int nplans, int nchildren, ExplainState *es)
Definition: explain.c:3828
static void ExplainIndexScanDetails(Oid indexid, ScanDirection indexorderdir, ExplainState *es)
Definition: explain.c:3466
static void show_group_keys(GroupState *gstate, List *ancestors, ExplainState *es)
Definition: explain.c:2462
struct SharedJitInstrumentation * worker_jit_instrument
Definition: execnodes.h:959
static void show_buffer_usage(ExplainState *es, const BufferUsage *usage)
Definition: explain.c:3304
static void show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es)
Definition: explain.c:2152
List * lappend(List *list, void *datum)
Definition: list.c:321
bool timing
Definition: explain.h:46
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
Instrumentation instrument[FLEXIBLE_ARRAY_MEMBER]
Definition: instrument.h:81
bool verbose
Definition: explain.h:41
BufferUsage bufusage
Definition: instrument.h:74
static void ExplainCustomChildren(CustomScanState *css, List *ancestors, ExplainState *es)
Definition: explain.c:3885
Definition: nodes.h:84
Plan * plan
Definition: execnodes.h:945
int num_workers
Definition: plannodes.h:887
void(* ExplainCustomScan)(CustomScanState *node, List *ancestors, ExplainState *es)
Definition: extensible.h:151
static void show_merge_append_keys(MergeAppendState *mstate, List *ancestors, ExplainState *es)
Definition: explain.c:2314
static void ExplainIndentText(ExplainState *es)
Definition: explain.c:4665
List * lcons(void *datum, List *list)
Definition: list.c:453
#define lfirst(lc)
Definition: pg_list.h:190
AggSplit aggsplit
Definition: plannodes.h:820
static void ExplainSubPlans(List *plans, List *ancestors, const char *relationship, ExplainState *es)
Definition: explain.c:3842
bool wal
Definition: explain.h:45
static void show_hash_info(HashState *hashstate, ExplainState *es)
Definition: explain.c:2959
ExplainWorkersState * workers_state
Definition: explain.h:61
static void show_eval_params(Bitmapset *bms_params, ExplainState *es)
Definition: explain.c:3252
static void show_sort_keys(SortState *sortstate, List *ancestors, ExplainState *es)
Definition: explain.c:2282
static int list_length(const List *l)
Definition: pg_list.h:169
ExplainFormat format
Definition: explain.h:49
#define DO_AGGSPLIT_SKIPFINAL(as)
Definition: nodes.h:792
static const struct fns functions
Definition: regcomp.c:298
static const char * explain_get_index_name(Oid indexId)
Definition: explain.c:3282
double ntuples2
Definition: instrument.h:70
#define nodeTag(nodeptr)
Definition: nodes.h:534
static void show_expression(Node *node, const char *qlabel, PlanState *planstate, List *ancestors, bool useprefix, ExplainState *es)
Definition: explain.c:2210
Bitmapset * initParam
Definition: plannodes.h:891
static void show_incremental_sort_keys(IncrementalSortState *incrsortstate, List *ancestors, ExplainState *es)
Definition: explain.c:2297
Definition: nodes.h:85
int num_workers
Definition: plannodes.h:902
static void ExplainFlushWorkersState(ExplainState *es)
Definition: explain.c:4022
Definition: nodes.h:82
bool buffers
Definition: explain.h:44
static void show_foreignscan_info(ForeignScanState *fsstate, ExplainState *es)
Definition: explain.c:3231
static void ExplainScanTarget(Scan *plan, ExplainState *es)
Definition: explain.c:3505
void ExplainCloseGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4356
Definition: plannodes.h:816
#define innerPlanState(node)
Definition: execnodes.h:1038
void ExplainOpenGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4293
Definition: pg_list.h:50
StringInfo str
Definition: explain.h:39
static void show_agg_keys(AggState *astate, List *ancestors, ExplainState *es)
Definition: explain.c:2330
static void ExplainMemberNodes(PlanState **planstates, int nplans, List *ancestors, ExplainState *es)
Definition: explain.c:3810
List * list_delete_first(List *list)
Definition: list.c:860
static void show_hashagg_info(AggState *hashstate, ExplainState *es)
Definition: explain.c:3050
Definition: nodes.h:87

◆ ExplainOnePlan()

void ExplainOnePlan ( PlannedStmt plannedstmt,
IntoClause into,
ExplainState es,
const char *  queryString,
ParamListInfo  params,
QueryEnvironment queryEnv,
const instr_time planduration,
const BufferUsage bufusage 
)

Definition at line 500 of file explain.c.

References ExplainState::analyze, Assert, ExplainState::buffers, CMD_UTILITY, CommandCounterIncrement(), PlannedStmt::commandType, ExplainState::costs, CreateIntoRelDestReceiver(), CreateQueryDesc(), generate_unaccent_rules::dest, elapsed_time(), EXEC_FLAG_EXPLAIN_ONLY, ExecutorEnd(), ExecutorFinish(), ExecutorRun(), ExecutorStart(), EXPLAIN_FORMAT_TEXT, ExplainCloseGroup(), ExplainOpenGroup(), ExplainPrintJITSummary(), ExplainPrintPlan(), ExplainPrintTriggers(), ExplainPropertyFloat(), ExplainState::format, ForwardScanDirection, FreeQueryDesc(), GetActiveSnapshot(), GetIntoRelEFlags(), ExplainState::indent, INSTR_TIME_GET_DOUBLE, INSTR_TIME_SET_CURRENT, INSTRUMENT_BUFFERS, INSTRUMENT_ROWS, INSTRUMENT_TIMER, INSTRUMENT_WAL, InvalidSnapshot, NoMovementScanDirection, None_Receiver, PopActiveSnapshot(), PushCopiedSnapshot(), show_buffer_usage(), IntoClause::skipData, ExplainState::summary, ExplainState::timing, UpdateActiveSnapshotCommandId(), and ExplainState::wal.

Referenced by ExplainExecuteQuery(), and ExplainOneQuery().

504 {
506  QueryDesc *queryDesc;
507  instr_time starttime;
508  double totaltime = 0;
509  int eflags;
510  int instrument_option = 0;
511 
512  Assert(plannedstmt->commandType != CMD_UTILITY);
513 
514  if (es->analyze && es->timing)
515  instrument_option |= INSTRUMENT_TIMER;
516  else if (es->analyze)
517  instrument_option |= INSTRUMENT_ROWS;
518 
519  if (es->buffers)
520  instrument_option |= INSTRUMENT_BUFFERS;
521  if (es->wal)
522  instrument_option |= INSTRUMENT_WAL;
523 
524  /*
525  * We always collect timing for the entire statement, even when node-level
526  * timing is off, so we don't look at es->timing here. (We could skip
527  * this if !es->summary, but it's hardly worth the complication.)
528  */
529  INSTR_TIME_SET_CURRENT(starttime);
530 
531  /*
532  * Use a snapshot with an updated command ID to ensure this query sees
533  * results of any previously executed queries.
534  */
537 
538  /*
539  * Normally we discard the query's output, but if explaining CREATE TABLE
540  * AS, we'd better use the appropriate tuple receiver.
541  */
542  if (into)
543  dest = CreateIntoRelDestReceiver(into);
544  else
545  dest = None_Receiver;
546 
547  /* Create a QueryDesc for the query */
548  queryDesc = CreateQueryDesc(plannedstmt, queryString,
550  dest, params, queryEnv, instrument_option);
551 
552  /* Select execution options */
553  if (es->analyze)
554  eflags = 0; /* default run-to-completion flags */
555  else
556  eflags = EXEC_FLAG_EXPLAIN_ONLY;
557  if (into)
558  eflags |= GetIntoRelEFlags(into);
559 
560  /* call ExecutorStart to prepare the plan for execution */
561  ExecutorStart(queryDesc, eflags);
562 
563  /* Execute the plan for statistics if asked for */
564  if (es->analyze)
565  {
566  ScanDirection dir;
567 
568  /* EXPLAIN ANALYZE CREATE TABLE AS WITH NO DATA is weird */
569  if (into && into->skipData)
571  else
572  dir = ForwardScanDirection;
573 
574  /* run the plan */
575  ExecutorRun(queryDesc, dir, 0L, true);
576 
577  /* run cleanup too */
578  ExecutorFinish(queryDesc);
579 
580  /* We can't run ExecutorEnd 'till we're done printing the stats... */
581  totaltime += elapsed_time(&starttime);
582  }
583 
584  ExplainOpenGroup("Query", NULL, true, es);
585 
586  /* Create textual dump of plan tree */
587  ExplainPrintPlan(es, queryDesc);
588 
589  if (es->summary && (planduration || bufusage))
590  ExplainOpenGroup("Planning", "Planning", true, es);
591 
592  if (es->summary && planduration)
593  {
594  double plantime = INSTR_TIME_GET_DOUBLE(*planduration);
595 
596  ExplainPropertyFloat("Planning Time", "ms", 1000.0 * plantime, 3, es);
597  }
598 
599  /* Show buffer usage */
600  if (es->summary && bufusage)
601  {
602  if (es->format == EXPLAIN_FORMAT_TEXT)
603  es->indent++;
604  show_buffer_usage(es, bufusage);
605  if (es->format == EXPLAIN_FORMAT_TEXT)
606  es->indent--;
607  }
608 
609  if (es->summary && (planduration || bufusage))
610  ExplainCloseGroup("Planning", "Planning", true, es);
611 
612  /* Print info about runtime of triggers */
613  if (es->analyze)
614  ExplainPrintTriggers(es, queryDesc);
615 
616  /*
617  * Print info about JITing. Tied to es->costs because we don't want to
618  * display this in regression tests, as it'd cause output differences
619  * depending on build options. Might want to separate that out from COSTS
620  * at a later stage.
621  */
622  if (es->costs)
623  ExplainPrintJITSummary(es, queryDesc);
624 
625  /*
626  * Close down the query and free resources. Include time for this in the
627  * total execution time (although it should be pretty minimal).
628  */
629  INSTR_TIME_SET_CURRENT(starttime);
630 
631  ExecutorEnd(queryDesc);
632 
633  FreeQueryDesc(queryDesc);
634 
636 
637  /* We need a CCI just in case query expanded to multiple plans */
638  if (es->analyze)
640 
641  totaltime += elapsed_time(&starttime);
642 
643  /*
644  * We only report execution time if we actually ran the query (that is,
645  * the user specified ANALYZE), and if summary reporting is enabled (the
646  * user can set SUMMARY OFF to not have the timing information included in
647  * the output). By default, ANALYZE sets SUMMARY to true.
648  */
649  if (es->summary && es->analyze)
650  ExplainPropertyFloat("Execution Time", "ms", 1000.0 * totaltime, 3,
651  es);
652 
653  ExplainCloseGroup("Query", NULL, true, es);
654 }
bool summary
Definition: explain.h:47
void UpdateActiveSnapshotCommandId(void)
Definition: snapmgr.c:783
void FreeQueryDesc(QueryDesc *qdesc)
Definition: pquery.c:105
void ExplainPropertyFloat(const char *qlabel, const char *unit, double value, int ndigits, ExplainState *es)
Definition: explain.c:4264
struct timeval instr_time
Definition: instr_time.h:150
void ExecutorStart(QueryDesc *queryDesc, int eflags)
Definition: execMain.c:143
Snapshot GetActiveSnapshot(void)
Definition: snapmgr.c:841
void PopActiveSnapshot(void)
Definition: snapmgr.c:814
#define INSTR_TIME_GET_DOUBLE(t)
Definition: instr_time.h:199
bool skipData
Definition: primnodes.h:119
bool costs
Definition: explain.h:43
DestReceiver * None_Receiver
Definition: dest.c:96
bool analyze
Definition: explain.h:42
void ExecutorEnd(QueryDesc *queryDesc)
Definition: execMain.c:462
int GetIntoRelEFlags(IntoClause *intoClause)
Definition: createas.c:393
void ExplainPrintTriggers(ExplainState *es, QueryDesc *queryDesc)
Definition: explain.c:780
void ExplainPrintPlan(ExplainState *es, QueryDesc *queryDesc)
Definition: explain.c:731
void ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once)
Definition: execMain.c:301
void PushCopiedSnapshot(Snapshot snapshot)
Definition: snapmgr.c:771
QueryDesc * CreateQueryDesc(PlannedStmt *plannedstmt, const char *sourceText, Snapshot snapshot, Snapshot crosscheck_snapshot, DestReceiver *dest, ParamListInfo params, QueryEnvironment *queryEnv, int instrument_options)
Definition: pquery.c:67
ScanDirection
Definition: sdir.h:22
DestReceiver * CreateIntoRelDestReceiver(IntoClause *intoClause)
Definition: createas.c:411
int indent
Definition: explain.h:51
static void show_buffer_usage(ExplainState *es, const BufferUsage *usage)
Definition: explain.c:3304
void ExecutorFinish(QueryDesc *queryDesc)
Definition: execMain.c:402
bool timing
Definition: explain.h:46
#define InvalidSnapshot
Definition: snapshot.h:123
void CommandCounterIncrement(void)
Definition: xact.c:1021
CmdType commandType
Definition: plannodes.h:46
#define Assert(condition)
Definition: c.h:745
bool wal
Definition: explain.h:45
ExplainFormat format
Definition: explain.h:49
static double elapsed_time(instr_time *starttime)
Definition: explain.c:1028
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:156
bool buffers
Definition: explain.h:44
void ExplainCloseGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4356
void ExplainPrintJITSummary(ExplainState *es, QueryDesc *queryDesc)
Definition: explain.c:826
void ExplainOpenGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4293
#define EXEC_FLAG_EXPLAIN_ONLY
Definition: executor.h:56

◆ ExplainOneQuery()

static void ExplainOneQuery ( Query query,
int  cursorOptions,
IntoClause into,
ExplainState es,
const char *  queryString,
ParamListInfo  params,
QueryEnvironment queryEnv 
)
static

Definition at line 365 of file explain.c.

References BufferUsageAccumDiff(), CMD_UTILITY, Query::commandType, ExplainOnePlan(), ExplainOneQuery_hook, ExplainOneUtility(), INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, pg_plan_query(), pgBufferUsage, and Query::utilityStmt.

Referenced by ExplainOneUtility(), and ExplainQuery().

369 {
370  /* planner will not cope with utility statements */
371  if (query->commandType == CMD_UTILITY)
372  {
373  ExplainOneUtility(query->utilityStmt, into, es, queryString, params,
374  queryEnv);
375  return;
376  }
377 
378  /* if an advisor plugin is present, let it manage things */
380  (*ExplainOneQuery_hook) (query, cursorOptions, into, es,
381  queryString, params, queryEnv);
382  else
383  {
384  PlannedStmt *plan;
385  instr_time planstart,
386  planduration;
387  BufferUsage bufusage_start,
388  bufusage;
389 
390  if (es->buffers)
391  bufusage_start = pgBufferUsage;
392  INSTR_TIME_SET_CURRENT(planstart);
393 
394  /* plan the query */
395  plan = pg_plan_query(query, queryString, cursorOptions, params);
396 
397  INSTR_TIME_SET_CURRENT(planduration);
398  INSTR_TIME_SUBTRACT(planduration, planstart);
399 
400  /* calc differences of buffer counters. */
401  if (es->buffers)
402  {
403  memset(&bufusage, 0, sizeof(BufferUsage));
404  BufferUsageAccumDiff(&bufusage, &pgBufferUsage, &bufusage_start);
405  }
406 
407  /* run it (if needed) and produce output */
408  ExplainOnePlan(plan, into, es, queryString, params, queryEnv,
409  &planduration, (es->buffers ? &bufusage : NULL));
410  }
411 }
struct timeval instr_time
Definition: instr_time.h:150
Node * utilityStmt
Definition: parsenodes.h:120
void BufferUsageAccumDiff(BufferUsage *dst, const BufferUsage *add, const BufferUsage *sub)
Definition: instrument.c:225
#define INSTR_TIME_SUBTRACT(x, y)
Definition: instr_time.h:170
ExplainOneQuery_hook_type ExplainOneQuery_hook
Definition: explain.c:44
CmdType commandType
Definition: parsenodes.h:112
void ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv, const instr_time *planduration, const BufferUsage *bufusage)
Definition: explain.c:500
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:156
PlannedStmt * pg_plan_query(Query *querytree, const char *query_string, int cursorOptions, ParamListInfo boundParams)
Definition: postgres.c:857
void ExplainOneUtility(Node *utilityStmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv)
Definition: explain.c:425
BufferUsage pgBufferUsage
Definition: instrument.c:20

◆ ExplainOneUtility()

void ExplainOneUtility ( Node utilityStmt,
IntoClause into,
ExplainState es,
const char *  queryString,
ParamListInfo  params,
QueryEnvironment queryEnv 
)

Definition at line 425 of file explain.c.

References appendStringInfoString(), Assert, castNode, copyObject, CURSOR_OPT_PARALLEL_OK, EXPLAIN_FORMAT_TEXT, ExplainDummyGroup(), ExplainExecuteQuery(), ExplainOneQuery(), ExplainState::format, CreateTableAsStmt::into, IsA, linitial_node, list_length(), DeclareCursorStmt::options, DeclareCursorStmt::query, CreateTableAsStmt::query, QueryRewrite(), and ExplainState::str.

Referenced by ExplainExecuteQuery(), and ExplainOneQuery().

428 {
429  if (utilityStmt == NULL)
430  return;
431 
432  if (IsA(utilityStmt, CreateTableAsStmt))
433  {
434  /*
435  * We have to rewrite the contained SELECT and then pass it back to
436  * ExplainOneQuery. It's probably not really necessary to copy the
437  * contained parsetree another time, but let's be safe.
438  */
439  CreateTableAsStmt *ctas = (CreateTableAsStmt *) utilityStmt;
440  List *rewritten;
441 
442  rewritten = QueryRewrite(castNode(Query, copyObject(ctas->query)));
443  Assert(list_length(rewritten) == 1);
444  ExplainOneQuery(linitial_node(Query, rewritten),
445  CURSOR_OPT_PARALLEL_OK, ctas->into, es,
446  queryString, params, queryEnv);
447  }
448  else if (IsA(utilityStmt, DeclareCursorStmt))
449  {
450  /*
451  * Likewise for DECLARE CURSOR.
452  *
453  * Notice that if you say EXPLAIN ANALYZE DECLARE CURSOR then we'll
454  * actually run the query. This is different from pre-8.3 behavior
455  * but seems more useful than not running the query. No cursor will
456  * be created, however.
457  */
458  DeclareCursorStmt *dcs = (DeclareCursorStmt *) utilityStmt;
459  List *rewritten;
460 
461  rewritten = QueryRewrite(castNode(Query, copyObject(dcs->query)));
462  Assert(list_length(rewritten) == 1);
463  ExplainOneQuery(linitial_node(Query, rewritten),
464  dcs->options, NULL, es,
465  queryString, params, queryEnv);
466  }
467  else if (IsA(utilityStmt, ExecuteStmt))
468  ExplainExecuteQuery((ExecuteStmt *) utilityStmt, into, es,
469  queryString, params, queryEnv);
470  else if (IsA(utilityStmt, NotifyStmt))
471  {
472  if (es->format == EXPLAIN_FORMAT_TEXT)
473  appendStringInfoString(es->str, "NOTIFY\n");
474  else
475  ExplainDummyGroup("Notify", NULL, es);
476  }
477  else
478  {
479  if (es->format == EXPLAIN_FORMAT_TEXT)
481  "Utility statements have no plan structure\n");
482  else
483  ExplainDummyGroup("Utility Statement", NULL, es);
484  }
485 }
#define IsA(nodeptr, _type_)
Definition: nodes.h:580
List * QueryRewrite(Query *parsetree)
#define castNode(_type_, nodeptr)
Definition: nodes.h:598
#define linitial_node(type, l)
Definition: pg_list.h:198
static void ExplainDummyGroup(const char *objtype, const char *labelname, ExplainState *es)
Definition: explain.c:4503
void ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv)
Definition: prepare.c:606
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
static void ExplainOneQuery(Query *query, int cursorOptions, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv)
Definition: explain.c:365
IntoClause * into
Definition: parsenodes.h:3277
#define Assert(condition)
Definition: c.h:745
static int list_length(const List *l)
Definition: pg_list.h:169
ExplainFormat format
Definition: explain.h:49
#define CURSOR_OPT_PARALLEL_OK
Definition: parsenodes.h:2715
#define copyObject(obj)
Definition: nodes.h:645
Definition: pg_list.h:50
StringInfo str
Definition: explain.h:39

◆ ExplainOpenGroup()

void ExplainOpenGroup ( const char *  objtype,
const char *  labelname,
bool  labeled,
ExplainState es 
)

Definition at line 4293 of file explain.c.

References appendStringInfo(), appendStringInfoChar(), appendStringInfoSpaces(), appendStringInfoString(), escape_json(), EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainJSONLineEnding(), ExplainXMLTag(), ExplainYAMLLineStarting(), ExplainState::format, ExplainState::grouping_stack, ExplainState::indent, lcons_int(), ExplainState::str, and X_OPENING.

Referenced by ExplainFlushWorkersState(), ExplainNode(), ExplainOnePlan(), ExplainPrintJIT(), ExplainPrintSettings(), ExplainPrintTriggers(), report_triggers(), show_grouping_set_keys(), show_grouping_sets(), show_incremental_sort_group_info(), and show_modifytable_info().

4295 {
4296  switch (es->format)
4297  {
4298  case EXPLAIN_FORMAT_TEXT:
4299  /* nothing to do */
4300  break;
4301 
4302  case EXPLAIN_FORMAT_XML:
4303  ExplainXMLTag(objtype, X_OPENING, es);
4304  es->indent++;
4305  break;
4306 
4307  case EXPLAIN_FORMAT_JSON:
4309  appendStringInfoSpaces(es->str, 2 * es->indent);
4310  if (labelname)
4311  {
4312  escape_json(es->str, labelname);
4313  appendStringInfoString(es->str, ": ");
4314  }
4315  appendStringInfoChar(es->str, labeled ? '{' : '[');
4316 
4317  /*
4318  * In JSON format, the grouping_stack is an integer list. 0 means
4319  * we've emitted nothing at this grouping level, 1 means we've
4320  * emitted something (and so the next item needs a comma). See
4321  * ExplainJSONLineEnding().
4322  */
4323  es->grouping_stack = lcons_int(0, es->grouping_stack);
4324  es->indent++;
4325  break;
4326 
4327  case EXPLAIN_FORMAT_YAML:
4328 
4329  /*
4330  * In YAML format, the grouping stack is an integer list. 0 means
4331  * we've emitted nothing at this grouping level AND this grouping
4332  * level is unlabeled and must be marked with "- ". See
4333  * ExplainYAMLLineStarting().
4334  */
4336  if (labelname)
4337  {
4338  appendStringInfo(es->str, "%s: ", labelname);
4339  es->grouping_stack = lcons_int(1, es->grouping_stack);
4340  }
4341  else
4342  {
4343  appendStringInfoString(es->str, "- ");
4344  es->grouping_stack = lcons_int(0, es->grouping_stack);
4345  }
4346  es->indent++;
4347  break;
4348  }
4349 }
void escape_json(StringInfo buf, const char *str)
Definition: json.c:1279
List * lcons_int(int datum, List *list)
Definition: list.c:471
static void ExplainXMLTag(const char *tagname, int flags, ExplainState *es)
Definition: explain.c:4638
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
static void ExplainYAMLLineStarting(ExplainState *es)
Definition: explain.c:4700
List * grouping_stack
Definition: explain.h:52
int indent
Definition: explain.h:51
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
void appendStringInfoSpaces(StringInfo str, int count)
Definition: stringinfo.c:206
static void ExplainJSONLineEnding(ExplainState *es)
Definition: explain.c:4680
#define X_OPENING
Definition: explain.c:51
ExplainFormat format
Definition: explain.h:49
StringInfo str
Definition: explain.h:39

◆ ExplainOpenSetAsideGroup()

static void ExplainOpenSetAsideGroup ( const char *  objtype,
const char *  labelname,
bool  labeled,
int  depth,
ExplainState es 
)
static

Definition at line 4403 of file explain.c.

References EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainState::format, ExplainState::grouping_stack, ExplainState::indent, and lcons_int().

Referenced by ExplainOpenWorker().

4405 {
4406  switch (es->format)
4407  {
4408  case EXPLAIN_FORMAT_TEXT:
4409  /* nothing to do */
4410  break;
4411 
4412  case EXPLAIN_FORMAT_XML:
4413  es->indent += depth;
4414  break;
4415 
4416  case EXPLAIN_FORMAT_JSON:
4417  es->grouping_stack = lcons_int(0, es->grouping_stack);
4418  es->indent += depth;
4419  break;
4420 
4421  case EXPLAIN_FORMAT_YAML:
4422  if (labelname)
4423  es->grouping_stack = lcons_int(1, es->grouping_stack);
4424  else
4425  es->grouping_stack = lcons_int(0, es->grouping_stack);
4426  es->indent += depth;
4427  break;
4428  }
4429 }
List * lcons_int(int datum, List *list)
Definition: list.c:471
List * grouping_stack
Definition: explain.h:52
int indent
Definition: explain.h:51
ExplainFormat format
Definition: explain.h:49

◆ ExplainOpenWorker()

static void ExplainOpenWorker ( int  n,
ExplainState es 
)
static

Definition at line 3924 of file explain.c.

References appendStringInfo(), Assert, EXPLAIN_FORMAT_TEXT, ExplainIndentText(), ExplainOpenSetAsideGroup(), ExplainPropertyInteger(), ExplainRestoreGroup(), ExplainState::format, ExplainState::indent, initStringInfo(), StringInfoData::len, ExplainWorkersState::prev_str, ExplainState::str, ExplainWorkersState::worker_inited, ExplainWorkersState::worker_state_save, ExplainWorkersState::worker_str, and ExplainState::workers_state.

Referenced by ExplainNode(), show_hashagg_info(), show_incremental_sort_info(), and show_sort_info().

3925 {
3926  ExplainWorkersState *wstate = es->workers_state;
3927 
3928  Assert(wstate);
3929  Assert(n >= 0 && n < wstate->num_workers);
3930 
3931  /* Save prior output buffer pointer */
3932  wstate->prev_str = es->str;
3933 
3934  if (!wstate->worker_inited[n])
3935  {
3936  /* First time through, so create the buffer for this worker */
3937  initStringInfo(&wstate->worker_str[n]);
3938  es->str = &wstate->worker_str[n];
3939 
3940  /*
3941  * Push suitable initial formatting state for this worker's field
3942  * group. We allow one extra logical nesting level, since this group
3943  * will eventually be wrapped in an outer "Workers" group.
3944  */
3945  ExplainOpenSetAsideGroup("Worker", NULL, true, 2, es);
3946 
3947  /*
3948  * In non-TEXT formats we always emit a "Worker Number" field, even if
3949  * there's no other data for this worker.
3950  */
3951  if (es->format != EXPLAIN_FORMAT_TEXT)
3952  ExplainPropertyInteger("Worker Number", NULL, n, es);
3953 
3954  wstate->worker_inited[n] = true;
3955  }
3956  else
3957  {
3958  /* Resuming output for a worker we've already emitted some data for */
3959  es->str = &wstate->worker_str[n];
3960 
3961  /* Restore formatting state saved by last ExplainCloseWorker() */
3962  ExplainRestoreGroup(es, 2, &wstate->worker_state_save[n]);
3963  }
3964 
3965  /*
3966  * In TEXT format, prefix the first output line for this worker with
3967  * "Worker N:". Then, any additional lines should be indented one more
3968  * stop than the "Worker N" line is.
3969  */
3970  if (es->format == EXPLAIN_FORMAT_TEXT)
3971  {
3972  if (es->str->len == 0)
3973  {
3974  ExplainIndentText(es);
3975  appendStringInfo(es->str, "Worker %d: ", n);
3976  }
3977 
3978  es->indent++;
3979  }
3980 }
int * worker_state_save
Definition: explain.h:33
void ExplainPropertyInteger(const char *qlabel, const char *unit, int64 value, ExplainState *es)
Definition: explain.c:4237
static void ExplainRestoreGroup(ExplainState *es, int depth, int *state_save)
Definition: explain.c:4472
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
StringInfoData * worker_str
Definition: explain.h:32
int indent
Definition: explain.h:51
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
bool * worker_inited
Definition: explain.h:31
static void ExplainIndentText(ExplainState *es)
Definition: explain.c:4665
#define Assert(condition)
Definition: c.h:745
ExplainWorkersState * workers_state
Definition: explain.h:61
ExplainFormat format
Definition: explain.h:49
StringInfo prev_str
Definition: explain.h:34
StringInfo str
Definition: explain.h:39
static void ExplainOpenSetAsideGroup(const char *objtype, const char *labelname, bool labeled, int depth, ExplainState *es)
Definition: explain.c:4403

◆ ExplainPreScanNode()

static bool ExplainPreScanNode ( PlanState planstate,
Bitmapset **  rels_used 
)
static

Definition at line 1047 of file explain.c.

References bms_add_member(), bms_add_members(), nodeTag, PlanState::plan, planstate_tree_walker(), T_Append, T_BitmapHeapScan, T_CteScan, T_CustomScan, T_ForeignScan, T_FunctionScan, T_IndexOnlyScan, T_IndexScan, T_MergeAppend, T_ModifyTable, T_NamedTuplestoreScan, T_SampleScan, T_SeqScan, T_SubqueryScan, T_TableFuncScan, T_TidScan, T_ValuesScan, and T_WorkTableScan.

Referenced by ExplainPrintPlan().

1048 {
1049  Plan *plan = planstate->plan;
1050 
1051  switch (nodeTag(plan))
1052  {
1053  case T_SeqScan:
1054  case T_SampleScan:
1055  case T_IndexScan:
1056  case T_IndexOnlyScan:
1057  case T_BitmapHeapScan:
1058  case T_TidScan:
1059  case T_SubqueryScan:
1060  case T_FunctionScan:
1061  case T_TableFuncScan:
1062  case T_ValuesScan:
1063  case T_CteScan:
1064  case T_NamedTuplestoreScan:
1065  case T_WorkTableScan:
1066  *rels_used = bms_add_member(*rels_used,
1067  ((Scan *) plan)->scanrelid);
1068  break;
1069  case T_ForeignScan:
1070  *rels_used = bms_add_members(*rels_used,
1071  ((ForeignScan *) plan)->fs_relids);
1072  break;
1073  case T_CustomScan:
1074  *rels_used = bms_add_members(*rels_used,
1075  ((CustomScan *) plan)->custom_relids);
1076  break;
1077  case T_ModifyTable:
1078  *rels_used = bms_add_member(*rels_used,
1079  ((ModifyTable *) plan)->nominalRelation);
1080  if (((ModifyTable *) plan)->exclRelRTI)
1081  *rels_used = bms_add_member(*rels_used,
1082  ((ModifyTable *) plan)->exclRelRTI);
1083  break;
1084  case T_Append:
1085  *rels_used = bms_add_members(*rels_used,
1086  ((Append *) plan)->apprelids);
1087  break;
1088  case T_MergeAppend:
1089  *rels_used = bms_add_members(*rels_used,
1090  ((MergeAppend *) plan)->apprelids);
1091  break;
1092  default:
1093  break;
1094  }
1095 
1096  return planstate_tree_walker(planstate, ExplainPreScanNode, rels_used);
1097 }
Definition: nodes.h:49
Plan * plan
Definition: execnodes.h:945
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:736
#define nodeTag(nodeptr)
Definition: nodes.h:534
static bool ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used)
Definition: explain.c:1047
bool planstate_tree_walker(PlanState *planstate, bool(*walker)(), void *context)
Definition: nodeFuncs.c:3882
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:793

◆ ExplainPrintJIT()

static void ExplainPrintJIT ( ExplainState es,
int  jit_flags,
JitInstrumentation ji 
)
static

Definition at line 852 of file explain.c.

References ExplainState::analyze, appendStringInfo(), appendStringInfoString(), JitInstrumentation::created_functions, JitInstrumentation::emission_counter, EXPLAIN_FORMAT_TEXT, ExplainCloseGroup(), ExplainIndentText(), ExplainOpenGroup(), ExplainPropertyBool(), ExplainPropertyFloat(), ExplainPropertyInteger(), ExplainState::format, JitInstrumentation::generation_counter, ExplainState::indent, JitInstrumentation::inlining_counter, INSTR_TIME_ADD, INSTR_TIME_GET_DOUBLE, INSTR_TIME_SET_ZERO, JitInstrumentation::optimization_counter, PGJIT_DEFORM, PGJIT_EXPR, PGJIT_INLINE, PGJIT_OPT3, ExplainState::str, and ExplainState::timing.

Referenced by ExplainNode(), and ExplainPrintJITSummary().

853 {
854  instr_time total_time;
855 
856  /* don't print information if no JITing happened */
857  if (!ji || ji->created_functions == 0)
858  return;
859 
860  /* calculate total time */
861  INSTR_TIME_SET_ZERO(total_time);
862  INSTR_TIME_ADD(total_time, ji->generation_counter);
863  INSTR_TIME_ADD(total_time, ji->inlining_counter);
864  INSTR_TIME_ADD(total_time, ji->optimization_counter);
865  INSTR_TIME_ADD(total_time, ji->emission_counter);
866 
867  ExplainOpenGroup("JIT", "JIT", true, es);
868 
869  /* for higher density, open code the text output format */
870  if (es->format == EXPLAIN_FORMAT_TEXT)
871  {
872  ExplainIndentText(es);
873  appendStringInfoString(es->str, "JIT:\n");
874  es->indent++;
875 
876  ExplainPropertyInteger("Functions", NULL, ji->created_functions, es);
877 
878  ExplainIndentText(es);
879  appendStringInfo(es->str, "Options: %s %s, %s %s, %s %s, %s %s\n",
880  "Inlining", jit_flags & PGJIT_INLINE ? "true" : "false",
881  "Optimization", jit_flags & PGJIT_OPT3 ? "true" : "false",
882  "Expressions", jit_flags & PGJIT_EXPR ? "true" : "false",
883  "Deforming", jit_flags & PGJIT_DEFORM ? "true" : "false");
884 
885  if (es->analyze && es->timing)
886  {
887  ExplainIndentText(es);
888  appendStringInfo(es->str,
889  "Timing: %s %.3f ms, %s %.3f ms, %s %.3f ms, %s %.3f ms, %s %.3f ms\n",
890  "Generation", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->generation_counter),
891  "Inlining", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->inlining_counter),
892  "Optimization", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->optimization_counter),
893  "Emission", 1000.0 * INSTR_TIME_GET_DOUBLE(ji->emission_counter),
894  "Total", 1000.0 * INSTR_TIME_GET_DOUBLE(total_time));
895  }
896 
897  es->indent--;
898  }
899  else
900  {
901  ExplainPropertyInteger("Functions", NULL, ji->created_functions, es);
902 
903  ExplainOpenGroup("Options", "Options", true, es);
904  ExplainPropertyBool("Inlining", jit_flags & PGJIT_INLINE, es);
905  ExplainPropertyBool("Optimization", jit_flags & PGJIT_OPT3, es);
906  ExplainPropertyBool("Expressions", jit_flags & PGJIT_EXPR, es);
907  ExplainPropertyBool("Deforming", jit_flags & PGJIT_DEFORM, es);
908  ExplainCloseGroup("Options", "Options", true, es);
909 
910  if (es->analyze && es->timing)
911  {
912  ExplainOpenGroup("Timing", "Timing", true, es);
913 
914  ExplainPropertyFloat("Generation", "ms",
916  3, es);
917  ExplainPropertyFloat("Inlining", "ms",
919  3, es);
920  ExplainPropertyFloat("Optimization", "ms",
922  3, es);
923  ExplainPropertyFloat("Emission", "ms",
925  3, es);
926  ExplainPropertyFloat("Total", "ms",
927  1000.0 * INSTR_TIME_GET_DOUBLE(total_time),
928  3, es);
929 
930  ExplainCloseGroup("Timing", "Timing", true, es);
931  }
932  }
933 
934  ExplainCloseGroup("JIT", "JIT", true, es);
935 }
void ExplainPropertyBool(const char *qlabel, bool value, ExplainState *es)
Definition: explain.c:4278
#define PGJIT_EXPR
Definition: jit.h:23
void ExplainPropertyInteger(const char *qlabel, const char *unit, int64 value, ExplainState *es)
Definition: explain.c:4237
instr_time generation_counter
Definition: jit.h:33
void ExplainPropertyFloat(const char *qlabel, const char *unit, double value, int ndigits, ExplainState *es)
Definition: explain.c:4264
struct timeval instr_time
Definition: instr_time.h:150
#define INSTR_TIME_SET_ZERO(t)
Definition: instr_time.h:154
#define INSTR_TIME_GET_DOUBLE(t)
Definition: instr_time.h:199
bool analyze
Definition: explain.h:42
#define PGJIT_OPT3
Definition: jit.h:21
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
size_t created_functions
Definition: jit.h:30
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
#define INSTR_TIME_ADD(x, y)
Definition: instr_time.h:158
instr_time optimization_counter
Definition: jit.h:39
int indent
Definition: explain.h:51
bool timing
Definition: explain.h:46
instr_time inlining_counter
Definition: jit.h:36
#define PGJIT_INLINE
Definition: jit.h:22
static void ExplainIndentText(ExplainState *es)
Definition: explain.c:4665
instr_time emission_counter
Definition: jit.h:42
ExplainFormat format
Definition: explain.h:49
void ExplainCloseGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4356
#define PGJIT_DEFORM
Definition: jit.h:24
void ExplainOpenGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4293
StringInfo str
Definition: explain.h:39

◆ ExplainPrintJITSummary()

void ExplainPrintJITSummary ( ExplainState es,
QueryDesc queryDesc 
)

Definition at line 826 of file explain.c.

References EState::es_jit, EState::es_jit_flags, EState::es_jit_worker_instr, QueryDesc::estate, ExplainPrintJIT(), JitContext::instr, InstrJitAgg(), and PGJIT_PERFORM.

Referenced by explain_ExecutorEnd(), and ExplainOnePlan().

827 {
828  JitInstrumentation ji = {0};
829 
830  if (!(queryDesc->estate->es_jit_flags & PGJIT_PERFORM))
831  return;
832 
833  /*
834  * Work with a copy instead of modifying the leader state, since this
835  * function may be called twice
836  */
837  if (queryDesc->estate->es_jit)
838  InstrJitAgg(&ji, &queryDesc->estate->es_jit->instr);
839 
840  /* If this process has done JIT in parallel workers, merge stats */
841  if (queryDesc->estate->es_jit_worker_instr)
842  InstrJitAgg(&ji, queryDesc->estate->es_jit_worker_instr);
843 
844  ExplainPrintJIT(es, queryDesc->estate->es_jit_flags, &ji);
845 }
EState * estate
Definition: execdesc.h:48
struct JitContext * es_jit
Definition: execnodes.h:601
struct JitInstrumentation * es_jit_worker_instr
Definition: execnodes.h:602
static void ExplainPrintJIT(ExplainState *es, int jit_flags, JitInstrumentation *ji)
Definition: explain.c:852
JitInstrumentation instr
Definition: jit.h:61
int es_jit_flags
Definition: execnodes.h:600
void InstrJitAgg(JitInstrumentation *dst, JitInstrumentation *add)
Definition: jit.c:184
#define PGJIT_PERFORM
Definition: jit.h:20

◆ ExplainPrintPlan()

void ExplainPrintPlan ( ExplainState es,
QueryDesc queryDesc 
)

Definition at line 731 of file explain.c.

References Assert, deparse_context_for_plan_tree(), ExplainState::deparse_cxt, ExplainNode(), ExplainPreScanNode(), ExplainPrintSettings(), ExplainState::hide_workers, IsA, NIL, outerPlanState, PlanState::plan, QueryDesc::plannedstmt, QueryDesc::planstate, ExplainState::printed_subplans, ExplainState::pstmt, ExplainState::rtable, PlannedStmt::rtable, ExplainState::rtable_names, and select_rtable_names_for_explain().

Referenced by explain_ExecutorEnd(), and ExplainOnePlan().

732 {
733  Bitmapset *rels_used = NULL;
734  PlanState *ps;
735 
736  /* Set up ExplainState fields associated with this plan tree */
737  Assert(queryDesc->plannedstmt != NULL);
738  es->pstmt = queryDesc->plannedstmt;
739  es->rtable = queryDesc->plannedstmt->rtable;
740  ExplainPreScanNode(queryDesc->planstate, &rels_used);
743  es->rtable_names);
744  es->printed_subplans = NULL;
745 
746  /*
747  * Sometimes we mark a Gather node as "invisible", which means that it's
748  * not to be displayed in EXPLAIN output. The purpose of this is to allow
749  * running regression tests with force_parallel_mode=regress to get the
750  * same results as running the same tests with force_parallel_mode=off.
751  * Such marking is currently only supported on a Gather at the top of the
752  * plan. We skip that node, and we must also hide per-worker detail data
753  * further down in the plan tree.
754  */
755  ps = queryDesc->planstate;
756  if (IsA(ps, GatherState) && ((Gather *) ps->plan)->invisible)
757  {
758  ps = outerPlanState(ps);
759  es->hide_workers = true;
760  }
761  ExplainNode(ps, NIL, NULL, NULL, es);
762 
763  /*
764  * If requested, include information about GUC parameters with values that
765  * don't match the built-in defaults.
766  */
768 }
#define NIL
Definition: pg_list.h:65
static void ExplainPrintSettings(ExplainState *es)
Definition: explain.c:661
#define IsA(nodeptr, _type_)
Definition: nodes.h:580
bool hide_workers
Definition: explain.h:59
Bitmapset * printed_subplans
Definition: explain.h:58
List * deparse_cxt
Definition: explain.h:57
PlannedStmt * pstmt
Definition: explain.h:54
List * rtable_names
Definition: explain.h:56
List * select_rtable_names_for_explain(List *rtable, Bitmapset *rels_used)
Definition: ruleutils.c:3420
static void ExplainNode(PlanState *planstate, List *ancestors, const char *relationship, const char *plan_name, ExplainState *es)
Definition: explain.c:1121
PlanState * planstate
Definition: execdesc.h:49
#define outerPlanState(node)
Definition: execnodes.h:1039
List * deparse_context_for_plan_tree(PlannedStmt *pstmt, List *rtable_names)
Definition: ruleutils.c:3328
Plan * plan
Definition: execnodes.h:945
#define Assert(condition)
Definition: c.h:745
List * rtable
Definition: plannodes.h:66
static bool ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used)
Definition: explain.c:1047
PlannedStmt * plannedstmt
Definition: execdesc.h:37
List * rtable
Definition: explain.h:55

◆ ExplainPrintSettings()

static void ExplainPrintSettings ( ExplainState es)
static

Definition at line 661 of file explain.c.

References appendStringInfo(), appendStringInfoString(), StringInfoData::data, EXPLAIN_FORMAT_TEXT, ExplainCloseGroup(), ExplainOpenGroup(), ExplainPropertyText(), ExplainState::format, get_explain_guc_options(), GetConfigOptionByName(), i, initStringInfo(), config_generic::name, ExplainState::settings, and generate_unaccent_rules::str.

Referenced by ExplainPrintPlan().

662 {
663  int num;
664  struct config_generic **gucs;
665 
666  /* bail out if information about settings not requested */
667  if (!es->settings)
668  return;
669 
670  /* request an array of relevant settings */
671  gucs = get_explain_guc_options(&num);
672 
673  if (es->format != EXPLAIN_FORMAT_TEXT)
674  {
675  ExplainOpenGroup("Settings", "Settings", true, es);
676 
677  for (int i = 0; i < num; i++)
678  {
679  char *setting;
680  struct config_generic *conf = gucs[i];
681 
682  setting = GetConfigOptionByName(conf->name, NULL, true);
683 
684  ExplainPropertyText(conf->name, setting, es);
685  }
686 
687  ExplainCloseGroup("Settings", "Settings", true, es);
688  }
689  else
690  {
692 
693  /* In TEXT mode, print nothing if there are no options */
694  if (num <= 0)
695  return;
696 
697  initStringInfo(&str);
698 
699  for (int i = 0; i < num; i++)
700  {
701  char *setting;
702  struct config_generic *conf = gucs[i];
703 
704  if (i > 0)
705  appendStringInfoString(&str, ", ");
706 
707  setting = GetConfigOptionByName(conf->name, NULL, true);
708 
709  if (setting)
710  appendStringInfo(&str, "%s = '%s'", conf->name, setting);
711  else
712  appendStringInfo(&str, "%s = NULL", conf->name);
713  }
714 
715  ExplainPropertyText("Settings", str.data, es);
716  }
717 }
const char * name
Definition: guc_tables.h:149
struct config_generic ** get_explain_guc_options(int *num)
Definition: guc.c:9107
void ExplainPropertyText(const char *qlabel, const char *value, ExplainState *es)
Definition: explain.c:4228
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
char * GetConfigOptionByName(const char *name, const char **varname, bool missing_ok)
Definition: guc.c:9200
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
ExplainFormat format
Definition: explain.h:49
int i
void ExplainCloseGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4356
void ExplainOpenGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4293
bool settings
Definition: explain.h:48

◆ ExplainPrintTriggers()

void ExplainPrintTriggers ( ExplainState es,
QueryDesc queryDesc 
)

Definition at line 780 of file explain.c.

References EState::es_num_result_relations, EState::es_num_root_result_relations, EState::es_result_relations, EState::es_root_result_relations, EState::es_trig_target_relations, EState::es_tuple_routing_result_relations, QueryDesc::estate, ExplainCloseGroup(), ExplainOpenGroup(), lfirst, NIL, and report_triggers().

Referenced by explain_ExecutorEnd(), and ExplainOnePlan().

781 {
782  ResultRelInfo *rInfo;
783  bool show_relname;
784  int numrels = queryDesc->estate->es_num_result_relations;
785  int numrootrels = queryDesc->estate->es_num_root_result_relations;
786  List *routerels;
787  List *targrels;
788  int nr;
789  ListCell *l;
790 
791  routerels = queryDesc->estate->es_tuple_routing_result_relations;
792  targrels = queryDesc->estate->es_trig_target_relations;
793 
794  ExplainOpenGroup("Triggers", "Triggers", false, es);
795 
796  show_relname = (numrels > 1 || numrootrels > 0 ||
797  routerels != NIL || targrels != NIL);
798  rInfo = queryDesc->estate->es_result_relations;
799  for (nr = 0; nr < numrels; rInfo++, nr++)
800  report_triggers(rInfo, show_relname, es);
801 
802  rInfo = queryDesc->estate->es_root_result_relations;
803  for (nr = 0; nr < numrootrels; rInfo++, nr++)
804  report_triggers(rInfo, show_relname, es);
805 
806  foreach(l, routerels)
807  {
808  rInfo = (ResultRelInfo *) lfirst(l);
809  report_triggers(rInfo, show_relname, es);
810  }
811 
812  foreach(l, targrels)
813  {
814  rInfo = (ResultRelInfo *) lfirst(l);
815  report_triggers(rInfo, show_relname, es);
816  }
817 
818  ExplainCloseGroup("Triggers", "Triggers", false, es);
819 }
#define NIL
Definition: pg_list.h:65
EState * estate
Definition: execdesc.h:48
ResultRelInfo * es_result_relations
Definition: execnodes.h:525
static void report_triggers(ResultRelInfo *rInfo, bool show_relname, ExplainState *es)
Definition: explain.c:957
int es_num_root_result_relations
Definition: execnodes.h:536
List * es_trig_target_relations
Definition: execnodes.h:546
int es_num_result_relations
Definition: execnodes.h:526
List * es_tuple_routing_result_relations
Definition: execnodes.h:543
#define lfirst(lc)
Definition: pg_list.h:190
ResultRelInfo * es_root_result_relations
Definition: execnodes.h:535
void ExplainCloseGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4356
void ExplainOpenGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4293
Definition: pg_list.h:50

◆ ExplainProperty()

static void ExplainProperty ( const char *  qlabel,
const char *  unit,
const char *  value,
bool  numeric,
ExplainState es 
)
static

Definition at line 4175 of file explain.c.

References appendStringInfo(), appendStringInfoChar(), appendStringInfoSpaces(), appendStringInfoString(), escape_json(), escape_xml(), escape_yaml(), EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainIndentText(), ExplainJSONLineEnding(), ExplainXMLTag(), ExplainYAMLLineStarting(), ExplainState::format, ExplainState::indent, pfree(), ExplainState::str, generate_unaccent_rules::str, X_CLOSING, X_NOWHITESPACE, and X_OPENING.

Referenced by ExplainPropertyBool(), ExplainPropertyFloat(), ExplainPropertyInteger(), ExplainPropertyText(), and ExplainPropertyUInteger().

4177 {
4178  switch (es->format)
4179  {
4180  case EXPLAIN_FORMAT_TEXT:
4181  ExplainIndentText(es);
4182  if (unit)
4183  appendStringInfo(es->str, "%s: %s %s\n", qlabel, value, unit);
4184  else
4185  appendStringInfo(es->str, "%s: %s\n", qlabel, value);
4186  break;
4187 
4188  case EXPLAIN_FORMAT_XML:
4189  {
4190  char *str;
4191 
4192  appendStringInfoSpaces(es->str, es->indent * 2);
4193  ExplainXMLTag(qlabel, X_OPENING | X_NOWHITESPACE, es);
4194  str = escape_xml(value);
4195  appendStringInfoString(es->str, str);
4196  pfree(str);
4197  ExplainXMLTag(qlabel, X_CLOSING | X_NOWHITESPACE, es);
4198  appendStringInfoChar(es->str, '\n');
4199  }
4200  break;
4201 
4202  case EXPLAIN_FORMAT_JSON:
4204  appendStringInfoSpaces(es->str, es->indent * 2);
4205  escape_json(es->str, qlabel);
4206  appendStringInfoString(es->str, ": ");
4207  if (numeric)
4209  else
4210  escape_json(es->str, value);
4211  break;
4212 
4213  case EXPLAIN_FORMAT_YAML:
4215  appendStringInfo(es->str, "%s: ", qlabel);
4216  if (numeric)
4218  else
4219  escape_yaml(es->str, value);
4220  break;
4221  }
4222 }
void escape_json(StringInfo buf, const char *str)
Definition: json.c:1279
static void ExplainXMLTag(const char *tagname, int flags, ExplainState *es)
Definition: explain.c:4638
#define X_CLOSING
Definition: explain.c:52
void pfree(void *pointer)
Definition: mcxt.c:1056
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
static void ExplainYAMLLineStarting(ExplainState *es)
Definition: explain.c:4700
int indent
Definition: explain.h:51
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
static void escape_yaml(StringInfo buf, const char *str)
Definition: explain.c:4725
void appendStringInfoSpaces(StringInfo str, int count)
Definition: stringinfo.c:206
static void ExplainJSONLineEnding(ExplainState *es)
Definition: explain.c:4680
static struct @143 value
#define X_OPENING
Definition: explain.c:51
static void ExplainIndentText(ExplainState *es)
Definition: explain.c:4665
#define X_NOWHITESPACE
Definition: explain.c:54
ExplainFormat format
Definition: explain.h:49
char * escape_xml(const char *str)
Definition: xml.c:2353
StringInfo str
Definition: explain.h:39

◆ ExplainPropertyBool()

void ExplainPropertyBool ( const char *  qlabel,
bool  value,
ExplainState es 
)

Definition at line 4278 of file explain.c.

References ExplainProperty().

Referenced by ExplainNode(), and ExplainPrintJIT().

4279 {
4280  ExplainProperty(qlabel, NULL, value ? "true" : "false", true, es);
4281 }
static struct @143 value
static void ExplainProperty(const char *qlabel, const char *unit, const char *value, bool numeric, ExplainState *es)
Definition: explain.c:4175

◆ ExplainPropertyFloat()

void ExplainPropertyFloat ( const char *  qlabel,
const char *  unit,
double  value,
int  ndigits,
ExplainState es 
)

Definition at line 4264 of file explain.c.

References buf, ExplainProperty(), pfree(), and psprintf().

Referenced by ExplainNode(), ExplainOnePlan(), ExplainPrintJIT(), report_triggers(), show_buffer_usage(), show_instrumentation_count(), and show_modifytable_info().

4266 {
4267  char *buf;
4268 
4269  buf = psprintf("%.*f", ndigits, value);
4270  ExplainProperty(qlabel, unit, buf, true, es);
4271  pfree(buf);
4272 }
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
void pfree(void *pointer)
Definition: mcxt.c:1056
static char * buf
Definition: pg_test_fsync.c:67
static struct @143 value
static void ExplainProperty(const char *qlabel, const char *unit, const char *value, bool numeric, ExplainState *es)
Definition: explain.c:4175

◆ ExplainPropertyInteger()

void ExplainPropertyInteger ( const char *  qlabel,
const char *  unit,
int64  value,
ExplainState es 
)

Definition at line 4237 of file explain.c.

References buf, ExplainProperty(), INT64_FORMAT, and snprintf.

Referenced by ExplainMissingMembers(), ExplainNode(), ExplainOpenWorker(), ExplainPrintJIT(), fileExplainForeignScan(), show_buffer_usage(), show_hash_info(), show_hashagg_info(), show_incremental_sort_group_info(), show_sort_info(), show_tidbitmap_info(), and show_wal_usage().

4239 {
4240  char buf[32];
4241 
4242  snprintf(buf, sizeof(buf), INT64_FORMAT, value);
4243  ExplainProperty(qlabel, unit, buf, true, es);
4244 }
static char * buf
Definition: pg_test_fsync.c:67
static struct @143 value
#define INT64_FORMAT
Definition: c.h:416
#define snprintf
Definition: port.h:193
static void ExplainProperty(const char *qlabel, const char *unit, const char *value, bool numeric, ExplainState *es)
Definition: explain.c:4175

◆ ExplainPropertyList()

void ExplainPropertyList ( const char *  qlabel,
List data,
ExplainState es 
)

Definition at line 4052 of file explain.c.

References appendStringInfo(), appendStringInfoChar(), appendStringInfoSpaces(), appendStringInfoString(), escape_json(), escape_xml(), escape_yaml(), EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainIndentText(), ExplainJSONLineEnding(), ExplainXMLTag(), ExplainYAMLLineStarting(), ExplainState::format, ExplainState::indent, lfirst, pfree(), ExplainState::str, generate_unaccent_rules::str, X_CLOSING, and X_OPENING.

Referenced by ExplainPropertyListNested(), show_eval_params(), show_incremental_sort_group_info(), show_modifytable_info(), show_plan_tlist(), show_sort_group_keys(), and show_tablesample().

4053 {
4054  ListCell *lc;
4055  bool first = true;
4056 
4057  switch (es->format)
4058  {
4059  case EXPLAIN_FORMAT_TEXT:
4060  ExplainIndentText(es);
4061  appendStringInfo(es->str, "%s: ", qlabel);
4062  foreach(lc, data)
4063  {
4064  if (!first)
4065  appendStringInfoString(es->str, ", ");
4066  appendStringInfoString(es->str, (const char *) lfirst(lc));
4067  first = false;
4068  }
4069  appendStringInfoChar(es->str, '\n');
4070  break;
4071 
4072  case EXPLAIN_FORMAT_XML:
4073  ExplainXMLTag(qlabel, X_OPENING, es);
4074  foreach(lc, data)
4075  {
4076  char *str;
4077 
4078  appendStringInfoSpaces(es->str, es->indent * 2 + 2);
4079  appendStringInfoString(es->str, "<Item>");
4080  str = escape_xml((const char *) lfirst(lc));
4081  appendStringInfoString(es->str, str);
4082  pfree(str);
4083  appendStringInfoString(es->str, "</Item>\n");
4084  }
4085  ExplainXMLTag(qlabel, X_CLOSING, es);
4086  break;
4087 
4088  case EXPLAIN_FORMAT_JSON:
4090  appendStringInfoSpaces(es->str, es->indent * 2);
4091  escape_json(es->str, qlabel);
4092  appendStringInfoString(es->str, ": [");
4093  foreach(lc, data)
4094  {
4095  if (!first)
4096  appendStringInfoString(es->str, ", ");
4097  escape_json(es->str, (const char *) lfirst(lc));
4098  first = false;
4099  }
4100  appendStringInfoChar(es->str, ']');
4101  break;
4102 
4103  case EXPLAIN_FORMAT_YAML:
4105  appendStringInfo(es->str, "%s: ", qlabel);
4106  foreach(lc, data)
4107  {
4108  appendStringInfoChar(es->str, '\n');
4109  appendStringInfoSpaces(es->str, es->indent * 2 + 2);
4110  appendStringInfoString(es->str, "- ");
4111  escape_yaml(es->str, (const char *) lfirst(lc));
4112  }
4113  break;
4114  }
4115 }
void escape_json(StringInfo buf, const char *str)
Definition: json.c:1279
static void ExplainXMLTag(const char *tagname, int flags, ExplainState *es)
Definition: explain.c:4638
#define X_CLOSING
Definition: explain.c:52
void pfree(void *pointer)
Definition: mcxt.c:1056
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
static void ExplainYAMLLineStarting(ExplainState *es)
Definition: explain.c:4700
int indent
Definition: explain.h:51
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
static void escape_yaml(StringInfo buf, const char *str)
Definition: explain.c:4725
void appendStringInfoSpaces(StringInfo str, int count)
Definition: stringinfo.c:206
static void ExplainJSONLineEnding(ExplainState *es)
Definition: explain.c:4680
#define X_OPENING
Definition: explain.c:51
static void ExplainIndentText(ExplainState *es)
Definition: explain.c:4665
#define lfirst(lc)
Definition: pg_list.h:190
ExplainFormat format
Definition: explain.h:49
char * escape_xml(const char *str)
Definition: xml.c:2353
StringInfo str
Definition: explain.h:39

◆ ExplainPropertyListNested()

void ExplainPropertyListNested ( const char *  qlabel,
List data,
ExplainState es 
)

Definition at line 4122 of file explain.c.

References appendStringInfoChar(), appendStringInfoSpaces(), appendStringInfoString(), escape_json(), escape_yaml(), EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainJSONLineEnding(), ExplainPropertyList(), ExplainYAMLLineStarting(), ExplainState::format, ExplainState::indent, lfirst, and ExplainState::str.

Referenced by show_grouping_set_keys().

4123 {
4124  ListCell *lc;
4125  bool first = true;
4126 
4127  switch (es->format)
4128  {
4129  case EXPLAIN_FORMAT_TEXT:
4130  case EXPLAIN_FORMAT_XML:
4131  ExplainPropertyList(qlabel, data, es);
4132  return;
4133 
4134  case EXPLAIN_FORMAT_JSON:
4136  appendStringInfoSpaces(es->str, es->indent * 2);
4137  appendStringInfoChar(es->str, '[');
4138  foreach(lc, data)
4139  {
4140  if (!first)
4141  appendStringInfoString(es->str, ", ");
4142  escape_json(es->str, (const char *) lfirst(lc));
4143  first = false;
4144  }
4145  appendStringInfoChar(es->str, ']');
4146  break;
4147 
4148  case EXPLAIN_FORMAT_YAML:
4150  appendStringInfoString(es->str, "- [");
4151  foreach(lc, data)
4152  {
4153  if (!first)
4154  appendStringInfoString(es->str, ", ");
4155  escape_yaml(es->str, (const char *) lfirst(lc));
4156  first = false;
4157  }
4158  appendStringInfoChar(es->str, ']');
4159  break;
4160  }
4161 }
void escape_json(StringInfo buf, const char *str)
Definition: json.c:1279
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
static void ExplainYAMLLineStarting(ExplainState *es)
Definition: explain.c:4700
int indent
Definition: explain.h:51
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
static void escape_yaml(StringInfo buf, const char *str)
Definition: explain.c:4725
void appendStringInfoSpaces(StringInfo str, int count)
Definition: stringinfo.c:206
static void ExplainJSONLineEnding(ExplainState *es)
Definition: explain.c:4680
void ExplainPropertyList(const char *qlabel, List *data, ExplainState *es)
Definition: explain.c:4052
#define lfirst(lc)
Definition: pg_list.h:190
ExplainFormat format
Definition: explain.h:49
StringInfo str
Definition: explain.h:39

◆ ExplainPropertyText()

void ExplainPropertyText ( const char *  qlabel,
const char *  value,
ExplainState es 
)

Definition at line 4228 of file explain.c.

References ExplainProperty().

Referenced by ExplainIndexScanDetails(), ExplainNode(), ExplainPrintSettings(), ExplainQueryText(), ExplainTargetRel(), fileExplainForeignScan(), postgresExplainDirectModify(), postgresExplainForeignModify(), postgresExplainForeignScan(), report_triggers(), show_expression(), show_grouping_set_keys(), show_modifytable_info(), show_sort_info(), and show_tablesample().

4229 {
4230  ExplainProperty(qlabel, NULL, value, false, es);
4231 }
static struct @143 value
static void ExplainProperty(const char *qlabel, const char *unit, const char *value, bool numeric, ExplainState *es)
Definition: explain.c:4175

◆ ExplainPropertyUInteger()

void ExplainPropertyUInteger ( const char *  qlabel,
const char *  unit,
uint64  value,
ExplainState es 
)

Definition at line 4250 of file explain.c.

References buf, ExplainProperty(), snprintf, and UINT64_FORMAT.

Referenced by show_wal_usage().

4252 {
4253  char buf[32];
4254 
4255  snprintf(buf, sizeof(buf), UINT64_FORMAT, value);
4256  ExplainProperty(qlabel, unit, buf, true, es);
4257 }
static char * buf
Definition: pg_test_fsync.c:67
static struct @143 value
#define snprintf
Definition: port.h:193
static void ExplainProperty(const char *qlabel, const char *unit, const char *value, bool numeric, ExplainState *es)
Definition: explain.c:4175
#define UINT64_FORMAT
Definition: c.h:417

◆ ExplainQuery()

void ExplainQuery ( ParseState pstate,
ExplainStmt stmt,
ParamListInfo  params,
DestReceiver dest 
)

Definition at line 160 of file explain.c.

References ExplainState::analyze, appendStringInfoString(), Assert, begin_tup_output_tupdesc(), ExplainState::buffers, castNode, copyObject, ExplainState::costs, CURSOR_OPT_PARALLEL_OK, StringInfoData::data, defGetBoolean(), defGetString(), DefElem::defname, do_text_output_multiline(), do_text_output_oneline, end_tup_output(), ereport, errcode(), errmsg(), ERROR, EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainBeginOutput(), ExplainEndOutput(), ExplainOneQuery(), ExplainResultDesc(), ExplainSeparatePlans(), ExplainState::format, ExplainState::indent, lfirst, lfirst_node, lnext(), DefElem::location, NewExplainState(), NIL, ExplainStmt::options, ParseState::p_queryEnv, ParseState::p_sourcetext, parser_errposition(), pfree(), ExplainStmt::query, QueryRewrite(), ExplainState::settings, ExplainState::str, ExplainState::summary, ExplainState::timing, TTSOpsVirtual, ExplainState::verbose, and ExplainState::wal.

Referenced by standard_ProcessUtility().

162 {
164  TupOutputState *tstate;
165  List *rewritten;
166  ListCell *lc;
167  bool timing_set = false;
168  bool summary_set = false;
169 
170  /* Parse options list. */
171  foreach(lc, stmt->options)
172  {
173  DefElem *opt = (DefElem *) lfirst(lc);
174 
175  if (strcmp(opt->defname, "analyze") == 0)
176  es->analyze = defGetBoolean(opt);
177  else if (strcmp(opt->defname, "verbose") == 0)
178  es->verbose = defGetBoolean(opt);
179  else if (strcmp(opt->defname, "costs") == 0)
180  es->costs = defGetBoolean(opt);
181  else if (strcmp(opt->defname, "buffers") == 0)
182  es->buffers = defGetBoolean(opt);
183  else if (strcmp(opt->defname, "wal") == 0)
184  es->wal = defGetBoolean(opt);
185  else if (strcmp(opt->defname, "settings") == 0)
186  es->settings = defGetBoolean(opt);
187  else if (strcmp(opt->defname, "timing") == 0)
188  {
189  timing_set = true;
190  es->timing = defGetBoolean(opt);
191  }
192  else if (strcmp(opt->defname, "summary") == 0)
193  {
194  summary_set = true;
195  es->summary = defGetBoolean(opt);
196  }
197  else if (strcmp(opt->defname, "format") == 0)
198  {
199  char *p = defGetString(opt);
200 
201  if (strcmp(p, "text") == 0)
203  else if (strcmp(p, "xml") == 0)
205  else if (strcmp(p, "json") == 0)
207  else if (strcmp(p, "yaml") == 0)
209  else
210  ereport(ERROR,
211  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
212  errmsg("unrecognized value for EXPLAIN option \"%s\": \"%s\"",
213  opt->defname, p),
214  parser_errposition(pstate, opt->location)));
215  }
216  else
217  ereport(ERROR,
218  (errcode(ERRCODE_SYNTAX_ERROR),
219  errmsg("unrecognized EXPLAIN option \"%s\"",
220  opt->defname),
221  parser_errposition(pstate, opt->location)));
222  }
223 
224  if (es->buffers && !es->analyze)
225  ereport(ERROR,
226  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
227  errmsg("EXPLAIN option BUFFERS requires ANALYZE")));
228 
229  if (es->wal && !es->analyze)
230  ereport(ERROR,
231  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
232  errmsg("EXPLAIN option WAL requires ANALYZE")));
233 
234  /* if the timing was not set explicitly, set default value */
235  es->timing = (timing_set) ? es->timing : es->analyze;
236 
237  /* check that timing is used with EXPLAIN ANALYZE */
238  if (es->timing && !es->analyze)
239  ereport(ERROR,
240  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
241  errmsg("EXPLAIN option TIMING requires ANALYZE")));
242 
243  /* if the summary was not set explicitly, set default value */
244  es->summary = (summary_set) ? es->summary : es->analyze;
245 
246  /*
247  * Parse analysis was done already, but we still have to run the rule
248  * rewriter. We do not do AcquireRewriteLocks: we assume the query either
249  * came straight from the parser, or suitable locks were acquired by
250  * plancache.c.
251  *
252  * Because the rewriter and planner tend to scribble on the input, we make
253  * a preliminary copy of the source querytree. This prevents problems in
254  * the case that the EXPLAIN is in a portal or plpgsql function and is
255  * executed repeatedly. (See also the same hack in DECLARE CURSOR and
256  * PREPARE.) XXX FIXME someday.
257  */
258  rewritten = QueryRewrite(castNode(Query, copyObject(stmt->query)));
259 
260  /* emit opening boilerplate */
261  ExplainBeginOutput(es);
262 
263  if (rewritten == NIL)
264  {
265  /*
266  * In the case of an INSTEAD NOTHING, tell at least that. But in
267  * non-text format, the output is delimited, so this isn't necessary.
268  */
269  if (es->format == EXPLAIN_FORMAT_TEXT)
270  appendStringInfoString(es->str, "Query rewrites to nothing\n");
271  }
272  else
273  {
274  ListCell *l;
275 
276  /* Explain every plan */
277  foreach(l, rewritten)
278  {
280  CURSOR_OPT_PARALLEL_OK, NULL, es,
281  pstate->p_sourcetext, params, pstate->p_queryEnv);
282 
283  /* Separate plans with an appropriate separator */
284  if (lnext(rewritten, l) != NULL)
286  }
287  }
288 
289  /* emit closing boilerplate */
290  ExplainEndOutput(es);
291  Assert(es->indent == 0);
292 
293  /* output tuples */
294  tstate = begin_tup_output_tupdesc(dest, ExplainResultDesc(stmt),
295  &TTSOpsVirtual);
296  if (es->format == EXPLAIN_FORMAT_TEXT)
297  do_text_output_multiline(tstate, es->str->data);
298  else
299  do_text_output_oneline(tstate, es->str->data);
300  end_tup_output(tstate);
301 
302  pfree(es->str->data);
303 }
#define NIL
Definition: pg_list.h:65
bool summary
Definition: explain.h:47
ExplainState * NewExplainState(void)
Definition: explain.c:309
List * QueryRewrite(Query *parsetree)
void ExplainSeparatePlans(ExplainState *es)
Definition: explain.c:4609
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:321
#define castNode(_type_, nodeptr)
Definition: nodes.h:598
QueryEnvironment * p_queryEnv
Definition: parse_node.h:203
const TupleTableSlotOps TTSOpsVirtual
Definition: execTuples.c:83
int errcode(int sqlerrcode)
Definition: elog.c:610
List * options
Definition: parsenodes.h:3257
bool costs
Definition: explain.h:43
bool analyze
Definition: explain.h:42
Node * query
Definition: parsenodes.h:3256
void ExplainEndOutput(ExplainState *es)
Definition: explain.c:4580
bool defGetBoolean(DefElem *def)
Definition: define.c:111
void pfree(void *pointer)
Definition: mcxt.c:1056
void end_tup_output(TupOutputState *tstate)
Definition: execTuples.c:2314
void ExplainBeginOutput(ExplainState *es)
Definition: explain.c:4549
#define ERROR
Definition: elog.h:43
TupleDesc ExplainResultDesc(ExplainStmt *stmt)
Definition: explain.c:326
char * defGetString(DefElem *def)
Definition: define.c:49
TupOutputState * begin_tup_output_tupdesc(DestReceiver *dest, TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:2236
#define lfirst_node(type, lc)
Definition: pg_list.h:193
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
int location
Definition: parsenodes.h:735
int indent
Definition: explain.h:51
const char * p_sourcetext
Definition: parse_node.h:179
bool timing
Definition: explain.h:46
static void ExplainOneQuery(Query *query, int cursorOptions, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv)
Definition: explain.c:365
void do_text_output_multiline(TupOutputState *tstate, const char *txt)
Definition: execTuples.c:2284
bool verbose
Definition: explain.h:41
#define ereport(elevel,...)
Definition: elog.h:144
#define Assert(condition)
Definition: c.h:745
#define lfirst(lc)
Definition: pg_list.h:190
bool wal
Definition: explain.h:45
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:110
ExplainFormat format
Definition: explain.h:49
#define do_text_output_oneline(tstate, str_to_emit)
Definition: executor.h:479
#define CURSOR_OPT_PARALLEL_OK
Definition: parsenodes.h:2715
int errmsg(const char *fmt,...)
Definition: elog.c:824
bool buffers
Definition: explain.h:44
char * defname
Definition: parsenodes.h:732
#define copyObject(obj)
Definition: nodes.h:645
Definition: pg_list.h:50
StringInfo str
Definition: explain.h:39
bool settings
Definition: explain.h:48

◆ ExplainQueryText()

void ExplainQueryText ( ExplainState es,
QueryDesc queryDesc 
)

Definition at line 946 of file explain.c.

References ExplainPropertyText(), and QueryDesc::sourceText.

Referenced by explain_ExecutorEnd().

947 {
948  if (queryDesc->sourceText)
949  ExplainPropertyText("Query Text", queryDesc->sourceText, es);
950 }
void ExplainPropertyText(const char *qlabel, const char *value, ExplainState *es)
Definition: explain.c:4228
const char * sourceText
Definition: execdesc.h:38

◆ ExplainRestoreGroup()

static void ExplainRestoreGroup ( ExplainState es,
int  depth,
int *  state_save 
)
static

Definition at line 4472 of file explain.c.

References EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainState::format, ExplainState::grouping_stack, ExplainState::indent, and lcons_int().

Referenced by ExplainOpenWorker().

4473 {
4474  switch (es->format)
4475  {
4476  case EXPLAIN_FORMAT_TEXT:
4477  /* nothing to do */
4478  break;
4479 
4480  case EXPLAIN_FORMAT_XML:
4481  es->indent += depth;
4482  break;
4483 
4484  case EXPLAIN_FORMAT_JSON:
4485  es->grouping_stack = lcons_int(*state_save, es->grouping_stack);
4486  es->indent += depth;
4487  break;
4488 
4489  case EXPLAIN_FORMAT_YAML:
4490  es->grouping_stack = lcons_int(*state_save, es->grouping_stack);
4491  es->indent += depth;
4492  break;
4493  }
4494 }
List * lcons_int(int datum, List *list)
Definition: list.c:471
List * grouping_stack
Definition: explain.h:52
int indent
Definition: explain.h:51
ExplainFormat format
Definition: explain.h:49

◆ ExplainResultDesc()

TupleDesc ExplainResultDesc ( ExplainStmt stmt)

Definition at line 326 of file explain.c.

References CreateTemplateTupleDesc(), defGetString(), DefElem::defname, lfirst, ExplainStmt::options, and TupleDescInitEntry().

Referenced by ExplainQuery(), and UtilityTupleDescriptor().

327 {
328  TupleDesc tupdesc;
329  ListCell *lc;
330  Oid result_type = TEXTOID;
331 
332  /* Check for XML format option */
333  foreach(lc, stmt->options)
334  {
335  DefElem *opt = (DefElem *) lfirst(lc);
336 
337  if (strcmp(opt->defname, "format") == 0)
338  {
339  char *p = defGetString(opt);
340 
341  if (strcmp(p, "xml") == 0)
342  result_type = XMLOID;
343  else if (strcmp(p, "json") == 0)
344  result_type = JSONOID;
345  else
346  result_type = TEXTOID;
347  /* don't "break", as ExplainQuery will use the last value */
348  }
349  }
350 
351  /* Need a tuple descriptor representing a single TEXT or XML column */
352  tupdesc = CreateTemplateTupleDesc(1);
353  TupleDescInitEntry(tupdesc, (AttrNumber) 1, "QUERY PLAN",
354  result_type, -1, 0);
355  return tupdesc;
356 }
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:44
List * options
Definition: parsenodes.h:3257
unsigned int Oid
Definition: postgres_ext.h:31
char * defGetString(DefElem *def)
Definition: define.c:49
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:603
#define lfirst(lc)
Definition: pg_list.h:190
char * defname
Definition: parsenodes.h:732
int16 AttrNumber
Definition: attnum.h:21

◆ ExplainSaveGroup()

static void ExplainSaveGroup ( ExplainState es,
int  depth,
int *  state_save 
)
static

Definition at line 4442 of file explain.c.

References EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainState::format, ExplainState::grouping_stack, ExplainState::indent, linitial_int, and list_delete_first().

Referenced by ExplainCloseWorker().

4443 {
4444  switch (es->format)
4445  {
4446  case EXPLAIN_FORMAT_TEXT:
4447  /* nothing to do */
4448  break;
4449 
4450  case EXPLAIN_FORMAT_XML:
4451  es->indent -= depth;
4452  break;
4453 
4454  case EXPLAIN_FORMAT_JSON:
4455  es->indent -= depth;
4456  *state_save = linitial_int(es->grouping_stack);
4458  break;
4459 
4460  case EXPLAIN_FORMAT_YAML:
4461  es->indent -= depth;
4462  *state_save = linitial_int(es->grouping_stack);
4464  break;
4465  }
4466 }
#define linitial_int(l)
Definition: pg_list.h:196
List * grouping_stack
Definition: explain.h:52
int indent
Definition: explain.h:51
ExplainFormat format
Definition: explain.h:49
List * list_delete_first(List *list)
Definition: list.c:860

◆ ExplainScanTarget()

static void ExplainScanTarget ( Scan plan,
ExplainState es 
)
static

Definition at line 3505 of file explain.c.

References ExplainTargetRel().

Referenced by ExplainNode().

3506 {
3507  ExplainTargetRel((Plan *) plan, plan->scanrelid, es);
3508 }
static void ExplainTargetRel(Plan *plan, Index rti, ExplainState *es)
Definition: explain.c:3527

◆ ExplainSeparatePlans()

void ExplainSeparatePlans ( ExplainState es)

Definition at line 4609 of file explain.c.

References appendStringInfoChar(), EXPLAIN_FORMAT_JSON, EXPLAIN_FORMAT_TEXT, EXPLAIN_FORMAT_XML, EXPLAIN_FORMAT_YAML, ExplainState::format, and ExplainState::str.

Referenced by ExplainExecuteQuery(), and ExplainQuery().

4610 {
4611  switch (es->format)
4612  {
4613  case EXPLAIN_FORMAT_TEXT:
4614  /* add a blank line */
4615  appendStringInfoChar(es->str, '\n');
4616  break;
4617 
4618  case EXPLAIN_FORMAT_XML:
4619  case EXPLAIN_FORMAT_JSON:
4620  case EXPLAIN_FORMAT_YAML:
4621  /* nothing to do */
4622  break;
4623  }
4624 }
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
ExplainFormat format
Definition: explain.h:49
StringInfo str
Definition: explain.h:39

◆ ExplainSubPlans()

static void ExplainSubPlans ( List plans,
List ancestors,
const char *  relationship,
ExplainState es 
)
static

Definition at line 3842 of file explain.c.

References bms_add_member(), bms_is_member(), ExplainNode(), lcons(), lfirst, list_delete_first(), SubPlan::plan_id, SubPlan::plan_name, SubPlanState::planstate, ExplainState::printed_subplans, and SubPlanState::subplan.

Referenced by ExplainNode().

3844 {
3845  ListCell *lst;
3846 
3847  foreach(lst, plans)
3848  {
3849  SubPlanState *sps = (SubPlanState *) lfirst(lst);
3850  SubPlan *sp = sps->subplan;
3851 
3852  /*
3853  * There can be multiple SubPlan nodes referencing the same physical
3854  * subplan (same plan_id, which is its index in PlannedStmt.subplans).
3855  * We should print a subplan only once, so track which ones we already
3856  * printed. This state must be global across the plan tree, since the
3857  * duplicate nodes could be in different plan nodes, eg both a bitmap
3858  * indexscan's indexqual and its parent heapscan's recheck qual. (We
3859  * do not worry too much about which plan node we show the subplan as
3860  * attached to in such cases.)
3861  */
3862  if (bms_is_member(sp->plan_id, es->printed_subplans))
3863  continue;
3865  sp->plan_id);
3866 
3867  /*
3868  * Treat the SubPlan node as an ancestor of the plan node(s) within
3869  * it, so that ruleutils.c can find the referents of subplan
3870  * parameters.
3871  */
3872  ancestors = lcons(sp, ancestors);
3873 
3874  ExplainNode(sps->planstate, ancestors,
3875  relationship, sp->plan_name, es);
3876 
3877  ancestors = list_delete_first(ancestors);
3878  }
3879 }
int plan_id
Definition: primnodes.h:709
Bitmapset * printed_subplans
Definition: explain.h:58
static void ExplainNode(PlanState *planstate, List *ancestors, const char *relationship, const char *plan_name, ExplainState *es)
Definition: explain.c:1121
struct PlanState * planstate
Definition: execnodes.h:853
SubPlan * subplan
Definition: execnodes.h:852
List * lcons(void *datum, List *list)
Definition: list.c:453
char * plan_name
Definition: primnodes.h:711
#define lfirst(lc)
Definition: pg_list.h:190
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:736
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:427
List * list_delete_first(List *list)
Definition: list.c:860

◆ ExplainTargetRel()

static void ExplainTargetRel ( Plan plan,
Index  rti,
ExplainState es 
)
static

Definition at line 3527 of file explain.c.

References Alias::aliasname, appendStringInfo(), appendStringInfoString(), Assert, RangeTblEntry::eref, EXPLAIN_FORMAT_TEXT, ExplainPropertyText(), ExplainState::format, RangeTblFunction::funcexpr, FuncExpr::funcid, FunctionScan::functions, get_func_name(), get_namespace_name(), get_rel_name(), IsA, linitial, list_length(), list_nth(), nodeTag, quote_identifier(), RangeTblEntry::relid, rt_fetch, ExplainState::rtable, ExplainState::rtable_names, RTE_CTE, RTE_FUNCTION, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, ExplainState::str, T_BitmapHeapScan, T_CteScan, T_CustomScan, T_ForeignScan, T_FunctionScan, T_IndexOnlyScan, T_IndexScan, T_ModifyTable, T_NamedTuplestoreScan, T_SampleScan, T_SeqScan, T_TableFuncScan, T_TidScan, T_ValuesScan, T_WorkTableScan, and ExplainState::verbose.

Referenced by ExplainModifyTarget(), ExplainScanTarget(), and show_modifytable_info().

3528 {
3529  char *objectname = NULL;
3530  char *namespace = NULL;
3531  const char *objecttag = NULL;
3532  RangeTblEntry *rte;
3533  char *refname;
3534 
3535  rte = rt_fetch(rti, es->rtable);
3536  refname = (char *) list_nth(es->rtable_names, rti - 1);
3537  if (refname == NULL)
3538  refname = rte->eref->aliasname;
3539 
3540  switch (nodeTag(plan))
3541  {
3542  case T_SeqScan:
3543  case T_SampleScan:
3544  case T_IndexScan:
3545  case T_IndexOnlyScan:
3546  case T_BitmapHeapScan:
3547  case T_TidScan:
3548  case T_ForeignScan:
3549  case T_CustomScan:
3550  case T_ModifyTable:
3551  /* Assert it's on a real relation */
3552  Assert(rte->rtekind == RTE_RELATION);
3553  objectname = get_rel_name(rte->relid);
3554  if (es->verbose)
3555  namespace = get_namespace_name(get_rel_namespace(rte->relid));
3556  objecttag = "Relation Name";
3557  break;
3558  case T_FunctionScan:
3559  {
3560  FunctionScan *fscan = (FunctionScan *) plan;
3561 
3562  /* Assert it's on a RangeFunction */
3563  Assert(rte->rtekind == RTE_FUNCTION);
3564 
3565  /*
3566  * If the expression is still a function call of a single
3567  * function, we can get the real name of the function.
3568  * Otherwise, punt. (Even if it was a single function call
3569  * originally, the optimizer could have simplified it away.)
3570  */
3571  if (list_length(fscan->functions) == 1)
3572  {
3573  RangeTblFunction *rtfunc = (RangeTblFunction *) linitial(fscan->functions);
3574 
3575  if (IsA(rtfunc->funcexpr, FuncExpr))
3576  {
3577  FuncExpr *funcexpr = (FuncExpr *) rtfunc->funcexpr;
3578  Oid funcid = funcexpr->funcid;
3579 
3580  objectname = get_func_name(funcid);
3581  if (es->verbose)
3582  namespace =
3584  }
3585  }
3586  objecttag = "Function Name";
3587  }
3588  break;
3589  case T_TableFuncScan:
3590  Assert(rte->rtekind == RTE_TABLEFUNC);
3591  objectname = "xmltable";
3592  objecttag = "Table Function Name";
3593  break;
3594  case T_ValuesScan:
3595  Assert(rte->rtekind == RTE_VALUES);
3596  break;
3597  case T_CteScan:
3598  /* Assert it's on a non-self-reference CTE */
3599  Assert(rte->rtekind == RTE_CTE);
3600  Assert(!rte->self_reference);
3601  objectname = rte->ctename;
3602  objecttag = "CTE Name";
3603  break;
3604  case T_NamedTuplestoreScan:
3606  objectname = rte->enrname;
3607  objecttag = "Tuplestore Name";
3608  break;
3609  case T_WorkTableScan:
3610  /* Assert it's on a self-reference CTE */
3611  Assert(rte->rtekind == RTE_CTE);
3612  Assert(rte->self_reference);
3613  objectname = rte->ctename;
3614  objecttag = "CTE Name";
3615  break;
3616  default:
3617  break;
3618  }
3619 
3620  if (es->format == EXPLAIN_FORMAT_TEXT)
3621  {
3622  appendStringInfoString(es->str, " on");
3623  if (namespace != NULL)
3624  appendStringInfo(es->str, " %s.%s", quote_identifier(namespace),
3625  quote_identifier(objectname));
3626  else if (objectname != NULL)
3627  appendStringInfo(es->str, " %s", quote_identifier(objectname));
3628  if (objectname == NULL || strcmp(refname, objectname) != 0)
3629  appendStringInfo(es->str, " %s", quote_identifier(refname));
3630  }
3631  else
3632  {
3633  if (objecttag != NULL && objectname != NULL)
3634  ExplainPropertyText(objecttag, objectname, es);
3635  if (namespace != NULL)
3636  ExplainPropertyText("Schema", namespace, es);
3637  ExplainPropertyText("Alias", refname, es);
3638  }
3639 }
#define IsA(nodeptr, _type_)
Definition: nodes.h:580
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:10727
Oid get_func_namespace(Oid funcid)
Definition: lsyscache.c:1544
List * functions
Definition: plannodes.h:525
Oid get_rel_namespace(Oid relid)
Definition: lsyscache.c:1864
unsigned int Oid
Definition: postgres_ext.h:31
List * rtable_names
Definition: explain.h:56
void ExplainPropertyText(const char *qlabel, const char *value, ExplainState *es)
Definition: explain.c:4228
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
#define linitial(l)
Definition: pg_list.h:195
Oid funcid
Definition: primnodes.h:469
static void * list_nth(const List *list, int n)
Definition: pg_list.h:277
char * get_func_name(Oid funcid)
Definition: lsyscache.c:1520
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3191
char * enrname
Definition: parsenodes.h:1108
#define rt_fetch(rangetable_index, rangetable)
Definition: parsetree.h:31
bool self_reference
Definition: parsenodes.h:1081
bool verbose
Definition: explain.h:41
#define Assert(condition)
Definition: c.h:745
char * aliasname
Definition: primnodes.h:42
static int list_length(const List *l)
Definition: pg_list.h:169
ExplainFormat format
Definition: explain.h:49
#define nodeTag(nodeptr)
Definition: nodes.h:534
RTEKind rtekind
Definition: parsenodes.h:976
char * ctename
Definition: parsenodes.h:1079
Alias * eref
Definition: parsenodes.h:1115
char * get_rel_name(Oid relid)
Definition: lsyscache.c:1840
StringInfo str
Definition: explain.h:39
List * rtable
Definition: explain.h:55

◆ ExplainXMLTag()

static void ExplainXMLTag ( const char *  tagname,
int  flags,
ExplainState es 
)
static

Definition at line 4638 of file explain.c.

References appendStringInfoChar(), appendStringInfoCharMacro, appendStringInfoSpaces(), appendStringInfoString(), ExplainState::indent, ExplainState::str, X_CLOSE_IMMEDIATE, X_CLOSING, and X_NOWHITESPACE.

Referenced by ExplainCloseGroup(), ExplainDummyGroup(), ExplainOpenGroup(), ExplainProperty(), and ExplainPropertyList().

4639 {
4640  const char *s;
4641  const char *valid = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.";
4642 
4643  if ((flags & X_NOWHITESPACE) == 0)
4644  appendStringInfoSpaces(es->str, 2 * es->indent);
4645  appendStringInfoCharMacro(es->str, '<');
4646  if ((flags & X_CLOSING) != 0)
4647  appendStringInfoCharMacro(es->str, '/');
4648  for (s = tagname; *s; s++)
4649  appendStringInfoChar(es->str, strchr(valid, *s) ? *s : '-');
4650  if ((flags & X_CLOSE_IMMEDIATE) != 0)
4651  appendStringInfoString(es->str, " /");
4652  appendStringInfoCharMacro(es->str, '>');
4653  if ((flags & X_NOWHITESPACE) == 0)
4654  appendStringInfoCharMacro(es->str, '\n');
4655 }
#define X_CLOSING
Definition: explain.c:52
#define appendStringInfoCharMacro(str, ch)
Definition: stringinfo.h:128
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
int indent
Definition: explain.h:51
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
void appendStringInfoSpaces(StringInfo str, int count)
Definition: stringinfo.c:206
#define X_NOWHITESPACE
Definition: explain.c:54
#define X_CLOSE_IMMEDIATE
Definition: explain.c:53
StringInfo str
Definition: explain.h:39

◆ ExplainYAMLLineStarting()

static void ExplainYAMLLineStarting ( ExplainState es)
static

Definition at line 4700 of file explain.c.

References appendStringInfoChar(), appendStringInfoSpaces(), Assert, EXPLAIN_FORMAT_YAML, ExplainState::format, ExplainState::grouping_stack, ExplainState::indent, linitial_int, and ExplainState::str.

Referenced by ExplainDummyGroup(), ExplainOpenGroup(), ExplainProperty(), ExplainPropertyList(), and ExplainPropertyListNested().

4701 {
4703  if (linitial_int(es->grouping_stack) == 0)
4704  {
4705  linitial_int(es->grouping_stack) = 1;
4706  }
4707  else
4708  {
4709  appendStringInfoChar(es->str, '\n');
4710  appendStringInfoSpaces(es->str, es->indent * 2);
4711  }
4712 }
#define linitial_int(l)
Definition: pg_list.h:196
List * grouping_stack
Definition: explain.h:52
int indent
Definition: explain.h:51
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
void appendStringInfoSpaces(StringInfo str, int count)
Definition: stringinfo.c:206
#define Assert(condition)
Definition: c.h:745
ExplainFormat format
Definition: explain.h:49
StringInfo str
Definition: explain.h:39

◆ NewExplainState()

ExplainState* NewExplainState ( void  )

Definition at line 309 of file explain.c.

References ExplainState::costs, makeStringInfo(), palloc0(), and ExplainState::str.

Referenced by explain_ExecutorEnd(), and ExplainQuery().

310 {
311  ExplainState *es = (ExplainState *) palloc0(sizeof(ExplainState));
312 
313  /* Set default options (most fields can be left as zeroes). */
314  es->costs = true;
315  /* Prepare output buffer. */
316  es->str = makeStringInfo();
317 
318  return es;
319 }
StringInfo makeStringInfo(void)
Definition: stringinfo.c:41
bool costs
Definition: explain.h:43
void * palloc0(Size size)
Definition: mcxt.c:980
StringInfo str
Definition: explain.h:39

◆ report_triggers()

static void report_triggers ( ResultRelInfo rInfo,
bool  show_relname,
ExplainState es 
)
static

Definition at line 957 of file explain.c.

References appendStringInfo(), appendStringInfoString(), EXPLAIN_FORMAT_TEXT, ExplainCloseGroup(), ExplainOpenGroup(), ExplainPropertyFloat(), ExplainPropertyText(), ExplainState::format, get_constraint_name(), InstrEndLoop(), Instrumentation::ntuples, TriggerDesc::numtriggers, OidIsValid, pfree(), RelationGetRelationName, relname, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigInstrument, ExplainState::str, Trigger::tgconstraint, Trigger::tgname, ExplainState::timing, Instrumentation::total, TriggerDesc::triggers, and ExplainState::verbose.

Referenced by ExplainPrintTriggers().

958 {
959  int nt;
960 
961  if (!rInfo->ri_TrigDesc || !rInfo->ri_TrigInstrument)
962  return;
963  for (nt = 0; nt < rInfo->ri_TrigDesc->numtriggers; nt++)
964  {
965  Trigger *trig = rInfo->ri_TrigDesc->triggers + nt;
966  Instrumentation *instr = rInfo->ri_TrigInstrument + nt;
967  char *relname;
968  char *conname = NULL;
969 
970  /* Must clean up instrumentation state */
971  InstrEndLoop(instr);
972 
973  /*
974  * We ignore triggers that were never invoked; they likely aren't
975  * relevant to the current query type.
976  */
977  if (instr->ntuples == 0)
978  continue;
979 
980  ExplainOpenGroup("Trigger", NULL, true, es);
981 
982  relname = RelationGetRelationName(rInfo->ri_RelationDesc);
983  if (OidIsValid(trig->tgconstraint))
984  conname = get_constraint_name(trig->tgconstraint);
985 
986  /*
987  * In text format, we avoid printing both the trigger name and the
988  * constraint name unless VERBOSE is specified. In non-text formats
989  * we just print everything.
990  */
991  if (es->format == EXPLAIN_FORMAT_TEXT)
992  {
993  if (es->verbose || conname == NULL)
994  appendStringInfo(es->str, "Trigger %s", trig->tgname);
995  else
996  appendStringInfoString(es->str, "Trigger");
997  if (conname)
998  appendStringInfo(es->str, " for constraint %s", conname);
999  if (show_relname)
1000  appendStringInfo(es->str, " on %s", relname);
1001  if (es->timing)
1002  appendStringInfo(es->str, ": time=%.3f calls=%.0f\n",
1003  1000.0 * instr->total, instr->ntuples);
1004  else
1005  appendStringInfo(es->str, ": calls=%.0f\n", instr->ntuples);
1006  }
1007  else
1008  {
1009  ExplainPropertyText("Trigger Name", trig->tgname, es);
1010  if (conname)
1011  ExplainPropertyText("Constraint Name", conname, es);
1012  ExplainPropertyText("Relation", relname, es);
1013  if (es->timing)
1014  ExplainPropertyFloat("Time", "ms", 1000.0 * instr->total, 3,
1015  es);
1016  ExplainPropertyFloat("Calls", NULL, instr->ntuples, 0, es);
1017  }
1018 
1019  if (conname)
1020  pfree(conname);
1021 
1022  ExplainCloseGroup("Trigger", NULL, true, es);
1023  }
1024 }
Relation ri_RelationDesc
Definition: execnodes.h:413
char * get_constraint_name(Oid conoid)
Definition: lsyscache.c:1079
void ExplainPropertyFloat(const char *qlabel, const char *unit, double value, int ndigits, ExplainState *es)
Definition: explain.c:4264
Instrumentation * ri_TrigInstrument
Definition: execnodes.h:434
NameData relname
Definition: pg_class.h:38
#define OidIsValid(objectId)
Definition: c.h:651
void InstrEndLoop(Instrumentation *instr)
Definition: instrument.c:121
void ExplainPropertyText(const char *qlabel, const char *value, ExplainState *es)
Definition: explain.c:4228
void pfree(void *pointer)
Definition: mcxt.c:1056
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
Oid tgconstraint
Definition: reltrigger.h:35
char * tgname
Definition: reltrigger.h:27
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
Trigger * triggers
Definition: reltrigger.h:49
#define RelationGetRelationName(relation)
Definition: rel.h:490
double ntuples
Definition: instrument.h:69
TriggerDesc * ri_TrigDesc
Definition: execnodes.h:425
bool timing
Definition: explain.h:46
int numtriggers
Definition: reltrigger.h:50
bool verbose
Definition: explain.h:41
ExplainFormat format
Definition: explain.h:49
void ExplainCloseGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4356
void ExplainOpenGroup(const char *objtype, const char *labelname, bool labeled, ExplainState *es)
Definition: explain.c:4293
StringInfo str
Definition: explain.h:39

◆ show_agg_keys()

static void show_agg_keys ( AggState astate,
List ancestors,
ExplainState es 
)
static

Definition at line 2330 of file explain.c.

References Agg::groupingSets, Agg::grpColIdx, lcons(), list_delete_first(), Agg::numCols, outerPlanState, PlanState::plan, ScanState::ps, show_grouping_sets(), show_sort_group_keys(), and AggState::ss.

Referenced by ExplainNode().

2332 {
2333  Agg *plan = (Agg *) astate->ss.ps.plan;
2334 
2335  if (plan->numCols > 0 || plan->groupingSets)
2336  {
2337  /* The key columns refer to the tlist of the child plan */
2338  ancestors = lcons(plan, ancestors);
2339 
2340  if (plan->groupingSets)
2341  show_grouping_sets(outerPlanState(astate), plan, ancestors, es);
2342  else
2343  show_sort_group_keys(outerPlanState(astate), "Group Key",
2344  plan->numCols, 0, plan->grpColIdx,
2345  NULL, NULL, NULL,
2346  ancestors, es);
2347 
2348  ancestors = list_delete_first(ancestors);
2349  }
2350 }
int numCols
Definition: plannodes.h:821
AttrNumber * grpColIdx
Definition: plannodes.h:822
static void show_sort_group_keys(PlanState *planstate, const char *qlabel, int nkeys, int nPresortedKeys, AttrNumber *keycols, Oid *sortOperators, Oid *collations, bool *nullsFirst, List *ancestors, ExplainState *es)
Definition: explain.c:2482
ScanState ss
Definition: execnodes.h:2146
PlanState ps