开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
explain.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：7k
源码类别：

数据库系统

开发平台：

Unix_Linux

explain.c：源码内容
  1. /*
  2.  * explain.c
  3.  *   Explain the query execution plan
  4.  *
  5.  * Copyright (c) 1994-5, Regents of the University of California
  6.  *
  7.  *   $Id: explain.c,v 1.38.2.1 1999/08/02 05:56:58 scrappy Exp $
  8.  *
  9.  */
  11. #include "postgres.h"
  13. #include "commands/explain.h"
  14. #include "lib/stringinfo.h"
  15. #include "nodes/print.h"
  16. #include "optimizer/planner.h"
  17. #include "parser/parsetree.h"
  18. #include "rewrite/rewriteHandler.h"
  19. #include "utils/relcache.h"
  21. typedef struct ExplainState
  22. {
  23. /* options */
  24. bool printCost; /* print cost */
  25. bool printNodes; /* do nodeToString() instead */
  26. /* other states */
  27. List    *rtable; /* range table */
  28. } ExplainState;
  30. static char *Explain_PlanToString(Plan *plan, ExplainState *es);
  31. static void printLongNotice(const char *header, const char *message);
  32. static void ExplainOneQuery(Query *query, bool verbose, CommandDest dest);
  35. /*
  36.  * ExplainQuery -
  37.  *   print out the execution plan for a given query
  38.  *
  39.  */
  40. void
  41. ExplainQuery(Query *query, bool verbose, CommandDest dest)
  42. {
  43. List    *rewritten;
  44. List    *l;
  46. /* rewriter and planner may not work in aborted state? */
  47. if (IsAbortedTransactionBlockState())
  48. {
  49. elog(NOTICE, "(transaction aborted): %s",
  50.  "queries ignored until END");
  51. return;
  52. }
  54. /* rewriter and planner will not cope with utility statements */
  55. if (query->commandType == CMD_UTILITY)
  56. {
  57. elog(NOTICE, "Utility statements have no plan structure");
  58. return;
  59. }
  61. /* Rewrite through rule system */
  62. rewritten = QueryRewrite(query);
  64. /* In the case of an INSTEAD NOTHING, tell at least that */
  65. if (rewritten == NIL)
  66. {
  67. elog(NOTICE, "Query rewrites to nothing");
  68. return;
  69. }
  71. /* Explain every plan */
  72. foreach(l, rewritten)
  73. ExplainOneQuery(lfirst(l), verbose, dest);
  74. }
  76. /*
  77.  * ExplainOneQuery -
  78.  *   print out the execution plan for one query
  79.  *
  80.  */
  81. static void
  82. ExplainOneQuery(Query *query, bool verbose, CommandDest dest)
  83. {
  84. char    *s;
  85. Plan    *plan;
  86. ExplainState *es;
  88. /* plan the query */
  89. plan = planner(query);
  91. /* pg_plan could have failed */
  92. if (plan == NULL)
  93. return;
  95. es = (ExplainState *) palloc(sizeof(ExplainState));
  96. MemSet(es, 0, sizeof(ExplainState));
  98. es->printCost = true; /* default */
  100. if (verbose)
  101. es->printNodes = true;
  103. es->rtable = query->rtable;
  105. if (es->printNodes)
  106. {
  107. s = nodeToString(plan);
  108. if (s)
  109. {
  110. printLongNotice("QUERY DUMP:nn", s);
  111. pfree(s);
  112. }
  113. }
  115. if (es->printCost)
  116. {
  117. s = Explain_PlanToString(plan, es);
  118. if (s)
  119. {
  120. printLongNotice("QUERY PLAN:nn", s);
  121. pfree(s);
  122. }
  123. }
  125. if (es->printNodes)
  126. pprint(plan); /* display in postmaster log file */
  128. pfree(es);
  129. }
  131. /*****************************************************************************
  132.  *
  133.  *****************************************************************************/
  135. /*
  136.  * explain_outNode -
  137.  *   converts a Node into ascii string and append it to 'str'
  138.  */
  139. static void
  140. explain_outNode(StringInfo str, Plan *plan, int indent, ExplainState *es)
  141. {
  142. List    *l;
  143. Relation relation;
  144. char    *pname;
  145. int i;
  147. if (plan == NULL)
  148. {
  149. appendStringInfo(str, "n");
  150. return;
  151. }
  153. switch (nodeTag(plan))
  154. {
  155. case T_Result:
  156. pname = "Result";
  157. break;
  158. case T_Append:
  159. pname = "Append";
  160. break;
  161. case T_NestLoop:
  162. pname = "Nested Loop";
  163. break;
  164. case T_MergeJoin:
  165. pname = "Merge Join";
  166. break;
  167. case T_HashJoin:
  168. pname = "Hash Join";
  169. break;
  170. case T_SeqScan:
  171. pname = "Seq Scan";
  172. break;
  173. case T_IndexScan:
  174. pname = "Index Scan";
  175. break;
  176. case T_Noname:
  177. pname = "Noname Scan";
  178. break;
  179. case T_Sort:
  180. pname = "Sort";
  181. break;
  182. case T_Group:
  183. pname = "Group";
  184. break;
  185. case T_Agg:
  186. pname = "Aggregate";
  187. break;
  188. case T_Unique:
  189. pname = "Unique";
  190. break;
  191. case T_Hash:
  192. pname = "Hash";
  193. break;
  194. default:
  195. pname = "???";
  196. break;
  197. }
  199. appendStringInfo(str, pname);
  200. switch (nodeTag(plan))
  201. {
  202. case T_IndexScan:
  203. appendStringInfo(str, " using ");
  204. i = 0;
  205. foreach(l, ((IndexScan *) plan)->indxid)
  206. {
  207. relation = RelationIdCacheGetRelation((int) lfirst(l));
  208. if (++i > 1)
  209. appendStringInfo(str, ", ");
  210. appendStringInfo(str,
  211.  stringStringInfo((RelationGetRelationName(relation))->data));
  212. }
  213. case T_SeqScan:
  214. if (((Scan *) plan)->scanrelid > 0)
  215. {
  216. RangeTblEntry *rte = nth(((Scan *) plan)->scanrelid - 1, es->rtable);
  218. appendStringInfo(str, " on ");
  219. if (strcmp(rte->refname, rte->relname) != 0)
  220. {
  221. appendStringInfo(str, "%s ",
  222.  stringStringInfo(rte->relname));
  223. }
  224. appendStringInfo(str, stringStringInfo(rte->refname));
  225. }
  226. break;
  227. default:
  228. break;
  229. }
  230. if (es->printCost)
  231. {
  232. appendStringInfo(str, "  (cost=%.2f rows=%d width=%d)",
  233.  plan->cost, plan->plan_size, plan->plan_width);
  234. }
  235. appendStringInfo(str, "n");
  237. /* initPlan-s */
  238. if (plan->initPlan)
  239. {
  240. List    *saved_rtable = es->rtable;
  241. List    *lst;
  243. for (i = 0; i < indent; i++)
  244. appendStringInfo(str, "  ");
  245. appendStringInfo(str, "  InitPlann");
  246. foreach(lst, plan->initPlan)
  247. {
  248. es->rtable = ((SubPlan *) lfirst(lst))->rtable;
  249. for (i = 0; i < indent; i++)
  250. appendStringInfo(str, "  ");
  251. appendStringInfo(str, "    ->  ");
  252. explain_outNode(str, ((SubPlan *) lfirst(lst))->plan, indent + 2, es);
  253. }
  254. es->rtable = saved_rtable;
  255. }
  257. /* lefttree */
  258. if (outerPlan(plan))
  259. {
  260. for (i = 0; i < indent; i++)
  261. appendStringInfo(str, "  ");
  262. appendStringInfo(str, "  ->  ");
  263. explain_outNode(str, outerPlan(plan), indent + 3, es);
  264. }
  266. /* righttree */
  267. if (innerPlan(plan))
  268. {
  269. for (i = 0; i < indent; i++)
  270. appendStringInfo(str, "  ");
  271. appendStringInfo(str, "  ->  ");
  272. explain_outNode(str, innerPlan(plan), indent + 3, es);
  273. }
  275. /* subPlan-s */
  276. if (plan->subPlan)
  277. {
  278. List    *saved_rtable = es->rtable;
  279. List    *lst;
  281. for (i = 0; i < indent; i++)
  282. appendStringInfo(str, "  ");
  283. appendStringInfo(str, "  SubPlann");
  284. foreach(lst, plan->subPlan)
  285. {
  286. es->rtable = ((SubPlan *) lfirst(lst))->rtable;
  287. for (i = 0; i < indent; i++)
  288. appendStringInfo(str, "  ");
  289. appendStringInfo(str, "    ->  ");
  290. explain_outNode(str, ((SubPlan *) lfirst(lst))->plan, indent + 4, es);
  291. }
  292. es->rtable = saved_rtable;
  293. }
  295. if (nodeTag(plan) == T_Append)
  296. {
  297. List    *saved_rtable = es->rtable;
  298. List    *lst;
  299. int whichplan = 0;
  300. Append    *appendplan = (Append *) plan;
  302. foreach(lst, appendplan->appendplans)
  303. {
  304. Plan    *subnode = (Plan *) lfirst(lst);
  306. if (appendplan->inheritrelid > 0)
  307. {
  308. ResTarget  *rtentry;
  310. rtentry = nth(whichplan, appendplan->inheritrtable);
  311. Assert(rtentry != NULL);
  312. rt_store(appendplan->inheritrelid, es->rtable, rtentry);
  313. }
  314. else
  315. es->rtable = nth(whichplan, appendplan->unionrtables);
  317. for (i = 0; i < indent; i++)
  318. appendStringInfo(str, "  ");
  319. appendStringInfo(str, "    ->  ");
  321. explain_outNode(str, subnode, indent + 4, es);
  323. whichplan++;
  324. }
  325. es->rtable = saved_rtable;
  326. }
  327. return;
  328. }
  330. static char *
  331. Explain_PlanToString(Plan *plan, ExplainState *es)
  332. {
  333. StringInfoData str;
  335. /* see stringinfo.h for an explanation of this maneuver */
  336. initStringInfo(&str);
  337. if (plan != NULL)
  338. explain_outNode(&str, plan, 0, es);
  339. return str.data;
  340. }
  342. /*
  343.  * Print a message that might exceed the size of the elog message buffer.
  344.  * This is a crock ... there shouldn't be an upper limit to what you can elog().
  345.  */
  346. static void
  347. printLongNotice(const char *header, const char *message)
  348. {
  349. int len = strlen(message);
  351. elog(NOTICE, "%.20s%.*s", header, ELOG_MAXLEN - 64, message);
  352. len -= ELOG_MAXLEN - 64;
  353. while (len > 0)
  354. {
  355. message += ELOG_MAXLEN - 64;
  356. elog(NOTICE, "%.*s", ELOG_MAXLEN - 64, message);
  357. len -= ELOG_MAXLEN - 64;
  358. }
  359. }