src/treeview.c

   1 /*
   2 ** 2015-06-08
   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 **
  13 ** This file contains C code to implement the TreeView debugging routines.
  14 ** These routines print a parse tree to standard output for debugging and
  15 ** analysis.
  16 **
  17 ** The interfaces in this file is only available when compiling
  18 ** with SQLITE_DEBUG.
  19 */
  20 #include "sqliteInt.h"
  21 #ifdef SQLITE_DEBUG
  22
  23 /*
  24 ** Add a new subitem to the tree.  The moreToFollow flag indicates that this
  25 ** is not the last item in the tree.
  26 */
  27 static TreeView *sqlite3TreeViewPush(TreeView *p, u8 moreToFollow){
  28   if( p==0 ){
  29     p = sqlite3_malloc64( sizeof(*p) );
  30     if( p==0 ) return 0;
  31     memset(p, 0, sizeof(*p));
  32   }else{
  33     p->iLevel++;
  34   }
  35   assert( moreToFollow==0 || moreToFollow==1 );
  36   if( p->iLevel<sizeof(p->bLine) ) p->bLine[p->iLevel] = moreToFollow;
  37   return p;
  38 }
  39
  40 /*
  41 ** Finished with one layer of the tree
  42 */
  43 static void sqlite3TreeViewPop(TreeView *p){
  44   if( p==0 ) return;
  45   p->iLevel--;
  46   if( p->iLevel<0 ) sqlite3_free(p);
  47 }
  48
  49 /*
  50 ** Generate a single line of output for the tree, with a prefix that contains
  51 ** all the appropriate tree lines
  52 */
  53 static void sqlite3TreeViewLine(TreeView *p, const char *zFormat, ...){
  54   va_list ap;
  55   int i;
  56   StrAccum acc;
  57   char zBuf[500];
  58   sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0);
  59   if( p ){
  60     for(i=0; i<p->iLevel && i<sizeof(p->bLine)-1; i++){
  61       sqlite3_str_append(&acc, p->bLine[i] ? "|   " : "    ", 4);
  62     }
  63     sqlite3_str_append(&acc, p->bLine[i] ? "|-- " : "'-- ", 4);
  64   }
  65   if( zFormat!=0 ){
  66     va_start(ap, zFormat);
  67     sqlite3_str_vappendf(&acc, zFormat, ap);
  68     va_end(ap);
  69     assert( acc.nChar>0 || acc.accError );
  70     sqlite3_str_append(&acc, "\n", 1);
  71   }
  72   sqlite3StrAccumFinish(&acc);
  73   fprintf(stdout,"%s", zBuf);
  74   fflush(stdout);
  75 }
  76
  77 /*
  78 ** Shorthand for starting a new tree item that consists of a single label
  79 */
  80 static void sqlite3TreeViewItem(TreeView *p, const char *zLabel,u8 moreFollows){
  81   p = sqlite3TreeViewPush(p, moreFollows);
  82   sqlite3TreeViewLine(p, "%s", zLabel);
  83 }
  84
  85 /*
  86 ** Generate a human-readable description of a WITH clause.
  87 */
  88 void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 moreToFollow){
  89   int i;
  90   if( pWith==0 ) return;
  91   if( pWith->nCte==0 ) return;
  92   if( pWith->pOuter ){
  93     sqlite3TreeViewLine(pView, "WITH (0x%p, pOuter=0x%p)",pWith,pWith->pOuter);
  94   }else{
  95     sqlite3TreeViewLine(pView, "WITH (0x%p)", pWith);
  96   }
  97   if( pWith->nCte>0 ){
  98     pView = sqlite3TreeViewPush(pView, 1);
  99     for(i=0; i<pWith->nCte; i++){
 100       StrAccum x;
 101       char zLine[1000];
 102       const struct Cte *pCte = &pWith->a[i];
 103       sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0);
 104       sqlite3_str_appendf(&x, "%s", pCte->zName);
 105       if( pCte->pCols && pCte->pCols->nExpr>0 ){
 106         char cSep = '(';
 107         int j;
 108         for(j=0; j<pCte->pCols->nExpr; j++){
 109           sqlite3_str_appendf(&x, "%c%s", cSep, pCte->pCols->a[j].zEName);
 110           cSep = ',';
 111         }
 112         sqlite3_str_appendf(&x, ")");
 113       }
 114       if( pCte->pUse ){
 115         sqlite3_str_appendf(&x, " (pUse=0x%p, nUse=%d)", pCte->pUse,
 116                  pCte->pUse->nUse);
 117       }
 118       sqlite3StrAccumFinish(&x);
 119       sqlite3TreeViewItem(pView, zLine, i<pWith->nCte-1);
 120       sqlite3TreeViewSelect(pView, pCte->pSelect, 0);
 121       sqlite3TreeViewPop(pView);
 122     }
 123     sqlite3TreeViewPop(pView);
 124   }
 125 }
 126
 127 /*
 128 ** Generate a human-readable description of a SrcList object.
 129 */
 130 void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc){
 131   int i;
 132   for(i=0; i<pSrc->nSrc; i++){
 133     const SrcItem *pItem = &pSrc->a[i];
 134     StrAccum x;
 135     char zLine[100];
 136     sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0);
 137     x.printfFlags |= SQLITE_PRINTF_INTERNAL;
 138     sqlite3_str_appendf(&x, "{%d:*} %!S", pItem->iCursor, pItem);
 139     if( pItem->pTab ){
 140       sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx",
 141            pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed);
 142     }
 143     if( pItem->fg.jointype & JT_LEFT ){
 144       sqlite3_str_appendf(&x, " LEFT-JOIN");
 145     }
 146     if( pItem->fg.fromDDL ){
 147       sqlite3_str_appendf(&x, " DDL");
 148     }
 149     if( pItem->fg.isCte ){
 150       sqlite3_str_appendf(&x, " CteUse=0x%p", pItem->u2.pCteUse);
 151     }
 152     sqlite3StrAccumFinish(&x);
 153     sqlite3TreeViewItem(pView, zLine, i<pSrc->nSrc-1);
 154     if( pItem->pSelect ){
 155       sqlite3TreeViewSelect(pView, pItem->pSelect, 0);
 156     }
 157     if( pItem->fg.isTabFunc ){
 158       sqlite3TreeViewExprList(pView, pItem->u1.pFuncArg, 0, "func-args:");
 159     }
 160     sqlite3TreeViewPop(pView);
 161   }
 162 }
 163
 164 /*
 165 ** Generate a human-readable description of a Select object.
 166 */
 167 void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){
 168   int n = 0;
 169   int cnt = 0;
 170   if( p==0 ){
 171     sqlite3TreeViewLine(pView, "nil-SELECT");
 172     return;
 173   }
 174   pView = sqlite3TreeViewPush(pView, moreToFollow);
 175   if( p->pWith ){
 176     sqlite3TreeViewWith(pView, p->pWith, 1);
 177     cnt = 1;
 178     sqlite3TreeViewPush(pView, 1);
 179   }
 180   do{
 181     if( p->selFlags & SF_WhereBegin ){
 182       sqlite3TreeViewLine(pView, "sqlite3WhereBegin()");
 183     }else{
 184       sqlite3TreeViewLine(pView,
 185         "SELECT%s%s (%u/%p) selFlags=0x%x nSelectRow=%d",
 186         ((p->selFlags & SF_Distinct) ? " DISTINCT" : ""),
 187         ((p->selFlags & SF_Aggregate) ? " agg_flag" : ""),
 188         p->selId, p, p->selFlags,
 189         (int)p->nSelectRow
 190       );
 191     }
 192     if( cnt++ ) sqlite3TreeViewPop(pView);
 193     if( p->pPrior ){
 194       n = 1000;
 195     }else{
 196       n = 0;
 197       if( p->pSrc && p->pSrc->nSrc ) n++;
 198       if( p->pWhere ) n++;
 199       if( p->pGroupBy ) n++;
 200       if( p->pHaving ) n++;
 201       if( p->pOrderBy ) n++;
 202       if( p->pLimit ) n++;
 203 #ifndef SQLITE_OMIT_WINDOWFUNC
 204       if( p->pWin ) n++;
 205       if( p->pWinDefn ) n++;
 206 #endif
 207     }
 208     if( p->pEList ){
 209       sqlite3TreeViewExprList(pView, p->pEList, n>0, "result-set");
 210     }
 211     n--;
 212 #ifndef SQLITE_OMIT_WINDOWFUNC
 213     if( p->pWin ){
 214       Window *pX;
 215       pView = sqlite3TreeViewPush(pView, (n--)>0);
 216       sqlite3TreeViewLine(pView, "window-functions");
 217       for(pX=p->pWin; pX; pX=pX->pNextWin){
 218         sqlite3TreeViewWinFunc(pView, pX, pX->pNextWin!=0);
 219       }
 220       sqlite3TreeViewPop(pView);
 221     }
 222 #endif
 223     if( p->pSrc && p->pSrc->nSrc ){
 224       pView = sqlite3TreeViewPush(pView, (n--)>0);
 225       sqlite3TreeViewLine(pView, "FROM");
 226       sqlite3TreeViewSrcList(pView, p->pSrc);
 227       sqlite3TreeViewPop(pView);
 228     }
 229     if( p->pWhere ){
 230       sqlite3TreeViewItem(pView, "WHERE", (n--)>0);
 231       sqlite3TreeViewExpr(pView, p->pWhere, 0);
 232       sqlite3TreeViewPop(pView);
 233     }
 234     if( p->pGroupBy ){
 235       sqlite3TreeViewExprList(pView, p->pGroupBy, (n--)>0, "GROUPBY");
 236     }
 237     if( p->pHaving ){
 238       sqlite3TreeViewItem(pView, "HAVING", (n--)>0);
 239       sqlite3TreeViewExpr(pView, p->pHaving, 0);
 240       sqlite3TreeViewPop(pView);
 241     }
 242 #ifndef SQLITE_OMIT_WINDOWFUNC
 243     if( p->pWinDefn ){
 244       Window *pX;
 245       sqlite3TreeViewItem(pView, "WINDOW", (n--)>0);
 246       for(pX=p->pWinDefn; pX; pX=pX->pNextWin){
 247         sqlite3TreeViewWindow(pView, pX, pX->pNextWin!=0);
 248       }
 249       sqlite3TreeViewPop(pView);
 250     }
 251 #endif
 252     if( p->pOrderBy ){
 253       sqlite3TreeViewExprList(pView, p->pOrderBy, (n--)>0, "ORDERBY");
 254     }
 255     if( p->pLimit ){
 256       sqlite3TreeViewItem(pView, "LIMIT", (n--)>0);
 257       sqlite3TreeViewExpr(pView, p->pLimit->pLeft, p->pLimit->pRight!=0);
 258       if( p->pLimit->pRight ){
 259         sqlite3TreeViewItem(pView, "OFFSET", (n--)>0);
 260         sqlite3TreeViewExpr(pView, p->pLimit->pRight, 0);
 261         sqlite3TreeViewPop(pView);
 262       }
 263       sqlite3TreeViewPop(pView);
 264     }
 265     if( p->pPrior ){
 266       const char *zOp = "UNION";
 267       switch( p->op ){
 268         case TK_ALL:         zOp = "UNION ALL";  break;
 269         case TK_INTERSECT:   zOp = "INTERSECT";  break;
 270         case TK_EXCEPT:      zOp = "EXCEPT";     break;
 271       }
 272       sqlite3TreeViewItem(pView, zOp, 1);
 273     }
 274     p = p->pPrior;
 275   }while( p!=0 );
 276   sqlite3TreeViewPop(pView);
 277 }
 278
 279 #ifndef SQLITE_OMIT_WINDOWFUNC
 280 /*
 281 ** Generate a description of starting or stopping bounds
 282 */
 283 void sqlite3TreeViewBound(
 284   TreeView *pView,        /* View context */
 285   u8 eBound,              /* UNBOUNDED, CURRENT, PRECEDING, FOLLOWING */
 286   Expr *pExpr,            /* Value for PRECEDING or FOLLOWING */
 287   u8 moreToFollow         /* True if more to follow */
 288 ){
 289   switch( eBound ){
 290     case TK_UNBOUNDED: {
 291       sqlite3TreeViewItem(pView, "UNBOUNDED", moreToFollow);
 292       sqlite3TreeViewPop(pView);
 293       break;
 294     }
 295     case TK_CURRENT: {
 296       sqlite3TreeViewItem(pView, "CURRENT", moreToFollow);
 297       sqlite3TreeViewPop(pView);
 298       break;
 299     }
 300     case TK_PRECEDING: {
 301       sqlite3TreeViewItem(pView, "PRECEDING", moreToFollow);
 302       sqlite3TreeViewExpr(pView, pExpr, 0);
 303       sqlite3TreeViewPop(pView);
 304       break;
 305     }
 306     case TK_FOLLOWING: {
 307       sqlite3TreeViewItem(pView, "FOLLOWING", moreToFollow);
 308       sqlite3TreeViewExpr(pView, pExpr, 0);
 309       sqlite3TreeViewPop(pView);
 310       break;
 311     }
 312   }
 313 }
 314 #endif /* SQLITE_OMIT_WINDOWFUNC */
 315
 316 #ifndef SQLITE_OMIT_WINDOWFUNC
 317 /*
 318 ** Generate a human-readable explanation for a Window object
 319 */
 320 void sqlite3TreeViewWindow(TreeView *pView, const Window *pWin, u8 more){
 321   int nElement = 0;
 322   if( pWin->pFilter ){
 323     sqlite3TreeViewItem(pView, "FILTER", 1);
 324     sqlite3TreeViewExpr(pView, pWin->pFilter, 0);
 325     sqlite3TreeViewPop(pView);
 326   }
 327   pView = sqlite3TreeViewPush(pView, more);
 328   if( pWin->zName ){
 329     sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin);
 330   }else{
 331     sqlite3TreeViewLine(pView, "OVER (%p)", pWin);
 332   }
 333   if( pWin->zBase )    nElement++;
 334   if( pWin->pOrderBy ) nElement++;
 335   if( pWin->eFrmType ) nElement++;
 336   if( pWin->eExclude ) nElement++;
 337   if( pWin->zBase ){
 338     sqlite3TreeViewPush(pView, (--nElement)>0);
 339     sqlite3TreeViewLine(pView, "window: %s", pWin->zBase);
 340     sqlite3TreeViewPop(pView);
 341   }
 342   if( pWin->pPartition ){
 343     sqlite3TreeViewExprList(pView, pWin->pPartition, nElement>0,"PARTITION-BY");
 344   }
 345   if( pWin->pOrderBy ){
 346     sqlite3TreeViewExprList(pView, pWin->pOrderBy, (--nElement)>0, "ORDER-BY");
 347   }
 348   if( pWin->eFrmType ){
 349     char zBuf[30];
 350     const char *zFrmType = "ROWS";
 351     if( pWin->eFrmType==TK_RANGE ) zFrmType = "RANGE";
 352     if( pWin->eFrmType==TK_GROUPS ) zFrmType = "GROUPS";
 353     sqlite3_snprintf(sizeof(zBuf),zBuf,"%s%s",zFrmType,
 354         pWin->bImplicitFrame ? " (implied)" : "");
 355     sqlite3TreeViewItem(pView, zBuf, (--nElement)>0);
 356     sqlite3TreeViewBound(pView, pWin->eStart, pWin->pStart, 1);
 357     sqlite3TreeViewBound(pView, pWin->eEnd, pWin->pEnd, 0);
 358     sqlite3TreeViewPop(pView);
 359   }
 360   if( pWin->eExclude ){
 361     char zBuf[30];
 362     const char *zExclude;
 363     switch( pWin->eExclude ){
 364       case TK_NO:      zExclude = "NO OTHERS";   break;
 365       case TK_CURRENT: zExclude = "CURRENT ROW"; break;
 366       case TK_GROUP:   zExclude = "GROUP";       break;
 367       case TK_TIES:    zExclude = "TIES";        break;
 368       default:
 369         sqlite3_snprintf(sizeof(zBuf),zBuf,"invalid(%d)", pWin->eExclude);
 370         zExclude = zBuf;
 371         break;
 372     }
 373     sqlite3TreeViewPush(pView, 0);
 374     sqlite3TreeViewLine(pView, "EXCLUDE %s", zExclude);
 375     sqlite3TreeViewPop(pView);
 376   }
 377   sqlite3TreeViewPop(pView);
 378 }
 379 #endif /* SQLITE_OMIT_WINDOWFUNC */
 380
 381 #ifndef SQLITE_OMIT_WINDOWFUNC
 382 /*
 383 ** Generate a human-readable explanation for a Window Function object
 384 */
 385 void sqlite3TreeViewWinFunc(TreeView *pView, const Window *pWin, u8 more){
 386   pView = sqlite3TreeViewPush(pView, more);
 387   sqlite3TreeViewLine(pView, "WINFUNC %s(%d)",
 388                        pWin->pFunc->zName, pWin->pFunc->nArg);
 389   sqlite3TreeViewWindow(pView, pWin, 0);
 390   sqlite3TreeViewPop(pView);
 391 }
 392 #endif /* SQLITE_OMIT_WINDOWFUNC */
 393
 394 /*
 395 ** Generate a human-readable explanation of an expression tree.
 396 */
 397 void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){
 398   const char *zBinOp = 0;   /* Binary operator */
 399   const char *zUniOp = 0;   /* Unary operator */
 400   char zFlgs[200];
 401   pView = sqlite3TreeViewPush(pView, moreToFollow);
 402   if( pExpr==0 ){
 403     sqlite3TreeViewLine(pView, "nil");
 404     sqlite3TreeViewPop(pView);
 405     return;
 406   }
 407   if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags ){
 408     StrAccum x;
 409     sqlite3StrAccumInit(&x, 0, zFlgs, sizeof(zFlgs), 0);
 410     sqlite3_str_appendf(&x, " fg.af=%x.%c",
 411       pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n');
 412     if( ExprHasProperty(pExpr, EP_FromJoin) ){
 413       sqlite3_str_appendf(&x, " iRJT=%d", pExpr->iRightJoinTable);
 414     }
 415     if( ExprHasProperty(pExpr, EP_FromDDL) ){
 416       sqlite3_str_appendf(&x, " DDL");
 417     }
 418     if( ExprHasVVAProperty(pExpr, EP_Immutable) ){
 419       sqlite3_str_appendf(&x, " IMMUTABLE");
 420     }
 421     sqlite3StrAccumFinish(&x);
 422   }else{
 423     zFlgs[0] = 0;
 424   }
 425   switch( pExpr->op ){
 426     case TK_AGG_COLUMN: {
 427       sqlite3TreeViewLine(pView, "AGG{%d:%d}%s",
 428             pExpr->iTable, pExpr->iColumn, zFlgs);
 429       break;
 430     }
 431     case TK_COLUMN: {
 432       if( pExpr->iTable<0 ){
 433         /* This only happens when coding check constraints */
 434         char zOp2[16];
 435         if( pExpr->op2 ){
 436           sqlite3_snprintf(sizeof(zOp2),zOp2," op2=0x%02x",pExpr->op2);
 437         }else{
 438           zOp2[0] = 0;
 439         }
 440         sqlite3TreeViewLine(pView, "COLUMN(%d)%s%s",
 441                                     pExpr->iColumn, zFlgs, zOp2);
 442       }else{
 443         sqlite3TreeViewLine(pView, "{%d:%d} pTab=%p%s",
 444                         pExpr->iTable, pExpr->iColumn,
 445                         pExpr->y.pTab, zFlgs);
 446       }
 447       if( ExprHasProperty(pExpr, EP_FixedCol) ){
 448         sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
 449       }
 450       break;
 451     }
 452     case TK_INTEGER: {
 453       if( pExpr->flags & EP_IntValue ){
 454         sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue);
 455       }else{
 456         sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken);
 457       }
 458       break;
 459     }
 460 #ifndef SQLITE_OMIT_FLOATING_POINT
 461     case TK_FLOAT: {
 462       sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken);
 463       break;
 464     }
 465 #endif
 466     case TK_STRING: {
 467       sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken);
 468       break;
 469     }
 470     case TK_NULL: {
 471       sqlite3TreeViewLine(pView,"NULL");
 472       break;
 473     }
 474     case TK_TRUEFALSE: {
 475       sqlite3TreeViewLine(pView,
 476          sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE");
 477       break;
 478     }
 479 #ifndef SQLITE_OMIT_BLOB_LITERAL
 480     case TK_BLOB: {
 481       sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken);
 482       break;
 483     }
 484 #endif
 485     case TK_VARIABLE: {
 486       sqlite3TreeViewLine(pView,"VARIABLE(%s,%d)",
 487                           pExpr->u.zToken, pExpr->iColumn);
 488       break;
 489     }
 490     case TK_REGISTER: {
 491       sqlite3TreeViewLine(pView,"REGISTER(%d)", pExpr->iTable);
 492       break;
 493     }
 494     case TK_ID: {
 495       sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken);
 496       break;
 497     }
 498 #ifndef SQLITE_OMIT_CAST
 499     case TK_CAST: {
 500       /* Expressions of the form:   CAST(pLeft AS token) */
 501       sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken);
 502       sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
 503       break;
 504     }
 505 #endif /* SQLITE_OMIT_CAST */
 506     case TK_LT:      zBinOp = "LT";     break;
 507     case TK_LE:      zBinOp = "LE";     break;
 508     case TK_GT:      zBinOp = "GT";     break;
 509     case TK_GE:      zBinOp = "GE";     break;
 510     case TK_NE:      zBinOp = "NE";     break;
 511     case TK_EQ:      zBinOp = "EQ";     break;
 512     case TK_IS:      zBinOp = "IS";     break;
 513     case TK_ISNOT:   zBinOp = "ISNOT";  break;
 514     case TK_AND:     zBinOp = "AND";    break;
 515     case TK_OR:      zBinOp = "OR";     break;
 516     case TK_PLUS:    zBinOp = "ADD";    break;
 517     case TK_STAR:    zBinOp = "MUL";    break;
 518     case TK_MINUS:   zBinOp = "SUB";    break;
 519     case TK_REM:     zBinOp = "REM";    break;
 520     case TK_BITAND:  zBinOp = "BITAND"; break;
 521     case TK_BITOR:   zBinOp = "BITOR";  break;
 522     case TK_SLASH:   zBinOp = "DIV";    break;
 523     case TK_LSHIFT:  zBinOp = "LSHIFT"; break;
 524     case TK_RSHIFT:  zBinOp = "RSHIFT"; break;
 525     case TK_CONCAT:  zBinOp = "CONCAT"; break;
 526     case TK_DOT:     zBinOp = "DOT";    break;
 527     case TK_LIMIT:   zBinOp = "LIMIT";  break;
 528
 529     case TK_UMINUS:  zUniOp = "UMINUS"; break;
 530     case TK_UPLUS:   zUniOp = "UPLUS";  break;
 531     case TK_BITNOT:  zUniOp = "BITNOT"; break;
 532     case TK_NOT:     zUniOp = "NOT";    break;
 533     case TK_ISNULL:  zUniOp = "ISNULL"; break;
 534     case TK_NOTNULL: zUniOp = "NOTNULL"; break;
 535
 536     case TK_TRUTH: {
 537       int x;
 538       const char *azOp[] = {
 539          "IS-FALSE", "IS-TRUE", "IS-NOT-FALSE", "IS-NOT-TRUE"
 540       };
 541       assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT );
 542       assert( pExpr->pRight );
 543       assert( sqlite3ExprSkipCollate(pExpr->pRight)->op==TK_TRUEFALSE );
 544       x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight);
 545       zUniOp = azOp[x];
 546       break;
 547     }
 548
 549     case TK_SPAN: {
 550       sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken);
 551       sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
 552       break;
 553     }
 554
 555     case TK_COLLATE: {
 556       /* COLLATE operators without the EP_Collate flag are intended to
 557       ** emulate collation associated with a table column.  These show
 558       ** up in the treeview output as "SOFT-COLLATE".  Explicit COLLATE
 559       ** operators that appear in the original SQL always have the
 560       ** EP_Collate bit set and appear in treeview output as just "COLLATE" */
 561       sqlite3TreeViewLine(pView, "%sCOLLATE %Q%s",
 562         !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "",
 563         pExpr->u.zToken, zFlgs);
 564       sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
 565       break;
 566     }
 567
 568     case TK_AGG_FUNCTION:
 569     case TK_FUNCTION: {
 570       ExprList *pFarg;       /* List of function arguments */
 571       Window *pWin;
 572       if( ExprHasProperty(pExpr, EP_TokenOnly) ){
 573         pFarg = 0;
 574         pWin = 0;
 575       }else{
 576         pFarg = pExpr->x.pList;
 577 #ifndef SQLITE_OMIT_WINDOWFUNC
 578         pWin = ExprHasProperty(pExpr, EP_WinFunc) ? pExpr->y.pWin : 0;
 579 #else
 580         pWin = 0;
 581 #endif
 582       }
 583       if( pExpr->op==TK_AGG_FUNCTION ){
 584         sqlite3TreeViewLine(pView, "AGG_FUNCTION%d %Q%s agg=%d[%d]/%p",
 585                              pExpr->op2, pExpr->u.zToken, zFlgs,
 586                              pExpr->pAggInfo ? pExpr->pAggInfo->selId : 0,
 587                              pExpr->iAgg, pExpr->pAggInfo);
 588       }else if( pExpr->op2!=0 ){
 589         const char *zOp2;
 590         char zBuf[8];
 591         sqlite3_snprintf(sizeof(zBuf),zBuf,"0x%02x",pExpr->op2);
 592         zOp2 = zBuf;
 593         if( pExpr->op2==NC_IsCheck ) zOp2 = "NC_IsCheck";
 594         if( pExpr->op2==NC_IdxExpr ) zOp2 = "NC_IdxExpr";
 595         if( pExpr->op2==NC_PartIdx ) zOp2 = "NC_PartIdx";
 596         if( pExpr->op2==NC_GenCol ) zOp2 = "NC_GenCol";
 597         sqlite3TreeViewLine(pView, "FUNCTION %Q%s op2=%s",
 598                             pExpr->u.zToken, zFlgs, zOp2);
 599       }else{
 600         sqlite3TreeViewLine(pView, "FUNCTION %Q%s", pExpr->u.zToken, zFlgs);
 601       }
 602       if( pFarg ){
 603         sqlite3TreeViewExprList(pView, pFarg, pWin!=0, 0);
 604       }
 605 #ifndef SQLITE_OMIT_WINDOWFUNC
 606       if( pWin ){
 607         sqlite3TreeViewWindow(pView, pWin, 0);
 608       }
 609 #endif
 610       break;
 611     }
 612 #ifndef SQLITE_OMIT_SUBQUERY
 613     case TK_EXISTS: {
 614       sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags);
 615       sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
 616       break;
 617     }
 618     case TK_SELECT: {
 619       sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags);
 620       sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
 621       break;
 622     }
 623     case TK_IN: {
 624       sqlite3TreeViewLine(pView, "IN flags=0x%x", pExpr->flags);
 625       sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
 626       if( ExprHasProperty(pExpr, EP_xIsSelect) ){
 627         sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
 628       }else{
 629         sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
 630       }
 631       break;
 632     }
 633 #endif /* SQLITE_OMIT_SUBQUERY */
 634
 635     /*
 636     **    x BETWEEN y AND z
 637     **
 638     ** This is equivalent to
 639     **
 640     **    x>=y AND x<=z
 641     **
 642     ** X is stored in pExpr->pLeft.
 643     ** Y is stored in pExpr->pList->a[0].pExpr.
 644     ** Z is stored in pExpr->pList->a[1].pExpr.
 645     */
 646     case TK_BETWEEN: {
 647       Expr *pX = pExpr->pLeft;
 648       Expr *pY = pExpr->x.pList->a[0].pExpr;
 649       Expr *pZ = pExpr->x.pList->a[1].pExpr;
 650       sqlite3TreeViewLine(pView, "BETWEEN");
 651       sqlite3TreeViewExpr(pView, pX, 1);
 652       sqlite3TreeViewExpr(pView, pY, 1);
 653       sqlite3TreeViewExpr(pView, pZ, 0);
 654       break;
 655     }
 656     case TK_TRIGGER: {
 657       /* If the opcode is TK_TRIGGER, then the expression is a reference
 658       ** to a column in the new.* or old.* pseudo-tables available to
 659       ** trigger programs. In this case Expr.iTable is set to 1 for the
 660       ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
 661       ** is set to the column of the pseudo-table to read, or to -1 to
 662       ** read the rowid field.
 663       */
 664       sqlite3TreeViewLine(pView, "%s(%d)",
 665           pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn);
 666       break;
 667     }
 668     case TK_CASE: {
 669       sqlite3TreeViewLine(pView, "CASE");
 670       sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
 671       sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
 672       break;
 673     }
 674 #ifndef SQLITE_OMIT_TRIGGER
 675     case TK_RAISE: {
 676       const char *zType = "unk";
 677       switch( pExpr->affExpr ){
 678         case OE_Rollback:   zType = "rollback";  break;
 679         case OE_Abort:      zType = "abort";     break;
 680         case OE_Fail:       zType = "fail";      break;
 681         case OE_Ignore:     zType = "ignore";    break;
 682       }
 683       sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken);
 684       break;
 685     }
 686 #endif
 687     case TK_MATCH: {
 688       sqlite3TreeViewLine(pView, "MATCH {%d:%d}%s",
 689                           pExpr->iTable, pExpr->iColumn, zFlgs);
 690       sqlite3TreeViewExpr(pView, pExpr->pRight, 0);
 691       break;
 692     }
 693     case TK_VECTOR: {
 694       char *z = sqlite3_mprintf("VECTOR%s",zFlgs);
 695       sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z);
 696       sqlite3_free(z);
 697       break;
 698     }
 699     case TK_SELECT_COLUMN: {
 700       sqlite3TreeViewLine(pView, "SELECT-COLUMN %d", pExpr->iColumn);
 701       sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0);
 702       break;
 703     }
 704     case TK_IF_NULL_ROW: {
 705       sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable);
 706       sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
 707       break;
 708     }
 709     case TK_ERROR: {
 710       Expr tmp;
 711       sqlite3TreeViewLine(pView, "ERROR");
 712       tmp = *pExpr;
 713       tmp.op = pExpr->op2;
 714       sqlite3TreeViewExpr(pView, &tmp, 0);
 715       break;
 716     }
 717     default: {
 718       sqlite3TreeViewLine(pView, "op=%d", pExpr->op);
 719       break;
 720     }
 721   }
 722   if( zBinOp ){
 723     sqlite3TreeViewLine(pView, "%s%s", zBinOp, zFlgs);
 724     sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
 725     sqlite3TreeViewExpr(pView, pExpr->pRight, 0);
 726   }else if( zUniOp ){
 727     sqlite3TreeViewLine(pView, "%s%s", zUniOp, zFlgs);
 728    sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
 729   }
 730   sqlite3TreeViewPop(pView);
 731 }
 732
 733
 734 /*
 735 ** Generate a human-readable explanation of an expression list.
 736 */
 737 void sqlite3TreeViewBareExprList(
 738   TreeView *pView,
 739   const ExprList *pList,
 740   const char *zLabel
 741 ){
 742   if( zLabel==0 || zLabel[0]==0 ) zLabel = "LIST";
 743   if( pList==0 ){
 744     sqlite3TreeViewLine(pView, "%s (empty)", zLabel);
 745   }else{
 746     int i;
 747     sqlite3TreeViewLine(pView, "%s", zLabel);
 748     for(i=0; i<pList->nExpr; i++){
 749       int j = pList->a[i].u.x.iOrderByCol;
 750       char *zName = pList->a[i].zEName;
 751       int moreToFollow = i<pList->nExpr - 1;
 752       if( pList->a[i].eEName!=ENAME_NAME ) zName = 0;
 753       if( j || zName ){
 754         sqlite3TreeViewPush(pView, moreToFollow);
 755         moreToFollow = 0;
 756         sqlite3TreeViewLine(pView, 0);
 757         if( zName ){
 758           fprintf(stdout, "AS %s ", zName);
 759         }
 760         if( j ){
 761           fprintf(stdout, "iOrderByCol=%d", j);
 762         }
 763         fprintf(stdout, "\n");
 764         fflush(stdout);
 765       }
 766       sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow);
 767       if( j || zName ){
 768         sqlite3TreeViewPop(pView);
 769       }
 770     }
 771   }
 772 }
 773 void sqlite3TreeViewExprList(
 774   TreeView *pView,
 775   const ExprList *pList,
 776   u8 moreToFollow,
 777   const char *zLabel
 778 ){
 779   pView = sqlite3TreeViewPush(pView, moreToFollow);
 780   sqlite3TreeViewBareExprList(pView, pList, zLabel);
 781   sqlite3TreeViewPop(pView);
 782 }
 783
 784 #endif /* SQLITE_DEBUG */