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 ** $Id: walker.c,v 1.4 2009/04/08 13:51:52 drh Exp $ 16 */ 17 #include "sqliteInt.h" 18 #include <stdlib.h> 19 #include <string.h> 20 21 22 /* 23 ** Walk an expression tree. Invoke the callback once for each node 24 ** of the expression, while decending. (In other words, the callback 25 ** is invoked before visiting children.) 26 ** 27 ** The return value from the callback should be one of the WRC_* 28 ** constants to specify how to proceed with the walk. 29 ** 30 ** WRC_Continue Continue descending down the tree. 31 ** 32 ** WRC_Prune Do not descend into child nodes. But allow 33 ** the walk to continue with sibling nodes. 34 ** 35 ** WRC_Abort Do no more callbacks. Unwind the stack and 36 ** return the top-level walk call. 37 ** 38 ** The return value from this routine is WRC_Abort to abandon the tree walk 39 ** and WRC_Continue to continue. 40 */ 41 int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){ 42 int rc; 43 if( pExpr==0 ) return WRC_Continue; 44 testcase( ExprHasProperty(pExpr, EP_TokenOnly) ); 45 testcase( ExprHasProperty(pExpr, EP_SpanToken) ); 46 testcase( ExprHasProperty(pExpr, EP_Reduced) ); 47 rc = pWalker->xExprCallback(pWalker, pExpr); 48 if( rc==WRC_Continue 49 && !ExprHasAnyProperty(pExpr,EP_TokenOnly|EP_SpanToken) ){ 50 if( sqlite3WalkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort; 51 if( sqlite3WalkExpr(pWalker, pExpr->pRight) ) return WRC_Abort; 52 if( ExprHasProperty(pExpr, EP_xIsSelect) ){ 53 if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort; 54 }else{ 55 if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort; 56 } 57 } 58 return rc & WRC_Abort; 59 } 60 61 /* 62 ** Call sqlite3WalkExpr() for every expression in list p or until 63 ** an abort request is seen. 64 */ 65 int sqlite3WalkExprList(Walker *pWalker, ExprList *p){ 66 int i, rc = WRC_Continue; 67 struct ExprList_item *pItem; 68 if( p ){ 69 for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){ 70 if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort; 71 } 72 } 73 return rc & WRC_Continue; 74 } 75 76 /* 77 ** Walk all expressions associated with SELECT statement p. Do 78 ** not invoke the SELECT callback on p, but do (of course) invoke 79 ** any expr callbacks and SELECT callbacks that come from subqueries. 80 ** Return WRC_Abort or WRC_Continue. 81 */ 82 int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){ 83 if( sqlite3WalkExprList(pWalker, p->pEList) ) return WRC_Abort; 84 if( sqlite3WalkExpr(pWalker, p->pWhere) ) return WRC_Abort; 85 if( sqlite3WalkExprList(pWalker, p->pGroupBy) ) return WRC_Abort; 86 if( sqlite3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort; 87 if( sqlite3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort; 88 if( sqlite3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort; 89 if( sqlite3WalkExpr(pWalker, p->pOffset) ) return WRC_Abort; 90 return WRC_Continue; 91 } 92 93 /* 94 ** Walk the parse trees associated with all subqueries in the 95 ** FROM clause of SELECT statement p. Do not invoke the select 96 ** callback on p, but do invoke it on each FROM clause subquery 97 ** and on any subqueries further down in the tree. Return 98 ** WRC_Abort or WRC_Continue; 99 */ 100 int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){ 101 SrcList *pSrc; 102 int i; 103 struct SrcList_item *pItem; 104 105 pSrc = p->pSrc; 106 if( pSrc ){ 107 for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){ 108 if( sqlite3WalkSelect(pWalker, pItem->pSelect) ){ 109 return WRC_Abort; 110 } 111 } 112 } 113 return WRC_Continue; 114 } 115 116 /* 117 ** Call sqlite3WalkExpr() for every expression in Select statement p. 118 ** Invoke sqlite3WalkSelect() for subqueries in the FROM clause and 119 ** on the compound select chain, p->pPrior. 120 ** 121 ** Return WRC_Continue under normal conditions. Return WRC_Abort if 122 ** there is an abort request. 123 ** 124 ** If the Walker does not have an xSelectCallback() then this routine 125 ** is a no-op returning WRC_Continue. 126 */ 127 int sqlite3WalkSelect(Walker *pWalker, Select *p){ 128 int rc; 129 if( p==0 || pWalker->xSelectCallback==0 ) return WRC_Continue; 130 rc = WRC_Continue; 131 while( p ){ 132 rc = pWalker->xSelectCallback(pWalker, p); 133 if( rc ) break; 134 if( sqlite3WalkSelectExpr(pWalker, p) ) return WRC_Abort; 135 if( sqlite3WalkSelectFrom(pWalker, p) ) return WRC_Abort; 136 p = p->pPrior; 137 } 138 return rc & WRC_Abort; 139 } 140