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