d3d3ec0d89
It is possible for a NestLoop plan node to pass an OUTER Var into an "inner indexscan" that is an Append construct (derived from an inheritance tree or UNION ALL subquery). The OUTER tuple is then passed down at runtime to the leaf indexscan node(s) where it will actually be used. EXPLAIN has to likewise pass the information about the nestloop's outer subplan down through the Append node, else it will fail to print the outer-reference Vars (with complaints like "bogus varno: 65001"). However, there was a case missed in all this: we could also have gating Result nodes that were inserted into the appendrel plan tree to deal with pseudoconstant qual conditions. So EXPLAIN has to pass down the outer plan node to a Result's subplan, too. Per example from Jon Nelson. The problem is gone in 9.1 because we replaced the nestloop outer-tuple kluge with a Param-based data transfer mechanism. Also, so far as I can tell, the case can't happen before 8.4 because of restrictions on what sorts of appendrel members could be pulled up into the parent query. So this patch is only needed for 8.4 and 9.0.
1346 lines
34 KiB
C
1346 lines
34 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* explain.c
|
|
* Explain query execution plans
|
|
*
|
|
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994-5, Regents of the University of California
|
|
*
|
|
* IDENTIFICATION
|
|
* $PostgreSQL: pgsql/src/backend/commands/explain.c,v 1.186 2009/06/11 14:48:55 momjian Exp $
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#include "postgres.h"
|
|
|
|
#include "access/xact.h"
|
|
#include "catalog/pg_constraint.h"
|
|
#include "catalog/pg_type.h"
|
|
#include "commands/explain.h"
|
|
#include "commands/prepare.h"
|
|
#include "commands/trigger.h"
|
|
#include "executor/instrument.h"
|
|
#include "optimizer/clauses.h"
|
|
#include "optimizer/planner.h"
|
|
#include "optimizer/var.h"
|
|
#include "parser/parsetree.h"
|
|
#include "rewrite/rewriteHandler.h"
|
|
#include "tcop/tcopprot.h"
|
|
#include "utils/builtins.h"
|
|
#include "utils/guc.h"
|
|
#include "utils/lsyscache.h"
|
|
#include "utils/tuplesort.h"
|
|
#include "utils/snapmgr.h"
|
|
|
|
|
|
/* Hook for plugins to get control in ExplainOneQuery() */
|
|
ExplainOneQuery_hook_type ExplainOneQuery_hook = NULL;
|
|
|
|
/* Hook for plugins to get control in explain_get_index_name() */
|
|
explain_get_index_name_hook_type explain_get_index_name_hook = NULL;
|
|
|
|
|
|
typedef struct ExplainState
|
|
{
|
|
/* options */
|
|
bool printTList; /* print plan targetlists */
|
|
bool printAnalyze; /* print actual times */
|
|
/* other states */
|
|
PlannedStmt *pstmt; /* top of plan */
|
|
List *rtable; /* range table */
|
|
} ExplainState;
|
|
|
|
static void ExplainOneQuery(Query *query, ExplainStmt *stmt,
|
|
const char *queryString,
|
|
ParamListInfo params, TupOutputState *tstate);
|
|
static void report_triggers(ResultRelInfo *rInfo, bool show_relname,
|
|
StringInfo buf);
|
|
static double elapsed_time(instr_time *starttime);
|
|
static void explain_outNode(StringInfo str,
|
|
Plan *plan, PlanState *planstate,
|
|
Plan *outer_plan,
|
|
int indent, ExplainState *es);
|
|
static void show_plan_tlist(Plan *plan,
|
|
StringInfo str, int indent, ExplainState *es);
|
|
static void show_scan_qual(List *qual, const char *qlabel,
|
|
int scanrelid, Plan *scan_plan, Plan *outer_plan,
|
|
StringInfo str, int indent, ExplainState *es);
|
|
static void show_upper_qual(List *qual, const char *qlabel, Plan *plan,
|
|
StringInfo str, int indent, ExplainState *es);
|
|
static void show_sort_keys(Plan *sortplan, int nkeys, AttrNumber *keycols,
|
|
const char *qlabel,
|
|
StringInfo str, int indent, ExplainState *es);
|
|
static void show_sort_info(SortState *sortstate,
|
|
StringInfo str, int indent, ExplainState *es);
|
|
static const char *explain_get_index_name(Oid indexId);
|
|
|
|
|
|
/*
|
|
* ExplainQuery -
|
|
* execute an EXPLAIN command
|
|
*/
|
|
void
|
|
ExplainQuery(ExplainStmt *stmt, const char *queryString,
|
|
ParamListInfo params, DestReceiver *dest)
|
|
{
|
|
Oid *param_types;
|
|
int num_params;
|
|
TupOutputState *tstate;
|
|
List *rewritten;
|
|
ListCell *l;
|
|
|
|
/* Convert parameter type data to the form parser wants */
|
|
getParamListTypes(params, ¶m_types, &num_params);
|
|
|
|
/*
|
|
* Run parse analysis and rewrite. Note this also acquires sufficient
|
|
* locks on the source table(s).
|
|
*
|
|
* Because the parser and planner tend to scribble on their input, we make
|
|
* a preliminary copy of the source querytree. This prevents problems in
|
|
* the case that the EXPLAIN is in a portal or plpgsql function and is
|
|
* executed repeatedly. (See also the same hack in DECLARE CURSOR and
|
|
* PREPARE.) XXX FIXME someday.
|
|
*/
|
|
rewritten = pg_analyze_and_rewrite((Node *) copyObject(stmt->query),
|
|
queryString, param_types, num_params);
|
|
|
|
/* prepare for projection of tuples */
|
|
tstate = begin_tup_output_tupdesc(dest, ExplainResultDesc(stmt));
|
|
|
|
if (rewritten == NIL)
|
|
{
|
|
/* In the case of an INSTEAD NOTHING, tell at least that */
|
|
do_text_output_oneline(tstate, "Query rewrites to nothing");
|
|
}
|
|
else
|
|
{
|
|
/* Explain every plan */
|
|
foreach(l, rewritten)
|
|
{
|
|
ExplainOneQuery((Query *) lfirst(l), stmt,
|
|
queryString, params, tstate);
|
|
/* put a blank line between plans */
|
|
if (lnext(l) != NULL)
|
|
do_text_output_oneline(tstate, "");
|
|
}
|
|
}
|
|
|
|
end_tup_output(tstate);
|
|
}
|
|
|
|
/*
|
|
* ExplainResultDesc -
|
|
* construct the result tupledesc for an EXPLAIN
|
|
*/
|
|
TupleDesc
|
|
ExplainResultDesc(ExplainStmt *stmt)
|
|
{
|
|
TupleDesc tupdesc;
|
|
|
|
/* need a tuple descriptor representing a single TEXT column */
|
|
tupdesc = CreateTemplateTupleDesc(1, false);
|
|
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "QUERY PLAN",
|
|
TEXTOID, -1, 0);
|
|
return tupdesc;
|
|
}
|
|
|
|
/*
|
|
* ExplainOneQuery -
|
|
* print out the execution plan for one Query
|
|
*/
|
|
static void
|
|
ExplainOneQuery(Query *query, ExplainStmt *stmt, const char *queryString,
|
|
ParamListInfo params, TupOutputState *tstate)
|
|
{
|
|
/* planner will not cope with utility statements */
|
|
if (query->commandType == CMD_UTILITY)
|
|
{
|
|
ExplainOneUtility(query->utilityStmt, stmt,
|
|
queryString, params, tstate);
|
|
return;
|
|
}
|
|
|
|
/* if an advisor plugin is present, let it manage things */
|
|
if (ExplainOneQuery_hook)
|
|
(*ExplainOneQuery_hook) (query, stmt, queryString, params, tstate);
|
|
else
|
|
{
|
|
PlannedStmt *plan;
|
|
|
|
/* plan the query */
|
|
plan = pg_plan_query(query, 0, params);
|
|
|
|
/* run it (if needed) and produce output */
|
|
ExplainOnePlan(plan, stmt, queryString, params, tstate);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* ExplainOneUtility -
|
|
* print out the execution plan for one utility statement
|
|
* (In general, utility statements don't have plans, but there are some
|
|
* we treat as special cases)
|
|
*
|
|
* This is exported because it's called back from prepare.c in the
|
|
* EXPLAIN EXECUTE case
|
|
*/
|
|
void
|
|
ExplainOneUtility(Node *utilityStmt, ExplainStmt *stmt,
|
|
const char *queryString, ParamListInfo params,
|
|
TupOutputState *tstate)
|
|
{
|
|
if (utilityStmt == NULL)
|
|
return;
|
|
|
|
if (IsA(utilityStmt, ExecuteStmt))
|
|
ExplainExecuteQuery((ExecuteStmt *) utilityStmt, stmt,
|
|
queryString, params, tstate);
|
|
else if (IsA(utilityStmt, NotifyStmt))
|
|
do_text_output_oneline(tstate, "NOTIFY");
|
|
else
|
|
do_text_output_oneline(tstate,
|
|
"Utility statements have no plan structure");
|
|
}
|
|
|
|
/*
|
|
* ExplainOnePlan -
|
|
* given a planned query, execute it if needed, and then print
|
|
* EXPLAIN output
|
|
*
|
|
* Since we ignore any DeclareCursorStmt that might be attached to the query,
|
|
* 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.
|
|
*
|
|
* This is exported because it's called back from prepare.c in the
|
|
* EXPLAIN EXECUTE case, and because an index advisor plugin would need
|
|
* to call it.
|
|
*/
|
|
void
|
|
ExplainOnePlan(PlannedStmt *plannedstmt, ExplainStmt *stmt,
|
|
const char *queryString, ParamListInfo params,
|
|
TupOutputState *tstate)
|
|
{
|
|
QueryDesc *queryDesc;
|
|
instr_time starttime;
|
|
double totaltime = 0;
|
|
StringInfoData buf;
|
|
int eflags;
|
|
|
|
/*
|
|
* Use a snapshot with an updated command ID to ensure this query sees
|
|
* results of any previously executed queries.
|
|
*/
|
|
PushUpdatedSnapshot(GetActiveSnapshot());
|
|
|
|
/* Create a QueryDesc requesting no output */
|
|
queryDesc = CreateQueryDesc(plannedstmt, queryString,
|
|
GetActiveSnapshot(), InvalidSnapshot,
|
|
None_Receiver, params,
|
|
stmt->analyze);
|
|
|
|
INSTR_TIME_SET_CURRENT(starttime);
|
|
|
|
/* If analyzing, we need to cope with queued triggers */
|
|
if (stmt->analyze)
|
|
AfterTriggerBeginQuery();
|
|
|
|
/* Select execution options */
|
|
if (stmt->analyze)
|
|
eflags = 0; /* default run-to-completion flags */
|
|
else
|
|
eflags = EXEC_FLAG_EXPLAIN_ONLY;
|
|
|
|
/* call ExecutorStart to prepare the plan for execution */
|
|
ExecutorStart(queryDesc, eflags);
|
|
|
|
/* Execute the plan for statistics if asked for */
|
|
if (stmt->analyze)
|
|
{
|
|
/* run the plan */
|
|
ExecutorRun(queryDesc, ForwardScanDirection, 0L);
|
|
|
|
/* We can't clean up 'till we're done printing the stats... */
|
|
totaltime += elapsed_time(&starttime);
|
|
}
|
|
|
|
/* Create textual dump of plan tree */
|
|
initStringInfo(&buf);
|
|
ExplainPrintPlan(&buf, queryDesc, stmt->analyze, stmt->verbose);
|
|
|
|
/*
|
|
* If we ran the command, run any AFTER triggers it queued. (Note this
|
|
* will not include DEFERRED triggers; since those don't run until end of
|
|
* transaction, we can't measure them.) Include into total runtime.
|
|
*/
|
|
if (stmt->analyze)
|
|
{
|
|
INSTR_TIME_SET_CURRENT(starttime);
|
|
AfterTriggerEndQuery(queryDesc->estate);
|
|
totaltime += elapsed_time(&starttime);
|
|
}
|
|
|
|
/* Print info about runtime of triggers */
|
|
if (stmt->analyze)
|
|
{
|
|
ResultRelInfo *rInfo;
|
|
bool show_relname;
|
|
int numrels = queryDesc->estate->es_num_result_relations;
|
|
List *targrels = queryDesc->estate->es_trig_target_relations;
|
|
int nr;
|
|
ListCell *l;
|
|
|
|
show_relname = (numrels > 1 || targrels != NIL);
|
|
rInfo = queryDesc->estate->es_result_relations;
|
|
for (nr = 0; nr < numrels; rInfo++, nr++)
|
|
report_triggers(rInfo, show_relname, &buf);
|
|
|
|
foreach(l, targrels)
|
|
{
|
|
rInfo = (ResultRelInfo *) lfirst(l);
|
|
report_triggers(rInfo, show_relname, &buf);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Close down the query and free resources. Include time for this in the
|
|
* total runtime (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 (stmt->analyze)
|
|
CommandCounterIncrement();
|
|
|
|
totaltime += elapsed_time(&starttime);
|
|
|
|
if (stmt->analyze)
|
|
appendStringInfo(&buf, "Total runtime: %.3f ms\n",
|
|
1000.0 * totaltime);
|
|
do_text_output_multiline(tstate, buf.data);
|
|
|
|
pfree(buf.data);
|
|
}
|
|
|
|
/*
|
|
* ExplainPrintPlan -
|
|
* convert a QueryDesc's plan tree to text and append it to 'str'
|
|
*
|
|
* 'analyze' means to include runtime instrumentation results
|
|
* 'verbose' means a verbose printout (currently, it shows targetlists)
|
|
*
|
|
* NB: will not work on utility statements
|
|
*/
|
|
void
|
|
ExplainPrintPlan(StringInfo str, QueryDesc *queryDesc,
|
|
bool analyze, bool verbose)
|
|
{
|
|
ExplainState es;
|
|
|
|
Assert(queryDesc->plannedstmt != NULL);
|
|
|
|
memset(&es, 0, sizeof(es));
|
|
es.printTList = verbose;
|
|
es.printAnalyze = analyze;
|
|
es.pstmt = queryDesc->plannedstmt;
|
|
es.rtable = queryDesc->plannedstmt->rtable;
|
|
|
|
explain_outNode(str,
|
|
queryDesc->plannedstmt->planTree, queryDesc->planstate,
|
|
NULL, 0, &es);
|
|
}
|
|
|
|
/*
|
|
* report_triggers -
|
|
* report execution stats for a single relation's triggers
|
|
*/
|
|
static void
|
|
report_triggers(ResultRelInfo *rInfo, bool show_relname, StringInfo buf)
|
|
{
|
|
int nt;
|
|
|
|
if (!rInfo->ri_TrigDesc || !rInfo->ri_TrigInstrument)
|
|
return;
|
|
for (nt = 0; nt < rInfo->ri_TrigDesc->numtriggers; nt++)
|
|
{
|
|
Trigger *trig = rInfo->ri_TrigDesc->triggers + nt;
|
|
Instrumentation *instr = rInfo->ri_TrigInstrument + nt;
|
|
char *conname;
|
|
|
|
/* Must clean up instrumentation state */
|
|
InstrEndLoop(instr);
|
|
|
|
/*
|
|
* We ignore triggers that were never invoked; they likely aren't
|
|
* relevant to the current query type.
|
|
*/
|
|
if (instr->ntuples == 0)
|
|
continue;
|
|
|
|
if (OidIsValid(trig->tgconstraint) &&
|
|
(conname = get_constraint_name(trig->tgconstraint)) != NULL)
|
|
{
|
|
appendStringInfo(buf, "Trigger for constraint %s", conname);
|
|
pfree(conname);
|
|
}
|
|
else
|
|
appendStringInfo(buf, "Trigger %s", trig->tgname);
|
|
|
|
if (show_relname)
|
|
appendStringInfo(buf, " on %s",
|
|
RelationGetRelationName(rInfo->ri_RelationDesc));
|
|
|
|
appendStringInfo(buf, ": time=%.3f calls=%.0f\n",
|
|
1000.0 * instr->total, instr->ntuples);
|
|
}
|
|
}
|
|
|
|
/* Compute elapsed time in seconds since given timestamp */
|
|
static double
|
|
elapsed_time(instr_time *starttime)
|
|
{
|
|
instr_time endtime;
|
|
|
|
INSTR_TIME_SET_CURRENT(endtime);
|
|
INSTR_TIME_SUBTRACT(endtime, *starttime);
|
|
return INSTR_TIME_GET_DOUBLE(endtime);
|
|
}
|
|
|
|
/*
|
|
* explain_outNode -
|
|
* converts a Plan node into ascii string and appends it to 'str'
|
|
*
|
|
* planstate points to the executor state node corresponding to the plan node.
|
|
* We need this to get at the instrumentation data (if any) as well as the
|
|
* list of subplans.
|
|
*
|
|
* outer_plan, if not null, references another plan node that is the outer
|
|
* side of a join with the current node. This is only interesting for
|
|
* deciphering runtime keys of an inner indexscan.
|
|
*/
|
|
static void
|
|
explain_outNode(StringInfo str,
|
|
Plan *plan, PlanState *planstate,
|
|
Plan *outer_plan,
|
|
int indent, ExplainState *es)
|
|
{
|
|
const char *pname;
|
|
int i;
|
|
|
|
if (plan == NULL)
|
|
{
|
|
appendStringInfoChar(str, '\n');
|
|
return;
|
|
}
|
|
|
|
switch (nodeTag(plan))
|
|
{
|
|
case T_Result:
|
|
pname = "Result";
|
|
break;
|
|
case T_Append:
|
|
pname = "Append";
|
|
break;
|
|
case T_RecursiveUnion:
|
|
pname = "Recursive Union";
|
|
break;
|
|
case T_BitmapAnd:
|
|
pname = "BitmapAnd";
|
|
break;
|
|
case T_BitmapOr:
|
|
pname = "BitmapOr";
|
|
break;
|
|
case T_NestLoop:
|
|
switch (((NestLoop *) plan)->join.jointype)
|
|
{
|
|
case JOIN_INNER:
|
|
pname = "Nested Loop";
|
|
break;
|
|
case JOIN_LEFT:
|
|
pname = "Nested Loop Left Join";
|
|
break;
|
|
case JOIN_FULL:
|
|
pname = "Nested Loop Full Join";
|
|
break;
|
|
case JOIN_RIGHT:
|
|
pname = "Nested Loop Right Join";
|
|
break;
|
|
case JOIN_SEMI:
|
|
pname = "Nested Loop Semi Join";
|
|
break;
|
|
case JOIN_ANTI:
|
|
pname = "Nested Loop Anti Join";
|
|
break;
|
|
default:
|
|
pname = "Nested Loop ??? Join";
|
|
break;
|
|
}
|
|
break;
|
|
case T_MergeJoin:
|
|
switch (((MergeJoin *) plan)->join.jointype)
|
|
{
|
|
case JOIN_INNER:
|
|
pname = "Merge Join";
|
|
break;
|
|
case JOIN_LEFT:
|
|
pname = "Merge Left Join";
|
|
break;
|
|
case JOIN_FULL:
|
|
pname = "Merge Full Join";
|
|
break;
|
|
case JOIN_RIGHT:
|
|
pname = "Merge Right Join";
|
|
break;
|
|
case JOIN_SEMI:
|
|
pname = "Merge Semi Join";
|
|
break;
|
|
case JOIN_ANTI:
|
|
pname = "Merge Anti Join";
|
|
break;
|
|
default:
|
|
pname = "Merge ??? Join";
|
|
break;
|
|
}
|
|
break;
|
|
case T_HashJoin:
|
|
switch (((HashJoin *) plan)->join.jointype)
|
|
{
|
|
case JOIN_INNER:
|
|
pname = "Hash Join";
|
|
break;
|
|
case JOIN_LEFT:
|
|
pname = "Hash Left Join";
|
|
break;
|
|
case JOIN_FULL:
|
|
pname = "Hash Full Join";
|
|
break;
|
|
case JOIN_RIGHT:
|
|
pname = "Hash Right Join";
|
|
break;
|
|
case JOIN_SEMI:
|
|
pname = "Hash Semi Join";
|
|
break;
|
|
case JOIN_ANTI:
|
|
pname = "Hash Anti Join";
|
|
break;
|
|
default:
|
|
pname = "Hash ??? Join";
|
|
break;
|
|
}
|
|
break;
|
|
case T_SeqScan:
|
|
pname = "Seq Scan";
|
|
break;
|
|
case T_IndexScan:
|
|
pname = "Index Scan";
|
|
break;
|
|
case T_BitmapIndexScan:
|
|
pname = "Bitmap Index Scan";
|
|
break;
|
|
case T_BitmapHeapScan:
|
|
pname = "Bitmap Heap Scan";
|
|
break;
|
|
case T_TidScan:
|
|
pname = "Tid Scan";
|
|
break;
|
|
case T_SubqueryScan:
|
|
pname = "Subquery Scan";
|
|
break;
|
|
case T_FunctionScan:
|
|
pname = "Function Scan";
|
|
break;
|
|
case T_ValuesScan:
|
|
pname = "Values Scan";
|
|
break;
|
|
case T_CteScan:
|
|
pname = "CTE Scan";
|
|
break;
|
|
case T_WorkTableScan:
|
|
pname = "WorkTable Scan";
|
|
break;
|
|
case T_Material:
|
|
pname = "Materialize";
|
|
break;
|
|
case T_Sort:
|
|
pname = "Sort";
|
|
break;
|
|
case T_Group:
|
|
pname = "Group";
|
|
break;
|
|
case T_Agg:
|
|
switch (((Agg *) plan)->aggstrategy)
|
|
{
|
|
case AGG_PLAIN:
|
|
pname = "Aggregate";
|
|
break;
|
|
case AGG_SORTED:
|
|
pname = "GroupAggregate";
|
|
break;
|
|
case AGG_HASHED:
|
|
pname = "HashAggregate";
|
|
break;
|
|
default:
|
|
pname = "Aggregate ???";
|
|
break;
|
|
}
|
|
break;
|
|
case T_WindowAgg:
|
|
pname = "WindowAgg";
|
|
break;
|
|
case T_Unique:
|
|
pname = "Unique";
|
|
break;
|
|
case T_SetOp:
|
|
switch (((SetOp *) plan)->strategy)
|
|
{
|
|
case SETOP_SORTED:
|
|
switch (((SetOp *) plan)->cmd)
|
|
{
|
|
case SETOPCMD_INTERSECT:
|
|
pname = "SetOp Intersect";
|
|
break;
|
|
case SETOPCMD_INTERSECT_ALL:
|
|
pname = "SetOp Intersect All";
|
|
break;
|
|
case SETOPCMD_EXCEPT:
|
|
pname = "SetOp Except";
|
|
break;
|
|
case SETOPCMD_EXCEPT_ALL:
|
|
pname = "SetOp Except All";
|
|
break;
|
|
default:
|
|
pname = "SetOp ???";
|
|
break;
|
|
}
|
|
break;
|
|
case SETOP_HASHED:
|
|
switch (((SetOp *) plan)->cmd)
|
|
{
|
|
case SETOPCMD_INTERSECT:
|
|
pname = "HashSetOp Intersect";
|
|
break;
|
|
case SETOPCMD_INTERSECT_ALL:
|
|
pname = "HashSetOp Intersect All";
|
|
break;
|
|
case SETOPCMD_EXCEPT:
|
|
pname = "HashSetOp Except";
|
|
break;
|
|
case SETOPCMD_EXCEPT_ALL:
|
|
pname = "HashSetOp Except All";
|
|
break;
|
|
default:
|
|
pname = "HashSetOp ???";
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
pname = "SetOp ???";
|
|
break;
|
|
}
|
|
break;
|
|
case T_Limit:
|
|
pname = "Limit";
|
|
break;
|
|
case T_Hash:
|
|
pname = "Hash";
|
|
break;
|
|
default:
|
|
pname = "???";
|
|
break;
|
|
}
|
|
|
|
appendStringInfoString(str, pname);
|
|
switch (nodeTag(plan))
|
|
{
|
|
case T_IndexScan:
|
|
if (ScanDirectionIsBackward(((IndexScan *) plan)->indexorderdir))
|
|
appendStringInfoString(str, " Backward");
|
|
appendStringInfo(str, " using %s",
|
|
explain_get_index_name(((IndexScan *) plan)->indexid));
|
|
/* FALL THRU */
|
|
case T_SeqScan:
|
|
case T_BitmapHeapScan:
|
|
case T_TidScan:
|
|
if (((Scan *) plan)->scanrelid > 0)
|
|
{
|
|
RangeTblEntry *rte = rt_fetch(((Scan *) plan)->scanrelid,
|
|
es->rtable);
|
|
char *relname;
|
|
|
|
/* Assume it's on a real relation */
|
|
Assert(rte->rtekind == RTE_RELATION);
|
|
|
|
/* We only show the rel name, not schema name */
|
|
relname = get_rel_name(rte->relid);
|
|
|
|
appendStringInfo(str, " on %s",
|
|
quote_identifier(relname));
|
|
if (strcmp(rte->eref->aliasname, relname) != 0)
|
|
appendStringInfo(str, " %s",
|
|
quote_identifier(rte->eref->aliasname));
|
|
}
|
|
break;
|
|
case T_BitmapIndexScan:
|
|
appendStringInfo(str, " on %s",
|
|
explain_get_index_name(((BitmapIndexScan *) plan)->indexid));
|
|
break;
|
|
case T_SubqueryScan:
|
|
if (((Scan *) plan)->scanrelid > 0)
|
|
{
|
|
RangeTblEntry *rte = rt_fetch(((Scan *) plan)->scanrelid,
|
|
es->rtable);
|
|
|
|
appendStringInfo(str, " %s",
|
|
quote_identifier(rte->eref->aliasname));
|
|
}
|
|
break;
|
|
case T_FunctionScan:
|
|
if (((Scan *) plan)->scanrelid > 0)
|
|
{
|
|
RangeTblEntry *rte = rt_fetch(((Scan *) plan)->scanrelid,
|
|
es->rtable);
|
|
Node *funcexpr;
|
|
char *proname;
|
|
|
|
/* Assert it's on a RangeFunction */
|
|
Assert(rte->rtekind == RTE_FUNCTION);
|
|
|
|
/*
|
|
* If the expression is still a function call, we can get the
|
|
* real name of the function. Otherwise, punt (this can
|
|
* happen if the optimizer simplified away the function call,
|
|
* for example).
|
|
*/
|
|
funcexpr = ((FunctionScan *) plan)->funcexpr;
|
|
if (funcexpr && IsA(funcexpr, FuncExpr))
|
|
{
|
|
Oid funcid = ((FuncExpr *) funcexpr)->funcid;
|
|
|
|
/* We only show the func name, not schema name */
|
|
proname = get_func_name(funcid);
|
|
}
|
|
else
|
|
proname = rte->eref->aliasname;
|
|
|
|
appendStringInfo(str, " on %s",
|
|
quote_identifier(proname));
|
|
if (strcmp(rte->eref->aliasname, proname) != 0)
|
|
appendStringInfo(str, " %s",
|
|
quote_identifier(rte->eref->aliasname));
|
|
}
|
|
break;
|
|
case T_ValuesScan:
|
|
if (((Scan *) plan)->scanrelid > 0)
|
|
{
|
|
RangeTblEntry *rte = rt_fetch(((Scan *) plan)->scanrelid,
|
|
es->rtable);
|
|
char *valsname;
|
|
|
|
/* Assert it's on a values rte */
|
|
Assert(rte->rtekind == RTE_VALUES);
|
|
|
|
valsname = rte->eref->aliasname;
|
|
|
|
appendStringInfo(str, " on %s",
|
|
quote_identifier(valsname));
|
|
}
|
|
break;
|
|
case T_CteScan:
|
|
if (((Scan *) plan)->scanrelid > 0)
|
|
{
|
|
RangeTblEntry *rte = rt_fetch(((Scan *) plan)->scanrelid,
|
|
es->rtable);
|
|
|
|
/* Assert it's on a non-self-reference CTE */
|
|
Assert(rte->rtekind == RTE_CTE);
|
|
Assert(!rte->self_reference);
|
|
|
|
appendStringInfo(str, " on %s",
|
|
quote_identifier(rte->ctename));
|
|
if (strcmp(rte->eref->aliasname, rte->ctename) != 0)
|
|
appendStringInfo(str, " %s",
|
|
quote_identifier(rte->eref->aliasname));
|
|
}
|
|
break;
|
|
case T_WorkTableScan:
|
|
if (((Scan *) plan)->scanrelid > 0)
|
|
{
|
|
RangeTblEntry *rte = rt_fetch(((Scan *) plan)->scanrelid,
|
|
es->rtable);
|
|
|
|
/* Assert it's on a self-reference CTE */
|
|
Assert(rte->rtekind == RTE_CTE);
|
|
Assert(rte->self_reference);
|
|
|
|
appendStringInfo(str, " on %s",
|
|
quote_identifier(rte->ctename));
|
|
if (strcmp(rte->eref->aliasname, rte->ctename) != 0)
|
|
appendStringInfo(str, " %s",
|
|
quote_identifier(rte->eref->aliasname));
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
appendStringInfo(str, " (cost=%.2f..%.2f rows=%.0f width=%d)",
|
|
plan->startup_cost, plan->total_cost,
|
|
plan->plan_rows, plan->plan_width);
|
|
|
|
/*
|
|
* We have to forcibly clean up the instrumentation state because we
|
|
* haven't done ExecutorEnd yet. This is pretty grotty ...
|
|
*/
|
|
if (planstate->instrument)
|
|
InstrEndLoop(planstate->instrument);
|
|
|
|
if (planstate->instrument && planstate->instrument->nloops > 0)
|
|
{
|
|
double nloops = planstate->instrument->nloops;
|
|
|
|
appendStringInfo(str, " (actual time=%.3f..%.3f rows=%.0f loops=%.0f)",
|
|
1000.0 * planstate->instrument->startup / nloops,
|
|
1000.0 * planstate->instrument->total / nloops,
|
|
planstate->instrument->ntuples / nloops,
|
|
planstate->instrument->nloops);
|
|
}
|
|
else if (es->printAnalyze)
|
|
appendStringInfo(str, " (never executed)");
|
|
appendStringInfoChar(str, '\n');
|
|
|
|
/* target list */
|
|
if (es->printTList)
|
|
show_plan_tlist(plan, str, indent, es);
|
|
|
|
/* quals, sort keys, etc */
|
|
switch (nodeTag(plan))
|
|
{
|
|
case T_IndexScan:
|
|
show_scan_qual(((IndexScan *) plan)->indexqualorig,
|
|
"Index Cond",
|
|
((Scan *) plan)->scanrelid,
|
|
plan, outer_plan,
|
|
str, indent, es);
|
|
show_scan_qual(plan->qual,
|
|
"Filter",
|
|
((Scan *) plan)->scanrelid,
|
|
plan, outer_plan,
|
|
str, indent, es);
|
|
break;
|
|
case T_BitmapIndexScan:
|
|
show_scan_qual(((BitmapIndexScan *) plan)->indexqualorig,
|
|
"Index Cond",
|
|
((Scan *) plan)->scanrelid,
|
|
plan, outer_plan,
|
|
str, indent, es);
|
|
break;
|
|
case T_BitmapHeapScan:
|
|
/* XXX do we want to show this in production? */
|
|
show_scan_qual(((BitmapHeapScan *) plan)->bitmapqualorig,
|
|
"Recheck Cond",
|
|
((Scan *) plan)->scanrelid,
|
|
plan, outer_plan,
|
|
str, indent, es);
|
|
/* FALL THRU */
|
|
case T_SeqScan:
|
|
case T_FunctionScan:
|
|
case T_ValuesScan:
|
|
case T_CteScan:
|
|
case T_WorkTableScan:
|
|
show_scan_qual(plan->qual,
|
|
"Filter",
|
|
((Scan *) plan)->scanrelid,
|
|
plan, outer_plan,
|
|
str, indent, es);
|
|
break;
|
|
case T_SubqueryScan:
|
|
show_scan_qual(plan->qual,
|
|
"Filter",
|
|
((Scan *) plan)->scanrelid,
|
|
plan, outer_plan,
|
|
str, indent, es);
|
|
break;
|
|
case T_TidScan:
|
|
{
|
|
/*
|
|
* The tidquals list has OR semantics, so be sure to show it
|
|
* as an OR condition.
|
|
*/
|
|
List *tidquals = ((TidScan *) plan)->tidquals;
|
|
|
|
if (list_length(tidquals) > 1)
|
|
tidquals = list_make1(make_orclause(tidquals));
|
|
show_scan_qual(tidquals,
|
|
"TID Cond",
|
|
((Scan *) plan)->scanrelid,
|
|
plan, outer_plan,
|
|
str, indent, es);
|
|
show_scan_qual(plan->qual,
|
|
"Filter",
|
|
((Scan *) plan)->scanrelid,
|
|
plan, outer_plan,
|
|
str, indent, es);
|
|
}
|
|
break;
|
|
case T_NestLoop:
|
|
show_upper_qual(((NestLoop *) plan)->join.joinqual,
|
|
"Join Filter", plan,
|
|
str, indent, es);
|
|
show_upper_qual(plan->qual,
|
|
"Filter", plan,
|
|
str, indent, es);
|
|
break;
|
|
case T_MergeJoin:
|
|
show_upper_qual(((MergeJoin *) plan)->mergeclauses,
|
|
"Merge Cond", plan,
|
|
str, indent, es);
|
|
show_upper_qual(((MergeJoin *) plan)->join.joinqual,
|
|
"Join Filter", plan,
|
|
str, indent, es);
|
|
show_upper_qual(plan->qual,
|
|
"Filter", plan,
|
|
str, indent, es);
|
|
break;
|
|
case T_HashJoin:
|
|
show_upper_qual(((HashJoin *) plan)->hashclauses,
|
|
"Hash Cond", plan,
|
|
str, indent, es);
|
|
show_upper_qual(((HashJoin *) plan)->join.joinqual,
|
|
"Join Filter", plan,
|
|
str, indent, es);
|
|
show_upper_qual(plan->qual,
|
|
"Filter", plan,
|
|
str, indent, es);
|
|
break;
|
|
case T_Agg:
|
|
case T_Group:
|
|
show_upper_qual(plan->qual,
|
|
"Filter", plan,
|
|
str, indent, es);
|
|
break;
|
|
case T_Sort:
|
|
show_sort_keys(plan,
|
|
((Sort *) plan)->numCols,
|
|
((Sort *) plan)->sortColIdx,
|
|
"Sort Key",
|
|
str, indent, es);
|
|
show_sort_info((SortState *) planstate,
|
|
str, indent, es);
|
|
break;
|
|
case T_Result:
|
|
show_upper_qual((List *) ((Result *) plan)->resconstantqual,
|
|
"One-Time Filter", plan,
|
|
str, indent, es);
|
|
show_upper_qual(plan->qual,
|
|
"Filter", plan,
|
|
str, indent, es);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* initPlan-s */
|
|
if (plan->initPlan)
|
|
{
|
|
ListCell *lst;
|
|
|
|
foreach(lst, planstate->initPlan)
|
|
{
|
|
SubPlanState *sps = (SubPlanState *) lfirst(lst);
|
|
SubPlan *sp = (SubPlan *) sps->xprstate.expr;
|
|
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " %s\n", sp->plan_name);
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " -> ");
|
|
explain_outNode(str,
|
|
exec_subplan_get_plan(es->pstmt, sp),
|
|
sps->planstate,
|
|
NULL,
|
|
indent + 4, es);
|
|
}
|
|
}
|
|
|
|
/* lefttree */
|
|
if (outerPlan(plan))
|
|
{
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " -> ");
|
|
|
|
/*
|
|
* Ordinarily we don't pass down our own outer_plan value to our child
|
|
* nodes, but in bitmap scan trees we must, since the bottom
|
|
* BitmapIndexScan nodes may have outer references. Also, we must do
|
|
* so at a Result node, because it might be a pseudoconstant-qual
|
|
* gating node inserted into an inner indexscan plan.
|
|
*/
|
|
explain_outNode(str, outerPlan(plan),
|
|
outerPlanState(planstate),
|
|
(IsA(plan, BitmapHeapScan) ||
|
|
IsA(plan, Result)) ? outer_plan : NULL,
|
|
indent + 3, es);
|
|
}
|
|
|
|
/* righttree */
|
|
if (innerPlan(plan))
|
|
{
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " -> ");
|
|
explain_outNode(str, innerPlan(plan),
|
|
innerPlanState(planstate),
|
|
outerPlan(plan),
|
|
indent + 3, es);
|
|
}
|
|
|
|
if (IsA(plan, Append))
|
|
{
|
|
Append *appendplan = (Append *) plan;
|
|
AppendState *appendstate = (AppendState *) planstate;
|
|
ListCell *lst;
|
|
int j;
|
|
|
|
j = 0;
|
|
foreach(lst, appendplan->appendplans)
|
|
{
|
|
Plan *subnode = (Plan *) lfirst(lst);
|
|
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " -> ");
|
|
|
|
/*
|
|
* Ordinarily we don't pass down our own outer_plan value to our
|
|
* child nodes, but in an Append we must, since we might be
|
|
* looking at an appendrel indexscan with outer references from
|
|
* the member scans.
|
|
*/
|
|
explain_outNode(str, subnode,
|
|
appendstate->appendplans[j],
|
|
outer_plan,
|
|
indent + 3, es);
|
|
j++;
|
|
}
|
|
}
|
|
|
|
if (IsA(plan, BitmapAnd))
|
|
{
|
|
BitmapAnd *bitmapandplan = (BitmapAnd *) plan;
|
|
BitmapAndState *bitmapandstate = (BitmapAndState *) planstate;
|
|
ListCell *lst;
|
|
int j;
|
|
|
|
j = 0;
|
|
foreach(lst, bitmapandplan->bitmapplans)
|
|
{
|
|
Plan *subnode = (Plan *) lfirst(lst);
|
|
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " -> ");
|
|
|
|
explain_outNode(str, subnode,
|
|
bitmapandstate->bitmapplans[j],
|
|
outer_plan, /* pass down same outer plan */
|
|
indent + 3, es);
|
|
j++;
|
|
}
|
|
}
|
|
|
|
if (IsA(plan, BitmapOr))
|
|
{
|
|
BitmapOr *bitmaporplan = (BitmapOr *) plan;
|
|
BitmapOrState *bitmaporstate = (BitmapOrState *) planstate;
|
|
ListCell *lst;
|
|
int j;
|
|
|
|
j = 0;
|
|
foreach(lst, bitmaporplan->bitmapplans)
|
|
{
|
|
Plan *subnode = (Plan *) lfirst(lst);
|
|
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " -> ");
|
|
|
|
explain_outNode(str, subnode,
|
|
bitmaporstate->bitmapplans[j],
|
|
outer_plan, /* pass down same outer plan */
|
|
indent + 3, es);
|
|
j++;
|
|
}
|
|
}
|
|
|
|
if (IsA(plan, SubqueryScan))
|
|
{
|
|
SubqueryScan *subqueryscan = (SubqueryScan *) plan;
|
|
SubqueryScanState *subquerystate = (SubqueryScanState *) planstate;
|
|
Plan *subnode = subqueryscan->subplan;
|
|
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " -> ");
|
|
|
|
explain_outNode(str, subnode,
|
|
subquerystate->subplan,
|
|
NULL,
|
|
indent + 3, es);
|
|
}
|
|
|
|
/* subPlan-s */
|
|
if (planstate->subPlan)
|
|
{
|
|
ListCell *lst;
|
|
|
|
foreach(lst, planstate->subPlan)
|
|
{
|
|
SubPlanState *sps = (SubPlanState *) lfirst(lst);
|
|
SubPlan *sp = (SubPlan *) sps->xprstate.expr;
|
|
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " %s\n", sp->plan_name);
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " -> ");
|
|
explain_outNode(str,
|
|
exec_subplan_get_plan(es->pstmt, sp),
|
|
sps->planstate,
|
|
NULL,
|
|
indent + 4, es);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Show the targetlist of a plan node
|
|
*/
|
|
static void
|
|
show_plan_tlist(Plan *plan,
|
|
StringInfo str, int indent, ExplainState *es)
|
|
{
|
|
List *context;
|
|
bool useprefix;
|
|
ListCell *lc;
|
|
int i;
|
|
|
|
/* No work if empty tlist (this occurs eg in bitmap indexscans) */
|
|
if (plan->targetlist == NIL)
|
|
return;
|
|
/* The tlist of an Append isn't real helpful, so suppress it */
|
|
if (IsA(plan, Append))
|
|
return;
|
|
/* Likewise for RecursiveUnion */
|
|
if (IsA(plan, RecursiveUnion))
|
|
return;
|
|
|
|
/* Set up deparsing context */
|
|
context = deparse_context_for_plan((Node *) plan,
|
|
NULL,
|
|
es->rtable,
|
|
es->pstmt->subplans);
|
|
useprefix = list_length(es->rtable) > 1;
|
|
|
|
/* Emit line prefix */
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " Output: ");
|
|
|
|
/* Deparse each non-junk result column */
|
|
i = 0;
|
|
foreach(lc, plan->targetlist)
|
|
{
|
|
TargetEntry *tle = (TargetEntry *) lfirst(lc);
|
|
|
|
if (tle->resjunk)
|
|
continue;
|
|
if (i++ > 0)
|
|
appendStringInfo(str, ", ");
|
|
appendStringInfoString(str,
|
|
deparse_expression((Node *) tle->expr, context,
|
|
useprefix, false));
|
|
}
|
|
|
|
appendStringInfoChar(str, '\n');
|
|
}
|
|
|
|
/*
|
|
* Show a qualifier expression for a scan plan node
|
|
*
|
|
* Note: outer_plan is the referent for any OUTER vars in the scan qual;
|
|
* this would be the outer side of a nestloop plan. Pass NULL if none.
|
|
*/
|
|
static void
|
|
show_scan_qual(List *qual, const char *qlabel,
|
|
int scanrelid, Plan *scan_plan, Plan *outer_plan,
|
|
StringInfo str, int indent, ExplainState *es)
|
|
{
|
|
List *context;
|
|
bool useprefix;
|
|
Node *node;
|
|
char *exprstr;
|
|
int i;
|
|
|
|
/* No work if empty qual */
|
|
if (qual == NIL)
|
|
return;
|
|
|
|
/* Convert AND list to explicit AND */
|
|
node = (Node *) make_ands_explicit(qual);
|
|
|
|
/* Set up deparsing context */
|
|
context = deparse_context_for_plan((Node *) scan_plan,
|
|
(Node *) outer_plan,
|
|
es->rtable,
|
|
es->pstmt->subplans);
|
|
useprefix = (outer_plan != NULL || IsA(scan_plan, SubqueryScan));
|
|
|
|
/* Deparse the expression */
|
|
exprstr = deparse_expression(node, context, useprefix, false);
|
|
|
|
/* And add to str */
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " %s: %s\n", qlabel, exprstr);
|
|
}
|
|
|
|
/*
|
|
* Show a qualifier expression for an upper-level plan node
|
|
*/
|
|
static void
|
|
show_upper_qual(List *qual, const char *qlabel, Plan *plan,
|
|
StringInfo str, int indent, ExplainState *es)
|
|
{
|
|
List *context;
|
|
bool useprefix;
|
|
Node *node;
|
|
char *exprstr;
|
|
int i;
|
|
|
|
/* No work if empty qual */
|
|
if (qual == NIL)
|
|
return;
|
|
|
|
/* Set up deparsing context */
|
|
context = deparse_context_for_plan((Node *) plan,
|
|
NULL,
|
|
es->rtable,
|
|
es->pstmt->subplans);
|
|
useprefix = list_length(es->rtable) > 1;
|
|
|
|
/* Deparse the expression */
|
|
node = (Node *) make_ands_explicit(qual);
|
|
exprstr = deparse_expression(node, context, useprefix, false);
|
|
|
|
/* And add to str */
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " %s: %s\n", qlabel, exprstr);
|
|
}
|
|
|
|
/*
|
|
* Show the sort keys for a Sort node.
|
|
*/
|
|
static void
|
|
show_sort_keys(Plan *sortplan, int nkeys, AttrNumber *keycols,
|
|
const char *qlabel,
|
|
StringInfo str, int indent, ExplainState *es)
|
|
{
|
|
List *context;
|
|
bool useprefix;
|
|
int keyno;
|
|
char *exprstr;
|
|
int i;
|
|
|
|
if (nkeys <= 0)
|
|
return;
|
|
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " %s: ", qlabel);
|
|
|
|
/* Set up deparsing context */
|
|
context = deparse_context_for_plan((Node *) sortplan,
|
|
NULL,
|
|
es->rtable,
|
|
es->pstmt->subplans);
|
|
useprefix = list_length(es->rtable) > 1;
|
|
|
|
for (keyno = 0; keyno < nkeys; keyno++)
|
|
{
|
|
/* find key expression in tlist */
|
|
AttrNumber keyresno = keycols[keyno];
|
|
TargetEntry *target = get_tle_by_resno(sortplan->targetlist, keyresno);
|
|
|
|
if (!target)
|
|
elog(ERROR, "no tlist entry for key %d", keyresno);
|
|
/* Deparse the expression, showing any top-level cast */
|
|
exprstr = deparse_expression((Node *) target->expr, context,
|
|
useprefix, true);
|
|
/* And add to str */
|
|
if (keyno > 0)
|
|
appendStringInfo(str, ", ");
|
|
appendStringInfoString(str, exprstr);
|
|
}
|
|
|
|
appendStringInfo(str, "\n");
|
|
}
|
|
|
|
/*
|
|
* If it's EXPLAIN ANALYZE, show tuplesort explain info for a sort node
|
|
*/
|
|
static void
|
|
show_sort_info(SortState *sortstate,
|
|
StringInfo str, int indent, ExplainState *es)
|
|
{
|
|
Assert(IsA(sortstate, SortState));
|
|
if (es->printAnalyze && sortstate->sort_Done &&
|
|
sortstate->tuplesortstate != NULL)
|
|
{
|
|
char *sortinfo;
|
|
int i;
|
|
|
|
sortinfo = tuplesort_explain((Tuplesortstate *) sortstate->tuplesortstate);
|
|
for (i = 0; i < indent; i++)
|
|
appendStringInfo(str, " ");
|
|
appendStringInfo(str, " %s\n", sortinfo);
|
|
pfree(sortinfo);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Fetch the name of an index in an EXPLAIN
|
|
*
|
|
* We allow plugins to get control here so that plans involving hypothetical
|
|
* indexes can be explained.
|
|
*/
|
|
static const char *
|
|
explain_get_index_name(Oid indexId)
|
|
{
|
|
const char *result;
|
|
|
|
if (explain_get_index_name_hook)
|
|
result = (*explain_get_index_name_hook) (indexId);
|
|
else
|
|
result = NULL;
|
|
if (result == NULL)
|
|
{
|
|
/* default behavior: look in the catalogs and quote it */
|
|
result = get_rel_name(indexId);
|
|
if (result == NULL)
|
|
elog(ERROR, "cache lookup failed for index %u", indexId);
|
|
result = quote_identifier(result);
|
|
}
|
|
return result;
|
|
}
|