1998-12-14 09:11:17 +01:00
|
|
|
/*
|
1999-02-14 00:22:53 +01:00
|
|
|
* explain.c
|
1997-09-07 07:04:48 +02:00
|
|
|
* Explain the query execution plan
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2001-01-24 20:43:33 +01:00
|
|
|
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994-5, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2002-03-12 01:52:10 +01:00
|
|
|
* $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.71 2002/03/12 00:51:35 tgl Exp $
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*/
|
1996-10-23 09:42:13 +02:00
|
|
|
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "postgres.h"
|
1996-11-06 09:21:43 +01:00
|
|
|
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "commands/explain.h"
|
2001-09-18 03:59:07 +02:00
|
|
|
#include "executor/instrument.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "lib/stringinfo.h"
|
|
|
|
#include "nodes/print.h"
|
2002-03-12 01:52:10 +01:00
|
|
|
#include "optimizer/clauses.h"
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "optimizer/planner.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "parser/parsetree.h"
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "rewrite/rewriteHandler.h"
|
2001-09-18 03:59:07 +02:00
|
|
|
#include "tcop/pquery.h"
|
2002-03-12 01:52:10 +01:00
|
|
|
#include "utils/builtins.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "utils/relcache.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2002-03-12 01:52:10 +01:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
typedef struct ExplainState
|
|
|
|
{
|
|
|
|
/* options */
|
1997-09-08 04:41:22 +02:00
|
|
|
bool printCost; /* print cost */
|
1998-08-04 17:00:28 +02:00
|
|
|
bool printNodes; /* do nodeToString() instead */
|
1997-09-07 07:04:48 +02:00
|
|
|
/* other states */
|
1997-09-08 04:41:22 +02:00
|
|
|
List *rtable; /* range table */
|
1997-09-08 23:56:23 +02:00
|
|
|
} ExplainState;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2001-09-18 03:59:07 +02:00
|
|
|
static StringInfo Explain_PlanToString(Plan *plan, ExplainState *es);
|
|
|
|
static void ExplainOneQuery(Query *query, bool verbose, bool analyze, CommandDest dest);
|
2002-03-12 01:52:10 +01:00
|
|
|
static void show_scan_qual(List *qual, bool is_or_qual, const char *qlabel,
|
|
|
|
int scanrelid,
|
|
|
|
StringInfo str, int indent, ExplainState *es);
|
|
|
|
static void show_upper_qual(List *qual, const char *qlabel,
|
|
|
|
const char *outer_name, int outer_varno, Plan *outer_plan,
|
|
|
|
const char *inner_name, int inner_varno, Plan *inner_plan,
|
|
|
|
StringInfo str, int indent, ExplainState *es);
|
|
|
|
static Node *make_ors_ands_explicit(List *orclauses);
|
1998-10-21 18:21:29 +02:00
|
|
|
|
1999-08-31 03:28:37 +02:00
|
|
|
/* Convert a null string pointer into "<>" */
|
|
|
|
#define stringStringInfo(s) (((s) == NULL) ? "<>" : (s))
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ExplainQuery -
|
1997-09-07 07:04:48 +02:00
|
|
|
* print out the execution plan for a given query
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
void
|
2001-09-18 03:59:07 +02:00
|
|
|
ExplainQuery(Query *query, bool verbose, bool analyze, CommandDest dest)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1999-05-25 18:15:34 +02:00
|
|
|
List *rewritten;
|
|
|
|
List *l;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1999-05-10 01:31:47 +02:00
|
|
|
/* rewriter and planner may not work in aborted state? */
|
1997-09-07 07:04:48 +02:00
|
|
|
if (IsAbortedTransactionBlockState())
|
|
|
|
{
|
2002-03-06 07:10:59 +01:00
|
|
|
elog(WARNING, "(transaction aborted): %s",
|
1997-09-07 07:04:48 +02:00
|
|
|
"queries ignored until END");
|
1999-05-10 01:31:47 +02:00
|
|
|
return;
|
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-01-27 02:41:19 +01:00
|
|
|
/* rewriter will not cope with utility statements */
|
1999-05-10 01:31:47 +02:00
|
|
|
if (query->commandType == CMD_UTILITY)
|
|
|
|
{
|
2002-03-06 07:10:59 +01:00
|
|
|
elog(NOTICE, "Utility statements have no plan structure");
|
1997-09-07 07:04:48 +02:00
|
|
|
return;
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-10-21 18:21:29 +02:00
|
|
|
/* Rewrite through rule system */
|
|
|
|
rewritten = QueryRewrite(query);
|
|
|
|
|
|
|
|
/* In the case of an INSTEAD NOTHING, tell at least that */
|
|
|
|
if (rewritten == NIL)
|
|
|
|
{
|
2002-03-06 07:10:59 +01:00
|
|
|
elog(NOTICE, "Query rewrites to nothing");
|
1998-10-21 18:21:29 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Explain every plan */
|
|
|
|
foreach(l, rewritten)
|
2001-09-18 03:59:07 +02:00
|
|
|
ExplainOneQuery(lfirst(l), verbose, analyze, dest);
|
1998-10-21 18:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ExplainOneQuery -
|
|
|
|
* print out the execution plan for one query
|
|
|
|
*/
|
|
|
|
static void
|
2001-09-18 03:59:07 +02:00
|
|
|
ExplainOneQuery(Query *query, bool verbose, bool analyze, CommandDest dest)
|
1998-10-21 18:21:29 +02:00
|
|
|
{
|
|
|
|
Plan *plan;
|
|
|
|
ExplainState *es;
|
2001-09-18 03:59:07 +02:00
|
|
|
double totaltime = 0;
|
1998-10-21 18:21:29 +02:00
|
|
|
|
2001-01-27 02:41:19 +01:00
|
|
|
/* planner will not cope with utility statements */
|
|
|
|
if (query->commandType == CMD_UTILITY)
|
|
|
|
{
|
|
|
|
if (query->utilityStmt && IsA(query->utilityStmt, NotifyStmt))
|
Commit to match discussed elog() changes. Only update is that LOG is
now just below FATAL in server_min_messages. Added more text to
highlight ordering difference between it and client_min_messages.
---------------------------------------------------------------------------
REALLYFATAL => PANIC
STOP => PANIC
New INFO level the prints to client by default
New LOG level the prints to server log by default
Cause VACUUM information to print only to the client
NOTICE => INFO where purely information messages are sent
DEBUG => LOG for purely server status messages
DEBUG removed, kept as backward compatible
DEBUG5, DEBUG4, DEBUG3, DEBUG2, DEBUG1 added
DebugLvl removed in favor of new DEBUG[1-5] symbols
New server_min_messages GUC parameter with values:
DEBUG[5-1], INFO, NOTICE, ERROR, LOG, FATAL, PANIC
New client_min_messages GUC parameter with values:
DEBUG[5-1], LOG, INFO, NOTICE, ERROR, FATAL, PANIC
Server startup now logged with LOG instead of DEBUG
Remove debug_level GUC parameter
elog() numbers now start at 10
Add test to print error message if older elog() values are passed to elog()
Bootstrap mode now has a -d that requires an argument, like postmaster
2002-03-02 22:39:36 +01:00
|
|
|
elog(INFO, "QUERY PLAN:\n\nNOTIFY\n");
|
2001-01-27 02:41:19 +01:00
|
|
|
else
|
Commit to match discussed elog() changes. Only update is that LOG is
now just below FATAL in server_min_messages. Added more text to
highlight ordering difference between it and client_min_messages.
---------------------------------------------------------------------------
REALLYFATAL => PANIC
STOP => PANIC
New INFO level the prints to client by default
New LOG level the prints to server log by default
Cause VACUUM information to print only to the client
NOTICE => INFO where purely information messages are sent
DEBUG => LOG for purely server status messages
DEBUG removed, kept as backward compatible
DEBUG5, DEBUG4, DEBUG3, DEBUG2, DEBUG1 added
DebugLvl removed in favor of new DEBUG[1-5] symbols
New server_min_messages GUC parameter with values:
DEBUG[5-1], INFO, NOTICE, ERROR, LOG, FATAL, PANIC
New client_min_messages GUC parameter with values:
DEBUG[5-1], LOG, INFO, NOTICE, ERROR, FATAL, PANIC
Server startup now logged with LOG instead of DEBUG
Remove debug_level GUC parameter
elog() numbers now start at 10
Add test to print error message if older elog() values are passed to elog()
Bootstrap mode now has a -d that requires an argument, like postmaster
2002-03-02 22:39:36 +01:00
|
|
|
elog(INFO, "QUERY PLAN:\n\nUTILITY\n");
|
2001-01-27 02:41:19 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
1999-05-10 01:31:47 +02:00
|
|
|
/* plan the query */
|
1997-09-07 07:04:48 +02:00
|
|
|
plan = planner(query);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/* pg_plan could have failed */
|
|
|
|
if (plan == NULL)
|
|
|
|
return;
|
1996-12-29 20:31:16 +01:00
|
|
|
|
2001-09-18 03:59:07 +02:00
|
|
|
/* Execute the plan for statistics if asked for */
|
|
|
|
if (analyze)
|
|
|
|
{
|
|
|
|
struct timeval starttime;
|
|
|
|
struct timeval endtime;
|
|
|
|
|
|
|
|
/*
|
2001-10-25 07:50:21 +02:00
|
|
|
* Set up the instrumentation for the top node. This will cascade
|
|
|
|
* during plan initialisation
|
2001-09-18 03:59:07 +02:00
|
|
|
*/
|
|
|
|
plan->instrument = InstrAlloc();
|
|
|
|
|
|
|
|
gettimeofday(&starttime, NULL);
|
2002-02-26 23:47:12 +01:00
|
|
|
ProcessQuery(query, plan, None, NULL);
|
2001-09-18 03:59:07 +02:00
|
|
|
CommandCounterIncrement();
|
|
|
|
gettimeofday(&endtime, NULL);
|
|
|
|
|
2001-10-25 07:50:21 +02:00
|
|
|
endtime.tv_sec -= starttime.tv_sec;
|
2001-09-18 03:59:07 +02:00
|
|
|
endtime.tv_usec -= starttime.tv_usec;
|
|
|
|
while (endtime.tv_usec < 0)
|
|
|
|
{
|
|
|
|
endtime.tv_usec += 1000000;
|
|
|
|
endtime.tv_sec--;
|
|
|
|
}
|
|
|
|
totaltime = (double) endtime.tv_sec +
|
|
|
|
(double) endtime.tv_usec / 1000000.0;
|
|
|
|
}
|
|
|
|
|
1997-12-29 06:13:57 +01:00
|
|
|
es = (ExplainState *) palloc(sizeof(ExplainState));
|
1997-09-18 22:22:58 +02:00
|
|
|
MemSet(es, 0, sizeof(ExplainState));
|
1996-12-29 20:31:16 +01:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
es->printCost = true; /* default */
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (verbose)
|
|
|
|
es->printNodes = true;
|
1996-12-29 01:53:20 +01:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
es->rtable = query->rtable;
|
|
|
|
|
|
|
|
if (es->printNodes)
|
1998-11-08 20:38:34 +01:00
|
|
|
{
|
2001-09-18 03:59:07 +02:00
|
|
|
char *s;
|
|
|
|
|
1998-08-04 17:00:28 +02:00
|
|
|
s = nodeToString(plan);
|
1998-11-08 20:38:34 +01:00
|
|
|
if (s)
|
|
|
|
{
|
Commit to match discussed elog() changes. Only update is that LOG is
now just below FATAL in server_min_messages. Added more text to
highlight ordering difference between it and client_min_messages.
---------------------------------------------------------------------------
REALLYFATAL => PANIC
STOP => PANIC
New INFO level the prints to client by default
New LOG level the prints to server log by default
Cause VACUUM information to print only to the client
NOTICE => INFO where purely information messages are sent
DEBUG => LOG for purely server status messages
DEBUG removed, kept as backward compatible
DEBUG5, DEBUG4, DEBUG3, DEBUG2, DEBUG1 added
DebugLvl removed in favor of new DEBUG[1-5] symbols
New server_min_messages GUC parameter with values:
DEBUG[5-1], INFO, NOTICE, ERROR, LOG, FATAL, PANIC
New client_min_messages GUC parameter with values:
DEBUG[5-1], LOG, INFO, NOTICE, ERROR, FATAL, PANIC
Server startup now logged with LOG instead of DEBUG
Remove debug_level GUC parameter
elog() numbers now start at 10
Add test to print error message if older elog() values are passed to elog()
Bootstrap mode now has a -d that requires an argument, like postmaster
2002-03-02 22:39:36 +01:00
|
|
|
elog(INFO, "QUERY DUMP:\n\n%s", s);
|
1998-11-08 20:38:34 +01:00
|
|
|
pfree(s);
|
|
|
|
}
|
|
|
|
}
|
1998-09-01 06:40:42 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (es->printCost)
|
|
|
|
{
|
2001-09-18 03:59:07 +02:00
|
|
|
StringInfo str;
|
|
|
|
|
|
|
|
str = Explain_PlanToString(plan, es);
|
|
|
|
if (analyze)
|
|
|
|
appendStringInfo(str, "Total runtime: %.2f msec\n",
|
|
|
|
1000.0 * totaltime);
|
Commit to match discussed elog() changes. Only update is that LOG is
now just below FATAL in server_min_messages. Added more text to
highlight ordering difference between it and client_min_messages.
---------------------------------------------------------------------------
REALLYFATAL => PANIC
STOP => PANIC
New INFO level the prints to client by default
New LOG level the prints to server log by default
Cause VACUUM information to print only to the client
NOTICE => INFO where purely information messages are sent
DEBUG => LOG for purely server status messages
DEBUG removed, kept as backward compatible
DEBUG5, DEBUG4, DEBUG3, DEBUG2, DEBUG1 added
DebugLvl removed in favor of new DEBUG[1-5] symbols
New server_min_messages GUC parameter with values:
DEBUG[5-1], INFO, NOTICE, ERROR, LOG, FATAL, PANIC
New client_min_messages GUC parameter with values:
DEBUG[5-1], LOG, INFO, NOTICE, ERROR, FATAL, PANIC
Server startup now logged with LOG instead of DEBUG
Remove debug_level GUC parameter
elog() numbers now start at 10
Add test to print error message if older elog() values are passed to elog()
Bootstrap mode now has a -d that requires an argument, like postmaster
2002-03-02 22:39:36 +01:00
|
|
|
elog(INFO, "QUERY PLAN:\n\n%s", str->data);
|
2001-09-18 03:59:07 +02:00
|
|
|
pfree(str->data);
|
|
|
|
pfree(str);
|
1996-12-29 01:53:20 +01:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-08-04 18:44:31 +02:00
|
|
|
if (es->printNodes)
|
1998-09-01 06:40:42 +02:00
|
|
|
pprint(plan); /* display in postmaster log file */
|
1998-08-04 18:44:31 +02:00
|
|
|
|
1997-12-29 06:13:57 +01:00
|
|
|
pfree(es);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* explain_outNode -
|
1997-09-07 07:04:48 +02:00
|
|
|
* converts a Node into ascii string and append it to 'str'
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
static void
|
1997-09-08 23:56:23 +02:00
|
|
|
explain_outNode(StringInfo str, Plan *plan, int indent, ExplainState *es)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1999-05-25 18:15:34 +02:00
|
|
|
List *l;
|
1998-04-27 18:57:09 +02:00
|
|
|
Relation relation;
|
1999-05-25 18:15:34 +02:00
|
|
|
char *pname;
|
|
|
|
int i;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if (plan == NULL)
|
|
|
|
{
|
|
|
|
appendStringInfo(str, "\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (nodeTag(plan))
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
case T_Result:
|
|
|
|
pname = "Result";
|
|
|
|
break;
|
|
|
|
case T_Append:
|
|
|
|
pname = "Append";
|
|
|
|
break;
|
|
|
|
case T_NestLoop:
|
|
|
|
pname = "Nested Loop";
|
|
|
|
break;
|
|
|
|
case T_MergeJoin:
|
|
|
|
pname = "Merge Join";
|
|
|
|
break;
|
|
|
|
case T_HashJoin:
|
|
|
|
pname = "Hash Join";
|
|
|
|
break;
|
|
|
|
case T_SeqScan:
|
|
|
|
pname = "Seq Scan";
|
|
|
|
break;
|
|
|
|
case T_IndexScan:
|
|
|
|
pname = "Index Scan";
|
|
|
|
break;
|
2000-09-29 20:21:41 +02:00
|
|
|
case T_TidScan:
|
|
|
|
pname = "Tid Scan";
|
|
|
|
break;
|
|
|
|
case T_SubqueryScan:
|
|
|
|
pname = "Subquery Scan";
|
|
|
|
break;
|
1999-08-17 01:47:23 +02:00
|
|
|
case T_Material:
|
|
|
|
pname = "Materialize";
|
|
|
|
break;
|
1997-09-08 04:41:22 +02:00
|
|
|
case T_Sort:
|
|
|
|
pname = "Sort";
|
|
|
|
break;
|
|
|
|
case T_Group:
|
|
|
|
pname = "Group";
|
|
|
|
break;
|
|
|
|
case T_Agg:
|
|
|
|
pname = "Aggregate";
|
|
|
|
break;
|
|
|
|
case T_Unique:
|
|
|
|
pname = "Unique";
|
|
|
|
break;
|
2000-10-05 21:11:39 +02:00
|
|
|
case T_SetOp:
|
|
|
|
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;
|
2000-10-26 23:38:24 +02:00
|
|
|
case T_Limit:
|
|
|
|
pname = "Limit";
|
|
|
|
break;
|
1997-09-08 04:41:22 +02:00
|
|
|
case T_Hash:
|
|
|
|
pname = "Hash";
|
|
|
|
break;
|
|
|
|
default:
|
1999-05-10 01:31:47 +02:00
|
|
|
pname = "???";
|
1997-09-08 04:41:22 +02:00
|
|
|
break;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
appendStringInfo(str, pname);
|
|
|
|
switch (nodeTag(plan))
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
case T_IndexScan:
|
2000-04-12 19:17:23 +02:00
|
|
|
if (ScanDirectionIsBackward(((IndexScan *) plan)->indxorderdir))
|
1999-08-09 08:20:27 +02:00
|
|
|
appendStringInfo(str, " Backward");
|
1998-04-27 18:57:09 +02:00
|
|
|
appendStringInfo(str, " using ");
|
1998-11-22 11:48:45 +01:00
|
|
|
i = 0;
|
1999-05-25 18:15:34 +02:00
|
|
|
foreach(l, ((IndexScan *) plan)->indxid)
|
1998-11-22 11:48:45 +01:00
|
|
|
{
|
1999-09-18 21:08:25 +02:00
|
|
|
relation = RelationIdGetRelation(lfirsti(l));
|
|
|
|
Assert(relation);
|
2000-02-15 21:49:31 +01:00
|
|
|
appendStringInfo(str, "%s%s",
|
|
|
|
(++i > 1) ? ", " : "",
|
2000-04-12 19:17:23 +02:00
|
|
|
stringStringInfo(RelationGetRelationName(relation)));
|
1999-09-18 21:08:25 +02:00
|
|
|
/* drop relcache refcount from RelationIdGetRelation */
|
|
|
|
RelationDecrementReferenceCount(relation);
|
1998-11-22 11:48:45 +01:00
|
|
|
}
|
2000-02-15 21:49:31 +01:00
|
|
|
/* FALL THRU */
|
1998-04-27 18:57:09 +02:00
|
|
|
case T_SeqScan:
|
2000-02-15 21:49:31 +01:00
|
|
|
case T_TidScan:
|
1997-09-08 04:41:22 +02:00
|
|
|
if (((Scan *) plan)->scanrelid > 0)
|
|
|
|
{
|
2000-09-29 20:21:41 +02:00
|
|
|
RangeTblEntry *rte = rt_fetch(((Scan *) plan)->scanrelid,
|
|
|
|
es->rtable);
|
|
|
|
|
|
|
|
/* Assume it's on a real relation */
|
|
|
|
Assert(rte->relname);
|
1997-09-08 04:41:22 +02:00
|
|
|
|
2000-02-15 21:49:31 +01:00
|
|
|
appendStringInfo(str, " on %s",
|
|
|
|
stringStringInfo(rte->relname));
|
2000-09-29 20:21:41 +02:00
|
|
|
if (strcmp(rte->eref->relname, rte->relname) != 0)
|
|
|
|
appendStringInfo(str, " %s",
|
2001-03-22 05:01:46 +01:00
|
|
|
stringStringInfo(rte->eref->relname));
|
2000-09-29 20:21:41 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_SubqueryScan:
|
|
|
|
if (((Scan *) plan)->scanrelid > 0)
|
|
|
|
{
|
|
|
|
RangeTblEntry *rte = rt_fetch(((Scan *) plan)->scanrelid,
|
|
|
|
es->rtable);
|
|
|
|
|
|
|
|
appendStringInfo(str, " %s",
|
|
|
|
stringStringInfo(rte->eref->relname));
|
1999-11-23 21:07:06 +01:00
|
|
|
}
|
|
|
|
break;
|
1997-09-08 04:41:22 +02:00
|
|
|
default:
|
|
|
|
break;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
if (es->printCost)
|
|
|
|
{
|
2000-02-15 21:49:31 +01:00
|
|
|
appendStringInfo(str, " (cost=%.2f..%.2f rows=%.0f width=%d)",
|
|
|
|
plan->startup_cost, plan->total_cost,
|
|
|
|
plan->plan_rows, plan->plan_width);
|
2001-09-18 03:59:07 +02:00
|
|
|
|
2001-10-25 07:50:21 +02:00
|
|
|
if (plan->instrument && plan->instrument->nloops > 0)
|
2001-09-18 03:59:07 +02:00
|
|
|
{
|
2001-10-25 07:50:21 +02:00
|
|
|
double nloops = plan->instrument->nloops;
|
2001-09-18 03:59:07 +02:00
|
|
|
|
|
|
|
appendStringInfo(str, " (actual time=%.2f..%.2f rows=%.0f loops=%.0f)",
|
|
|
|
1000.0 * plan->instrument->startup / nloops,
|
|
|
|
1000.0 * plan->instrument->total / nloops,
|
|
|
|
plan->instrument->ntuples / nloops,
|
|
|
|
plan->instrument->nloops);
|
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
appendStringInfo(str, "\n");
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2002-03-12 01:52:10 +01:00
|
|
|
/* quals */
|
|
|
|
switch (nodeTag(plan))
|
|
|
|
{
|
|
|
|
case T_IndexScan:
|
|
|
|
show_scan_qual(((IndexScan *) plan)->indxqualorig, true,
|
|
|
|
"indxqual",
|
|
|
|
((Scan *) plan)->scanrelid,
|
|
|
|
str, indent, es);
|
|
|
|
show_scan_qual(plan->qual, false, "qual",
|
|
|
|
((Scan *) plan)->scanrelid,
|
|
|
|
str, indent, es);
|
|
|
|
break;
|
|
|
|
case T_SeqScan:
|
|
|
|
case T_TidScan:
|
|
|
|
show_scan_qual(plan->qual, false, "qual",
|
|
|
|
((Scan *) plan)->scanrelid,
|
|
|
|
str, indent, es);
|
|
|
|
break;
|
|
|
|
case T_NestLoop:
|
|
|
|
show_upper_qual(((NestLoop *) plan)->join.joinqual, "joinqual",
|
|
|
|
"outer", OUTER, outerPlan(plan),
|
|
|
|
"inner", INNER, innerPlan(plan),
|
|
|
|
str, indent, es);
|
|
|
|
show_upper_qual(plan->qual, "qual",
|
|
|
|
"outer", OUTER, outerPlan(plan),
|
|
|
|
"inner", INNER, innerPlan(plan),
|
|
|
|
str, indent, es);
|
|
|
|
break;
|
|
|
|
case T_MergeJoin:
|
|
|
|
show_upper_qual(((MergeJoin *) plan)->mergeclauses, "merge",
|
|
|
|
"outer", OUTER, outerPlan(plan),
|
|
|
|
"inner", INNER, innerPlan(plan),
|
|
|
|
str, indent, es);
|
|
|
|
show_upper_qual(((MergeJoin *) plan)->join.joinqual, "joinqual",
|
|
|
|
"outer", OUTER, outerPlan(plan),
|
|
|
|
"inner", INNER, innerPlan(plan),
|
|
|
|
str, indent, es);
|
|
|
|
show_upper_qual(plan->qual, "qual",
|
|
|
|
"outer", OUTER, outerPlan(plan),
|
|
|
|
"inner", INNER, innerPlan(plan),
|
|
|
|
str, indent, es);
|
|
|
|
break;
|
|
|
|
case T_HashJoin:
|
|
|
|
show_upper_qual(((HashJoin *) plan)->hashclauses, "hash",
|
|
|
|
"outer", OUTER, outerPlan(plan),
|
|
|
|
"inner", INNER, innerPlan(plan),
|
|
|
|
str, indent, es);
|
|
|
|
show_upper_qual(((HashJoin *) plan)->join.joinqual, "joinqual",
|
|
|
|
"outer", OUTER, outerPlan(plan),
|
|
|
|
"inner", INNER, innerPlan(plan),
|
|
|
|
str, indent, es);
|
|
|
|
show_upper_qual(plan->qual, "qual",
|
|
|
|
"outer", OUTER, outerPlan(plan),
|
|
|
|
"inner", INNER, innerPlan(plan),
|
|
|
|
str, indent, es);
|
|
|
|
break;
|
|
|
|
case T_SubqueryScan:
|
|
|
|
show_upper_qual(plan->qual, "qual",
|
|
|
|
"subplan", 1, ((SubqueryScan *) plan)->subplan,
|
|
|
|
"", 0, NULL,
|
|
|
|
str, indent, es);
|
|
|
|
break;
|
|
|
|
case T_Agg:
|
|
|
|
case T_Group:
|
|
|
|
show_upper_qual(plan->qual, "qual",
|
|
|
|
"subplan", 0, outerPlan(plan),
|
|
|
|
"", 0, NULL,
|
|
|
|
str, indent, es);
|
|
|
|
break;
|
|
|
|
case T_Result:
|
|
|
|
show_upper_qual((List *) ((Result *) plan)->resconstantqual,
|
|
|
|
"constqual",
|
|
|
|
"subplan", OUTER, outerPlan(plan),
|
|
|
|
"", 0, NULL,
|
|
|
|
str, indent, es);
|
|
|
|
show_upper_qual(plan->qual, "qual",
|
|
|
|
"subplan", OUTER, outerPlan(plan),
|
|
|
|
"", 0, NULL,
|
|
|
|
str, indent, es);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
1998-02-13 04:21:30 +01:00
|
|
|
/* initPlan-s */
|
|
|
|
if (plan->initPlan)
|
|
|
|
{
|
1998-02-26 05:46:47 +01:00
|
|
|
List *saved_rtable = es->rtable;
|
|
|
|
List *lst;
|
|
|
|
|
1999-05-25 18:15:34 +02:00
|
|
|
for (i = 0; i < indent; i++)
|
1998-02-13 04:21:30 +01:00
|
|
|
appendStringInfo(str, " ");
|
|
|
|
appendStringInfo(str, " InitPlan\n");
|
1998-02-26 05:46:47 +01:00
|
|
|
foreach(lst, plan->initPlan)
|
1998-02-13 04:21:30 +01:00
|
|
|
{
|
1998-02-26 05:46:47 +01:00
|
|
|
es->rtable = ((SubPlan *) lfirst(lst))->rtable;
|
1998-02-13 04:21:30 +01:00
|
|
|
for (i = 0; i < indent; i++)
|
|
|
|
appendStringInfo(str, " ");
|
|
|
|
appendStringInfo(str, " -> ");
|
2000-09-29 20:21:41 +02:00
|
|
|
explain_outNode(str, ((SubPlan *) lfirst(lst))->plan,
|
|
|
|
indent + 4, es);
|
1998-02-13 04:21:30 +01:00
|
|
|
}
|
|
|
|
es->rtable = saved_rtable;
|
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/* lefttree */
|
|
|
|
if (outerPlan(plan))
|
|
|
|
{
|
|
|
|
for (i = 0; i < indent; i++)
|
|
|
|
appendStringInfo(str, " ");
|
1998-02-13 04:21:30 +01:00
|
|
|
appendStringInfo(str, " -> ");
|
|
|
|
explain_outNode(str, outerPlan(plan), indent + 3, es);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/* righttree */
|
|
|
|
if (innerPlan(plan))
|
|
|
|
{
|
|
|
|
for (i = 0; i < indent; i++)
|
|
|
|
appendStringInfo(str, " ");
|
1998-02-13 04:21:30 +01:00
|
|
|
appendStringInfo(str, " -> ");
|
|
|
|
explain_outNode(str, innerPlan(plan), indent + 3, es);
|
|
|
|
}
|
1998-02-26 05:46:47 +01:00
|
|
|
|
2000-09-29 20:21:41 +02:00
|
|
|
if (IsA(plan, Append))
|
1998-07-15 16:54:39 +02:00
|
|
|
{
|
2000-09-29 20:21:41 +02:00
|
|
|
Append *appendplan = (Append *) plan;
|
|
|
|
List *lst;
|
1998-07-15 16:54:39 +02:00
|
|
|
|
|
|
|
foreach(lst, appendplan->appendplans)
|
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
Plan *subnode = (Plan *) lfirst(lst);
|
1998-07-15 16:54:39 +02:00
|
|
|
|
|
|
|
for (i = 0; i < indent; i++)
|
|
|
|
appendStringInfo(str, " ");
|
2000-09-29 20:21:41 +02:00
|
|
|
appendStringInfo(str, " -> ");
|
1998-07-15 16:54:39 +02:00
|
|
|
|
2000-09-29 20:21:41 +02:00
|
|
|
explain_outNode(str, subnode, indent + 3, es);
|
1998-07-15 16:54:39 +02:00
|
|
|
}
|
|
|
|
}
|
2000-09-29 20:21:41 +02:00
|
|
|
|
|
|
|
if (IsA(plan, SubqueryScan))
|
|
|
|
{
|
|
|
|
SubqueryScan *subqueryscan = (SubqueryScan *) plan;
|
|
|
|
Plan *subnode = subqueryscan->subplan;
|
|
|
|
RangeTblEntry *rte = rt_fetch(subqueryscan->scan.scanrelid,
|
|
|
|
es->rtable);
|
|
|
|
List *saved_rtable = es->rtable;
|
|
|
|
|
|
|
|
Assert(rte->subquery != NULL);
|
|
|
|
es->rtable = rte->subquery->rtable;
|
|
|
|
|
|
|
|
for (i = 0; i < indent; i++)
|
|
|
|
appendStringInfo(str, " ");
|
|
|
|
appendStringInfo(str, " -> ");
|
|
|
|
|
|
|
|
explain_outNode(str, subnode, indent + 3, es);
|
|
|
|
|
|
|
|
es->rtable = saved_rtable;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* subPlan-s */
|
|
|
|
if (plan->subPlan)
|
|
|
|
{
|
|
|
|
List *saved_rtable = es->rtable;
|
|
|
|
List *lst;
|
|
|
|
|
|
|
|
for (i = 0; i < indent; i++)
|
|
|
|
appendStringInfo(str, " ");
|
|
|
|
appendStringInfo(str, " SubPlan\n");
|
|
|
|
foreach(lst, plan->subPlan)
|
|
|
|
{
|
|
|
|
es->rtable = ((SubPlan *) lfirst(lst))->rtable;
|
|
|
|
for (i = 0; i < indent; i++)
|
|
|
|
appendStringInfo(str, " ");
|
|
|
|
appendStringInfo(str, " -> ");
|
|
|
|
explain_outNode(str, ((SubPlan *) lfirst(lst))->plan,
|
|
|
|
indent + 4, es);
|
|
|
|
}
|
|
|
|
es->rtable = saved_rtable;
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2001-09-18 03:59:07 +02:00
|
|
|
static StringInfo
|
1997-09-08 23:56:23 +02:00
|
|
|
Explain_PlanToString(Plan *plan, ExplainState *es)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2001-10-25 07:50:21 +02:00
|
|
|
StringInfo str = makeStringInfo();
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1999-04-25 05:19:27 +02:00
|
|
|
if (plan != NULL)
|
2001-09-18 03:59:07 +02:00
|
|
|
explain_outNode(str, plan, 0, es);
|
|
|
|
return str;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
2002-03-12 01:52:10 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Show a qualifier expression for a scan plan node
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
show_scan_qual(List *qual, bool is_or_qual, const char *qlabel,
|
|
|
|
int scanrelid,
|
|
|
|
StringInfo str, int indent, ExplainState *es)
|
|
|
|
{
|
|
|
|
RangeTblEntry *rte;
|
|
|
|
List *context;
|
|
|
|
Node *node;
|
|
|
|
char *exprstr;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* No work if empty qual */
|
|
|
|
if (qual == NIL)
|
|
|
|
return;
|
|
|
|
if (is_or_qual)
|
|
|
|
{
|
|
|
|
if (lfirst(qual) == NIL && lnext(qual) == NIL)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Generate deparse context */
|
|
|
|
Assert(scanrelid > 0 && scanrelid <= length(es->rtable));
|
|
|
|
rte = rt_fetch(scanrelid, es->rtable);
|
|
|
|
|
|
|
|
/* Assume it's on a real relation */
|
|
|
|
Assert(rte->relname);
|
|
|
|
|
|
|
|
context = deparse_context_for(rte->relname, rte->relid);
|
|
|
|
|
|
|
|
/* Fix qual --- indexqual requires different processing */
|
|
|
|
if (is_or_qual)
|
|
|
|
node = make_ors_ands_explicit(qual);
|
|
|
|
else
|
|
|
|
node = (Node *) make_ands_explicit(qual);
|
|
|
|
|
|
|
|
/* Deparse the expression */
|
|
|
|
exprstr = deparse_expression(node, context, 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,
|
|
|
|
const char *outer_name, int outer_varno, Plan *outer_plan,
|
|
|
|
const char *inner_name, int inner_varno, Plan *inner_plan,
|
|
|
|
StringInfo str, int indent, ExplainState *es)
|
|
|
|
{
|
|
|
|
List *context;
|
|
|
|
Node *outercontext;
|
|
|
|
Node *innercontext;
|
|
|
|
Node *node;
|
|
|
|
char *exprstr;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* No work if empty qual */
|
|
|
|
if (qual == NIL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Generate deparse context */
|
|
|
|
if (outer_plan)
|
|
|
|
outercontext = deparse_context_for_subplan(outer_name,
|
|
|
|
outer_plan->targetlist,
|
|
|
|
es->rtable);
|
|
|
|
else
|
|
|
|
outercontext = NULL;
|
|
|
|
if (inner_plan)
|
|
|
|
innercontext = deparse_context_for_subplan(inner_name,
|
|
|
|
inner_plan->targetlist,
|
|
|
|
es->rtable);
|
|
|
|
else
|
|
|
|
innercontext = NULL;
|
|
|
|
context = deparse_context_for_plan(outer_varno, outercontext,
|
|
|
|
inner_varno, innercontext);
|
|
|
|
|
|
|
|
/* Deparse the expression */
|
|
|
|
node = (Node *) make_ands_explicit(qual);
|
|
|
|
exprstr = deparse_expression(node, context, (inner_plan != NULL));
|
|
|
|
|
|
|
|
/* And add to str */
|
|
|
|
for (i = 0; i < indent; i++)
|
|
|
|
appendStringInfo(str, " ");
|
|
|
|
appendStringInfo(str, " %s: %s\n", qlabel, exprstr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Indexscan qual lists have an implicit OR-of-ANDs structure. Make it
|
|
|
|
* explicit so deparsing works properly.
|
|
|
|
*/
|
|
|
|
static Node *
|
|
|
|
make_ors_ands_explicit(List *orclauses)
|
|
|
|
{
|
|
|
|
if (orclauses == NIL)
|
|
|
|
return NULL; /* probably can't happen */
|
|
|
|
else if (lnext(orclauses) == NIL)
|
|
|
|
return (Node *) make_ands_explicit(lfirst(orclauses));
|
|
|
|
else
|
|
|
|
{
|
|
|
|
List *args = NIL;
|
|
|
|
List *orptr;
|
|
|
|
|
|
|
|
foreach(orptr, orclauses)
|
|
|
|
{
|
|
|
|
args = lappend(args, make_ands_explicit(lfirst(orptr)));
|
|
|
|
}
|
|
|
|
|
|
|
|
return (Node *) make_orclause(args);
|
|
|
|
}
|
|
|
|
}
|