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

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

数据库系统

开发平台：

Unix_Linux

execProcnode.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * execProcnode.c
  4.  *  contains dispatch functions which call the appropriate "initialize",
  5.  *  "get a tuple", and "cleanup" routines for the given node type.
  6.  *  If the node has children, then it will presumably call ExecInitNode,
  7.  *  ExecProcNode, or ExecEndNode on it's subnodes and do the appropriate
  8.  *  processing..
  9.  *
  10.  * Copyright (c) 1994, Regents of the University of California
  11.  *
  12.  *
  13.  * IDENTIFICATION
  14.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/executor/execProcnode.c,v 1.14 1999/03/23 16:50:48 momjian Exp $
  15.  *
  16.  *-------------------------------------------------------------------------
  17.  */
  18. /*
  19.  *  INTERFACE ROUTINES
  20.  * ExecInitNode - initialize a plan node and it's subplans
  21.  * ExecProcNode - get a tuple by executing the plan node
  22.  * ExecEndNode - shut down a plan node and it's subplans
  23.  *
  24.  *  NOTES
  25.  * This used to be three files.  It is now all combined into
  26.  * one file so that it is easier to keep ExecInitNode, ExecProcNode,
  27.  * and ExecEndNode in sync when new nodes are added.
  28.  *
  29.  *  EXAMPLE
  30.  * suppose we want the age of the manager of the shoe department and
  31.  * the number of employees in that department.  so we have the query:
  32.  *
  33.  * retrieve (DEPT.no_emps, EMP.age)
  34.  * where EMP.name = DEPT.mgr and
  35.  *   DEPT.name = "shoe"
  36.  *
  37.  * Suppose the planner gives us the following plan:
  38.  *
  39.  * Nest Loop (DEPT.mgr = EMP.name)
  40.  * /
  41.  *    /  
  42.  *    Seq Scan Seq Scan
  43.  * DEPT   EMP
  44.  * (name = "shoe")
  45.  *
  46.  * ExecStart() is called first.
  47.  * It calls InitPlan() which calls ExecInitNode() on
  48.  * the root of the plan -- the nest loop node.
  49.  *
  50.  *   * ExecInitNode() notices that it is looking at a nest loop and
  51.  * as the code below demonstrates, it calls ExecInitNestLoop().
  52.  * Eventually this calls ExecInitNode() on the right and left subplans
  53.  * and so forth until the entire plan is initialized.
  54.  *
  55.  *   * Then when ExecRun() is called, it calls ExecutePlan() which
  56.  * calls ExecProcNode() repeatedly on the top node of the plan.
  57.  * Each time this happens, ExecProcNode() will end up calling
  58.  * ExecNestLoop(), which calls ExecProcNode() on its subplans.
  59.  * Each of these subplans is a sequential scan so ExecSeqScan() is
  60.  * called.  The slots returned by ExecSeqScan() may contain
  61.  * tuples which contain the attributes ExecNestLoop() uses to
  62.  * form the tuples it returns.
  63.  *
  64.  *   * Eventually ExecSeqScan() stops returning tuples and the nest
  65.  * loop join ends.  Lastly, ExecEnd() calls ExecEndNode() which
  66.  * calls ExecEndNestLoop() which in turn calls ExecEndNode() on
  67.  * its subplans which result in ExecEndSeqScan().
  68.  *
  69.  * This should show how the executor works by having
  70.  * ExecInitNode(), ExecProcNode() and ExecEndNode() dispatch
  71.  * their work to the appopriate node support routines which may
  72.  * in turn call these routines themselves on their subplans.
  73.  *
  74.  */
  75. #include "postgres.h"
  77. #include "miscadmin.h"
  78. #include "tcop/tcopprot.h"
  79. #include "executor/executor.h"
  80. #include "executor/nodeResult.h"
  81. #include "executor/nodeAppend.h"
  82. #include "executor/nodeSeqscan.h"
  83. #include "executor/nodeIndexscan.h"
  84. #include "executor/nodeNestloop.h"
  85. #include "executor/nodeMergejoin.h"
  86. #include "executor/nodeMaterial.h"
  87. #include "executor/nodeSort.h"
  88. #include "executor/nodeUnique.h"
  89. #include "executor/nodeGroup.h"
  90. #include "executor/nodeAgg.h"
  91. #include "executor/nodeHash.h"
  92. #include "executor/nodeHashjoin.h"
  93. #include "executor/nodeSubplan.h"
  95. /* ------------------------------------------------------------------------
  96.  * ExecInitNode
  97.  *
  98.  * Recursively initializes all the nodes in the plan rooted
  99.  * at 'node'.
  100.  *
  101.  * Initial States:
  102.  *   'node' is the plan produced by the query planner
  103.  *
  104.  * returns TRUE/FALSE on whether the plan was successfully initialized
  105.  * ------------------------------------------------------------------------
  106.  */
  107. bool
  108. ExecInitNode(Plan *node, EState *estate, Plan *parent)
  109. {
  110. bool result;
  111. List    *subp;
  113. /* ----------------
  114.  * do nothing when we get to the end
  115.  * of a leaf on tree.
  116.  * ----------------
  117.  */
  118. if (node == NULL)
  119. return FALSE;
  121. foreach(subp, node->initPlan)
  122. {
  123. result = ExecInitSubPlan((SubPlan *) lfirst(subp), estate, node);
  124. if (result == FALSE)
  125. return FALSE;
  126. }
  128. switch (nodeTag(node))
  129. {
  130. /* ----------------
  131.  * control nodes
  132.  * ----------------
  133.  */
  134. case T_Result:
  135. result = ExecInitResult((Result *) node, estate, parent);
  136. break;
  138. case T_Append:
  139. result = ExecInitAppend((Append *) node, estate, parent);
  140. break;
  142. /* ----------------
  143.  * scan nodes
  144.  * ----------------
  145.  */
  146. case T_SeqScan:
  147. result = ExecInitSeqScan((SeqScan *) node, estate, parent);
  148. break;
  150. case T_IndexScan:
  151. result = ExecInitIndexScan((IndexScan *) node, estate, parent);
  152. break;
  154. /* ----------------
  155.  * join nodes
  156.  * ----------------
  157.  */
  158. case T_NestLoop:
  159. result = ExecInitNestLoop((NestLoop *) node, estate, parent);
  160. break;
  162. case T_MergeJoin:
  163. result = ExecInitMergeJoin((MergeJoin *) node, estate, parent);
  164. break;
  166. /* ----------------
  167.  * materialization nodes
  168.  * ----------------
  169.  */
  170. case T_Material:
  171. result = ExecInitMaterial((Material *) node, estate, parent);
  172. break;
  174. case T_Sort:
  175. result = ExecInitSort((Sort *) node, estate, parent);
  176. break;
  178. case T_Unique:
  179. result = ExecInitUnique((Unique *) node, estate, parent);
  180. break;
  182. case T_Group:
  183. result = ExecInitGroup((Group *) node, estate, parent);
  184. break;
  186. case T_Agg:
  187. result = ExecInitAgg((Agg *) node, estate, parent);
  188. break;
  190. case T_Hash:
  191. result = ExecInitHash((Hash *) node, estate, parent);
  192. break;
  194. case T_HashJoin:
  195. result = ExecInitHashJoin((HashJoin *) node, estate, parent);
  196. break;
  198. default:
  199. elog(ERROR, "ExecInitNode: node %d unsupported", nodeTag(node));
  200. result = FALSE;
  201. }
  203. if (result != FALSE)
  204. {
  205. foreach(subp, node->subPlan)
  206. {
  207. result = ExecInitSubPlan((SubPlan *) lfirst(subp), estate, node);
  208. if (result == FALSE)
  209. return FALSE;
  210. }
  211. }
  213. return result;
  214. }
  217. /* ----------------------------------------------------------------
  218.  * ExecProcNode
  219.  *
  220.  * Initial States:
  221.  *   the query tree must be initialized once by calling ExecInit.
  222.  * ----------------------------------------------------------------
  223.  */
  224. TupleTableSlot *
  225. ExecProcNode(Plan *node, Plan *parent)
  226. {
  227. TupleTableSlot *result;
  229. /* ----------------
  230.  * deal with NULL nodes..
  231.  * ----------------
  232.  */
  234. if (QueryCancel)
  235. CancelQuery();
  237. if (node == NULL)
  238. return NULL;
  240. if (node->chgParam != NULL) /* something changed */
  241. ExecReScan(node, NULL, parent); /* let ReScan handle this */
  243. switch (nodeTag(node))
  244. {
  245. /* ----------------
  246.  * control nodes
  247.  * ----------------
  248.  */
  249. case T_Result:
  250. result = ExecResult((Result *) node);
  251. break;
  253. case T_Append:
  254. result = ExecProcAppend((Append *) node);
  255. break;
  257. /* ----------------
  258.  * scan nodes
  259.  * ----------------
  260.  */
  261. case T_SeqScan:
  262. result = ExecSeqScan((SeqScan *) node);
  263. break;
  265. case T_IndexScan:
  266. result = ExecIndexScan((IndexScan *) node);
  267. break;
  269. /* ----------------
  270.  * join nodes
  271.  * ----------------
  272.  */
  273. case T_NestLoop:
  274. result = ExecNestLoop((NestLoop *) node, parent);
  275. break;
  277. case T_MergeJoin:
  278. result = ExecMergeJoin((MergeJoin *) node);
  279. break;
  281. /* ----------------
  282.  * materialization nodes
  283.  * ----------------
  284.  */
  285. case T_Material:
  286. result = ExecMaterial((Material *) node);
  287. break;
  289. case T_Sort:
  290. result = ExecSort((Sort *) node);
  291. break;
  293. case T_Unique:
  294. result = ExecUnique((Unique *) node);
  295. break;
  297. case T_Group:
  298. result = ExecGroup((Group *) node);
  299. break;
  301. case T_Agg:
  302. result = ExecAgg((Agg *) node);
  303. break;
  305. case T_Hash:
  306. result = ExecHash((Hash *) node);
  307. break;
  309. case T_HashJoin:
  310. result = ExecHashJoin((HashJoin *) node);
  311. break;
  313. default:
  314. elog(ERROR, "ExecProcNode: node %d unsupported", nodeTag(node));
  315. result = NULL;
  316. }
  318. return result;
  319. }
  321. int
  322. ExecCountSlotsNode(Plan *node)
  323. {
  324. if (node == (Plan *) NULL)
  325. return 0;
  327. switch (nodeTag(node))
  328. {
  329. /* ----------------
  330.  * control nodes
  331.  * ----------------
  332.  */
  333. case T_Result:
  334. return ExecCountSlotsResult((Result *) node);
  336. case T_Append:
  337. return ExecCountSlotsAppend((Append *) node);
  339. /* ----------------
  340.  * scan nodes
  341.  * ----------------
  342.  */
  343. case T_SeqScan:
  344. return ExecCountSlotsSeqScan((SeqScan *) node);
  346. case T_IndexScan:
  347. return ExecCountSlotsIndexScan((IndexScan *) node);
  349. /* ----------------
  350.  * join nodes
  351.  * ----------------
  352.  */
  353. case T_NestLoop:
  354. return ExecCountSlotsNestLoop((NestLoop *) node);
  356. case T_MergeJoin:
  357. return ExecCountSlotsMergeJoin((MergeJoin *) node);
  359. /* ----------------
  360.  * materialization nodes
  361.  * ----------------
  362.  */
  363. case T_Material:
  364. return ExecCountSlotsMaterial((Material *) node);
  366. case T_Sort:
  367. return ExecCountSlotsSort((Sort *) node);
  369. case T_Unique:
  370. return ExecCountSlotsUnique((Unique *) node);
  372. case T_Group:
  373. return ExecCountSlotsGroup((Group *) node);
  375. case T_Agg:
  376. return ExecCountSlotsAgg((Agg *) node);
  378. case T_Hash:
  379. return ExecCountSlotsHash((Hash *) node);
  381. case T_HashJoin:
  382. return ExecCountSlotsHashJoin((HashJoin *) node);
  384. default:
  385. elog(ERROR, "ExecCountSlotsNode: node not yet supported: %d",
  386.  nodeTag(node));
  387. break;
  388. }
  389. return 0;
  390. }
  392. /* ----------------------------------------------------------------
  393.  * ExecEndNode
  394.  *
  395.  * Recursively cleans up all the nodes in the plan rooted
  396.  * at 'node'.
  397.  *
  398.  * After this operation, the query plan will not be able to
  399.  * processed any further. This should be called only after
  400.  * the query plan has been fully executed.
  401.  * ----------------------------------------------------------------
  402.  */
  403. void
  404. ExecEndNode(Plan *node, Plan *parent)
  405. {
  406. List    *subp;
  408. /* ----------------
  409.  * do nothing when we get to the end
  410.  * of a leaf on tree.
  411.  * ----------------
  412.  */
  413. if (node == NULL)
  414. return;
  416. foreach(subp, node->initPlan)
  417. ExecEndSubPlan((SubPlan *) lfirst(subp));
  418. foreach(subp, node->subPlan)
  419. ExecEndSubPlan((SubPlan *) lfirst(subp));
  420. if (node->chgParam != NULL)
  421. {
  422. freeList(node->chgParam);
  423. node->chgParam = NULL;
  424. }
  426. switch (nodeTag(node))
  427. {
  428. /* ----------------
  429.  * control nodes
  430.  * ----------------
  431.  */
  432. case T_Result:
  433. ExecEndResult((Result *) node);
  434. break;
  436. case T_Append:
  437. ExecEndAppend((Append *) node);
  438. break;
  440. /* ----------------
  441.  * scan nodes
  442.  * ----------------
  443.  */
  444. case T_SeqScan:
  445. ExecEndSeqScan((SeqScan *) node);
  446. break;
  448. case T_IndexScan:
  449. ExecEndIndexScan((IndexScan *) node);
  450. break;
  452. /* ----------------
  453.  * join nodes
  454.  * ----------------
  455.  */
  456. case T_NestLoop:
  457. ExecEndNestLoop((NestLoop *) node);
  458. break;
  460. case T_MergeJoin:
  461. ExecEndMergeJoin((MergeJoin *) node);
  462. break;
  464. /* ----------------
  465.  * materialization nodes
  466.  * ----------------
  467.  */
  468. case T_Material:
  469. ExecEndMaterial((Material *) node);
  470. break;
  472. case T_Sort:
  473. ExecEndSort((Sort *) node);
  474. break;
  476. case T_Unique:
  477. ExecEndUnique((Unique *) node);
  478. break;
  480. case T_Group:
  481. ExecEndGroup((Group *) node);
  482. break;
  484. case T_Agg:
  485. ExecEndAgg((Agg *) node);
  486. break;
  488. /* ----------------
  489.  * XXX add hooks to these
  490.  * ----------------
  491.  */
  492. case T_Hash:
  493. ExecEndHash((Hash *) node);
  494. break;
  496. case T_HashJoin:
  497. ExecEndHashJoin((HashJoin *) node);
  498. break;
  500. default:
  501. elog(ERROR, "ExecEndNode: node %d unsupported", nodeTag(node));
  502. break;
  503. }
  504. }