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