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

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

数据库系统

开发平台：

Unix_Linux

createplan.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * createplan.c
  4.  *   Routines to create the desired plan for processing a query
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.57.2.1 1999/07/29 03:34:11 tgl Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. #include <string.h>
  15. #include <sys/types.h>
  17. #include "postgres.h"
  19. #include <utils/syscache.h>
  20. #include <catalog/pg_index.h>
  22. #include "nodes/execnodes.h"
  23. #include "nodes/plannodes.h"
  24. #include "nodes/relation.h"
  25. #include "nodes/primnodes.h"
  26. #include "nodes/nodeFuncs.h"
  28. #include "nodes/makefuncs.h"
  30. #include "utils/lsyscache.h"
  31. #include "utils/palloc.h"
  32. #include "utils/builtins.h"
  34. #include "optimizer/restrictinfo.h"
  35. #include "optimizer/cost.h"
  36. #include "optimizer/clauses.h"
  37. #include "optimizer/planmain.h"
  38. #include "optimizer/tlist.h"
  39. #include "optimizer/planner.h"
  40. #include "optimizer/xfunc.h"
  41. #include "optimizer/internal.h"
  44. #define NONAME_SORT 1
  45. #define NONAME_MATERIAL 2
  47. static List *switch_outer(List *clauses);
  48. static Oid *generate_merge_input_sortorder(List *pathkeys,
  49.    MergeOrder *mergeorder);
  50. static Scan *create_scan_node(Path *best_path, List *tlist);
  51. static Join *create_join_node(JoinPath *best_path, List *tlist);
  52. static SeqScan *create_seqscan_node(Path *best_path, List *tlist,
  53. List *scan_clauses);
  54. static IndexScan *create_indexscan_node(IndexPath *best_path, List *tlist,
  55.   List *scan_clauses);
  56. static NestLoop *create_nestloop_node(NestPath *best_path, List *tlist,
  57.  List *clauses, Plan *outer_node, List *outer_tlist,
  58.  Plan *inner_node, List *inner_tlist);
  59. static MergeJoin *create_mergejoin_node(MergePath *best_path, List *tlist,
  60.   List *clauses, Plan *outer_node, List *outer_tlist,
  61.   Plan *inner_node, List *inner_tlist);
  62. static HashJoin *create_hashjoin_node(HashPath *best_path, List *tlist,
  63.  List *clauses, Plan *outer_node, List *outer_tlist,
  64.  Plan *inner_node, List *inner_tlist);
  65. static Node *fix_indxqual_references(Node *clause, Path *index_path);
  66. static Noname *make_noname(List *tlist, List *pathkeys, Oid *operators,
  67. Plan *plan_node, int nonametype);
  68. static IndexScan *make_indexscan(List *qptlist, List *qpqual, Index scanrelid,
  69.    List *indxid, List *indxqual, List *indxqualorig);
  70. static NestLoop *make_nestloop(List *qptlist, List *qpqual, Plan *lefttree,
  71.   Plan *righttree);
  72. static HashJoin *make_hashjoin(List *tlist, List *qpqual,
  73.   List *hashclauses, Plan *lefttree, Plan *righttree);
  74. static Hash *make_hash(List *tlist, Var *hashkey, Plan *lefttree);
  75. static MergeJoin *make_mergejoin(List *tlist, List *qpqual,
  76.    List *mergeclauses, Plan *righttree, Plan *lefttree);
  77. static Material *make_material(List *tlist, Oid nonameid, Plan *lefttree,
  78.   int keycount);
  79. static void copy_costsize(Plan *dest, Plan *src);
  81. /*
  82.  * create_plan
  83.  *   Creates the access plan for a query by tracing backwards through the
  84.  *   desired chain of pathnodes, starting at the node 'best_path'.  For
  85.  *   every pathnode found:
  86.  *   (1) Create a corresponding plan node containing appropriate id,
  87.  *   target list, and qualification information.
  88.  *   (2) Modify ALL clauses so that attributes are referenced using
  89.  *   relative values.
  90.  *   (3) Target lists are not modified, but will be in another routine.
  91.  *
  92.  *   best_path is the best access path
  93.  *
  94.  *   Returns the optimal(?) access plan.
  95.  */
  96. Plan *
  97. create_plan(Path *best_path)
  98. {
  99. List    *tlist;
  100. Plan    *plan_node = (Plan *) NULL;
  101. RelOptInfo *parent_rel;
  102. int size;
  103. int width;
  104. int pages;
  105. int tuples;
  107. parent_rel = best_path->parent;
  108. tlist = get_actual_tlist(parent_rel->targetlist);
  109. size = parent_rel->size;
  110. width = parent_rel->width;
  111. pages = parent_rel->pages;
  112. tuples = parent_rel->tuples;
  114. switch (best_path->pathtype)
  115. {
  116. case T_IndexScan:
  117. case T_SeqScan:
  118. plan_node = (Plan *) create_scan_node(best_path, tlist);
  119. break;
  120. case T_HashJoin:
  121. case T_MergeJoin:
  122. case T_NestLoop:
  123. plan_node = (Plan *) create_join_node((JoinPath *) best_path, tlist);
  124. break;
  125. default:
  126. /* do nothing */
  127. break;
  128. }
  130. plan_node->plan_size = size;
  131. plan_node->plan_width = width;
  132. if (pages == 0)
  133. pages = 1;
  134. plan_node->plan_tupperpage = tuples / pages;
  136. #ifdef NOT_USED /* fix xfunc */
  137. /* sort clauses by cost/(1-selectivity) -- JMH 2/26/92 */
  138. if (XfuncMode != XFUNC_OFF)
  139. {
  140. set_qpqual((Plan) plan_node,
  141.    lisp_qsort(get_qpqual((Plan) plan_node),
  142.   xfunc_clause_compare));
  143. if (XfuncMode != XFUNC_NOR)
  144. /* sort the disjuncts within each clause by cost -- JMH 3/4/92 */
  145. xfunc_disjunct_sort(plan_node->qpqual);
  146. }
  147. #endif
  149. return plan_node;
  150. }
  152. /*
  153.  * create_scan_node
  154.  *  Create a scan path for the parent relation of 'best_path'.
  155.  *
  156.  *  tlist is the targetlist for the base relation scanned by 'best_path'
  157.  *
  158.  *  Returns the scan node.
  159.  */
  160. static Scan *
  161. create_scan_node(Path *best_path, List *tlist)
  162. {
  164. Scan    *node = NULL;
  165. List    *scan_clauses;
  167. /*
  168.  * Extract the relevant clauses from the parent relation and replace
  169.  * the operator OIDs with the corresponding regproc ids.
  170.  *
  171.  * now that local predicate clauses are copied into paths in
  172.  * find_rel_paths() and then (possibly) pulled up in
  173.  * xfunc_trypullup(), we get the relevant clauses from the path
  174.  * itself, not its parent relation.   --- JMH, 6/15/92
  175.  */
  176. scan_clauses = fix_opids(get_actual_clauses(best_path->loc_restrictinfo));
  178. switch (best_path->pathtype)
  179. {
  180. case T_SeqScan:
  181. node = (Scan *) create_seqscan_node(best_path, tlist, scan_clauses);
  182. break;
  184. case T_IndexScan:
  185. node = (Scan *) create_indexscan_node((IndexPath *) best_path,
  186.   tlist,
  187.   scan_clauses);
  188. break;
  190. default:
  191. elog(ERROR, "create_scan_node: unknown node type",
  192.  best_path->pathtype);
  193. break;
  194. }
  196. return node;
  197. }
  199. /*
  200.  * create_join_node
  201.  *   Create a join path for 'best_path' and(recursively) paths for its
  202.  *   inner and outer paths.
  203.  *
  204.  *   'tlist' is the targetlist for the join relation corresponding to
  205.  * 'best_path'
  206.  *
  207.  *   Returns the join node.
  208.  */
  209. static Join *
  210. create_join_node(JoinPath *best_path, List *tlist)
  211. {
  212. Plan    *outer_node;
  213. List    *outer_tlist;
  214. Plan    *inner_node;
  215. List    *inner_tlist;
  216. List    *clauses;
  217. Join    *retval = NULL;
  219. outer_node = create_plan((Path *) best_path->outerjoinpath);
  220. outer_tlist = outer_node->targetlist;
  222. inner_node = create_plan((Path *) best_path->innerjoinpath);
  223. inner_tlist = inner_node->targetlist;
  225. clauses = get_actual_clauses(best_path->pathinfo);
  227. switch (best_path->path.pathtype)
  228. {
  229. case T_MergeJoin:
  230. retval = (Join *) create_mergejoin_node((MergePath *) best_path,
  231. tlist,
  232. clauses,
  233. outer_node,
  234. outer_tlist,
  235. inner_node,
  236. inner_tlist);
  237. break;
  238. case T_HashJoin:
  239. retval = (Join *) create_hashjoin_node((HashPath *) best_path,
  240.    tlist,
  241.    clauses,
  242.    outer_node,
  243.    outer_tlist,
  244.    inner_node,
  245.    inner_tlist);
  246. break;
  247. case T_NestLoop:
  248. retval = (Join *) create_nestloop_node((NestPath *) best_path,
  249.    tlist,
  250.    clauses,
  251.    outer_node,
  252.    outer_tlist,
  253.    inner_node,
  254.    inner_tlist);
  255. break;
  256. default:
  257. /* do nothing */
  258. elog(ERROR, "create_join_node: unknown node type",
  259.  best_path->path.pathtype);
  260. }
  262. #if 0
  264. /*
  265.  * * Expensive function pullups may have pulled local predicates *
  266.  * into this path node.  Put them in the qpqual of the plan node. *
  267.  * JMH, 6/15/92
  268.  */
  269. if (get_loc_restrictinfo(best_path) != NIL)
  270. set_qpqual((Plan) retval,
  271.    nconc(get_qpqual((Plan) retval),
  272.  fix_opids(get_actual_clauses
  273.    (get_loc_restrictinfo(best_path)))));
  274. #endif
  276. return retval;
  277. }
  279. /*****************************************************************************
  280.  *
  281.  * BASE-RELATION SCAN METHODS
  282.  *
  283.  *****************************************************************************/
  286. /*
  287.  * create_seqscan_node
  288.  *  Returns a seqscan node for the base relation scanned by 'best_path'
  289.  *  with restriction clauses 'scan_clauses' and targetlist 'tlist'.
  290.  */
  291. static SeqScan *
  292. create_seqscan_node(Path *best_path, List *tlist, List *scan_clauses)
  293. {
  294. SeqScan    *scan_node = (SeqScan *) NULL;
  295. Index scan_relid = -1;
  296. List    *temp;
  298. temp = best_path->parent->relids;
  299. if (temp == NULL)
  300. elog(ERROR, "scanrelid is empty");
  301. else
  302. scan_relid = (Index) lfirsti(temp); /* ??? who takes care of
  303.  * lnext? - ay */
  304. scan_node = make_seqscan(tlist,
  305.  scan_clauses,
  306.  scan_relid,
  307.  (Plan *) NULL);
  309. scan_node->plan.cost = best_path->path_cost;
  311. return scan_node;
  312. }
  314. /*
  315.  * create_indexscan_node
  316.  *   Returns a indexscan node for the base relation scanned by 'best_path'
  317.  *   with restriction clauses 'scan_clauses' and targetlist 'tlist'.
  318.  */
  319. static IndexScan *
  320. create_indexscan_node(IndexPath *best_path,
  321.   List *tlist,
  322.   List *scan_clauses)
  323. {
  325. /*
  326.  * Extract the(first if conjunct, only if disjunct) clause from the
  327.  * restrictinfo list.
  328.  */
  329. Expr    *index_clause = (Expr *) NULL;
  330. List    *indxqual = NIL;
  331. List    *qpqual = NIL;
  332. List    *fixed_indxqual = NIL;
  333. List    *ixid;
  334. IndexScan  *scan_node = (IndexScan *) NULL;
  335. bool lossy = FALSE;
  336. HeapTuple indexTuple;
  337. Form_pg_index index;
  339. /*
  340.  * If an 'or' clause is to be used with this index, the indxqual field
  341.  * will contain a list of the 'or' clause arguments, e.g., the
  342.  * clause(OR a b c) will generate: ((a) (b) (c)).  Otherwise, the
  343.  * indxqual will simply contain one conjunctive qualification: ((a)).
  344.  */
  345. if (best_path->indexqual != NULL)
  346. /* added call to fix_opids, JMH 6/23/92 */
  347. index_clause = (Expr *)
  348. lfirst(fix_opids(get_actual_clauses(best_path->indexqual)));
  350. if (or_clause((Node *) index_clause))
  351. {
  352. List    *temp = NIL;
  354. foreach(temp, index_clause->args)
  355. indxqual = lappend(indxqual, lcons(lfirst(temp), NIL));
  356. }
  357. else
  358. {
  359. indxqual = lcons(get_actual_clauses(best_path->indexqual),
  360.  NIL);
  361. }
  363. /* check and see if any indices are lossy */
  364. foreach(ixid, best_path->indexid)
  365. {
  366. indexTuple = SearchSysCacheTuple(INDEXRELID,
  367.  ObjectIdGetDatum(lfirsti(ixid)),
  368.  0, 0, 0);
  369. if (!HeapTupleIsValid(indexTuple))
  370. elog(ERROR, "create_plan: index %u not found", lfirsti(ixid));
  371. index = (Form_pg_index) GETSTRUCT(indexTuple);
  372. if (index->indislossy)
  373. lossy = TRUE;
  374. }
  377. /*
  378.  * The qpqual field contains all restrictions not automatically
  379.  * handled by the index.  Note that for non-lossy indices, the
  380.  * predicates in the indxqual are handled by the index, while for
  381.  * lossy indices the indxqual predicates need to be double-checked
  382.  * after the index fetches the best-guess tuples.
  383.  */
  384. if (or_clause((Node *) index_clause))
  385. {
  386. qpqual = set_difference(scan_clauses,
  387. lcons(index_clause, NIL));
  389. if (lossy)
  390. qpqual = lappend(qpqual, (List *) copyObject(index_clause));
  391. }
  392. else
  393. {
  394. qpqual = set_difference(scan_clauses, lfirst(indxqual));
  395. if (lossy)
  396. qpqual = nconc(qpqual,
  397.    (List *) copyObject(lfirst(indxqual)));
  398. }
  400. fixed_indxqual = (List *) fix_indxqual_references((Node *) indxqual, (Path *) best_path);
  402. scan_node = make_indexscan(tlist,
  403.    qpqual,
  404.    lfirsti(best_path->path.parent->relids),
  405.    best_path->indexid,
  406.    fixed_indxqual,
  407.    indxqual);
  409. scan_node->scan.plan.cost = best_path->path.path_cost;
  411. return scan_node;
  412. }
  414. /*****************************************************************************
  415.  *
  416.  * JOIN METHODS
  417.  *
  418.  *****************************************************************************/
  420. static NestLoop *
  421. create_nestloop_node(NestPath *best_path,
  422.  List *tlist,
  423.  List *clauses,
  424.  Plan *outer_node,
  425.  List *outer_tlist,
  426.  Plan *inner_node,
  427.  List *inner_tlist)
  428. {
  429. NestLoop   *join_node = (NestLoop *) NULL;
  431. if (IsA(inner_node, IndexScan))
  432. {
  434. /*
  435.  * An index is being used to reduce the number of tuples scanned
  436.  * in the inner relation. There will never be more than one index
  437.  * used in the inner scan path, so we need only consider the first
  438.  * set of qualifications in indxqual.
  439.  *
  440.  * But there may be more than one clause in this "first set" in the
  441.  * case of multi-column indices. - vadim 03/18/97
  442.  */
  444. List    *inner_indxqual = lfirst(((IndexScan *) inner_node)->indxqual);
  445. List    *inner_qual;
  446. bool found = false;
  448. foreach(inner_qual, inner_indxqual)
  449. {
  450. if (!qual_clause_p((Node *) lfirst(inner_qual)))
  451. {
  452. found = true;
  453. break;
  454. }
  455. }
  457. /*
  458.  * If we have in fact found a join index qualification, remove
  459.  * these index clauses from the nestloop's join clauses and reset
  460.  * the inner(index) scan's qualification so that the var nodes
  461.  * refer to the proper outer join relation attributes.
  462.  *
  463.  * XXX Re-moving index clauses doesn't work properly: 1.
  464.  * fix_indxqual_references may change varattno-s in
  465.  * inner_indxqual; 2. clauses may be commuted I havn't time to fix
  466.  * it at the moment.   - vadim 04/24/97
  467.  */
  468. if (found)
  469. {
  470. List    *new_inner_qual = NIL;
  472. clauses = set_difference(clauses, inner_indxqual); /* XXX */
  473. new_inner_qual = index_outerjoin_references(inner_indxqual,
  474.   outer_node->targetlist,
  475.    ((Scan *) inner_node)->scanrelid);
  476. ((IndexScan *) inner_node)->indxqual = lcons(new_inner_qual, NIL);
  477. }
  478. }
  479. else if (IsA_Join(inner_node))
  480. {
  481. inner_node = (Plan *) make_noname(inner_tlist,
  482.   NIL,
  483.   NULL,
  484.   inner_node,
  485.   NONAME_MATERIAL);
  486. }
  488. join_node = make_nestloop(tlist,
  489.   join_references(clauses,
  490.   outer_tlist,
  491.   inner_tlist),
  492.   outer_node,
  493.   inner_node);
  495. join_node->join.cost = best_path->path.path_cost;
  497. return join_node;
  498. }
  500. static MergeJoin *
  501. create_mergejoin_node(MergePath *best_path,
  502.   List *tlist,
  503.   List *clauses,
  504.   Plan *outer_node,
  505.   List *outer_tlist,
  506.   Plan *inner_node,
  507.   List *inner_tlist)
  508. {
  509. List    *qpqual,
  510.    *mergeclauses;
  511. MergeJoin  *join_node;
  514. /*
  515.  * Separate the mergeclauses from the other join qualification clauses
  516.  * and set those clauses to contain references to lower attributes.
  517.  */
  518. qpqual = join_references(set_difference(clauses,
  519. best_path->path_mergeclauses),
  520.  outer_tlist,
  521.  inner_tlist);
  523. /*
  524.  * Now set the references in the mergeclauses and rearrange them so
  525.  * that the outer variable is always on the left.
  526.  */
  527. mergeclauses = switch_outer(join_references(best_path->path_mergeclauses,
  528. outer_tlist,
  529. inner_tlist));
  531. /*
  532.  * Create explicit sort paths for the outer and inner join paths if
  533.  * necessary.  The sort cost was already accounted for in the path.
  534.  */
  535. if (best_path->outersortkeys)
  536. {
  537. Oid    *outer_order = generate_merge_input_sortorder(
  538. best_path->outersortkeys,
  539.  best_path->jpath.path.pathorder->ord.merge);
  541. outer_node = (Plan *) make_noname(outer_tlist,
  542.   best_path->outersortkeys,
  543.   outer_order,
  544.   outer_node,
  545.   NONAME_SORT);
  546. }
  548. if (best_path->innersortkeys)
  549. {
  550. Oid    *inner_order = generate_merge_input_sortorder(
  551. best_path->innersortkeys,
  552.  best_path->jpath.path.pathorder->ord.merge);
  554. inner_node = (Plan *) make_noname(inner_tlist,
  555.   best_path->innersortkeys,
  556.   inner_order,
  557.   inner_node,
  558.   NONAME_SORT);
  559. }
  561. join_node = make_mergejoin(tlist,
  562.    qpqual,
  563.    mergeclauses,
  564.    inner_node,
  565.    outer_node);
  567. join_node->join.cost = best_path->jpath.path.path_cost;
  569. return join_node;
  570. }
  572. /*
  573.  * create_hashjoin_node-- XXX HASH
  574.  *
  575.  *   Returns a new hashjoin node.
  576.  *
  577.  *   XXX hash join ops are totally bogus -- how the hell do we choose
  578.  * these??  at runtime?  what about a hash index?
  579.  */
  580. static HashJoin *
  581. create_hashjoin_node(HashPath *best_path,
  582.  List *tlist,
  583.  List *clauses,
  584.  Plan *outer_node,
  585.  List *outer_tlist,
  586.  Plan *inner_node,
  587.  List *inner_tlist)
  588. {
  589. List    *qpqual;
  590. List    *hashclauses;
  591. HashJoin   *join_node;
  592. Hash    *hash_node;
  593. Var    *innerhashkey;
  595. /*
  596.  * Separate the hashclauses from the other join qualification clauses
  597.  * and set those clauses to contain references to lower attributes.
  598.  */
  599. qpqual = join_references(set_difference(clauses,
  600. best_path->path_hashclauses),
  601.  outer_tlist,
  602.  inner_tlist);
  604. /*
  605.  * Now set the references in the hashclauses and rearrange them so
  606.  * that the outer variable is always on the left.
  607.  */
  608. hashclauses = switch_outer(join_references(best_path->path_hashclauses,
  609.    outer_tlist,
  610.    inner_tlist));
  612. innerhashkey = get_rightop(lfirst(hashclauses));
  614. hash_node = make_hash(inner_tlist, innerhashkey, inner_node);
  615. join_node = make_hashjoin(tlist,
  616.   qpqual,
  617.   hashclauses,
  618.   outer_node,
  619.   (Plan *) hash_node);
  621. join_node->join.cost = best_path->jpath.path.path_cost;
  623. return join_node;
  624. }
  627. /*****************************************************************************
  628.  *
  629.  * SUPPORTING ROUTINES
  630.  *
  631.  *****************************************************************************/
  633. /*
  634.  * fix_indxqual_references
  635.  * Adjust a qual clause to refer to an index instead of the original relation.
  636.  *
  637.  * Returns a modified copy of the given clause --- the original is not changed.
  638.  */
  640. static Node *
  641. fix_indxqual_references(Node *clause, Path *index_path)
  642. {
  643. if (clause == NULL)
  644. return NULL;
  645. else if (IsA(clause, Var))
  646. {
  647. if (lfirsti(index_path->parent->relids) == ((Var *) clause)->varno)
  648. {
  649. Node    *newclause;
  650. int pos = 0;
  651. int varatt = ((Var *) clause)->varattno;
  652. int    *indexkeys = ((IndexPath *) index_path)->indexkeys;
  654. if (indexkeys)
  655. {
  656. while (indexkeys[pos] != 0)
  657. {
  658. if (varatt == indexkeys[pos])
  659. break;
  660. pos++;
  661. }
  662. }
  663. newclause = copyObject(clause);
  664. ((Var *) newclause)->varattno = pos + 1;
  665. return newclause;
  666. }
  667. /* The Var is not part of the indexed relation, leave it alone */
  668. return copyObject(clause);
  669. }
  670. else if (single_node(clause))
  671. return copyObject(clause);
  672. else if (is_opclause(clause) &&
  673.  is_funcclause((Node *) get_leftop((Expr *) clause)) &&
  674. ((Func *) ((Expr *) get_leftop((Expr *) clause))->oper)->funcisindex)
  675. {
  677. /*
  678.  * This looks pretty seriously wrong to me, but I'm not sure what
  679.  * it's supposed to be doing ... tgl 5/99
  680.  */
  681. Var    *newvar = makeVar((Index) lfirsti(index_path->parent->relids),
  682.  1, /* func indices have one key */
  683. ((Func *) ((Expr *) clause)->oper)->functype,
  684.  -1,
  685.  0,
  686.  (Index) lfirsti(index_path->parent->relids),
  687.  0);
  689. return ((Node *) make_opclause((Oper *) ((Expr *) clause)->oper,
  690.    newvar,
  691.    get_rightop((Expr *) clause)));
  693. }
  694. else if (IsA(clause, Expr))
  695. {
  696. Expr    *expr = (Expr *) clause;
  697. List    *new_subclauses = NIL;
  698. List    *i;
  700. foreach(i, expr->args)
  701. {
  702. Node    *subclause = lfirst(i);
  704. new_subclauses = lappend(new_subclauses,
  705.  fix_indxqual_references(subclause,
  706.  index_path));
  707. }
  709. return (Node *) make_clause(expr->opType, expr->oper, new_subclauses);
  710. }
  711. else if (IsA(clause, List))
  712. {
  713. List    *new_subclauses = NIL;
  714. List    *i;
  716. foreach(i, (List *) clause)
  717. {
  718. Node    *subclause = lfirst(i);
  720. new_subclauses = lappend(new_subclauses,
  721.  fix_indxqual_references(subclause,
  722.  index_path));
  723. }
  725. return (Node *) new_subclauses;
  726. }
  727. else if (IsA(clause, ArrayRef))
  728. {
  729. ArrayRef   *oldnode = (ArrayRef *) clause;
  730. ArrayRef   *newnode = makeNode(ArrayRef);
  732. newnode->refattrlength = oldnode->refattrlength;
  733. newnode->refelemlength = oldnode->refelemlength;
  734. newnode->refelemtype = oldnode->refelemtype;
  735. newnode->refelembyval = oldnode->refelembyval;
  736. newnode->refupperindexpr = (List *)
  737. fix_indxqual_references((Node *) oldnode->refupperindexpr,
  738. index_path);
  739. newnode->reflowerindexpr = (List *)
  740. fix_indxqual_references((Node *) oldnode->reflowerindexpr,
  741. index_path);
  742. newnode->refexpr =
  743. fix_indxqual_references(oldnode->refexpr, index_path);
  744. newnode->refassgnexpr =
  745. fix_indxqual_references(oldnode->refassgnexpr, index_path);
  747. return (Node *) newnode;
  748. }
  749. else if (IsA(clause, CaseExpr))
  750. {
  751. CaseExpr   *oldnode = (CaseExpr *) clause;
  752. CaseExpr   *newnode = makeNode(CaseExpr);
  754. newnode->casetype = oldnode->casetype;
  755. newnode->arg = oldnode->arg; /* XXX should always be null
  756.  * anyway ... */
  757. newnode->args = (List *)
  758. fix_indxqual_references((Node *) oldnode->args,
  759. index_path);
  760. newnode->defresult =
  761. fix_indxqual_references(oldnode->defresult,
  762. index_path);
  764. return (Node *) newnode;
  765. }
  766. else if (IsA(clause, CaseWhen))
  767. {
  768. CaseWhen   *oldnode = (CaseWhen *) clause;
  769. CaseWhen   *newnode = makeNode(CaseWhen);
  771. newnode->expr =
  772. fix_indxqual_references(oldnode->expr,
  773. index_path);
  774. newnode->result =
  775. fix_indxqual_references(oldnode->result,
  776. index_path);
  778. return (Node *) newnode;
  779. }
  780. else
  781. {
  782. elog(ERROR, "fix_indxqual_references: Cannot handle node type %d",
  783.  nodeTag(clause));
  784. return NULL;
  785. }
  786. }
  789. /*
  790.  * switch_outer
  791.  *   Given a list of merge clauses, rearranges the elements within the
  792.  *   clauses so the outer join variable is on the left and the inner is on
  793.  *   the right.  The original list is not touched; a modified list
  794.  *   is returned.
  795.  */
  796. static List *
  797. switch_outer(List *clauses)
  798. {
  799. List    *t_list = NIL;
  800. Expr    *temp;
  801. List    *i;
  802. Expr    *clause;
  803. Node    *op;
  805. foreach(i, clauses)
  806. {
  807. clause = lfirst(i);
  808. Assert(is_opclause((Node *) clause));
  809. op = (Node *) get_rightop(clause);
  810. Assert(op != (Node *) NULL);
  811. if (IsA(op, ArrayRef))
  812. op = ((ArrayRef *) op)->refexpr;
  813. Assert(IsA(op, Var));
  814. if (var_is_outer((Var *) op))
  815. {
  817. /*
  818.  * Duplicate just enough of the structure to allow commuting
  819.  * the clause without changing the original list.  Could use
  820.  * copyObject, but a complete deep copy is overkill.
  821.  */
  822. temp = make_clause(clause->opType, clause->oper,
  823.    lcons(get_leftop(clause),
  824.  lcons(get_rightop(clause),
  825.    NIL)));
  826. /* Commute it --- note this modifies the temp node in-place. */
  827. CommuteClause((Node *) temp);
  828. t_list = lappend(t_list, temp);
  829. }
  830. else
  831. t_list = lappend(t_list, clause);
  832. }
  833. return t_list;
  834. }
  836. /*
  837.  * generate_merge_input_sortorder
  838.  *
  839.  * Generate the list of sort ops needed to sort one of the input paths for
  840.  * a merge.  We may have to use either left or right sortop for each item,
  841.  * since the original mergejoin clause may or may not have been commuted
  842.  * (compare switch_outer above).
  843.  *
  844.  * XXX This is largely a crock.  It works only because group_clauses_by_order
  845.  * only groups together mergejoin clauses that have identical MergeOrder info,
  846.  * which means we can safely use a single MergeOrder input to deal with all
  847.  * the data.  There should be a more general data structure that allows coping
  848.  * with groups of mergejoin clauses that have different join operators.
  849.  */
  850. static Oid *
  851. generate_merge_input_sortorder(List *pathkeys, MergeOrder *mergeorder)
  852. {
  853. int listlength = length(pathkeys);
  854. Oid    *result = (Oid *) palloc(sizeof(Oid) * (listlength + 1));
  855. Oid    *nextsortop = result;
  856. List    *p;
  858. foreach(p, pathkeys)
  859. {
  860. Var    *pkey = (Var *) lfirst((List *) lfirst(p));
  862. Assert(IsA(pkey, Var));
  863. if (pkey->vartype == mergeorder->left_type)
  864. *nextsortop++ = mergeorder->left_operator;
  865. else if (pkey->vartype == mergeorder->right_type)
  866. *nextsortop++ = mergeorder->right_operator;
  867. else
  868. elog(ERROR,
  869.  "generate_merge_input_sortorder: can't handle data type %d",
  870.  pkey->vartype);
  871. }
  872. *nextsortop++ = InvalidOid;
  873. return result;
  874. }
  876. /*
  877.  * set_noname_tlist_operators
  878.  *   Sets the key and keyop fields of resdom nodes in a target list.
  879.  *
  880.  *   'tlist' is the target list
  881.  *   'pathkeys' is a list of N keys in the form((key1) (key2)...(keyn)),
  882.  * corresponding to vars in the target list that are to
  883.  * be sorted or hashed
  884.  *   'operators' is the corresponding list of N sort or hash operators
  885.  *
  886.  *   Returns the modified-in-place target list.
  887.  */
  888. static List *
  889. set_noname_tlist_operators(List *tlist, List *pathkeys, Oid *operators)
  890. {
  891. int keyno = 1;
  892. Node    *pathkey;
  893. Resdom    *resdom;
  894. List    *i;
  896. foreach(i, pathkeys)
  897. {
  898. pathkey = lfirst((List *) lfirst(i));
  899. resdom = tlist_member((Var *) pathkey, tlist);
  900. if (resdom)
  901. {
  903. /*
  904.  * Order the resdom pathkey and replace the operator OID for
  905.  * each key with the regproc OID.
  906.  */
  907. resdom->reskey = keyno;
  908. resdom->reskeyop = get_opcode(operators[keyno - 1]);
  909. }
  910. keyno += 1;
  911. }
  912. return tlist;
  913. }
  915. /*
  916.  * Copy cost and size info from a lower plan node to an inserted node.
  917.  * This is not critical, since the decisions have already been made,
  918.  * but it helps produce more reasonable-looking EXPLAIN output.
  919.  */
  921. static void
  922. copy_costsize(Plan *dest, Plan *src)
  923. {
  924. if (src)
  925. {
  926. dest->cost = src->cost;
  927. dest->plan_size = src->plan_size;
  928. dest->plan_width = src->plan_width;
  929. }
  930. else
  931. {
  932. dest->cost = 0;
  933. dest->plan_size = 0;
  934. dest->plan_width = 0;
  935. }
  936. }
  939. /*****************************************************************************
  940.  *
  941.  *
  942.  *****************************************************************************/
  944. /*
  945.  * make_noname
  946.  *   Create plan nodes to sort or materialize relations into noname. The
  947.  *   result returned for a sort will look like (SEQSCAN(SORT(plan_node)))
  948.  *   or (SEQSCAN(MATERIAL(plan_node)))
  949.  *
  950.  *   'tlist' is the target list of the scan to be sorted or hashed
  951.  *   'pathkeys' is the list of keys which the sort or hash will be done on
  952.  *   'operators' is the operators with which the sort or hash is to be done
  953.  * (a list of operator OIDs)
  954.  *   'plan_node' is the node which yields tuples for the sort
  955.  *   'nonametype' indicates which operation(sort or hash) to perform
  956.  */
  957. static Noname *
  958. make_noname(List *tlist,
  959. List *pathkeys,
  960. Oid *operators,
  961. Plan *plan_node,
  962. int nonametype)
  963. {
  964. List    *noname_tlist;
  965. Noname    *retval = NULL;
  967. /* Create a new target list for the noname, with keys set. */
  968. noname_tlist = set_noname_tlist_operators(new_unsorted_tlist(tlist),
  969.   pathkeys,
  970.   operators);
  971. switch (nonametype)
  972. {
  973. case NONAME_SORT:
  974. retval = (Noname *) make_seqscan(tlist,
  975.  NIL,
  976.  _NONAME_RELATION_ID_,
  977.  (Plan *) make_sort(noname_tlist,
  978. _NONAME_RELATION_ID_,
  979. plan_node,
  980.   length(pathkeys)));
  981. break;
  983. case NONAME_MATERIAL:
  984. retval = (Noname *) make_seqscan(tlist,
  985.  NIL,
  986.  _NONAME_RELATION_ID_,
  987.  (Plan *) make_material(noname_tlist,
  988. _NONAME_RELATION_ID_,
  989. plan_node,
  990.   length(pathkeys)));
  991. break;
  993. default:
  994. elog(ERROR, "make_noname: unknown noname type %d", nonametype);
  996. }
  997. return retval;
  998. }
  1001. SeqScan    *
  1002. make_seqscan(List *qptlist,
  1003.  List *qpqual,
  1004.  Index scanrelid,
  1005.  Plan *lefttree)
  1006. {
  1007. SeqScan    *node = makeNode(SeqScan);
  1008. Plan    *plan = &node->plan;
  1010. copy_costsize(plan, lefttree);
  1011. plan->state = (EState *) NULL;
  1012. plan->targetlist = qptlist;
  1013. plan->qual = qpqual;
  1014. plan->lefttree = lefttree;
  1015. plan->righttree = NULL;
  1016. node->scanrelid = scanrelid;
  1017. node->scanstate = (CommonScanState *) NULL;
  1019. return node;
  1020. }
  1022. static IndexScan *
  1023. make_indexscan(List *qptlist,
  1024.    List *qpqual,
  1025.    Index scanrelid,
  1026.    List *indxid,
  1027.    List *indxqual,
  1028.    List *indxqualorig)
  1029. {
  1030. IndexScan  *node = makeNode(IndexScan);
  1031. Plan    *plan = &node->scan.plan;
  1033. copy_costsize(plan, NULL);
  1034. plan->state = (EState *) NULL;
  1035. plan->targetlist = qptlist;
  1036. plan->qual = qpqual;
  1037. plan->lefttree = NULL;
  1038. plan->righttree = NULL;
  1039. node->scan.scanrelid = scanrelid;
  1040. node->indxid = indxid;
  1041. node->indxqual = indxqual;
  1042. node->indxqualorig = indxqualorig;
  1043. node->scan.scanstate = (CommonScanState *) NULL;
  1045. return node;
  1046. }
  1049. static NestLoop *
  1050. make_nestloop(List *qptlist,
  1051.   List *qpqual,
  1052.   Plan *lefttree,
  1053.   Plan *righttree)
  1054. {
  1055. NestLoop   *node = makeNode(NestLoop);
  1056. Plan    *plan = &node->join;
  1058. /*
  1059.  * this cost estimate is entirely bogus... hopefully it will be
  1060.  * overwritten by caller.
  1061.  */
  1062. plan->cost = (lefttree ? lefttree->cost : 0) +
  1063. (righttree ? righttree->cost : 0);
  1064. plan->state = (EState *) NULL;
  1065. plan->targetlist = qptlist;
  1066. plan->qual = qpqual;
  1067. plan->lefttree = lefttree;
  1068. plan->righttree = righttree;
  1069. node->nlstate = (NestLoopState *) NULL;
  1071. return node;
  1072. }
  1074. static HashJoin *
  1075. make_hashjoin(List *tlist,
  1076.   List *qpqual,
  1077.   List *hashclauses,
  1078.   Plan *lefttree,
  1079.   Plan *righttree)
  1080. {
  1081. HashJoin   *node = makeNode(HashJoin);
  1082. Plan    *plan = &node->join;
  1084. /*
  1085.  * this cost estimate is entirely bogus... hopefully it will be
  1086.  * overwritten by caller.
  1087.  */
  1088. plan->cost = (lefttree ? lefttree->cost : 0) +
  1089. (righttree ? righttree->cost : 0);
  1090. plan->state = (EState *) NULL;
  1091. plan->targetlist = tlist;
  1092. plan->qual = qpqual;
  1093. plan->lefttree = lefttree;
  1094. plan->righttree = righttree;
  1095. node->hashclauses = hashclauses;
  1096. node->hashdone = false;
  1098. return node;
  1099. }
  1101. static Hash *
  1102. make_hash(List *tlist, Var *hashkey, Plan *lefttree)
  1103. {
  1104. Hash    *node = makeNode(Hash);
  1105. Plan    *plan = &node->plan;
  1107. copy_costsize(plan, lefttree);
  1108. plan->state = (EState *) NULL;
  1109. plan->targetlist = tlist;
  1110. plan->qual = NULL;
  1111. plan->lefttree = lefttree;
  1112. plan->righttree = NULL;
  1113. node->hashkey = hashkey;
  1115. return node;
  1116. }
  1118. static MergeJoin *
  1119. make_mergejoin(List *tlist,
  1120.    List *qpqual,
  1121.    List *mergeclauses,
  1122.    Plan *righttree,
  1123.    Plan *lefttree)
  1124. {
  1125. MergeJoin  *node = makeNode(MergeJoin);
  1126. Plan    *plan = &node->join;
  1128. /*
  1129.  * this cost estimate is entirely bogus... hopefully it will be
  1130.  * overwritten by caller.
  1131.  */
  1132. plan->cost = (lefttree ? lefttree->cost : 0) +
  1133. (righttree ? righttree->cost : 0);
  1134. plan->state = (EState *) NULL;
  1135. plan->targetlist = tlist;
  1136. plan->qual = qpqual;
  1137. plan->lefttree = lefttree;
  1138. plan->righttree = righttree;
  1139. node->mergeclauses = mergeclauses;
  1141. return node;
  1142. }
  1144. Sort *
  1145. make_sort(List *tlist, Oid nonameid, Plan *lefttree, int keycount)
  1146. {
  1147. Sort    *node = makeNode(Sort);
  1148. Plan    *plan = &node->plan;
  1150. copy_costsize(plan, lefttree);
  1151. plan->cost += cost_sort(NULL, plan->plan_size, plan->plan_width);
  1152. plan->state = (EState *) NULL;
  1153. plan->targetlist = tlist;
  1154. plan->qual = NIL;
  1155. plan->lefttree = lefttree;
  1156. plan->righttree = NULL;
  1157. node->nonameid = nonameid;
  1158. node->keycount = keycount;
  1160. return node;
  1161. }
  1163. static Material *
  1164. make_material(List *tlist,
  1165.   Oid nonameid,
  1166.   Plan *lefttree,
  1167.   int keycount)
  1168. {
  1169. Material   *node = makeNode(Material);
  1170. Plan    *plan = &node->plan;
  1172. copy_costsize(plan, lefttree);
  1173. plan->state = (EState *) NULL;
  1174. plan->targetlist = tlist;
  1175. plan->qual = NIL;
  1176. plan->lefttree = lefttree;
  1177. plan->righttree = NULL;
  1178. node->nonameid = nonameid;
  1179. node->keycount = keycount;
  1181. return node;
  1182. }
  1184. Agg *
  1185. make_agg(List *tlist, Plan *lefttree)
  1186. {
  1187. Agg    *node = makeNode(Agg);
  1189. copy_costsize(&node->plan, lefttree);
  1190. node->plan.state = (EState *) NULL;
  1191. node->plan.qual = NULL;
  1192. node->plan.targetlist = tlist;
  1193. node->plan.lefttree = lefttree;
  1194. node->plan.righttree = (Plan *) NULL;
  1195. node->aggs = NIL;
  1197. return node;
  1198. }
  1200. Group *
  1201. make_group(List *tlist,
  1202.    bool tuplePerGroup,
  1203.    int ngrp,
  1204.    AttrNumber *grpColIdx,
  1205.    Sort *lefttree)
  1206. {
  1207. Group    *node = makeNode(Group);
  1209. copy_costsize(&node->plan, (Plan *) lefttree);
  1210. node->plan.state = (EState *) NULL;
  1211. node->plan.qual = NULL;
  1212. node->plan.targetlist = tlist;
  1213. node->plan.lefttree = (Plan *) lefttree;
  1214. node->plan.righttree = (Plan *) NULL;
  1215. node->tuplePerGroup = tuplePerGroup;
  1216. node->numCols = ngrp;
  1217. node->grpColIdx = grpColIdx;
  1219. return node;
  1220. }
  1222. /*
  1223.  * A unique node always has a SORT node in the lefttree.
  1224.  *
  1225.  * the uniqueAttr argument must be a null-terminated string,
  1226.  * either the name of the attribute to select unique on
  1227.  * or "*"
  1228.  */
  1230. Unique *
  1231. make_unique(List *tlist, Plan *lefttree, char *uniqueAttr)
  1232. {
  1233. Unique    *node = makeNode(Unique);
  1234. Plan    *plan = &node->plan;
  1236. copy_costsize(plan, lefttree);
  1237. plan->state = (EState *) NULL;
  1238. plan->targetlist = tlist;
  1239. plan->qual = NIL;
  1240. plan->lefttree = lefttree;
  1241. plan->righttree = NULL;
  1242. node->nonameid = _NONAME_RELATION_ID_;
  1243. node->keycount = 0;
  1244. if (strcmp(uniqueAttr, "*") == 0)
  1245. node->uniqueAttr = NULL;
  1246. else
  1247. node->uniqueAttr = pstrdup(uniqueAttr);
  1248. return node;
  1249. }
  1251. #ifdef NOT_USED
  1252. List *
  1253. generate_fjoin(List *tlist)
  1254. {
  1255. List tlistP;
  1256. List newTlist = NIL;
  1257. List fjoinList = NIL;
  1258. int nIters = 0;
  1260. /*
  1261.  * Break the target list into elements with Iter nodes, and those
  1262.  * without them.
  1263.  */
  1264. foreach(tlistP, tlist)
  1265. {
  1266. List tlistElem;
  1268. tlistElem = lfirst(tlistP);
  1269. if (IsA(lsecond(tlistElem), Iter))
  1270. {
  1271. nIters++;
  1272. fjoinList = lappend(fjoinList, tlistElem);
  1273. }
  1274. else
  1275. newTlist = lappend(newTlist, tlistElem);
  1276. }
  1278. /*
  1279.  * if we have an Iter node then we need to flatten.
  1280.  */
  1281. if (nIters > 0)
  1282. {
  1283. List    *inner;
  1284. List    *tempList;
  1285. Fjoin    *fjoinNode;
  1286. DatumPtr results = (DatumPtr) palloc(nIters * sizeof(Datum));
  1287. BoolPtr alwaysDone = (BoolPtr) palloc(nIters * sizeof(bool));
  1289. inner = lfirst(fjoinList);
  1290. fjoinList = lnext(fjoinList);
  1291. fjoinNode = (Fjoin) MakeFjoin(false,
  1292.   nIters,
  1293.   inner,
  1294.   results,
  1295.   alwaysDone);
  1296. tempList = lcons(fjoinNode, fjoinList);
  1297. newTlist = lappend(newTlist, tempList);
  1298. }
  1299. return newTlist;
  1300. return tlist; /* do nothing for now - ay 10/94 */
  1301. }
  1303. #endif