#include "executor/executor.h"
#include "executor/instrument.h"
#include "parser/parse_node.h"

Include dependency graph for explain.h:

This graph shows which files directly or indirectly include this file:

Typedefs
typedef struct ExplainState	ExplainState

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

typedef void(*	explain_per_plan_hook_type) (PlannedStmt plannedstmt, IntoClause into, ExplainState es, const char queryString, ParamListInfo params, QueryEnvironment *queryEnv)

typedef void(*	explain_per_node_hook_type) (PlanState planstate, List ancestors, const char relationship, const char plan_name, ExplainState *es)

typedef const char (	explain_get_index_name_hook_type) (Oid indexId)

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

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

TupleDesc	ExplainResultDesc (ExplainStmt *stmt)

void	ExplainOneUtility (Node utilityStmt, IntoClause into, ExplainState es, ParseState pstate, ParamListInfo params)

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

void	ExplainPrintPlan (ExplainState es, QueryDesc queryDesc)

void	ExplainPrintTriggers (ExplainState es, QueryDesc queryDesc)

void	ExplainPrintJITSummary (ExplainState es, QueryDesc queryDesc)

void	ExplainQueryText (ExplainState es, QueryDesc queryDesc)

void	ExplainQueryParameters (ExplainState *es, ParamListInfo params, int maxlen)

Variables
PGDLLIMPORT ExplainOneQuery_hook_type	ExplainOneQuery_hook

PGDLLIMPORT explain_per_plan_hook_type	explain_per_plan_hook

PGDLLIMPORT explain_per_node_hook_type	explain_per_node_hook

PGDLLIMPORT explain_get_index_name_hook_type	explain_get_index_name_hook

Typedef Documentation

◆ explain_get_index_name_hook_type

typedef const char *(* explain_get_index_name_hook_type) (Oid indexId)

Definition at line 50 of file explain.h.

◆ explain_per_node_hook_type

typedef void(* explain_per_node_hook_type) (PlanState *planstate, List *ancestors, const char *relationship, const char *plan_name, ExplainState *es)

Definition at line 42 of file explain.h.

◆ explain_per_plan_hook_type

typedef void(* explain_per_plan_hook_type) (PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv)

Definition at line 33 of file explain.h.

◆ ExplainOneQuery_hook_type

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

Definition at line 23 of file explain.h.

◆ ExplainState

typedef struct ExplainState ExplainState

Definition at line 20 of file explain.h.

Function Documentation

◆ ExplainOnePlan()

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

extern

Definition at line 500 of file explain.c.

{
    DestReceiver *dest;
    QueryDesc  *queryDesc;
    instr_time  starttime;
    double      totaltime = 0;
    int         eflags;
    int         instrument_option = 0;
    SerializeMetrics serializeMetrics = {0};
 
    Assert(plannedstmt->commandType != CMD_UTILITY);
 
    if (es->analyze && es->timing)
        instrument_option |= INSTRUMENT_TIMER;
    else if (es->analyze)
        instrument_option |= INSTRUMENT_ROWS;
 
    if (es->buffers)
        instrument_option |= INSTRUMENT_BUFFERS;
    if (es->wal)
        instrument_option |= INSTRUMENT_WAL;
    if (es->io)
        instrument_option |= INSTRUMENT_IO;
 
    /*
     * We always collect timing for the entire statement, even when node-level
     * timing is off, so we don't look at es->timing here.  (We could skip
     * this if !es->summary, but it's hardly worth the complication.)
     */
    INSTR_TIME_SET_CURRENT(starttime);
 
    /*
     * Use a snapshot with an updated command ID to ensure this query sees
     * results of any previously executed queries.
     */
    PushCopiedSnapshot(GetActiveSnapshot());
    UpdateActiveSnapshotCommandId();
 
    /*
     * We discard the output if we have no use for it.  If we're explaining
     * CREATE TABLE AS, we'd better use the appropriate tuple receiver, while
     * the SERIALIZE option requires its own tuple receiver.  (If you specify
     * SERIALIZE while explaining CREATE TABLE AS, you'll see zeroes for the
     * results, which is appropriate since no data would have gone to the
     * client.)
     */
    if (into)
        dest = CreateIntoRelDestReceiver(into);
    else if (es->serialize != EXPLAIN_SERIALIZE_NONE)
        dest = CreateExplainSerializeDestReceiver(es);
    else
        dest = None_Receiver;
 
    /* Create a QueryDesc for the query */
    queryDesc = CreateQueryDesc(plannedstmt, queryString,
                                GetActiveSnapshot(), InvalidSnapshot,
                                dest, params, queryEnv, instrument_option);
 
    /* Select execution options */
    if (es->analyze)
        eflags = 0;             /* default run-to-completion flags */
    else
        eflags = EXEC_FLAG_EXPLAIN_ONLY;
    if (es->generic)
        eflags |= EXEC_FLAG_EXPLAIN_GENERIC;
    if (into)
        eflags |= GetIntoRelEFlags(into);
 
    /* call ExecutorStart to prepare the plan for execution */
    ExecutorStart(queryDesc, eflags);
 
    /* Execute the plan for statistics if asked for */
    if (es->analyze)
    {
        ScanDirection dir;
 
        /* EXPLAIN ANALYZE CREATE TABLE AS WITH NO DATA is weird */
        if (into && into->skipData)
            dir = NoMovementScanDirection;
        else
            dir = ForwardScanDirection;
 
        /* run the plan */
        ExecutorRun(queryDesc, dir, 0);
 
        /* run cleanup too */
        ExecutorFinish(queryDesc);
 
        /* We can't run ExecutorEnd 'till we're done printing the stats... */
        totaltime += elapsed_time(&starttime);
    }
 
    /* grab serialization metrics before we destroy the DestReceiver */
    if (es->serialize != EXPLAIN_SERIALIZE_NONE)
        serializeMetrics = GetSerializationMetrics(dest);
 
    /* call the DestReceiver's destroy method even during explain */
    dest->rDestroy(dest);
 
    ExplainOpenGroup("Query", NULL, true, es);
 
    /* Create textual dump of plan tree */
    ExplainPrintPlan(es, queryDesc);
 
    /* Show buffer and/or memory usage in planning */
    if (peek_buffer_usage(es, bufusage) || mem_counters)
    {
        ExplainOpenGroup("Planning", "Planning", true, es);
 
        if (es->format == EXPLAIN_FORMAT_TEXT)
        {
            ExplainIndentText(es);
            appendStringInfoString(es->str, "Planning:\n");
            es->indent++;
        }
 
        if (bufusage)
            show_buffer_usage(es, bufusage);
 
        if (mem_counters)
            show_memory_counters(es, mem_counters);
 
        if (es->format == EXPLAIN_FORMAT_TEXT)
            es->indent--;
 
        ExplainCloseGroup("Planning", "Planning", true, es);
    }
 
    if (es->summary && planduration)
    {
        double      plantime = INSTR_TIME_GET_DOUBLE(*planduration);
 
        ExplainPropertyFloat("Planning Time", "ms", 1000.0 * plantime, 3, es);
    }
 
    /* Print info about runtime of triggers */
    if (es->analyze)
        ExplainPrintTriggers(es, queryDesc);
 
    /*
     * Print info about JITing. Tied to es->costs because we don't want to
     * display this in regression tests, as it'd cause output differences
     * depending on build options.  Might want to separate that out from COSTS
     * at a later stage.
     */
    if (es->costs)
        ExplainPrintJITSummary(es, queryDesc);
 
    /* Print info about serialization of output */
    if (es->serialize != EXPLAIN_SERIALIZE_NONE)
        ExplainPrintSerialize(es, &serializeMetrics);
 
    /* Allow plugins to print additional information */
    if (explain_per_plan_hook)
        (*explain_per_plan_hook) (plannedstmt, into, es, queryString,
                                  params, queryEnv);
 
    /*
     * Close down the query and free resources.  Include time for this in the
     * total execution time (although it should be pretty minimal).
     */
    INSTR_TIME_SET_CURRENT(starttime);
 
    ExecutorEnd(queryDesc);
 
    FreeQueryDesc(queryDesc);
 
    PopActiveSnapshot();
 
    /* We need a CCI just in case query expanded to multiple plans */
    if (es->analyze)
        CommandCounterIncrement();
 
    totaltime += elapsed_time(&starttime);
 
    /*
     * We only report execution time if we actually ran the query (that is,
     * the user specified ANALYZE), and if summary reporting is enabled (the
     * user can set SUMMARY OFF to not have the timing information included in
     * the output).  By default, ANALYZE sets SUMMARY to true.
     */
    if (es->summary && es->analyze)
        ExplainPropertyFloat("Execution Time", "ms", 1000.0 * totaltime, 3,
                             es);
 
    ExplainCloseGroup("Query", NULL, true, es);
}

References ExplainState::analyze, appendStringInfoString(), Assert, ExplainState::buffers, CMD_UTILITY, CommandCounterIncrement(), PlannedStmt::commandType, ExplainState::costs, CreateExplainSerializeDestReceiver(), CreateIntoRelDestReceiver(), CreateQueryDesc(), elapsed_time(), EXEC_FLAG_EXPLAIN_GENERIC, EXEC_FLAG_EXPLAIN_ONLY, ExecutorEnd(), ExecutorFinish(), ExecutorRun(), ExecutorStart(), EXPLAIN_FORMAT_TEXT, explain_per_plan_hook, EXPLAIN_SERIALIZE_NONE, ExplainCloseGroup(), ExplainIndentText(), ExplainOpenGroup(), ExplainPrintJITSummary(), ExplainPrintPlan(), ExplainPrintSerialize(), ExplainPrintTriggers(), ExplainPropertyFloat(), fb(), ExplainState::format, ForwardScanDirection, FreeQueryDesc(), ExplainState::generic, GetActiveSnapshot(), GetIntoRelEFlags(), GetSerializationMetrics(), ExplainState::indent, INSTR_TIME_GET_DOUBLE, INSTR_TIME_SET_CURRENT, INSTRUMENT_BUFFERS, INSTRUMENT_IO, INSTRUMENT_ROWS, INSTRUMENT_TIMER, INSTRUMENT_WAL, InvalidSnapshot, ExplainState::io, NoMovementScanDirection, None_Receiver, peek_buffer_usage(), PopActiveSnapshot(), PushCopiedSnapshot(), ExplainState::serialize, show_buffer_usage(), show_memory_counters(), IntoClause::skipData, ExplainState::str, ExplainState::summary, ExplainState::timing, UpdateActiveSnapshotCommandId(), and ExplainState::wal.

Referenced by ExplainExecuteQuery(), and standard_ExplainOneQuery().

◆ ExplainOneUtility()

void ExplainOneUtility	(	Node *	utilityStmt,
		IntoClause *	into,
		ExplainState *	es,
		ParseState *	pstate,
		ParamListInfo	params
	)

extern

Definition at line 396 of file explain.c.

{
    if (utilityStmt == NULL)
        return;
 
    if (IsA(utilityStmt, CreateTableAsStmt))
    {
        /*
         * We have to rewrite the contained SELECT and then pass it back to
         * ExplainOneQuery.  Copy to be safe in the EXPLAIN EXECUTE case.
         */
        CreateTableAsStmt *ctas = (CreateTableAsStmt *) utilityStmt;
        Query      *ctas_query;
        List       *rewritten;
        JumbleState *jstate = NULL;
 
        /*
         * Check if the relation exists or not.  This is done at this stage to
         * avoid query planning or execution.
         */
        if (CreateTableAsRelExists(ctas))
        {
            if (ctas->objtype == OBJECT_TABLE)
                ExplainDummyGroup("CREATE TABLE AS", NULL, es);
            else if (ctas->objtype == OBJECT_MATVIEW)
                ExplainDummyGroup("CREATE MATERIALIZED VIEW", NULL, es);
            else
                elog(ERROR, "unexpected object type: %d",
                     (int) ctas->objtype);
            return;
        }
 
        ctas_query = castNode(Query, copyObject(ctas->query));
        if (IsQueryIdEnabled())
            jstate = JumbleQuery(ctas_query);
        if (post_parse_analyze_hook)
            (*post_parse_analyze_hook) (pstate, ctas_query, jstate);
        rewritten = QueryRewrite(ctas_query);
        Assert(list_length(rewritten) == 1);
        ExplainOneQuery(linitial_node(Query, rewritten),
                        CURSOR_OPT_PARALLEL_OK, ctas->into, es,
                        pstate, params);
    }
    else if (IsA(utilityStmt, DeclareCursorStmt))
    {
        /*
         * Likewise for DECLARE CURSOR.
         *
         * Notice that if you say EXPLAIN ANALYZE DECLARE CURSOR then we'll
         * actually run the query.  This is different from pre-8.3 behavior
         * but seems more useful than not running the query.  No cursor will
         * be created, however.
         */
        DeclareCursorStmt *dcs = (DeclareCursorStmt *) utilityStmt;
        Query      *dcs_query;
        List       *rewritten;
        JumbleState *jstate = NULL;
 
        dcs_query = castNode(Query, copyObject(dcs->query));
        if (IsQueryIdEnabled())
            jstate = JumbleQuery(dcs_query);
        if (post_parse_analyze_hook)
            (*post_parse_analyze_hook) (pstate, dcs_query, jstate);
 
        rewritten = QueryRewrite(dcs_query);
        Assert(list_length(rewritten) == 1);
        ExplainOneQuery(linitial_node(Query, rewritten),
                        dcs->options, NULL, es,
                        pstate, params);
    }
    else if (IsA(utilityStmt, ExecuteStmt))
        ExplainExecuteQuery((ExecuteStmt *) utilityStmt, into, es,
                            pstate, params);
    else if (IsA(utilityStmt, NotifyStmt))
    {
        if (es->format == EXPLAIN_FORMAT_TEXT)
            appendStringInfoString(es->str, "NOTIFY\n");
        else
            ExplainDummyGroup("Notify", NULL, es);
    }
    else
    {
        if (es->format == EXPLAIN_FORMAT_TEXT)
            appendStringInfoString(es->str,
                                   "Utility statements have no plan structure\n");
        else
            ExplainDummyGroup("Utility Statement", NULL, es);
    }
}

References appendStringInfoString(), Assert, castNode, copyObject, CreateTableAsRelExists(), CURSOR_OPT_PARALLEL_OK, elog, ERROR, EXPLAIN_FORMAT_TEXT, ExplainDummyGroup(), ExplainExecuteQuery(), ExplainOneQuery(), fb(), ExplainState::format, IsA, IsQueryIdEnabled(), JumbleQuery(), linitial_node, list_length(), OBJECT_MATVIEW, OBJECT_TABLE, post_parse_analyze_hook, QueryRewrite(), and ExplainState::str.

Referenced by ExplainExecuteQuery(), and ExplainOneQuery().

◆ ExplainPrintJITSummary()

void ExplainPrintJITSummary	(	ExplainState *	es,
		QueryDesc *	queryDesc
	)

extern

Definition at line 883 of file explain.c.

{
    JitInstrumentation ji = {0};
 
    if (!(queryDesc->estate->es_jit_flags & PGJIT_PERFORM))
        return;
 
    /*
     * Work with a copy instead of modifying the leader state, since this
     * function may be called twice
     */
    if (queryDesc->estate->es_jit)
        InstrJitAgg(&ji, &queryDesc->estate->es_jit->instr);
 
    /* If this process has done JIT in parallel workers, merge stats */
    if (queryDesc->estate->es_jit_worker_instr)
        InstrJitAgg(&ji, queryDesc->estate->es_jit_worker_instr);
 
    ExplainPrintJIT(es, queryDesc->estate->es_jit_flags, &ji);
}

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

Referenced by explain_ExecutorEnd(), and ExplainOnePlan().

◆ ExplainPrintPlan()

void ExplainPrintPlan	(	ExplainState *	es,
		QueryDesc *	queryDesc
	)

extern

Definition at line 767 of file explain.c.

{
    Bitmapset  *rels_used = NULL;
    PlanState  *ps;
    ListCell   *lc;
 
    /* Set up ExplainState fields associated with this plan tree */
    Assert(queryDesc->plannedstmt != NULL);
    es->pstmt = queryDesc->plannedstmt;
    es->rtable = queryDesc->plannedstmt->rtable;
    ExplainPreScanNode(queryDesc->planstate, &rels_used);
    es->rtable_names = select_rtable_names_for_explain(es->rtable, rels_used);
    es->deparse_cxt = deparse_context_for_plan_tree(queryDesc->plannedstmt,
                                                    es->rtable_names);
    es->printed_subplans = NULL;
    es->rtable_size = list_length(es->rtable);
    foreach(lc, es->rtable)
    {
        RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc);
 
        if (rte->rtekind == RTE_GROUP)
        {
            es->rtable_size--;
            break;
        }
    }
 
    /*
     * Sometimes we mark a Gather node as "invisible", which means that it's
     * not to be displayed in EXPLAIN output.  The purpose of this is to allow
     * running regression tests with debug_parallel_query=regress to get the
     * same results as running the same tests with debug_parallel_query=off.
     * Such marking is currently only supported on a Gather at the top of the
     * plan.  We skip that node, and we must also hide per-worker detail data
     * further down in the plan tree.
     */
    ps = queryDesc->planstate;
    if (IsA(ps, GatherState) && ((Gather *) ps->plan)->invisible)
    {
        ps = outerPlanState(ps);
        es->hide_workers = true;
    }
    ExplainNode(ps, NIL, NULL, NULL, es);
 
    /*
     * If requested, include information about GUC parameters with values that
     * don't match the built-in defaults.
     */
    ExplainPrintSettings(es);
 
    /*
     * COMPUTE_QUERY_ID_REGRESS means COMPUTE_QUERY_ID_AUTO, but we don't show
     * the queryid in any of the EXPLAIN plans to keep stable the results
     * generated by regression test suites.
     */
    if (es->verbose && queryDesc->plannedstmt->queryId != INT64CONST(0) &&
        compute_query_id != COMPUTE_QUERY_ID_REGRESS)
    {
        ExplainPropertyInteger("Query Identifier", NULL,
                               queryDesc->plannedstmt->queryId, es);
    }
}

References Assert, compute_query_id, COMPUTE_QUERY_ID_REGRESS, deparse_context_for_plan_tree(), ExplainState::deparse_cxt, ExplainNode(), ExplainPreScanNode(), ExplainPrintSettings(), ExplainPropertyInteger(), fb(), ExplainState::hide_workers, INT64CONST, IsA, lfirst_node, list_length(), NIL, outerPlanState, QueryDesc::plannedstmt, QueryDesc::planstate, ExplainState::printed_subplans, ps, ExplainState::pstmt, PlannedStmt::queryId, ExplainState::rtable, PlannedStmt::rtable, ExplainState::rtable_names, ExplainState::rtable_size, RTE_GROUP, select_rtable_names_for_explain(), and ExplainState::verbose.

Referenced by explain_ExecutorEnd(), and ExplainOnePlan().

◆ ExplainPrintTriggers()

void ExplainPrintTriggers	(	ExplainState *	es,
		QueryDesc *	queryDesc
	)

extern

Definition at line 840 of file explain.c.

{
    ResultRelInfo *rInfo;
    bool        show_relname;
    List       *resultrels;
    List       *routerels;
    List       *targrels;
    ListCell   *l;
 
    resultrels = queryDesc->estate->es_opened_result_relations;
    routerels = queryDesc->estate->es_tuple_routing_result_relations;
    targrels = queryDesc->estate->es_trig_target_relations;
 
    ExplainOpenGroup("Triggers", "Triggers", false, es);
 
    show_relname = (list_length(resultrels) > 1 ||
                    routerels != NIL || targrels != NIL);
    foreach(l, resultrels)
    {
        rInfo = (ResultRelInfo *) lfirst(l);
        report_triggers(rInfo, show_relname, es);
    }
 
    foreach(l, routerels)
    {
        rInfo = (ResultRelInfo *) lfirst(l);
        report_triggers(rInfo, show_relname, es);
    }
 
    foreach(l, targrels)
    {
        rInfo = (ResultRelInfo *) lfirst(l);
        report_triggers(rInfo, show_relname, es);
    }
 
    ExplainCloseGroup("Triggers", "Triggers", false, es);
}

References EState::es_opened_result_relations, EState::es_trig_target_relations, EState::es_tuple_routing_result_relations, QueryDesc::estate, ExplainCloseGroup(), ExplainOpenGroup(), fb(), lfirst, list_length(), NIL, and report_triggers().

Referenced by explain_ExecutorEnd(), and ExplainOnePlan().

◆ ExplainQuery()

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

extern

Definition at line 181 of file explain.c.

{
    ExplainState *es = NewExplainState();
    TupOutputState *tstate;
    JumbleState *jstate = NULL;
    Query      *query;
    List       *rewritten;
 
    /* Configure the ExplainState based on the provided options */
    ParseExplainOptionList(es, stmt->options, pstate);
 
    /* Extract the query and, if enabled, jumble it */
    query = castNode(Query, stmt->query);
    if (IsQueryIdEnabled())
        jstate = JumbleQuery(query);
 
    if (post_parse_analyze_hook)
        (*post_parse_analyze_hook) (pstate, query, jstate);
 
    /*
     * Parse analysis was done already, but we still have to run the rule
     * rewriter.  We do not do AcquireRewriteLocks: we assume the query either
     * came straight from the parser, or suitable locks were acquired by
     * plancache.c.
     */
    rewritten = QueryRewrite(castNode(Query, stmt->query));
 
    /* emit opening boilerplate */
    ExplainBeginOutput(es);
 
    if (rewritten == NIL)
    {
        /*
         * In the case of an INSTEAD NOTHING, tell at least that.  But in
         * non-text format, the output is delimited, so this isn't necessary.
         */
        if (es->format == EXPLAIN_FORMAT_TEXT)
            appendStringInfoString(es->str, "Query rewrites to nothing\n");
    }
    else
    {
        ListCell   *l;
 
        /* Explain every plan */
        foreach(l, rewritten)
        {
            ExplainOneQuery(lfirst_node(Query, l),
                            CURSOR_OPT_PARALLEL_OK, NULL, es,
                            pstate, params);
 
            /* Separate plans with an appropriate separator */
            if (lnext(rewritten, l) != NULL)
                ExplainSeparatePlans(es);
        }
    }
 
    /* emit closing boilerplate */
    ExplainEndOutput(es);
    Assert(es->indent == 0);
 
    /* output tuples */
    tstate = begin_tup_output_tupdesc(dest, ExplainResultDesc(stmt),
                                      &TTSOpsVirtual);
    if (es->format == EXPLAIN_FORMAT_TEXT)
        do_text_output_multiline(tstate, es->str->data);
    else
        do_text_output_oneline(tstate, es->str->data);
    end_tup_output(tstate);
 
    pfree(es->str->data);
}

References appendStringInfoString(), Assert, begin_tup_output_tupdesc(), castNode, CURSOR_OPT_PARALLEL_OK, StringInfoData::data, do_text_output_multiline(), do_text_output_oneline, end_tup_output(), EXPLAIN_FORMAT_TEXT, ExplainBeginOutput(), ExplainEndOutput(), ExplainOneQuery(), ExplainResultDesc(), ExplainSeparatePlans(), fb(), ExplainState::format, ExplainState::indent, IsQueryIdEnabled(), JumbleQuery(), lfirst_node, lnext(), NewExplainState(), NIL, ParseExplainOptionList(), pfree(), post_parse_analyze_hook, QueryRewrite(), stmt, ExplainState::str, and TTSOpsVirtual.

Referenced by standard_ProcessUtility().

◆ ExplainQueryParameters()

void ExplainQueryParameters	(	ExplainState *	es,
		ParamListInfo	params,
		int	maxlen
	)

extern

Definition at line 1082 of file explain.c.

{
    char       *str;
 
    /* This check is consistent with errdetail_params() */
    if (params == NULL || params->numParams <= 0 || maxlen == 0)
        return;
 
    str = BuildParamLogString(params, NULL, maxlen);
    if (str && str[0] != '\0')
        ExplainPropertyText("Query Parameters", str, es);
}

References BuildParamLogString(), ExplainPropertyText(), fb(), ParamListInfoData::numParams, and str.

Referenced by explain_ExecutorEnd().

◆ ExplainQueryText()

void ExplainQueryText	(	ExplainState *	es,
		QueryDesc *	queryDesc
	)

extern

Definition at line 1067 of file explain.c.

{
    if (queryDesc->sourceText)
        ExplainPropertyText("Query Text", queryDesc->sourceText, es);
}

References ExplainPropertyText(), and QueryDesc::sourceText.

Referenced by explain_ExecutorEnd().

◆ ExplainResultDesc()

TupleDesc ExplainResultDesc ( ExplainStmt * stmt )

extern

Definition at line 259 of file explain.c.

{
    TupleDesc   tupdesc;
    ListCell   *lc;
    Oid         result_type = TEXTOID;
 
    /* Check for XML format option */
    foreach(lc, stmt->options)
    {
        DefElem    *opt = (DefElem *) lfirst(lc);
 
        if (strcmp(opt->defname, "format") == 0)
        {
            char       *p = defGetString(opt);
 
            if (strcmp(p, "xml") == 0)
                result_type = XMLOID;
            else if (strcmp(p, "json") == 0)
                result_type = JSONOID;
            else
                result_type = TEXTOID;
            /* don't "break", as ExplainQuery will use the last value */
        }
    }
 
    /* Need a tuple descriptor representing a single TEXT or XML column */
    tupdesc = CreateTemplateTupleDesc(1);
    TupleDescInitEntry(tupdesc, (AttrNumber) 1, "QUERY PLAN",
                       result_type, -1, 0);
    TupleDescFinalize(tupdesc);
    return tupdesc;
}

References CreateTemplateTupleDesc(), defGetString(), DefElem::defname, fb(), lfirst, stmt, TupleDescFinalize(), and TupleDescInitEntry().

Referenced by ExplainQuery(), and UtilityTupleDescriptor().

◆ standard_ExplainOneQuery()

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

extern

Definition at line 324 of file explain.c.

{
    PlannedStmt *plan;
    instr_time  planstart,
                planduration;
    BufferUsage bufusage_start,
                bufusage;
    MemoryContextCounters mem_counters;
    MemoryContext planner_ctx = NULL;
    MemoryContext saved_ctx = NULL;
 
    if (es->memory)
    {
        /*
         * Create a new memory context to measure planner's memory consumption
         * accurately.  Note that if the planner were to be modified to use a
         * different memory context type, here we would be changing that to
         * AllocSet, which might be undesirable.  However, we don't have a way
         * to create a context of the same type as another, so we pray and
         * hope that this is OK.
         */
        planner_ctx = AllocSetContextCreate(CurrentMemoryContext,
                                            "explain analyze planner context",
                                            ALLOCSET_DEFAULT_SIZES);
        saved_ctx = MemoryContextSwitchTo(planner_ctx);
    }
 
    if (es->buffers)
        bufusage_start = pgBufferUsage;
    INSTR_TIME_SET_CURRENT(planstart);
 
    /* plan the query */
    plan = pg_plan_query(query, queryString, cursorOptions, params, es);
 
    INSTR_TIME_SET_CURRENT(planduration);
    INSTR_TIME_SUBTRACT(planduration, planstart);
 
    if (es->memory)
    {
        MemoryContextSwitchTo(saved_ctx);
        MemoryContextMemConsumed(planner_ctx, &mem_counters);
    }
 
    /* calc differences of buffer counters. */
    if (es->buffers)
    {
        memset(&bufusage, 0, sizeof(BufferUsage));
        BufferUsageAccumDiff(&bufusage, &pgBufferUsage, &bufusage_start);
    }
 
    /* run it (if needed) and produce output */
    ExplainOnePlan(plan, into, es, queryString, params, queryEnv,
                   &planduration, (es->buffers ? &bufusage : NULL),
                   es->memory ? &mem_counters : NULL);
}