granicus.if.org Git - postgresql/blob - src/backend/optimizer/util/var.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * var.c--
   4  *        Var node manipulation routines
   5  *
   6  * Copyright (c) 1994, Regents of the University of California
   7  *
   8  *
   9  * IDENTIFICATION
  10  *        $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.12 1998/06/15 19:28:50 momjian Exp $
  11  *
  12  *-------------------------------------------------------------------------
  13  */
  14 #include <sys/types.h>
  15
  16 #include "postgres.h"
  17
  18 #include <nodes/relation.h>
  19
  20 #include "nodes/primnodes.h"
  21 #include "nodes/plannodes.h"
  22 #include "nodes/nodeFuncs.h"
  23
  24 #include "optimizer/internal.h"
  25 #include "optimizer/clauses.h"
  26 #include "optimizer/var.h"
  27
  28 #include "parser/parsetree.h"
  29
  30 /*
  31  *              find_varnos
  32  *
  33  *              Descends down part of a parsetree (qual or tlist),
  34  *
  35  *              XXX assumes varno's are always integers, which shouldn't be true...
  36  *              (though it currently is, see primnodes.h)
  37  */
  38 List *
  39 pull_varnos(Node *me)
  40 {
  41         List       *i,
  42                            *result = NIL;
  43
  44         if (me == NULL)
  45                 return (NIL);
  46
  47         switch (nodeTag(me))
  48         {
  49                 case T_List:
  50                         foreach(i, (List *) me)
  51                                 result = nconc(result, pull_varnos(lfirst(i)));
  52                         break;
  53                 case T_ArrayRef:
  54                         foreach(i, ((ArrayRef *) me)->refupperindexpr)
  55                                 result = nconc(result, pull_varnos(lfirst(i)));
  56                         foreach(i, ((ArrayRef *) me)->reflowerindexpr)
  57                                 result = nconc(result, pull_varnos(lfirst(i)));
  58                         result = nconc(result, pull_varnos(((ArrayRef *) me)->refassgnexpr));
  59                         break;
  60                 case T_Var:
  61                         result = lconsi(((Var *) me)->varno, NIL);
  62                         break;
  63                 default:
  64                         break;
  65         }
  66         return (result);
  67 }
  68
  69 /*
  70  * contain_var_clause--
  71  *        Recursively find var nodes from a clause by pulling vars from the
  72  *        left and right operands of the clause.
  73  *
  74  *        Returns true if any varnode found.
  75  */
  76 bool
  77 contain_var_clause(Node *clause)
  78 {
  79         if (clause == NULL)
  80                 return FALSE;
  81         else if (IsA(clause, Var))
  82                 return TRUE;
  83         else if (IsA(clause, Iter))
  84                 return contain_var_clause(((Iter *) clause)->iterexpr);
  85         else if (single_node(clause))
  86                 return FALSE;
  87         else if (or_clause(clause) || and_clause(clause) || is_funcclause(clause))
  88         {
  89                 List       *temp;
  90
  91                 foreach(temp, ((Expr *) clause)->args)
  92                 {
  93                         if (contain_var_clause(lfirst(temp)))
  94                                 return TRUE;
  95                 }
  96                 return FALSE;
  97         }
  98         else if (is_subplan(clause))
  99         {
 100                 List       *temp;
 101
 102                 foreach(temp, ((Expr *) clause)->args)
 103                 {
 104                         if (contain_var_clause(lfirst(temp)))
 105                                 return TRUE;
 106                 }
 107                 /* Ok - check left sides of Oper-s */
 108                 foreach(temp, ((SubPlan *) ((Expr *) clause)->oper)->sublink->oper)
 109                 {
 110                         if (contain_var_clause(lfirst(((Expr *) lfirst(temp))->args)))
 111                                 return TRUE;
 112                 }
 113                 return FALSE;
 114         }
 115         else if (IsA(clause, ArrayRef))
 116         {
 117                 List       *temp;
 118
 119                 foreach(temp, ((ArrayRef *) clause)->refupperindexpr)
 120                 {
 121                         if (contain_var_clause(lfirst(temp)))
 122                                 return TRUE;
 123                 }
 124                 foreach(temp, ((ArrayRef *) clause)->reflowerindexpr)
 125                 {
 126                         if (contain_var_clause(lfirst(temp)))
 127                                 return TRUE;
 128                 }
 129                 if (contain_var_clause(((ArrayRef *) clause)->refexpr))
 130                         return TRUE;
 131                 if (contain_var_clause(((ArrayRef *) clause)->refassgnexpr))
 132                         return TRUE;
 133                 return FALSE;
 134         }
 135         else if (not_clause(clause))
 136                 return contain_var_clause((Node *) get_notclausearg((Expr *) clause));
 137         else if (is_opclause(clause))
 138                 return (contain_var_clause((Node *) get_leftop((Expr *) clause)) ||
 139                           contain_var_clause((Node *) get_rightop((Expr *) clause)));
 140
 141         return FALSE;
 142 }
 143
 144 /*
 145  * pull_var_clause--
 146  *        Recursively pulls all var nodes from a clause by pulling vars from the
 147  *        left and right operands of the clause.
 148  *
 149  *        Returns list of varnodes found.
 150  */
 151 List *
 152 pull_var_clause(Node *clause)
 153 {
 154         List       *retval = NIL;
 155
 156         if (clause == NULL)
 157                 return (NIL);
 158         else if (IsA(clause, Var))
 159                 retval = lcons(clause, NIL);
 160         else if (IsA(clause, Iter))
 161                 retval = pull_var_clause(((Iter *) clause)->iterexpr);
 162         else if (single_node(clause))
 163                 retval = NIL;
 164         else if (or_clause(clause) || and_clause(clause) || is_funcclause(clause))
 165         {
 166                 List       *temp;
 167
 168                 foreach(temp, ((Expr *) clause)->args)
 169                         retval = nconc(retval, pull_var_clause(lfirst(temp)));
 170         }
 171         else if (is_subplan(clause))
 172         {
 173                 List       *temp;
 174
 175                 foreach(temp, ((Expr *) clause)->args)
 176                         retval = nconc(retval, pull_var_clause(lfirst(temp)));
 177                 /* Ok - get Var-s from left sides of Oper-s */
 178                 foreach(temp, ((SubPlan *) ((Expr *) clause)->oper)->sublink->oper)
 179                         retval = nconc(retval,
 180                                  pull_var_clause(lfirst(((Expr *) lfirst(temp))->args)));
 181         }
 182         else if (IsA(clause, Aggreg))
 183                 retval = pull_var_clause(((Aggreg *) clause)->target);
 184         else if (IsA(clause, ArrayRef))
 185         {
 186                 List       *temp;
 187
 188                 foreach(temp, ((ArrayRef *) clause)->refupperindexpr)
 189                         retval = nconc(retval, pull_var_clause(lfirst(temp)));
 190                 foreach(temp, ((ArrayRef *) clause)->reflowerindexpr)
 191                         retval = nconc(retval, pull_var_clause(lfirst(temp)));
 192                 retval = nconc(retval,
 193                                            pull_var_clause(((ArrayRef *) clause)->refexpr));
 194                 retval = nconc(retval,
 195                                    pull_var_clause(((ArrayRef *) clause)->refassgnexpr));
 196         }
 197         else if (not_clause(clause))
 198                 retval = pull_var_clause((Node *) get_notclausearg((Expr *) clause));
 199         else if (is_opclause(clause))
 200                 retval = nconc(pull_var_clause((Node *) get_leftop((Expr *) clause)),
 201                                  pull_var_clause((Node *) get_rightop((Expr *) clause)));
 202         else
 203                 retval = NIL;
 204
 205         return (retval);
 206 }
 207
 208 /*
 209  *              var_equal
 210  *
 211  *              Returns t iff two var nodes correspond to the same attribute.
 212  */
 213 bool
 214 var_equal(Var *var1, Var *var2)
 215 {
 216         if (IsA(var1, Var) &&IsA(var2, Var) &&
 217                 (((Var *) var1)->varno == ((Var *) var2)->varno) &&
 218                 (((Var *) var1)->vartype == ((Var *) var2)->vartype) &&
 219                 (((Var *) var1)->vartypmod == ((Var *) var2)->vartypmod) &&
 220                 (((Var *) var1)->varlevelsup == ((Var *) var2)->varlevelsup) &&
 221                 (((Var *) var1)->varattno == ((Var *) var2)->varattno))
 222         {
 223                 Assert(((Var *) var1)->varlevelsup == 0);
 224                 return (true);
 225         }
 226         else
 227                 return (false);
 228 }