src/walker.c

   1 /*
   2 ** 2008 August 16
   3 **
   4 ** The author disclaims copyright to this source code.  In place of
   5 ** a legal notice, here is a blessing:
   6 **
   7 **    May you do good and not evil.
   8 **    May you find forgiveness for yourself and forgive others.
   9 **    May you share freely, never taking more than you give.
  10 **
  11 *************************************************************************
  12 ** This file contains routines used for walking the parser tree for
  13 ** an SQL statement.
  14 */
  15 #include "sqliteInt.h"
  16 #include <stdlib.h>
  17 #include <string.h>
  18
  19
  20 /*
  21 ** Walk an expression tree.  Invoke the callback once for each node
  22 ** of the expression, while descending.  (In other words, the callback
  23 ** is invoked before visiting children.)
  24 **
  25 ** The return value from the callback should be one of the WRC_*
  26 ** constants to specify how to proceed with the walk.
  27 **
  28 **    WRC_Continue      Continue descending down the tree.
  29 **
  30 **    WRC_Prune         Do not descend into child nodes, but allow
  31 **                      the walk to continue with sibling nodes.
  32 **
  33 **    WRC_Abort         Do no more callbacks.  Unwind the stack and
  34 **                      return from the top-level walk call.
  35 **
  36 ** The return value from this routine is WRC_Abort to abandon the tree walk
  37 ** and WRC_Continue to continue.
  38 */
  39 static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){
  40   int rc;
  41   testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
  42   testcase( ExprHasProperty(pExpr, EP_Reduced) );
  43   while(1){
  44     rc = pWalker->xExprCallback(pWalker, pExpr);
  45     if( rc ) return rc & WRC_Abort;
  46     if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
  47       if( pExpr->pLeft && walkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
  48        assert( pExpr->x.pList==0 || pExpr->pRight==0 );
  49       if( pExpr->pRight ){
  50         pExpr = pExpr->pRight;
  51         continue;
  52       }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
  53         if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
  54       }else if( pExpr->x.pList ){
  55         if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
  56       }
  57 #ifndef SQLITE_OMIT_WINDOWFUNC
  58       if( !ExprHasProperty(pExpr, EP_Reduced) && pExpr->pWin ){
  59         Window *pWin = pExpr->pWin;
  60         if( sqlite3WalkExprList(pWalker, pWin->pPartition) ) return WRC_Abort;
  61         if( sqlite3WalkExprList(pWalker, pWin->pOrderBy) ) return WRC_Abort;
  62         if( sqlite3WalkExpr(pWalker, pWin->pFilter) ) return WRC_Abort;
  63       }
  64 #endif
  65     }
  66     break;
  67   }
  68   return WRC_Continue;
  69 }
  70 int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
  71   return pExpr ? walkExpr(pWalker,pExpr) : WRC_Continue;
  72 }
  73
  74 /*
  75 ** Call sqlite3WalkExpr() for every expression in list p or until
  76 ** an abort request is seen.
  77 */
  78 int sqlite3WalkExprList(Walker *pWalker, ExprList *p){
  79   int i;
  80   struct ExprList_item *pItem;
  81   if( p ){
  82     for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){
  83       if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
  84     }
  85   }
  86   return WRC_Continue;
  87 }
  88
  89 /*
  90 ** Walk all expressions associated with SELECT statement p.  Do
  91 ** not invoke the SELECT callback on p, but do (of course) invoke
  92 ** any expr callbacks and SELECT callbacks that come from subqueries.
  93 ** Return WRC_Abort or WRC_Continue.
  94 */
  95 int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){
  96   if( sqlite3WalkExprList(pWalker, p->pEList) ) return WRC_Abort;
  97   if( sqlite3WalkExpr(pWalker, p->pWhere) ) return WRC_Abort;
  98   if( sqlite3WalkExprList(pWalker, p->pGroupBy) ) return WRC_Abort;
  99   if( sqlite3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort;
 100   if( sqlite3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort;
 101   if( sqlite3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort;
 102   return WRC_Continue;
 103 }
 104
 105 /*
 106 ** Walk the parse trees associated with all subqueries in the
 107 ** FROM clause of SELECT statement p.  Do not invoke the select
 108 ** callback on p, but do invoke it on each FROM clause subquery
 109 ** and on any subqueries further down in the tree.  Return
 110 ** WRC_Abort or WRC_Continue;
 111 */
 112 int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){
 113   SrcList *pSrc;
 114   int i;
 115   struct SrcList_item *pItem;
 116
 117   pSrc = p->pSrc;
 118   assert( pSrc!=0 );
 119   for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
 120     if( pItem->pSelect && sqlite3WalkSelect(pWalker, pItem->pSelect) ){
 121       return WRC_Abort;
 122     }
 123     if( pItem->fg.isTabFunc
 124      && sqlite3WalkExprList(pWalker, pItem->u1.pFuncArg)
 125     ){
 126       return WRC_Abort;
 127     }
 128   }
 129   return WRC_Continue;
 130 }
 131
 132 /*
 133 ** Call sqlite3WalkExpr() for every expression in Select statement p.
 134 ** Invoke sqlite3WalkSelect() for subqueries in the FROM clause and
 135 ** on the compound select chain, p->pPrior.
 136 **
 137 ** If it is not NULL, the xSelectCallback() callback is invoked before
 138 ** the walk of the expressions and FROM clause. The xSelectCallback2()
 139 ** method is invoked following the walk of the expressions and FROM clause,
 140 ** but only if both xSelectCallback and xSelectCallback2 are both non-NULL
 141 ** and if the expressions and FROM clause both return WRC_Continue;
 142 **
 143 ** Return WRC_Continue under normal conditions.  Return WRC_Abort if
 144 ** there is an abort request.
 145 **
 146 ** If the Walker does not have an xSelectCallback() then this routine
 147 ** is a no-op returning WRC_Continue.
 148 */
 149 int sqlite3WalkSelect(Walker *pWalker, Select *p){
 150   int rc;
 151   if( p==0 ) return WRC_Continue;
 152   if( pWalker->xSelectCallback==0 ) return WRC_Continue;
 153   do{
 154     rc = pWalker->xSelectCallback(pWalker, p);
 155     if( rc ) return rc & WRC_Abort;
 156     if( sqlite3WalkSelectExpr(pWalker, p)
 157      || sqlite3WalkSelectFrom(pWalker, p)
 158     ){
 159       return WRC_Abort;
 160     }
 161     if( pWalker->xSelectCallback2 ){
 162       pWalker->xSelectCallback2(pWalker, p);
 163     }
 164     p = p->pPrior;
 165   }while( p!=0 );
 166   return WRC_Continue;
 167 }