pg_overexplain.c File Reference

#include "postgres.h"
#include "catalog/pg_class.h"
#include "commands/defrem.h"
#include "commands/explain.h"
#include "commands/explain_format.h"
#include "commands/explain_state.h"
#include "fmgr.h"
#include "parser/parsetree.h"
#include "storage/lock.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"

Include dependency graph for pg_overexplain.c:

Go to the source code of this file.

Data Structures
struct	overexplain_options

Functions
	PG_MODULE_MAGIC_EXT (.name="pg_overexplain",.version=PG_VERSION)
static overexplain_options *	overexplain_ensure_options (ExplainState *es)
static void	overexplain_debug_handler (ExplainState *es, DefElem *opt, ParseState *pstate)
static void	overexplain_range_table_handler (ExplainState *es, DefElem *opt, ParseState *pstate)
static void	overexplain_per_node_hook (PlanState *planstate, List *ancestors, const char *relationship, const char *plan_name, ExplainState *es)
static void	overexplain_per_plan_hook (PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv)
static void	overexplain_debug (PlannedStmt *plannedstmt, ExplainState *es)
static void	overexplain_range_table (PlannedStmt *plannedstmt, ExplainState *es)
static void	overexplain_alias (const char *qlabel, Alias *alias, ExplainState *es)
static void	overexplain_bitmapset (const char *qlabel, Bitmapset *bms, ExplainState *es)
static void	overexplain_bitmapset_list (const char *qlabel, List *bms_list, ExplainState *es)
static void	overexplain_intlist (const char *qlabel, List *list, ExplainState *es)
void	_PG_init (void)

Variables
static int	es_extension_id
static explain_per_node_hook_type	prev_explain_per_node_hook
static explain_per_plan_hook_type	prev_explain_per_plan_hook

Function Documentation

_PG_init()

void _PG_init

(

void

)

Definition at line 70 of file pg_overexplain.c.

{
    /* Get an ID that we can use to cache data in an ExplainState. */
    es_extension_id = GetExplainExtensionId("pg_overexplain");
 
    /* Register the new EXPLAIN options implemented by this module. */
    RegisterExtensionExplainOption("debug", overexplain_debug_handler,
                                   GUCCheckBooleanExplainOption);
    RegisterExtensionExplainOption("range_table",
                                   overexplain_range_table_handler,
                                   GUCCheckBooleanExplainOption);
 
    /* Use the per-node and per-plan hooks to make our options do something. */
    prev_explain_per_node_hook = explain_per_node_hook;
    explain_per_node_hook = overexplain_per_node_hook;
    prev_explain_per_plan_hook = explain_per_plan_hook;
    explain_per_plan_hook = overexplain_per_plan_hook;
}

References es_extension_id, explain_per_node_hook, explain_per_plan_hook, GetExplainExtensionId(), GUCCheckBooleanExplainOption(), overexplain_debug_handler(), overexplain_per_node_hook(), overexplain_per_plan_hook(), overexplain_range_table_handler(), prev_explain_per_node_hook, prev_explain_per_plan_hook, and RegisterExtensionExplainOption().

overexplain_alias()

static void overexplain_alias ( const char *  qlabel, Alias *  alias, ExplainState *  es  )

static

Definition at line 805 of file pg_overexplain.c.

{
    StringInfoData buf;
    bool        first = true;
 
    Assert(alias != NULL);
 
    initStringInfo(&buf);
    appendStringInfo(&buf, "%s (", quote_identifier(alias->aliasname));
 
    foreach_node(String, cn, alias->colnames)
    {
        appendStringInfo(&buf, "%s%s",
                         first ? "" : ", ",
                         quote_identifier(cn->sval));
        first = false;
    }
 
    appendStringInfoChar(&buf, ')');
    ExplainPropertyText(qlabel, buf.data, es);
    pfree(buf.data);
}

References Alias::aliasname, appendStringInfo(), appendStringInfoChar(), Assert, buf, Alias::colnames, ExplainPropertyText(), fb(), foreach_node, initStringInfo(), pfree(), and quote_identifier().

Referenced by overexplain_range_table().

overexplain_bitmapset()

static void overexplain_bitmapset ( const char *  qlabel, Bitmapset *  bms, ExplainState *  es  )

static

Definition at line 834 of file pg_overexplain.c.

{
    int         x = -1;
 
    StringInfoData buf;
 
    if (bms_is_empty(bms))
    {
        ExplainPropertyText(qlabel, "none", es);
        return;
    }
 
    initStringInfo(&buf);
    while ((x = bms_next_member(bms, x)) >= 0)
        appendStringInfo(&buf, " %d", x);
    Assert(buf.data[0] == ' ');
    ExplainPropertyText(qlabel, buf.data + 1, es);
    pfree(buf.data);
}

References appendStringInfo(), Assert, bms_is_empty, bms_next_member(), buf, ExplainPropertyText(), fb(), initStringInfo(), pfree(), and x.

Referenced by overexplain_debug(), overexplain_per_node_hook(), and overexplain_range_table().

overexplain_bitmapset_list()

static void overexplain_bitmapset_list ( const char *  qlabel, List *  bms_list, ExplainState *  es  )

static

Definition at line 862 of file pg_overexplain.c.

{
    StringInfoData buf;
 
    initStringInfo(&buf);
 
    foreach_node(Bitmapset, bms, bms_list)
    {
        if (bms_membership(bms) == BMS_SINGLETON)
            appendStringInfo(&buf, " %d", bms_singleton_member(bms));
        else
        {
            int         x = -1;
            bool        first = true;
 
            appendStringInfoString(&buf, " (");
            while ((x = bms_next_member(bms, x)) >= 0)
            {
                if (first)
                    first = false;
                else
                    appendStringInfoChar(&buf, ' ');
                appendStringInfo(&buf, "%d", x);
            }
            appendStringInfoChar(&buf, ')');
        }
    }
 
    if (buf.len == 0)
    {
        ExplainPropertyText(qlabel, "none", es);
        return;
    }
 
    Assert(buf.data[0] == ' ');
    ExplainPropertyText(qlabel, buf.data + 1, es);
    pfree(buf.data);
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, bms_membership(), bms_next_member(), BMS_SINGLETON, bms_singleton_member(), buf, ExplainPropertyText(), fb(), foreach_node, initStringInfo(), pfree(), and x.

Referenced by overexplain_per_node_hook().

overexplain_debug()

static void overexplain_debug ( PlannedStmt *  plannedstmt, ExplainState *  es  )

static

Definition at line 347 of file pg_overexplain.c.

{
    char       *commandType = NULL;
    StringInfoData flags;
 
    /* Even in text mode, we want to set this output apart as its own group. */
    ExplainOpenGroup("PlannedStmt", "PlannedStmt", true, es);
    if (es->format == EXPLAIN_FORMAT_TEXT)
    {
        ExplainIndentText(es);
        appendStringInfoString(es->str, "PlannedStmt:\n");
        es->indent++;
    }
 
    /* Print the command type. */
    switch (plannedstmt->commandType)
    {
        case CMD_UNKNOWN:
            commandType = "unknown";
            break;
        case CMD_SELECT:
            commandType = "select";
            break;
        case CMD_UPDATE:
            commandType = "update";
            break;
        case CMD_INSERT:
            commandType = "insert";
            break;
        case CMD_DELETE:
            commandType = "delete";
            break;
        case CMD_MERGE:
            commandType = "merge";
            break;
        case CMD_UTILITY:
            commandType = "utility";
            break;
        case CMD_NOTHING:
            commandType = "nothing";
            break;
    }
    ExplainPropertyText("Command Type", commandType, es);
 
    /* Print various properties as a comma-separated list of flags. */
    initStringInfo(&flags);
    if (plannedstmt->hasReturning)
        appendStringInfoString(&flags, ", hasReturning");
    if (plannedstmt->hasModifyingCTE)
        appendStringInfoString(&flags, ", hasModifyingCTE");
    if (plannedstmt->canSetTag)
        appendStringInfoString(&flags, ", canSetTag");
    if (plannedstmt->transientPlan)
        appendStringInfoString(&flags, ", transientPlan");
    if (plannedstmt->dependsOnRole)
        appendStringInfoString(&flags, ", dependsOnRole");
    if (plannedstmt->parallelModeNeeded)
        appendStringInfoString(&flags, ", parallelModeNeeded");
    if (flags.len == 0)
        appendStringInfoString(&flags, ", none");
    ExplainPropertyText("Flags", flags.data + 2, es);
 
    /* Various lists of integers. */
    overexplain_bitmapset("Subplans Needing Rewind",
                          plannedstmt->rewindPlanIDs, es);
    overexplain_intlist("Relation OIDs",
                        plannedstmt->relationOids, es);
    overexplain_intlist("Executor Parameter Types",
                        plannedstmt->paramExecTypes, es);
 
    /*
     * Print the statement location. (If desired, we could alternatively print
     * stmt_location and stmt_len as two separate fields.)
     */
    if (plannedstmt->stmt_location == -1)
        ExplainPropertyText("Parse Location", "Unknown", es);
    else if (plannedstmt->stmt_len == 0)
        ExplainPropertyText("Parse Location",
                            psprintf("%d to end", plannedstmt->stmt_location),
                            es);
    else
        ExplainPropertyText("Parse Location",
                            psprintf("%d for %d bytes",
                                     plannedstmt->stmt_location,
                                     plannedstmt->stmt_len),
                            es);
 
    /* Done with this group. */
    if (es->format == EXPLAIN_FORMAT_TEXT)
        es->indent--;
    ExplainCloseGroup("PlannedStmt", "PlannedStmt", true, es);
}

References appendStringInfoString(), PlannedStmt::canSetTag, CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_NOTHING, CMD_SELECT, CMD_UNKNOWN, CMD_UPDATE, CMD_UTILITY, PlannedStmt::commandType, StringInfoData::data, PlannedStmt::dependsOnRole, EXPLAIN_FORMAT_TEXT, ExplainCloseGroup(), ExplainIndentText(), ExplainOpenGroup(), ExplainPropertyText(), fb(), ExplainState::format, PlannedStmt::hasModifyingCTE, PlannedStmt::hasReturning, ExplainState::indent, initStringInfo(), StringInfoData::len, overexplain_bitmapset(), overexplain_intlist(), PlannedStmt::parallelModeNeeded, PlannedStmt::paramExecTypes, psprintf(), PlannedStmt::relationOids, PlannedStmt::rewindPlanIDs, PlannedStmt::stmt_len, PlannedStmt::stmt_location, ExplainState::str, and PlannedStmt::transientPlan.

Referenced by overexplain_per_plan_hook().

overexplain_debug_handler()

static void overexplain_debug_handler ( ExplainState *  es, DefElem *  opt, ParseState *  pstate  )

static

Definition at line 113 of file pg_overexplain.c.

{
    overexplain_options *options = overexplain_ensure_options(es);
 
    options->debug = defGetBoolean(opt);
}

References defGetBoolean(), and overexplain_ensure_options().

Referenced by _PG_init().

overexplain_ensure_options()

static overexplain_options * overexplain_ensure_options ( ExplainState *  es )

static

Definition at line 94 of file pg_overexplain.c.

{
    overexplain_options *options;
 
    options = GetExplainExtensionState(es, es_extension_id);
 
    if (options == NULL)
    {
        options = palloc0_object(overexplain_options);
        SetExplainExtensionState(es, es_extension_id, options);
    }
 
    return options;
}

References es_extension_id, fb(), GetExplainExtensionState(), palloc0_object, and SetExplainExtensionState().

Referenced by overexplain_debug_handler(), and overexplain_range_table_handler().

overexplain_intlist()

static void overexplain_intlist ( const char *  qlabel, List *  list, ExplainState *  es  )

static

Definition at line 908 of file pg_overexplain.c.

{
    StringInfoData buf;
 
    initStringInfo(&buf);
 
    if (list == NIL)
    {
        ExplainPropertyText(qlabel, "none", es);
        return;
    }
 
    if (IsA(list, IntList))
    {
        foreach_int(i, list)
            appendStringInfo(&buf, " %d", i);
    }
    else if (IsA(list, OidList))
    {
        foreach_oid(o, list)
            appendStringInfo(&buf, " %u", o);
    }
    else if (IsA(list, XidList))
    {
        foreach_xid(x, list)
            appendStringInfo(&buf, " %u", x);
    }
    else
    {
        appendStringInfoString(&buf, " not an integer list");
        Assert(false);
    }
 
    if (buf.len > 0)
        ExplainPropertyText(qlabel, buf.data + 1, es);
 
    pfree(buf.data);
}

References appendStringInfo(), appendStringInfoString(), Assert, buf, ExplainPropertyText(), fb(), foreach_int, foreach_oid, foreach_xid, i, initStringInfo(), IsA, NIL, pfree(), and x.

Referenced by overexplain_debug().

overexplain_per_node_hook()

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

static

Definition at line 138 of file pg_overexplain.c.

{
    overexplain_options *options;
    Plan       *plan = planstate->plan;
 
    if (prev_explain_per_node_hook)
        (*prev_explain_per_node_hook) (planstate, ancestors, relationship,
                                       plan_name, es);
 
    options = GetExplainExtensionState(es, es_extension_id);
    if (options == NULL)
        return;
 
    /*
     * If the "debug" option was given, display miscellaneous fields from the
     * "Plan" node that would not otherwise be displayed.
     */
    if (options->debug)
    {
        /*
         * Normal EXPLAIN will display "Disabled: true" if the node is
         * disabled; but that is based on noticing that plan->disabled_nodes
         * is higher than the sum of its children; here, we display the raw
         * value, for debugging purposes.
         */
        ExplainPropertyInteger("Disabled Nodes", NULL, plan->disabled_nodes,
                               es);
 
        /*
         * Normal EXPLAIN will display the parallel_aware flag; here, we show
         * the parallel_safe flag as well.
         */
        ExplainPropertyBool("Parallel Safe", plan->parallel_safe, es);
 
        /*
         * The plan node ID isn't normally displayed, since it is only useful
         * for debugging.
         */
        ExplainPropertyInteger("Plan Node ID", NULL, plan->plan_node_id, es);
 
        /*
         * It is difficult to explain what extParam and allParam mean in plain
         * language, so we simply display these fields labelled with the
         * structure member name. For compactness, the text format omits the
         * display of this information when the bitmapset is empty.
         */
        if (es->format != EXPLAIN_FORMAT_TEXT || !bms_is_empty(plan->extParam))
            overexplain_bitmapset("extParam", plan->extParam, es);
        if (es->format != EXPLAIN_FORMAT_TEXT || !bms_is_empty(plan->allParam))
            overexplain_bitmapset("allParam", plan->allParam, es);
    }
 
    /*
     * If the "range_table" option was specified, display information about
     * the range table indexes for this node.
     */
    if (options->range_table)
    {
        bool        opened_elided_nodes = false;
 
        switch (nodeTag(plan))
        {
            case T_SeqScan:
            case T_SampleScan:
            case T_IndexScan:
            case T_IndexOnlyScan:
            case T_BitmapHeapScan:
            case T_TidScan:
            case T_TidRangeScan:
            case T_SubqueryScan:
            case T_FunctionScan:
            case T_TableFuncScan:
            case T_ValuesScan:
            case T_CteScan:
            case T_NamedTuplestoreScan:
            case T_WorkTableScan:
                ExplainPropertyInteger("Scan RTI", NULL,
                                       ((Scan *) plan)->scanrelid, es);
                break;
            case T_ForeignScan:
                overexplain_bitmapset("Scan RTIs",
                                      ((ForeignScan *) plan)->fs_base_relids,
                                      es);
                break;
            case T_CustomScan:
                overexplain_bitmapset("Scan RTIs",
                                      ((CustomScan *) plan)->custom_relids,
                                      es);
                break;
            case T_ModifyTable:
                ExplainPropertyInteger("Nominal RTI", NULL,
                                       ((ModifyTable *) plan)->nominalRelation, es);
                ExplainPropertyInteger("Exclude Relation RTI", NULL,
                                       ((ModifyTable *) plan)->exclRelRTI, es);
                break;
            case T_Append:
                overexplain_bitmapset("Append RTIs",
                                      ((Append *) plan)->apprelids,
                                      es);
                overexplain_bitmapset_list("Child Append RTIs",
                                           ((Append *) plan)->child_append_relid_sets,
                                           es);
                break;
            case T_MergeAppend:
                overexplain_bitmapset("Append RTIs",
                                      ((MergeAppend *) plan)->apprelids,
                                      es);
                overexplain_bitmapset_list("Child Append RTIs",
                                           ((MergeAppend *) plan)->child_append_relid_sets,
                                           es);
                break;
            case T_Result:
 
                /*
                 * 'relids' is only meaningful when plan->lefttree is NULL,
                 * but if somehow it ends up set when plan->lefttree is not
                 * NULL, print it anyway.
                 */
                if (plan->lefttree == NULL ||
                    ((Result *) plan)->relids != NULL)
                    overexplain_bitmapset("RTIs",
                                          ((Result *) plan)->relids,
                                          es);
                break;
            default:
                break;
        }
 
        foreach_node(ElidedNode, n, es->pstmt->elidedNodes)
        {
            char       *elidednodetag;
 
            if (n->plan_node_id != plan->plan_node_id)
                continue;
 
            if (!opened_elided_nodes)
            {
                ExplainOpenGroup("Elided Nodes", "Elided Nodes", false, es);
                opened_elided_nodes = true;
            }
 
            switch (n->elided_type)
            {
                case T_Append:
                    elidednodetag = "Append";
                    break;
                case T_MergeAppend:
                    elidednodetag = "MergeAppend";
                    break;
                case T_SubqueryScan:
                    elidednodetag = "SubqueryScan";
                    break;
                default:
                    elidednodetag = psprintf("%d", n->elided_type);
                    break;
            }
 
            ExplainOpenGroup("Elided Node", NULL, true, es);
            ExplainPropertyText("Elided Node Type", elidednodetag, es);
            overexplain_bitmapset("Elided Node RTIs", n->relids, es);
            ExplainCloseGroup("Elided Node", NULL, true, es);
        }
        if (opened_elided_nodes)
            ExplainCloseGroup("Elided Nodes", "Elided Nodes", false, es);
    }
}

References bms_is_empty, PlannedStmt::elidedNodes, es_extension_id, EXPLAIN_FORMAT_TEXT, ExplainCloseGroup(), ExplainOpenGroup(), ExplainPropertyBool(), ExplainPropertyInteger(), ExplainPropertyText(), fb(), foreach_node, ExplainState::format, GetExplainExtensionState(), nodeTag, overexplain_bitmapset(), overexplain_bitmapset_list(), PlanState::plan, plan, prev_explain_per_node_hook, psprintf(), and ExplainState::pstmt.

Referenced by _PG_init().

overexplain_per_plan_hook()

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

static

Definition at line 314 of file pg_overexplain.c.

{
    overexplain_options *options;
 
    if (prev_explain_per_plan_hook)
        (*prev_explain_per_plan_hook) (plannedstmt, into, es, queryString,
                                       params, queryEnv);
 
    options = GetExplainExtensionState(es, es_extension_id);
    if (options == NULL)
        return;
 
    if (options->debug)
        overexplain_debug(plannedstmt, es);
 
    if (options->range_table)
        overexplain_range_table(plannedstmt, es);
}

References es_extension_id, fb(), GetExplainExtensionState(), overexplain_debug(), overexplain_range_table(), and prev_explain_per_plan_hook.

Referenced by _PG_init().

overexplain_range_table()

static void overexplain_range_table ( PlannedStmt *  plannedstmt, ExplainState *  es  )

static

Definition at line 445 of file pg_overexplain.c.

{
    Index       rti;
    ListCell   *lc_subrtinfo = list_head(plannedstmt->subrtinfos);
    SubPlanRTInfo *rtinfo = NULL;
 
    /* Open group, one entry per RangeTblEntry */
    ExplainOpenGroup("Range Table", "Range Table", false, es);
 
    /* Iterate over the range table */
    for (rti = 1; rti <= list_length(plannedstmt->rtable); ++rti)
    {
        RangeTblEntry *rte = rt_fetch(rti, plannedstmt->rtable);
        char       *kind = NULL;
        char       *relkind;
        SubPlanRTInfo *next_rtinfo;
 
        /* Advance to next SubRTInfo, if it's time. */
        if (lc_subrtinfo != NULL)
        {
            next_rtinfo = lfirst(lc_subrtinfo);
            if (rti > next_rtinfo->rtoffset)
            {
                rtinfo = next_rtinfo;
                lc_subrtinfo = lnext(plannedstmt->subrtinfos, lc_subrtinfo);
            }
        }
 
        /* NULL entries are possible; skip them */
        if (rte == NULL)
            continue;
 
        /* Translate rtekind to a string */
        switch (rte->rtekind)
        {
            case RTE_RELATION:
                kind = "relation";
                break;
            case RTE_SUBQUERY:
                kind = "subquery";
                break;
            case RTE_JOIN:
                kind = "join";
                break;
            case RTE_FUNCTION:
                kind = "function";
                break;
            case RTE_TABLEFUNC:
                kind = "tablefunc";
                break;
            case RTE_VALUES:
                kind = "values";
                break;
            case RTE_CTE:
                kind = "cte";
                break;
            case RTE_NAMEDTUPLESTORE:
                kind = "namedtuplestore";
                break;
            case RTE_RESULT:
                kind = "result";
                break;
            case RTE_GROUP:
                kind = "group";
                break;
            case RTE_GRAPH_TABLE:
 
                /*
                 * We should not see RTE of this kind here since property
                 * graph RTE gets converted to subquery RTE in
                 * RewriteGraphTable(). In case we decide not to do the
                 * conversion and leave RTEkind unchanged in future, print
                 * correct name of RTE kind.
                 */
                kind = "graph_table";
                break;
        }
 
        /* Begin group for this specific RTE */
        ExplainOpenGroup("Range Table Entry", NULL, true, es);
 
        /*
         * In text format, the summary line displays the range table index and
         * rtekind, plus indications if rte->inh and/or rte->inFromCl are set.
         * In other formats, we display those as separate properties.
         */
        if (es->format == EXPLAIN_FORMAT_TEXT)
        {
            ExplainIndentText(es);
            appendStringInfo(es->str, "RTI %u (%s%s%s):\n", rti, kind,
                             rte->inh ? ", inherited" : "",
                             rte->inFromCl ? ", in-from-clause" : "");
            es->indent++;
        }
        else
        {
            ExplainPropertyUInteger("RTI", NULL, rti, es);
            ExplainPropertyText("Kind", kind, es);
            ExplainPropertyBool("Inherited", rte->inh, es);
            ExplainPropertyBool("In From Clause", rte->inFromCl, es);
        }
 
        /*
         * Indicate which subplan is the origin of which RTE. Note dummy
         * subplans. Here again, we crunch more onto one line in text format.
         */
        if (rtinfo != NULL)
        {
            if (es->format == EXPLAIN_FORMAT_TEXT)
            {
                if (!rtinfo->dummy)
                    ExplainPropertyText("Subplan", rtinfo->plan_name, es);
                else
                    ExplainPropertyText("Subplan",
                                        psprintf("%s (dummy)",
                                                 rtinfo->plan_name), es);
            }
            else
            {
                ExplainPropertyText("Subplan", rtinfo->plan_name, es);
                ExplainPropertyBool("Subplan Is Dummy", rtinfo->dummy, es);
            }
        }
 
        /* rte->alias is optional; rte->eref is requested */
        if (rte->alias != NULL)
            overexplain_alias("Alias", rte->alias, es);
        overexplain_alias("Eref", rte->eref, es);
 
        /*
         * We adhere to the usual EXPLAIN convention that schema names are
         * displayed only in verbose mode, and we emit nothing if there is no
         * relation OID.
         */
        if (rte->relid != 0)
        {
            const char *relname;
            const char *qualname;
 
            relname = quote_identifier(get_rel_name(rte->relid));
 
            if (es->verbose)
            {
                Oid         nspoid = get_rel_namespace(rte->relid);
                char       *nspname;
 
                nspname = get_namespace_name_or_temp(nspoid);
                qualname = psprintf("%s.%s", quote_identifier(nspname),
                                    relname);
            }
            else
                qualname = relname;
 
            ExplainPropertyText("Relation", qualname, es);
        }
 
        /* Translate relkind, if any, to a string */
        switch (rte->relkind)
        {
            case RELKIND_RELATION:
                relkind = "relation";
                break;
            case RELKIND_INDEX:
                relkind = "index";
                break;
            case RELKIND_SEQUENCE:
                relkind = "sequence";
                break;
            case RELKIND_TOASTVALUE:
                relkind = "toastvalue";
                break;
            case RELKIND_VIEW:
                relkind = "view";
                break;
            case RELKIND_MATVIEW:
                relkind = "matview";
                break;
            case RELKIND_COMPOSITE_TYPE:
                relkind = "composite_type";
                break;
            case RELKIND_FOREIGN_TABLE:
                relkind = "foreign_table";
                break;
            case RELKIND_PARTITIONED_TABLE:
                relkind = "partitioned_table";
                break;
            case RELKIND_PARTITIONED_INDEX:
                relkind = "partitioned_index";
                break;
            case RELKIND_PROPGRAPH:
                relkind = "property_graph";
                break;
            case '\0':
                relkind = NULL;
                break;
            default:
                relkind = psprintf("%c", rte->relkind);
                break;
        }
 
        /* If there is a relkind, show it */
        if (relkind != NULL)
            ExplainPropertyText("Relation Kind", relkind, es);
 
        /* If there is a lock mode, show it */
        if (rte->rellockmode != 0)
            ExplainPropertyText("Relation Lock Mode",
                                GetLockmodeName(DEFAULT_LOCKMETHOD,
                                                rte->rellockmode), es);
 
        /*
         * If there is a perminfoindex, show it. We don't try to display
         * information from the RTEPermissionInfo node here because they are
         * just indexes plannedstmt->permInfos which could be separately
         * dumped if someone wants to add EXPLAIN (PERMISSIONS) or similar.
         */
        if (rte->perminfoindex != 0)
            ExplainPropertyInteger("Permission Info Index", NULL,
                                   rte->perminfoindex, es);
 
        /*
         * add_rte_to_flat_rtable will clear rte->tablesample and
         * rte->subquery in the finished plan, so skip those fields.
         *
         * However, the security_barrier flag is not shown by the core code,
         * so let's print it here.
         */
        if (es->format != EXPLAIN_FORMAT_TEXT || rte->security_barrier)
            ExplainPropertyBool("Security Barrier", rte->security_barrier, es);
 
        /*
         * If this is a join, print out the fields that are specifically valid
         * for joins.
         */
        if (rte->rtekind == RTE_JOIN)
        {
            char       *jointype;
 
            switch (rte->jointype)
            {
                case JOIN_INNER:
                    jointype = "Inner";
                    break;
                case JOIN_LEFT:
                    jointype = "Left";
                    break;
                case JOIN_FULL:
                    jointype = "Full";
                    break;
                case JOIN_RIGHT:
                    jointype = "Right";
                    break;
                case JOIN_SEMI:
                    jointype = "Semi";
                    break;
                case JOIN_ANTI:
                    jointype = "Anti";
                    break;
                case JOIN_RIGHT_SEMI:
                    jointype = "Right Semi";
                    break;
                case JOIN_RIGHT_ANTI:
                    jointype = "Right Anti";
                    break;
                default:
                    jointype = "???";
                    break;
            }
 
            /* Join type */
            ExplainPropertyText("Join Type", jointype, es);
 
            /* # of JOIN USING columns */
            if (es->format != EXPLAIN_FORMAT_TEXT || rte->joinmergedcols != 0)
                ExplainPropertyInteger("JOIN USING Columns", NULL,
                                       rte->joinmergedcols, es);
 
            /*
             * add_rte_to_flat_rtable will clear joinaliasvars, joinleftcols,
             * joinrightcols, and join_using_alias here, so skip those fields.
             */
        }
 
        /*
         * add_rte_to_flat_rtable will clear functions, tablefunc, and
         * values_lists, but we can display funcordinality.
         */
        if (rte->rtekind == RTE_FUNCTION)
            ExplainPropertyBool("WITH ORDINALITY", rte->funcordinality, es);
 
        /*
         * If this is a CTE, print out CTE-related properties.
         */
        if (rte->rtekind == RTE_CTE)
        {
            ExplainPropertyText("CTE Name", rte->ctename, es);
            ExplainPropertyUInteger("CTE Levels Up", NULL, rte->ctelevelsup,
                                    es);
            ExplainPropertyBool("CTE Self-Reference", rte->self_reference, es);
        }
 
        /*
         * add_rte_to_flat_rtable will clear coltypes, coltypmods, and
         * colcollations, so skip those fields.
         *
         * If this is an ephemeral named relation, print out ENR-related
         * properties.
         */
        if (rte->rtekind == RTE_NAMEDTUPLESTORE)
        {
            ExplainPropertyText("ENR Name", rte->enrname, es);
            ExplainPropertyFloat("ENR Tuples", NULL, rte->enrtuples, 0, es);
        }
 
        /*
         * rewriteGraphTable() clears graph_pattern and graph_table_columns
         * fields, so skip them. No graph table specific fields are required
         * to be printed.
         */
 
        /*
         * add_rte_to_flat_rtable will clear groupexprs and securityQuals, so
         * skip that field. We have handled inFromCl above, so the only thing
         * left to handle here is rte->lateral.
         */
        if (es->format != EXPLAIN_FORMAT_TEXT || rte->lateral)
            ExplainPropertyBool("Lateral", rte->lateral, es);
 
        /* Done with this RTE */
        if (es->format == EXPLAIN_FORMAT_TEXT)
            es->indent--;
        ExplainCloseGroup("Range Table Entry", NULL, true, es);
    }
 
    /* Close the Range Table array before emitting PlannedStmt-level fields. */
    ExplainCloseGroup("Range Table", "Range Table", false, es);
 
    /*
     * Print PlannedStmt fields that contain RTIs.  These are properties of
     * the PlannedStmt, not of individual RTEs, so they belong outside the
     * Range Table array.
     */
    if (es->format != EXPLAIN_FORMAT_TEXT ||
        !bms_is_empty(plannedstmt->unprunableRelids))
        overexplain_bitmapset("Unprunable RTIs", plannedstmt->unprunableRelids,
                              es);
    if (es->format != EXPLAIN_FORMAT_TEXT ||
        !bms_is_empty(plannedstmt->resultRelationRelids))
        overexplain_bitmapset("Result RTIs", plannedstmt->resultRelationRelids,
                              es);
}

References appendStringInfo(), bms_is_empty, DEFAULT_LOCKMETHOD, EXPLAIN_FORMAT_TEXT, ExplainCloseGroup(), ExplainIndentText(), ExplainOpenGroup(), ExplainPropertyBool(), ExplainPropertyFloat(), ExplainPropertyInteger(), ExplainPropertyText(), ExplainPropertyUInteger(), fb(), ExplainState::format, get_namespace_name_or_temp(), get_rel_name(), get_rel_namespace(), GetLockmodeName(), ExplainState::indent, JOIN_ANTI, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, JOIN_RIGHT_ANTI, JOIN_RIGHT_SEMI, JOIN_SEMI, lfirst, list_head(), list_length(), lnext(), overexplain_alias(), overexplain_bitmapset(), psprintf(), quote_identifier(), relname, PlannedStmt::resultRelationRelids, rt_fetch, PlannedStmt::rtable, RTE_CTE, RTE_FUNCTION, RTE_GRAPH_TABLE, RTE_GROUP, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, ExplainState::str, PlannedStmt::subrtinfos, PlannedStmt::unprunableRelids, and ExplainState::verbose.

Referenced by overexplain_per_plan_hook().

overexplain_range_table_handler()

static void overexplain_range_table_handler ( ExplainState *  es, DefElem *  opt, ParseState *  pstate  )

static

Definition at line 124 of file pg_overexplain.c.

{
    overexplain_options *options = overexplain_ensure_options(es);
 
    options->range_table = defGetBoolean(opt);
}

References defGetBoolean(), and overexplain_ensure_options().

Referenced by _PG_init().

PG_MODULE_MAGIC_EXT()

PG_MODULE_MAGIC_EXT	(	.	name = "pg_overexplain",
		.	version = PG_VERSION
	)

Variable Documentation

es_extension_id

int es_extension_id

static

Definition at line 62 of file pg_overexplain.c.

Referenced by _PG_init(), overexplain_ensure_options(), overexplain_per_node_hook(), and overexplain_per_plan_hook().

prev_explain_per_node_hook

explain_per_node_hook_type prev_explain_per_node_hook

static

Definition at line 63 of file pg_overexplain.c.

Referenced by _PG_init(), and overexplain_per_node_hook().

prev_explain_per_plan_hook

explain_per_plan_hook_type prev_explain_per_plan_hook

static

Definition at line 64 of file pg_overexplain.c.

Referenced by _PG_init(), and overexplain_per_plan_hook().