Return to walker.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src

Annotation of embedaddon/sqlite3/src/walker.c, revision 1.1.1.1

1.1       misho       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 decending.  (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 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: int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
                     40:   int rc;
                     41:   if( pExpr==0 ) return WRC_Continue;
                     42:   testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
                     43:   testcase( ExprHasProperty(pExpr, EP_Reduced) );
                     44:   rc = pWalker->xExprCallback(pWalker, pExpr);
                     45:   if( rc==WRC_Continue
                     46:               && !ExprHasAnyProperty(pExpr,EP_TokenOnly) ){
                     47:     if( sqlite3WalkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
                     48:     if( sqlite3WalkExpr(pWalker, pExpr->pRight) ) return WRC_Abort;
                     49:     if( ExprHasProperty(pExpr, EP_xIsSelect) ){
                     50:       if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
                     51:     }else{
                     52:       if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
                     53:     }
                     54:   }
                     55:   return rc & WRC_Abort;
                     56: }
                     57: 
                     58: /*
                     59: ** Call sqlite3WalkExpr() for every expression in list p or until
                     60: ** an abort request is seen.
                     61: */
                     62: int sqlite3WalkExprList(Walker *pWalker, ExprList *p){
                     63:   int i;
                     64:   struct ExprList_item *pItem;
                     65:   if( p ){
                     66:     for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){
                     67:       if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
                     68:     }
                     69:   }
                     70:   return WRC_Continue;
                     71: }
                     72: 
                     73: /*
                     74: ** Walk all expressions associated with SELECT statement p.  Do
                     75: ** not invoke the SELECT callback on p, but do (of course) invoke
                     76: ** any expr callbacks and SELECT callbacks that come from subqueries.
                     77: ** Return WRC_Abort or WRC_Continue.
                     78: */
                     79: int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){
                     80:   if( sqlite3WalkExprList(pWalker, p->pEList) ) return WRC_Abort;
                     81:   if( sqlite3WalkExpr(pWalker, p->pWhere) ) return WRC_Abort;
                     82:   if( sqlite3WalkExprList(pWalker, p->pGroupBy) ) return WRC_Abort;
                     83:   if( sqlite3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort;
                     84:   if( sqlite3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort;
                     85:   if( sqlite3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort;
                     86:   if( sqlite3WalkExpr(pWalker, p->pOffset) ) return WRC_Abort;
                     87:   return WRC_Continue;
                     88: }
                     89: 
                     90: /*
                     91: ** Walk the parse trees associated with all subqueries in the
                     92: ** FROM clause of SELECT statement p.  Do not invoke the select
                     93: ** callback on p, but do invoke it on each FROM clause subquery
                     94: ** and on any subqueries further down in the tree.  Return 
                     95: ** WRC_Abort or WRC_Continue;
                     96: */
                     97: int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){
                     98:   SrcList *pSrc;
                     99:   int i;
                    100:   struct SrcList_item *pItem;
                    101: 
                    102:   pSrc = p->pSrc;
                    103:   if( ALWAYS(pSrc) ){
                    104:     for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
                    105:       if( sqlite3WalkSelect(pWalker, pItem->pSelect) ){
                    106:         return WRC_Abort;
                    107:       }
                    108:     }
                    109:   }
                    110:   return WRC_Continue;
                    111: } 
                    112: 
                    113: /*
                    114: ** Call sqlite3WalkExpr() for every expression in Select statement p.
                    115: ** Invoke sqlite3WalkSelect() for subqueries in the FROM clause and
                    116: ** on the compound select chain, p->pPrior.
                    117: **
                    118: ** Return WRC_Continue under normal conditions.  Return WRC_Abort if
                    119: ** there is an abort request.
                    120: **
                    121: ** If the Walker does not have an xSelectCallback() then this routine
                    122: ** is a no-op returning WRC_Continue.
                    123: */
                    124: int sqlite3WalkSelect(Walker *pWalker, Select *p){
                    125:   int rc;
                    126:   if( p==0 || pWalker->xSelectCallback==0 ) return WRC_Continue;
                    127:   rc = WRC_Continue;
                    128:   while( p  ){
                    129:     rc = pWalker->xSelectCallback(pWalker, p);
                    130:     if( rc ) break;
                    131:     if( sqlite3WalkSelectExpr(pWalker, p) ) return WRC_Abort;
                    132:     if( sqlite3WalkSelectFrom(pWalker, p) ) return WRC_Abort;
                    133:     p = p->pPrior;
                    134:   }
                    135:   return rc & WRC_Abort;
                    136: }