granicus.if.org Git - postgresql/blob - src/backend/optimizer/path/mergeutils.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * mergeutils.c--
   4  *        Utilities for finding applicable merge clauses and pathkeys
   5  *
   6  * Copyright (c) 1994, Regents of the University of California
   7  *
   8  *
   9  * IDENTIFICATION
  10  *        $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/mergeutils.c,v 1.17 1999/02/11 14:58:53 momjian Exp $
  11  *
  12  *-------------------------------------------------------------------------
  13  */
  14 #include "postgres.h"
  15
  16 #include "nodes/pg_list.h"
  17 #include "nodes/relation.h"
  18
  19 #include "optimizer/internal.h"
  20 #include "optimizer/paths.h"
  21 #include "optimizer/clauses.h"
  22 #include "optimizer/ordering.h"
  23
  24 /*
  25  * group-clauses-by-order--
  26  *        If a join clause node in 'restrictinfo-list' is mergejoinable, store
  27  *        it within a mergeinfo node containing other clause nodes with the same
  28  *        mergejoin ordering.
  29  *
  30  * 'restrictinfo-list' is the list of restrictinfo nodes
  31  * 'inner-relid' is the relid of the inner join relation
  32  *
  33  * Returns the new list of mergeinfo nodes.
  34  *
  35  */
  36 List *
  37 group_clauses_by_order(List *restrictinfo_list,
  38                                            int inner_relid)
  39 {
  40         List       *mergeinfo_list = NIL;
  41         List       *xrestrictinfo = NIL;
  42
  43         foreach(xrestrictinfo, restrictinfo_list)
  44         {
  45                 RestrictInfo *restrictinfo = (RestrictInfo *) lfirst(xrestrictinfo);
  46                 MergeOrder *merge_ordering = restrictinfo->mergejoinorder;
  47
  48                 if (merge_ordering)
  49                 {
  50
  51                         /*
  52                          * Create a new mergeinfo node and add it to 'mergeinfo-list'
  53                          * if one does not yet exist for this merge ordering.
  54                          */
  55                         PathOrder       *pathorder;
  56                         MergeInfo       *xmergeinfo;
  57                         Expr       *clause = restrictinfo->clause;
  58                         Var                *leftop = get_leftop(clause);
  59                         Var                *rightop = get_rightop(clause);
  60                         JoinKey    *jmkeys;
  61
  62                         pathorder = makeNode(PathOrder);
  63                         pathorder->ordtype = MERGE_ORDER;
  64                         pathorder->ord.merge = merge_ordering;
  65                         xmergeinfo = match_order_mergeinfo(pathorder, mergeinfo_list);
  66                         if (inner_relid == leftop->varno)
  67                         {
  68                                 jmkeys = makeNode(JoinKey);
  69                                 jmkeys->outer = rightop;
  70                                 jmkeys->inner = leftop;
  71                         }
  72                         else
  73                         {
  74                                 jmkeys = makeNode(JoinKey);
  75                                 jmkeys->outer = leftop;
  76                                 jmkeys->inner = rightop;
  77                         }
  78
  79                         if (xmergeinfo == NULL)
  80                         {
  81                                 xmergeinfo = makeNode(MergeInfo);
  82
  83                                 xmergeinfo->m_ordering = merge_ordering;
  84                                 mergeinfo_list = lcons(xmergeinfo,
  85                                                                            mergeinfo_list);
  86                         }
  87
  88                         ((JoinMethod *) xmergeinfo)->clauses = lcons(clause,
  89                                           ((JoinMethod *) xmergeinfo)->clauses);
  90                         ((JoinMethod *) xmergeinfo)->jmkeys = lcons(jmkeys,
  91                                           ((JoinMethod *) xmergeinfo)->jmkeys);
  92                 }
  93         }
  94         return mergeinfo_list;
  95 }
  96
  97
  98 /*
  99  * match-order-mergeinfo--
 100  *        Searches the list 'mergeinfo-list' for a mergeinfo node whose order
 101  *        field equals 'ordering'.
 102  *
 103  * Returns the node if it exists.
 104  *
 105  */
 106 MergeInfo *
 107 match_order_mergeinfo(PathOrder *ordering, List *mergeinfo_list)
 108 {
 109         MergeOrder *xmergeorder;
 110         List       *xmergeinfo = NIL;
 111
 112         foreach(xmergeinfo, mergeinfo_list)
 113         {
 114                 MergeInfo          *mergeinfo = (MergeInfo *) lfirst(xmergeinfo);
 115
 116                 xmergeorder = mergeinfo->m_ordering;
 117
 118                 if ((ordering->ordtype == MERGE_ORDER &&
 119                  equal_merge_ordering(ordering->ord.merge, xmergeorder)) ||
 120                         (ordering->ordtype == SORTOP_ORDER &&
 121                    equal_path_merge_ordering(ordering->ord.sortop, xmergeorder)))
 122                 {
 123
 124                         return mergeinfo;
 125                 }
 126         }
 127         return (MergeInfo *) NIL;
 128 }