home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / planner / plan / planmain.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  19.7 KB  |  705 lines
  1.  
  2. /*     
  3.  *      FILE
  4.  *         planmain
  5.  *     
  6.  *      DESCRIPTION
  7.  *         Routines to plan a single query
  8.  *     
  9.  */
  10. /* RcsId ("$Header: /private/postgres/src/planner/plan/RCS/planmain.c,v 1.39 1992/07/23 15:37:36 joey Exp $"); */
  11.  
  12. /*     
  13.  *      EXPORTS
  14.  *             Plan query_planner();
  15.  */
  16.  
  17.  
  18. #include "nodes/pg_lisp.h"
  19. #include "nodes/plannodes.h"
  20. #include "nodes/plannodes.a.h"
  21. #include "nodes/relation.h"
  22. #include "nodes/relation.a.h"
  23.  
  24. #include "parser/parse.h"
  25.  
  26. #include "planner/internal.h"
  27. #include "planner/allpaths.h"
  28. #include "planner/clause.h"
  29. #include "planner/createplan.h"
  30. #include "planner/keys.h"
  31. #include "planner/planmain.h"
  32. #include "planner/setrefs.h"
  33. #include "planner/sortresult.h"
  34. #include "planner/sortresult.h"
  35. #include "planner/tlist.h"
  36. #include "tcop/dest.h"
  37. #include "utils/log.h"
  38. #include "nodes/mnodes.h"
  39. #include "utils/mcxt.h"
  40.  
  41. extern int testFlag;
  42.  
  43. /*    
  44.  *        query_planner
  45.  *    
  46.  *        Routine to create a query plan.  It does so by first creating a
  47.  *        subplan for the topmost level of attributes in the query.  Then,
  48.  *        it modifies all target list and qualifications to consider the next
  49.  *        level of nesting and creates a plan for this modified query by
  50.  *        recursively calling itself.  The two pieces are then merged together
  51.  *        by creating a result node that indicates which attributes should
  52.  *        be placed where and any relation level qualifications to be
  53.  *        satisfied.
  54.  *    
  55.  *        'command-type' is the query command, e.g., retrieve, delete, etc.
  56.  *        'tlist' is the target list of the query
  57.  *        'qual' is the qualification of the query
  58.  *        'currentlevel' is the current nesting level
  59.  *        'maxlevel' is the maximum nesting level in this query
  60.  *    
  61.  *        Returns a query plan.
  62.  *    
  63.  */
  64.  
  65. /*  .. init-query-planner, query_planner    */
  66.  
  67. Plan
  68. query_planner (command_type,tlist,qual,currentlevel,maxlevel)
  69.      int command_type;
  70.      List tlist,qual;
  71.      int currentlevel;
  72.      int maxlevel ;
  73. {
  74.      LispValue constant_qual = LispNil;
  75.      LispValue sortkeys = LispNil;
  76.      LispValue flattened_tlist = LispNil;
  77.      List     level_tlist = LispNil;
  78.      List    result_of_flatten_tlist = LispNil;
  79.      List    agg_tlist = LispNil;
  80.      List    all_but_agg_tlist = LispNil;
  81.      int    aggidnum = -17; /* okay, a hack on uniquness */
  82.      Plan    thePlan = (Plan)NULL;
  83.      Plan    subplan = (Plan)NULL;
  84.      List    subtlist = LispNil;
  85.      Plan     restplan = (Plan)NULL;
  86.      List    resttlist = LispNil;
  87.      List    relation_level_clauses = LispNil;
  88.      Plan     plan = (Plan)NULL;
  89.  
  90.      /*    For the topmost nesting level, */
  91.      /* 1. Pull out any non-variable qualifications so these can be put in */
  92.      /*    the topmost result node.  The opids for the remaining */
  93.      /*    qualifications will be changed to regprocs later. */
  94.      /*    ------
  95.       *    NOTE: we used to have one field called 'opno' in the Oper
  96.       *    nodes which used to be also be called 'opid' in some comments.
  97.       *    This field was either the pg_operator oid, or the
  98.       *    regproc oid. However now we have two separate
  99.       *    fields, the 'opno' (pg_operator oid) and the 'opid' (pg_proc
  100.       *    oid) so things are a little bit more clear now...   [sp.]
  101.       *    ------
  102.       */
  103.      /* 2. Determine the keys on which the result is to be sorted. */
  104.      /* 3. Create a target list that consists solely of (resdom var) target */
  105.      /*    list entries, i.e., contains no arbitrary expressions. */
  106.      
  107.      if ( currentlevel == 1) {
  108.      /* A command without a target list or qualification is an error, */
  109.      /* except for "delete foo". */
  110.      
  111.      if (null (tlist) && null (qual)) {
  112.          if ( command_type == DELETE ||
  113.          /* Total hack here. I don't know how to handle
  114.         statements like notify in action bodies.
  115.         Notify doesn't return anything but
  116.         scans a system table. */
  117.          command_type == NOTIFY) {
  118.          return ((Plan)make_seqscan(LispNil, LispNil,
  119.                        (Index)CInteger(_query_result_relation_),
  120.                        (Plan)NULL));
  121.          } else
  122.            return((Plan)NULL);
  123.      }
  124.      constant_qual = pull_constant_clauses (qual);
  125.      qual = nset_difference (qual,constant_qual);
  126.      fix_opids (constant_qual);
  127.      sortkeys = relation_sortkeys (tlist);
  128.      /* flatten_tlist will now return (var, aggs, rest) */
  129.  
  130.      result_of_flatten_tlist = flatten_tlist(tlist);
  131.  
  132.      flattened_tlist = CAR(result_of_flatten_tlist);
  133.      agg_tlist = CADR(result_of_flatten_tlist);
  134.  
  135.      result_of_flatten_tlist = CDR(result_of_flatten_tlist);
  136.      all_but_agg_tlist = CADR(result_of_flatten_tlist);
  137.      if (flattened_tlist)
  138.        level_tlist = flattened_tlist;
  139.      else if (tlist)
  140.        level_tlist = all_but_agg_tlist;
  141.        /* orig_tlist minus the aggregates */
  142.      else
  143.        level_tlist = (List)NULL;
  144.      }
  145.  
  146.   if(agg_tlist) {
  147.      if(all_but_agg_tlist) {
  148.     thePlan = query_planner(command_type,
  149.         all_but_agg_tlist, qual, currentlevel, maxlevel);
  150.      }
  151.      else {
  152.      /* all we have are aggregates */
  153.      thePlan = (Plan)make_agg(CAR(agg_tlist), --aggidnum);
  154.      /* also, there should never be a case by now where we neither 
  155.       * have aggs nor all_but_aggs
  156.       */
  157.       agg_tlist = CDR(agg_tlist);
  158.      }
  159.      if(agg_tlist != NULL) {  /* are there any aggs left */
  160.        thePlan = make_aggplan(thePlan, agg_tlist, aggidnum);
  161.       }
  162.       return(thePlan);
  163.    }
  164.  
  165.      /*    A query may have a non-variable target list and a non-variable */
  166.      /*    qualification only under certain conditions: */
  167.      /*    - the query creates all-new tuples, or */
  168.      /*   - the query is a replace (a scan must still be done in this case). */
  169.  
  170.      if ((0 == maxlevel || 
  171.       (1 == currentlevel && null (flattened_tlist))) &&
  172.      null (qual)) {
  173.       switch (command_type) {
  174.          case RETRIEVE : 
  175.          case APPEND :
  176.            return ((Plan)make_result (tlist,
  177.                     LispNil,
  178.                     constant_qual,
  179.                     (Plan)NULL,
  180.                     (Plan)NULL));
  181.            break;
  182.  
  183.          case DELETE :
  184.          case REPLACE : 
  185.            {
  186.             /* XXX - let form, maybe incorrect */
  187.            SeqScan scan = make_seqscan (tlist,
  188.                            LispNil,
  189.                            (Index)CInteger(
  190.                            _query_result_relation_),
  191.                            (Plan)NULL);
  192.            if ( consp (constant_qual) ) {
  193.                return ((Plan)make_result (tlist,
  194.                          LispNil,
  195.                          constant_qual,
  196.                          (Plan)scan,
  197.                          (Plan)NULL));
  198.            } 
  199.            else {
  200.                return ((Plan)scan);
  201.            } 
  202.            }
  203.            break;
  204.            
  205.          default: /* return nil */
  206.            return((Plan)NULL);
  207.       }
  208.      }
  209. /*    Find the subplan (access path) for attributes at this nesting level */
  210. /*    and destructively modify the target list of the newly created */
  211. /*    subplan to contain the appropriate join references. */
  212.       
  213.      subplan = subplanner (level_tlist,
  214.                 tlist,
  215.                 qual,
  216.                 currentlevel,
  217.                 sortkeys);
  218.      
  219.      subtlist = get_qptargetlist (subplan);
  220.      set_tlist_references (subplan);
  221.  
  222. /*    If there are further nesting levels, call the planner again to */
  223. /*    create subplans for lower levels of nesting.  Modify the target */
  224. /*    list and qualifications to reflect the new nesting level. */
  225.  
  226.        if (currentlevel != maxlevel) {
  227.         elog(WARN, "level mismatch -- should never happen with new nested dot parsing scheme!");
  228.        }
  229. /*    Build a result node linking the plan for deeper nesting levels and */
  230. /*    the subplan for this level.  Note that a plan that has no right */
  231. /*    subtree may still have relation level and constant quals, so we */
  232. /*    still have to build an appropriate result node. */
  233.  
  234.      relation_level_clauses = pull_relation_level_clauses (qual);
  235.      
  236.      if ( restplan ||
  237.      relation_level_clauses ||
  238.      constant_qual) {
  239.       List resttlist = LispNil;
  240.       List subtlist = LispNil;
  241.       Plan plan;
  242.       
  243.       if ( restplan ) 
  244.         resttlist = get_qptargetlist (restplan);
  245.       subtlist = get_qptargetlist (subplan);
  246.       
  247.       plan = (Plan)make_result (new_result_tlist (tlist,
  248.                               subtlist,
  249.                               resttlist,
  250.                               currentlevel,
  251.                               valid_sortkeys(sortkeys)),
  252.                    new_result_qual(relation_level_clauses,
  253.                            subtlist,
  254.                            resttlist,
  255.                            currentlevel),
  256.                     constant_qual,
  257.                    subplan,
  258.                    restplan);
  259.       /*
  260.        * Change all varno's of the Result's node target list.
  261.        */
  262.       set_result_tlist_references((Result)plan);
  263.  
  264.       if ( valid_numkeys (sortkeys) ) 
  265.         return (sort_level_result (plan, CInteger(sortkeys)));
  266.       else 
  267.         return (plan);
  268.      }
  269.  
  270.      /*
  271.       * fix up the flattened target list of the plan root node so that
  272.       * expressions are evaluated.  this forces expression evaluations
  273.       * that may involve expensive function calls to be delayed to
  274.       * the very last stage of query execution.  this could be bad.
  275.       * but it is joey's responsibility to optimally push these
  276.       * expressions down the plan tree.  -- Wei
  277.       */
  278.      set_qptargetlist (subplan, flatten_tlist_vars (tlist,
  279.                         get_qptargetlist (subplan)));
  280.      /*
  281.       * Destructively modify the query plan's targetlist to add fjoin
  282.       * lists to flatten functions that return sets of base types
  283.       */
  284.      set_qptargetlist(subplan, generate_fjoin(get_qptargetlist(subplan)));
  285.  
  286.     /*    If a sort is required, explicitly sort this subplan since: */
  287.     /*    there is only one level of attributes in this query, and */
  288.     /*the sort spans across expressions and/or multiple relations and so */
  289.     /*        indices were not considered in planning the sort. */
  290.  
  291.      if ( valid_numkeys (sortkeys) ) 
  292.        return (sort_level_result (subplan,CInteger(sortkeys)));
  293.      else 
  294.        return (subplan);
  295.  
  296. }  /* function end  */
  297.  
  298. /*    
  299.  *        subplanner
  300.  *    
  301.  *        Subplanner creates an entire plan consisting of joins and scans
  302.  *        for processing a single level of attributes.  Nested attributes are 
  303.  *        transparent (i.e., essentially ignored) from here on.
  304.  *    
  305.  *        'flat-tlist' is the flattened target list
  306.  *    --which now is of the form (vars, aggs)--, jc
  307.  *        'original-tlist' is the unflattened target list
  308.  *        'qual' is the qualification to be satisfied
  309.  *        'level' is the current nesting level
  310.  *    
  311.  *        Returns a subplan.
  312.  *    
  313.  */
  314.  
  315. /*  .. query_planner    */
  316.  
  317. Plan
  318. subplanner (flat_tlist,original_tlist,qual,level,sortkeys)
  319.      LispValue flat_tlist,original_tlist,qual,sortkeys ;
  320.      int level;
  321. {
  322.     Rel final_relation;
  323.     List final_relation_list;
  324.  
  325.      /* Initialize the targetlist and qualification, adding entries to */
  326.      /* *query-relation-list* as relation references are found (e.g., in the */
  327.      /*  qualification, the targetlist, etc.) */
  328.  
  329.     _base_relation_list_ = LispNil;
  330.     _join_relation_list_ = LispNil;
  331.     initialize_targetlist (flat_tlist);
  332.     initialize_qualification (qual);
  333.  
  334.     
  335. /* Find all possible scan and join paths. */
  336. /* Mark all the clauses and relations that can be processed using special */
  337. /* join methods, then do the exhaustive path search. */
  338.  
  339.     initialize_join_clause_info (_base_relation_list_);
  340.     final_relation_list = find_paths (_base_relation_list_,
  341.                     level,
  342.                     sortkeys);
  343.     if (final_relation_list)
  344.       final_relation = (Rel)CAR (final_relation_list);
  345.     else
  346.       final_relation = (Rel)LispNil;
  347.      
  348. /*    If we want a sorted result and indices could have been used to do so, */
  349. /*    then explicitly sort those paths that weren't sorted by indices so we */
  350. /*  can determine whether using the implicit sort (index) is better than an */
  351. /*  explicit one. */
  352.  
  353.      if ( valid_sortkeys (sortkeys)) {
  354.      sort_relation_paths (get_pathlist (final_relation),
  355.                    sortkeys,
  356.                   final_relation,
  357.                   compute_targetlist_width(original_tlist));
  358.      }
  359. /*    Determine the cheapest path and create a subplan corresponding to it. */
  360.     
  361.     if (final_relation) {
  362.       if (testFlag) {
  363.       List planlist = LispNil;
  364.       List pathlist = LispNil;
  365.       LispValue x;
  366.       Path path;
  367.       Plan plan;
  368.       Choose chooseplan;
  369.       pathlist = get_pathlist(final_relation);
  370.       foreach (x, pathlist) {
  371.           path = (Path)CAR(x);
  372.           plan = create_plan(path);
  373.           planlist = nappend1(planlist, (LispValue)plan);
  374.         }
  375.       chooseplan = RMakeChoose();
  376.       set_chooseplanlist(chooseplan, planlist);
  377.       set_qptargetlist((Plan)chooseplan, get_qptargetlist(plan));
  378.       return (Plan)chooseplan;
  379.     }
  380.       return (create_plan ((Path)get_cheapestpath (final_relation)));
  381.      }
  382.     else {
  383.     printf(" Warn: final relation is nil \n");
  384.     return(create_plan ((Path)NULL));
  385.     }
  386.     
  387. }  /* function end  */
  388.  
  389. Result
  390. make_result( tlist,resrellevelqual,resconstantqual,left,right)
  391.      List tlist;
  392.      List resrellevelqual,resconstantqual;
  393.      Plan left,right;
  394. {
  395.     Result node = RMakeResult();
  396.     
  397.     tlist = generate_fjoin(tlist);
  398.     set_cost((Plan) node, 0.0);
  399.     set_fragment((Plan) node, 0);
  400.     set_state((Plan) node, NULL);
  401.     set_qptargetlist((Plan)node, tlist);
  402.     set_qpqual((Plan) node, LispNil);
  403.     set_lefttree((Plan)node, (PlanPtr)left);
  404.     set_righttree((Plan)node, (PlanPtr)right);
  405.  
  406.     set_resrellevelqual(node, resrellevelqual); 
  407.     set_resconstantqual(node, resconstantqual); 
  408.     set_resstate(node, NULL);
  409.     
  410.     return(node);
  411. } 
  412.  
  413. /* for modifying in case of aggregates.
  414.  * we know that there are aggregates in the tlist*/
  415. Plan
  416. make_aggplan(subplan, agg_tlist, aggidnum)
  417.     Plan subplan;
  418.     List agg_tlist;
  419.     int aggidnum;
  420. {
  421.      List agg_tl_entry = LispNil;
  422.      List add_to_tl = LispNil;
  423.      NestLoop joinnode = (NestLoop)NULL;
  424.      LispValue entry = LispNil;
  425.      List level_tlist = LispNil;
  426.      Agg aggnode;
  427. /*    extern search_quals(); */
  428.  
  429.     /* we're assuming that subplan is not null from the caller*/
  430.     agg_tl_entry = CAR(agg_tlist);
  431.     aggnode = make_agg(agg_tl_entry, --aggidnum);
  432.  
  433.         set_qptargetlist(subplan, nconc(get_qptargetlist(subplan),
  434.                      get_qptargetlist((Plan)aggnode)));
  435.     level_tlist = get_qptargetlist(subplan);
  436.     joinnode = make_nestloop(level_tlist, LispNil, (Plan)aggnode,
  437.                               subplan);
  438.     /* inner tree is the aggregate, outer tree is the rest of
  439.      * the plan.  quals are nil here since we don't have aggregate
  440.      * functions yet.
  441.      */
  442.  
  443.     if(CDR(agg_tlist)) {  /* is this the last agg_tlist entry? */
  444.        /* if not */
  445.        return make_aggplan((Plan)joinnode, CDR(agg_tlist), aggidnum);
  446.             /* XXX jc.  type problem with joinnode and Plan subplan? */
  447.          }
  448.      else { /* if so */
  449.           return((Plan) joinnode);
  450.      }
  451. }
  452.  
  453.  
  454.     
  455.  
  456. bool
  457. plan_isomorphic(p1, p2)
  458. Plan p1, p2;
  459. {
  460.     if (p1 == NULL) return (p2 == NULL);
  461.     if (p2 == NULL) return (p1 == NULL);
  462.     if (IsA(p1,Join) && IsA(p2,Join)) {
  463.     return (plan_isomorphic(get_lefttree(p1), get_lefttree(p2)) &&
  464.             plan_isomorphic(get_righttree(p1), get_righttree(p2)));
  465.       }
  466.     if (IsA(p1,Scan) && IsA(p2,Scan)) {
  467.     if (get_scanrelid((Scan)p1) == get_scanrelid((Scan)p2))
  468.         if (get_scanrelid((Scan)p1) == _TEMP_RELATION_ID_)
  469.         return plan_isomorphic(get_lefttree(p1), get_lefttree(p2));
  470.         else
  471.         return true;
  472.     else if (get_scanrelid((Scan)p1) == _TEMP_RELATION_ID_)
  473.         return plan_isomorphic(get_lefttree(p1), p2);
  474.     else if (get_scanrelid((Scan)p2) == _TEMP_RELATION_ID_)
  475.         return plan_isomorphic(p1, get_lefttree(p2));
  476.     return false;
  477.       }
  478.     if (IsA(p1,Temp) || IsA(p1,Hash) ||
  479.     (IsA(p1,Scan) && get_scanrelid((Scan)p1) == _TEMP_RELATION_ID_))
  480.     return plan_isomorphic(get_lefttree(p1), p2);
  481.     if (IsA(p2,Temp) || IsA(p2,Hash) ||
  482.     (IsA(p2,Scan) && get_scanrelid((Scan)p2) == _TEMP_RELATION_ID_))
  483.     return plan_isomorphic(p1, get_lefttree(p2));
  484.     return false;
  485. }
  486.  
  487. List
  488. group_planlist(planlist)
  489. List    planlist;
  490. {
  491.     List plangroups = LispNil;
  492.     Plan p1, p2;
  493.     List plist;
  494.     List g, x;
  495.  
  496.     plist = planlist;
  497.     while (!lispNullp(plist)) {
  498.     p1 = (Plan)CAR(plist);
  499.     g = lispCons((LispValue)p1, LispNil);
  500.     foreach (x, CDR(plist)) {
  501.         p2 = (Plan)CAR(x);
  502.         if (plan_isomorphic(p1, p2)) {
  503.         g = nappend1(g, (LispValue)p2);
  504.           }
  505.       }
  506.     plist = nset_difference(plist, g);
  507.     plangroups = nappend1(plangroups, g);
  508.       }
  509.     return plangroups;
  510. }
  511.  
  512. bool
  513. allNestLoop(plan)
  514. Plan    plan;
  515. {
  516.     if (plan == NULL) return true;
  517.     if (IsA(plan,Temp) ||
  518.     (IsA(plan,Scan) && get_scanrelid((Scan)plan) == _TEMP_RELATION_ID_))
  519.     return allNestLoop(get_lefttree(plan));
  520.     if (IsA(plan,NestLoop)) {
  521.     return allNestLoop(get_lefttree(plan)) &&
  522.            allNestLoop(get_righttree(plan));
  523.       }
  524.     if (IsA(plan,Join))
  525.     return false;
  526.     return true;
  527. }
  528.  
  529. Plan
  530. pickNestLoopPlan(plangroup)
  531. List    plangroup;
  532. {
  533.     LispValue x;
  534.     Plan p;
  535.  
  536.     foreach (x, plangroup) {
  537.     p = (Plan)CAR(x);
  538.     if (allNestLoop(p))
  539.         return p;
  540.       }
  541.     return NULL;
  542. }
  543.  
  544. void
  545. setPlanStats(p1, p2)
  546. Plan p1, p2;
  547. {
  548.     if (p1 == NULL || p2 == NULL)
  549.     return;
  550.     if (IsA(p1,Join) && IsA(p2,Join)) {
  551.     set_plan_size(p2, get_plan_size(p1));
  552.     setPlanStats(get_lefttree(p1), get_lefttree(p2));
  553.     /*
  554.     setPlanStats(get_righttree(p1), get_righttree(p2));
  555.     */
  556.     return;
  557.       }
  558.     if (IsA(p1,Temp) || IsA(p1,Hash) ||
  559.     (IsA(p1,Scan) && get_scanrelid((Scan)p1) == _TEMP_RELATION_ID_)) {
  560.     setPlanStats(get_lefttree(p1), p2);
  561.     return;
  562.       }
  563.     if (IsA(p2,Temp) || IsA(p2,Hash) ||
  564.     (IsA(p2,Scan) && get_scanrelid((Scan)p2) == _TEMP_RELATION_ID_)) {
  565.     set_plan_size(p2, get_plan_size(p1));
  566.     setPlanStats(p1, get_lefttree(p2));
  567.     return;
  568.       }
  569.     if (IsA(p1,Scan) && IsA(p2,Scan)) {
  570.     set_plan_size(p2, get_plan_size(p1));
  571.     return;
  572.       }
  573.     return;
  574. }
  575.  
  576. void
  577. resetPlanStats(p)
  578. Plan p;
  579. {
  580.     if (p == NULL) return;
  581.     set_plan_size(p, 0);
  582.     if (IsA(p,Join)) {
  583.     resetPlanStats(get_lefttree(p));
  584.     resetPlanStats(get_righttree(p));
  585.     return;
  586.       }
  587.     if (IsA(p,Scan)) {
  588.     if (get_scanrelid((Scan)p) == _TEMP_RELATION_ID_)
  589.        resetPlanStats(get_lefttree(p));
  590.     return;
  591.       }
  592.     resetPlanStats(get_lefttree(p));
  593.     return;
  594. }
  595.  
  596. void
  597. setPlanGroupStats(plan, planlist)
  598. Plan    plan;
  599. List    planlist;
  600. {
  601.     List x;
  602.     Plan p;
  603.  
  604.     foreach (x, planlist) {
  605.     p = (Plan)CAR(x);
  606.     setPlanStats(plan, p);
  607.      }
  608. }
  609.  
  610. bool _exec_collect_stats_ = false;
  611.  
  612. /*
  613.  * XXX mao speaking:
  614.  *
  615.  *    i assume that this routine is used by some planner wizard to
  616.  *    collect actual plan execution costs, and that it's not run
  617.  *    during ordinary postgres processing.  the planner shouldn't
  618.  *    be executing queries directly, right?
  619.  */
  620.  
  621. List
  622. setRealPlanStats(parsetree, planlist)
  623. List    parsetree;
  624. List    planlist;
  625. {
  626.     List plangroups;
  627.     List plangroup;
  628.     LispValue x;
  629.     List ordered_planlist;
  630.     Plan nlplan;
  631.  
  632.     _exec_collect_stats_ = true;
  633.     plangroups = group_planlist(planlist);
  634.     ordered_planlist = LispNil;
  635.     foreach (x, plangroups) {
  636.     plangroup = CAR(x);
  637.     nlplan = pickNestLoopPlan(plangroup);
  638.     if (nlplan == NULL) {
  639.         elog(NOTICE, "no nestloop plan in plan group!");
  640.         break;
  641.       }
  642.     if (IsA(nlplan,Join)) {
  643.         resetPlanStats(nlplan);
  644.         p_plan(nlplan);
  645.         ResetUsage();
  646.         ProcessQuery(parsetree, nlplan, (char *) NULL, (ObjectId *) NULL,
  647.              0, None);
  648.         ShowUsage();
  649.         plangroup = nLispRemove(plangroup, (LispValue)nlplan);
  650.         setPlanGroupStats(nlplan, plangroup);
  651.       }
  652.     else {
  653.         ordered_planlist = plangroup;
  654.         break;
  655.       }
  656.     ordered_planlist = nconc(ordered_planlist, plangroup);
  657.       }
  658.     _exec_collect_stats_ = false;
  659.     return ordered_planlist;
  660. }
  661.  
  662. bool
  663. plan_contain_redundant_hashjoin(plan)
  664. Plan plan;
  665. {
  666.     Plan outerplan, innerplan;
  667.     int outerpages, innerpages;
  668.     if (plan == NULL)
  669.     return false;
  670.     if (IsA(plan,HashJoin)) {
  671.     outerplan = (Plan) get_lefttree(plan);
  672.     innerplan = (Plan) get_lefttree((Plan)get_righttree(plan));
  673.     outerpages = page_size(get_plan_size(outerplan), 
  674.                    get_plan_width(outerplan));
  675.     innerpages = page_size(get_plan_size(innerplan),
  676.                    get_plan_width(innerplan));
  677.     if (!IsA(outerplan,Join) && outerpages < innerpages)
  678.         return true;
  679.       }
  680.     if (IsA(plan,Join))
  681.     return plan_contain_redundant_hashjoin(get_lefttree(plan)) ||
  682.            plan_contain_redundant_hashjoin(get_righttree(plan));
  683.     if (IsA(plan,Temp) || IsA(plan,Hash) ||
  684.     (IsA(plan,Scan) && get_scanrelid((Scan)plan) == _TEMP_RELATION_ID_))
  685.     return plan_contain_redundant_hashjoin(get_lefttree(plan));
  686.     return false;
  687. }
  688.  
  689. List
  690. pruneHashJoinPlans(planlist)
  691. List planlist;
  692. {
  693.     LispValue x;
  694.     Plan plan;
  695.     List retlist;
  696.  
  697.     retlist = LispNil;
  698.     foreach (x, planlist) {
  699.     plan = (Plan)CAR(x);
  700.     if (!plan_contain_redundant_hashjoin(plan))
  701.         retlist = nappend1(retlist, (LispValue)plan);
  702.       }
  703.     return retlist;
  704. }
  705.