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 void sqlite3TreeViewPush(TreeView **pp, u8 moreToFollow){ 28 TreeView *p = *pp; 29 if( p==0 ){ 30 *pp = p = sqlite3_malloc64( sizeof(*p) ); 31 if( p==0 ) return; 32 memset(p, 0, sizeof(*p)); 33 }else{ 34 p->iLevel++; 35 } 36 assert( moreToFollow==0 || moreToFollow==1 ); 37 if( p->iLevel<(int)sizeof(p->bLine) ) p->bLine[p->iLevel] = moreToFollow; 38 } 39 40 /* 41 ** Finished with one layer of the tree 42 */ 43 static void sqlite3TreeViewPop(TreeView **pp){ 44 TreeView *p = *pp; 45 if( p==0 ) return; 46 p->iLevel--; 47 if( p->iLevel<0 ){ 48 sqlite3_free(p); 49 *pp = 0; 50 } 51 } 52 53 /* 54 ** Generate a single line of output for the tree, with a prefix that contains 55 ** all the appropriate tree lines 56 */ 57 void sqlite3TreeViewLine(TreeView *p, const char *zFormat, ...){ 58 va_list ap; 59 int i; 60 StrAccum acc; 61 char zBuf[500]; 62 sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); 63 if( p ){ 64 for(i=0; i<p->iLevel && i<(int)sizeof(p->bLine)-1; i++){ 65 sqlite3_str_append(&acc, p->bLine[i] ? "| " : " ", 4); 66 } 67 sqlite3_str_append(&acc, p->bLine[i] ? "|-- " : "'-- ", 4); 68 } 69 if( zFormat!=0 ){ 70 va_start(ap, zFormat); 71 sqlite3_str_vappendf(&acc, zFormat, ap); 72 va_end(ap); 73 assert( acc.nChar>0 || acc.accError ); 74 sqlite3_str_append(&acc, "\n", 1); 75 } 76 sqlite3StrAccumFinish(&acc); 77 fprintf(stdout,"%s", zBuf); 78 fflush(stdout); 79 } 80 81 /* 82 ** Shorthand for starting a new tree item that consists of a single label 83 */ 84 static void sqlite3TreeViewItem(TreeView *p, const char *zLabel,u8 moreFollows){ 85 sqlite3TreeViewPush(&p, moreFollows); 86 sqlite3TreeViewLine(p, "%s", zLabel); 87 } 88 89 /* 90 ** Generate a human-readable description of a WITH clause. 91 */ 92 void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 moreToFollow){ 93 int i; 94 if( pWith==0 ) return; 95 if( pWith->nCte==0 ) return; 96 if( pWith->pOuter ){ 97 sqlite3TreeViewLine(pView, "WITH (0x%p, pOuter=0x%p)",pWith,pWith->pOuter); 98 }else{ 99 sqlite3TreeViewLine(pView, "WITH (0x%p)", pWith); 100 } 101 if( pWith->nCte>0 ){ 102 sqlite3TreeViewPush(&pView, moreToFollow); 103 for(i=0; i<pWith->nCte; i++){ 104 StrAccum x; 105 char zLine[1000]; 106 const struct Cte *pCte = &pWith->a[i]; 107 sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0); 108 sqlite3_str_appendf(&x, "%s", pCte->zName); 109 if( pCte->pCols && pCte->pCols->nExpr>0 ){ 110 char cSep = '('; 111 int j; 112 for(j=0; j<pCte->pCols->nExpr; j++){ 113 sqlite3_str_appendf(&x, "%c%s", cSep, pCte->pCols->a[j].zEName); 114 cSep = ','; 115 } 116 sqlite3_str_appendf(&x, ")"); 117 } 118 if( pCte->pUse ){ 119 sqlite3_str_appendf(&x, " (pUse=0x%p, nUse=%d)", pCte->pUse, 120 pCte->pUse->nUse); 121 } 122 sqlite3StrAccumFinish(&x); 123 sqlite3TreeViewItem(pView, zLine, i<pWith->nCte-1); 124 sqlite3TreeViewSelect(pView, pCte->pSelect, 0); 125 sqlite3TreeViewPop(&pView); 126 } 127 sqlite3TreeViewPop(&pView); 128 } 129 } 130 131 /* 132 ** Generate a human-readable description of a SrcList object. 133 */ 134 void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc){ 135 int i; 136 if( pSrc==0 ) return; 137 for(i=0; i<pSrc->nSrc; i++){ 138 const SrcItem *pItem = &pSrc->a[i]; 139 StrAccum x; 140 char zLine[100]; 141 sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0); 142 x.printfFlags |= SQLITE_PRINTF_INTERNAL; 143 sqlite3_str_appendf(&x, "{%d:*} %!S", pItem->iCursor, pItem); 144 if( pItem->pTab ){ 145 sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx", 146 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed); 147 } 148 if( (pItem->fg.jointype & (JT_LEFT|JT_RIGHT))==(JT_LEFT|JT_RIGHT) ){ 149 sqlite3_str_appendf(&x, " FULL-OUTER-JOIN"); 150 }else if( pItem->fg.jointype & JT_LEFT ){ 151 sqlite3_str_appendf(&x, " LEFT-JOIN"); 152 }else if( pItem->fg.jointype & JT_RIGHT ){ 153 sqlite3_str_appendf(&x, " RIGHT-JOIN"); 154 }else if( pItem->fg.jointype & JT_CROSS ){ 155 sqlite3_str_appendf(&x, " CROSS-JOIN"); 156 } 157 if( pItem->fg.jointype & JT_LTORJ ){ 158 sqlite3_str_appendf(&x, " LTORJ"); 159 } 160 if( pItem->fg.fromDDL ){ 161 sqlite3_str_appendf(&x, " DDL"); 162 } 163 if( pItem->fg.isCte ){ 164 sqlite3_str_appendf(&x, " CteUse=0x%p", pItem->u2.pCteUse); 165 } 166 sqlite3StrAccumFinish(&x); 167 sqlite3TreeViewItem(pView, zLine, i<pSrc->nSrc-1); 168 if( pItem->pSelect ){ 169 sqlite3TreeViewSelect(pView, pItem->pSelect, 0); 170 } 171 if( pItem->fg.isTabFunc ){ 172 sqlite3TreeViewExprList(pView, pItem->u1.pFuncArg, 0, "func-args:"); 173 } 174 sqlite3TreeViewPop(&pView); 175 } 176 } 177 178 /* 179 ** Generate a human-readable description of a Select object. 180 */ 181 void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){ 182 int n = 0; 183 int cnt = 0; 184 if( p==0 ){ 185 sqlite3TreeViewLine(pView, "nil-SELECT"); 186 return; 187 } 188 sqlite3TreeViewPush(&pView, moreToFollow); 189 if( p->pWith ){ 190 sqlite3TreeViewWith(pView, p->pWith, 1); 191 cnt = 1; 192 sqlite3TreeViewPush(&pView, 1); 193 } 194 do{ 195 if( p->selFlags & SF_WhereBegin ){ 196 sqlite3TreeViewLine(pView, "sqlite3WhereBegin()"); 197 }else{ 198 sqlite3TreeViewLine(pView, 199 "SELECT%s%s (%u/%p) selFlags=0x%x nSelectRow=%d", 200 ((p->selFlags & SF_Distinct) ? " DISTINCT" : ""), 201 ((p->selFlags & SF_Aggregate) ? " agg_flag" : ""), 202 p->selId, p, p->selFlags, 203 (int)p->nSelectRow 204 ); 205 } 206 if( cnt++ ) sqlite3TreeViewPop(&pView); 207 if( p->pPrior ){ 208 n = 1000; 209 }else{ 210 n = 0; 211 if( p->pSrc && p->pSrc->nSrc ) n++; 212 if( p->pWhere ) n++; 213 if( p->pGroupBy ) n++; 214 if( p->pHaving ) n++; 215 if( p->pOrderBy ) n++; 216 if( p->pLimit ) n++; 217 #ifndef SQLITE_OMIT_WINDOWFUNC 218 if( p->pWin ) n++; 219 if( p->pWinDefn ) n++; 220 #endif 221 } 222 if( p->pEList ){ 223 sqlite3TreeViewExprList(pView, p->pEList, n>0, "result-set"); 224 } 225 n--; 226 #ifndef SQLITE_OMIT_WINDOWFUNC 227 if( p->pWin ){ 228 Window *pX; 229 sqlite3TreeViewPush(&pView, (n--)>0); 230 sqlite3TreeViewLine(pView, "window-functions"); 231 for(pX=p->pWin; pX; pX=pX->pNextWin){ 232 sqlite3TreeViewWinFunc(pView, pX, pX->pNextWin!=0); 233 } 234 sqlite3TreeViewPop(&pView); 235 } 236 #endif 237 if( p->pSrc && p->pSrc->nSrc ){ 238 sqlite3TreeViewPush(&pView, (n--)>0); 239 sqlite3TreeViewLine(pView, "FROM"); 240 sqlite3TreeViewSrcList(pView, p->pSrc); 241 sqlite3TreeViewPop(&pView); 242 } 243 if( p->pWhere ){ 244 sqlite3TreeViewItem(pView, "WHERE", (n--)>0); 245 sqlite3TreeViewExpr(pView, p->pWhere, 0); 246 sqlite3TreeViewPop(&pView); 247 } 248 if( p->pGroupBy ){ 249 sqlite3TreeViewExprList(pView, p->pGroupBy, (n--)>0, "GROUPBY"); 250 } 251 if( p->pHaving ){ 252 sqlite3TreeViewItem(pView, "HAVING", (n--)>0); 253 sqlite3TreeViewExpr(pView, p->pHaving, 0); 254 sqlite3TreeViewPop(&pView); 255 } 256 #ifndef SQLITE_OMIT_WINDOWFUNC 257 if( p->pWinDefn ){ 258 Window *pX; 259 sqlite3TreeViewItem(pView, "WINDOW", (n--)>0); 260 for(pX=p->pWinDefn; pX; pX=pX->pNextWin){ 261 sqlite3TreeViewWindow(pView, pX, pX->pNextWin!=0); 262 } 263 sqlite3TreeViewPop(&pView); 264 } 265 #endif 266 if( p->pOrderBy ){ 267 sqlite3TreeViewExprList(pView, p->pOrderBy, (n--)>0, "ORDERBY"); 268 } 269 if( p->pLimit ){ 270 sqlite3TreeViewItem(pView, "LIMIT", (n--)>0); 271 sqlite3TreeViewExpr(pView, p->pLimit->pLeft, p->pLimit->pRight!=0); 272 if( p->pLimit->pRight ){ 273 sqlite3TreeViewItem(pView, "OFFSET", (n--)>0); 274 sqlite3TreeViewExpr(pView, p->pLimit->pRight, 0); 275 sqlite3TreeViewPop(&pView); 276 } 277 sqlite3TreeViewPop(&pView); 278 } 279 if( p->pPrior ){ 280 const char *zOp = "UNION"; 281 switch( p->op ){ 282 case TK_ALL: zOp = "UNION ALL"; break; 283 case TK_INTERSECT: zOp = "INTERSECT"; break; 284 case TK_EXCEPT: zOp = "EXCEPT"; break; 285 } 286 sqlite3TreeViewItem(pView, zOp, 1); 287 } 288 p = p->pPrior; 289 }while( p!=0 ); 290 sqlite3TreeViewPop(&pView); 291 } 292 293 #ifndef SQLITE_OMIT_WINDOWFUNC 294 /* 295 ** Generate a description of starting or stopping bounds 296 */ 297 void sqlite3TreeViewBound( 298 TreeView *pView, /* View context */ 299 u8 eBound, /* UNBOUNDED, CURRENT, PRECEDING, FOLLOWING */ 300 Expr *pExpr, /* Value for PRECEDING or FOLLOWING */ 301 u8 moreToFollow /* True if more to follow */ 302 ){ 303 switch( eBound ){ 304 case TK_UNBOUNDED: { 305 sqlite3TreeViewItem(pView, "UNBOUNDED", moreToFollow); 306 sqlite3TreeViewPop(&pView); 307 break; 308 } 309 case TK_CURRENT: { 310 sqlite3TreeViewItem(pView, "CURRENT", moreToFollow); 311 sqlite3TreeViewPop(&pView); 312 break; 313 } 314 case TK_PRECEDING: { 315 sqlite3TreeViewItem(pView, "PRECEDING", moreToFollow); 316 sqlite3TreeViewExpr(pView, pExpr, 0); 317 sqlite3TreeViewPop(&pView); 318 break; 319 } 320 case TK_FOLLOWING: { 321 sqlite3TreeViewItem(pView, "FOLLOWING", moreToFollow); 322 sqlite3TreeViewExpr(pView, pExpr, 0); 323 sqlite3TreeViewPop(&pView); 324 break; 325 } 326 } 327 } 328 #endif /* SQLITE_OMIT_WINDOWFUNC */ 329 330 #ifndef SQLITE_OMIT_WINDOWFUNC 331 /* 332 ** Generate a human-readable explanation for a Window object 333 */ 334 void sqlite3TreeViewWindow(TreeView *pView, const Window *pWin, u8 more){ 335 int nElement = 0; 336 if( pWin->pFilter ){ 337 sqlite3TreeViewItem(pView, "FILTER", 1); 338 sqlite3TreeViewExpr(pView, pWin->pFilter, 0); 339 sqlite3TreeViewPop(&pView); 340 } 341 sqlite3TreeViewPush(&pView, more); 342 if( pWin->zName ){ 343 sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin); 344 }else{ 345 sqlite3TreeViewLine(pView, "OVER (%p)", pWin); 346 } 347 if( pWin->zBase ) nElement++; 348 if( pWin->pOrderBy ) nElement++; 349 if( pWin->eFrmType ) nElement++; 350 if( pWin->eExclude ) nElement++; 351 if( pWin->zBase ){ 352 sqlite3TreeViewPush(&pView, (--nElement)>0); 353 sqlite3TreeViewLine(pView, "window: %s", pWin->zBase); 354 sqlite3TreeViewPop(&pView); 355 } 356 if( pWin->pPartition ){ 357 sqlite3TreeViewExprList(pView, pWin->pPartition, nElement>0,"PARTITION-BY"); 358 } 359 if( pWin->pOrderBy ){ 360 sqlite3TreeViewExprList(pView, pWin->pOrderBy, (--nElement)>0, "ORDER-BY"); 361 } 362 if( pWin->eFrmType ){ 363 char zBuf[30]; 364 const char *zFrmType = "ROWS"; 365 if( pWin->eFrmType==TK_RANGE ) zFrmType = "RANGE"; 366 if( pWin->eFrmType==TK_GROUPS ) zFrmType = "GROUPS"; 367 sqlite3_snprintf(sizeof(zBuf),zBuf,"%s%s",zFrmType, 368 pWin->bImplicitFrame ? " (implied)" : ""); 369 sqlite3TreeViewItem(pView, zBuf, (--nElement)>0); 370 sqlite3TreeViewBound(pView, pWin->eStart, pWin->pStart, 1); 371 sqlite3TreeViewBound(pView, pWin->eEnd, pWin->pEnd, 0); 372 sqlite3TreeViewPop(&pView); 373 } 374 if( pWin->eExclude ){ 375 char zBuf[30]; 376 const char *zExclude; 377 switch( pWin->eExclude ){ 378 case TK_NO: zExclude = "NO OTHERS"; break; 379 case TK_CURRENT: zExclude = "CURRENT ROW"; break; 380 case TK_GROUP: zExclude = "GROUP"; break; 381 case TK_TIES: zExclude = "TIES"; break; 382 default: 383 sqlite3_snprintf(sizeof(zBuf),zBuf,"invalid(%d)", pWin->eExclude); 384 zExclude = zBuf; 385 break; 386 } 387 sqlite3TreeViewPush(&pView, 0); 388 sqlite3TreeViewLine(pView, "EXCLUDE %s", zExclude); 389 sqlite3TreeViewPop(&pView); 390 } 391 sqlite3TreeViewPop(&pView); 392 } 393 #endif /* SQLITE_OMIT_WINDOWFUNC */ 394 395 #ifndef SQLITE_OMIT_WINDOWFUNC 396 /* 397 ** Generate a human-readable explanation for a Window Function object 398 */ 399 void sqlite3TreeViewWinFunc(TreeView *pView, const Window *pWin, u8 more){ 400 sqlite3TreeViewPush(&pView, more); 401 sqlite3TreeViewLine(pView, "WINFUNC %s(%d)", 402 pWin->pWFunc->zName, pWin->pWFunc->nArg); 403 sqlite3TreeViewWindow(pView, pWin, 0); 404 sqlite3TreeViewPop(&pView); 405 } 406 #endif /* SQLITE_OMIT_WINDOWFUNC */ 407 408 /* 409 ** Generate a human-readable explanation of an expression tree. 410 */ 411 void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){ 412 const char *zBinOp = 0; /* Binary operator */ 413 const char *zUniOp = 0; /* Unary operator */ 414 char zFlgs[200]; 415 sqlite3TreeViewPush(&pView, moreToFollow); 416 if( pExpr==0 ){ 417 sqlite3TreeViewLine(pView, "nil"); 418 sqlite3TreeViewPop(&pView); 419 return; 420 } 421 if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags ){ 422 StrAccum x; 423 sqlite3StrAccumInit(&x, 0, zFlgs, sizeof(zFlgs), 0); 424 sqlite3_str_appendf(&x, " fg.af=%x.%c", 425 pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n'); 426 if( ExprHasProperty(pExpr, EP_FromJoin) ){ 427 sqlite3_str_appendf(&x, " iJoin=%d", pExpr->w.iJoin); 428 } 429 if( ExprHasProperty(pExpr, EP_FromDDL) ){ 430 sqlite3_str_appendf(&x, " DDL"); 431 } 432 if( ExprHasVVAProperty(pExpr, EP_Immutable) ){ 433 sqlite3_str_appendf(&x, " IMMUTABLE"); 434 } 435 sqlite3StrAccumFinish(&x); 436 }else{ 437 zFlgs[0] = 0; 438 } 439 switch( pExpr->op ){ 440 case TK_AGG_COLUMN: { 441 sqlite3TreeViewLine(pView, "AGG{%d:%d}%s", 442 pExpr->iTable, pExpr->iColumn, zFlgs); 443 break; 444 } 445 case TK_COLUMN: { 446 if( pExpr->iTable<0 ){ 447 /* This only happens when coding check constraints */ 448 char zOp2[16]; 449 if( pExpr->op2 ){ 450 sqlite3_snprintf(sizeof(zOp2),zOp2," op2=0x%02x",pExpr->op2); 451 }else{ 452 zOp2[0] = 0; 453 } 454 sqlite3TreeViewLine(pView, "COLUMN(%d)%s%s", 455 pExpr->iColumn, zFlgs, zOp2); 456 }else{ 457 assert( ExprUseYTab(pExpr) ); 458 sqlite3TreeViewLine(pView, "{%d:%d} pTab=%p%s", 459 pExpr->iTable, pExpr->iColumn, 460 pExpr->y.pTab, zFlgs); 461 } 462 if( ExprHasProperty(pExpr, EP_FixedCol) ){ 463 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); 464 } 465 break; 466 } 467 case TK_INTEGER: { 468 if( pExpr->flags & EP_IntValue ){ 469 sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue); 470 }else{ 471 sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken); 472 } 473 break; 474 } 475 #ifndef SQLITE_OMIT_FLOATING_POINT 476 case TK_FLOAT: { 477 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 478 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); 479 break; 480 } 481 #endif 482 case TK_STRING: { 483 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 484 sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken); 485 break; 486 } 487 case TK_NULL: { 488 sqlite3TreeViewLine(pView,"NULL"); 489 break; 490 } 491 case TK_TRUEFALSE: { 492 sqlite3TreeViewLine(pView,"%s%s", 493 sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE", zFlgs); 494 break; 495 } 496 #ifndef SQLITE_OMIT_BLOB_LITERAL 497 case TK_BLOB: { 498 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 499 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); 500 break; 501 } 502 #endif 503 case TK_VARIABLE: { 504 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 505 sqlite3TreeViewLine(pView,"VARIABLE(%s,%d)", 506 pExpr->u.zToken, pExpr->iColumn); 507 break; 508 } 509 case TK_REGISTER: { 510 sqlite3TreeViewLine(pView,"REGISTER(%d)", pExpr->iTable); 511 break; 512 } 513 case TK_ID: { 514 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 515 sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken); 516 break; 517 } 518 #ifndef SQLITE_OMIT_CAST 519 case TK_CAST: { 520 /* Expressions of the form: CAST(pLeft AS token) */ 521 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 522 sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken); 523 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); 524 break; 525 } 526 #endif /* SQLITE_OMIT_CAST */ 527 case TK_LT: zBinOp = "LT"; break; 528 case TK_LE: zBinOp = "LE"; break; 529 case TK_GT: zBinOp = "GT"; break; 530 case TK_GE: zBinOp = "GE"; break; 531 case TK_NE: zBinOp = "NE"; break; 532 case TK_EQ: zBinOp = "EQ"; break; 533 case TK_IS: zBinOp = "IS"; break; 534 case TK_ISNOT: zBinOp = "ISNOT"; break; 535 case TK_AND: zBinOp = "AND"; break; 536 case TK_OR: zBinOp = "OR"; break; 537 case TK_PLUS: zBinOp = "ADD"; break; 538 case TK_STAR: zBinOp = "MUL"; break; 539 case TK_MINUS: zBinOp = "SUB"; break; 540 case TK_REM: zBinOp = "REM"; break; 541 case TK_BITAND: zBinOp = "BITAND"; break; 542 case TK_BITOR: zBinOp = "BITOR"; break; 543 case TK_SLASH: zBinOp = "DIV"; break; 544 case TK_LSHIFT: zBinOp = "LSHIFT"; break; 545 case TK_RSHIFT: zBinOp = "RSHIFT"; break; 546 case TK_CONCAT: zBinOp = "CONCAT"; break; 547 case TK_DOT: zBinOp = "DOT"; break; 548 case TK_LIMIT: zBinOp = "LIMIT"; break; 549 550 case TK_UMINUS: zUniOp = "UMINUS"; break; 551 case TK_UPLUS: zUniOp = "UPLUS"; break; 552 case TK_BITNOT: zUniOp = "BITNOT"; break; 553 case TK_NOT: zUniOp = "NOT"; break; 554 case TK_ISNULL: zUniOp = "ISNULL"; break; 555 case TK_NOTNULL: zUniOp = "NOTNULL"; break; 556 557 case TK_TRUTH: { 558 int x; 559 const char *azOp[] = { 560 "IS-FALSE", "IS-TRUE", "IS-NOT-FALSE", "IS-NOT-TRUE" 561 }; 562 assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT ); 563 assert( pExpr->pRight ); 564 assert( sqlite3ExprSkipCollate(pExpr->pRight)->op==TK_TRUEFALSE ); 565 x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight); 566 zUniOp = azOp[x]; 567 break; 568 } 569 570 case TK_SPAN: { 571 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 572 sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken); 573 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); 574 break; 575 } 576 577 case TK_COLLATE: { 578 /* COLLATE operators without the EP_Collate flag are intended to 579 ** emulate collation associated with a table column. These show 580 ** up in the treeview output as "SOFT-COLLATE". Explicit COLLATE 581 ** operators that appear in the original SQL always have the 582 ** EP_Collate bit set and appear in treeview output as just "COLLATE" */ 583 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 584 sqlite3TreeViewLine(pView, "%sCOLLATE %Q%s", 585 !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "", 586 pExpr->u.zToken, zFlgs); 587 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); 588 break; 589 } 590 591 case TK_AGG_FUNCTION: 592 case TK_FUNCTION: { 593 ExprList *pFarg; /* List of function arguments */ 594 Window *pWin; 595 if( ExprHasProperty(pExpr, EP_TokenOnly) ){ 596 pFarg = 0; 597 pWin = 0; 598 }else{ 599 assert( ExprUseXList(pExpr) ); 600 pFarg = pExpr->x.pList; 601 #ifndef SQLITE_OMIT_WINDOWFUNC 602 pWin = ExprHasProperty(pExpr, EP_WinFunc) ? pExpr->y.pWin : 0; 603 #else 604 pWin = 0; 605 #endif 606 } 607 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 608 if( pExpr->op==TK_AGG_FUNCTION ){ 609 sqlite3TreeViewLine(pView, "AGG_FUNCTION%d %Q%s agg=%d[%d]/%p", 610 pExpr->op2, pExpr->u.zToken, zFlgs, 611 pExpr->pAggInfo ? pExpr->pAggInfo->selId : 0, 612 pExpr->iAgg, pExpr->pAggInfo); 613 }else if( pExpr->op2!=0 ){ 614 const char *zOp2; 615 char zBuf[8]; 616 sqlite3_snprintf(sizeof(zBuf),zBuf,"0x%02x",pExpr->op2); 617 zOp2 = zBuf; 618 if( pExpr->op2==NC_IsCheck ) zOp2 = "NC_IsCheck"; 619 if( pExpr->op2==NC_IdxExpr ) zOp2 = "NC_IdxExpr"; 620 if( pExpr->op2==NC_PartIdx ) zOp2 = "NC_PartIdx"; 621 if( pExpr->op2==NC_GenCol ) zOp2 = "NC_GenCol"; 622 sqlite3TreeViewLine(pView, "FUNCTION %Q%s op2=%s", 623 pExpr->u.zToken, zFlgs, zOp2); 624 }else{ 625 sqlite3TreeViewLine(pView, "FUNCTION %Q%s", pExpr->u.zToken, zFlgs); 626 } 627 if( pFarg ){ 628 sqlite3TreeViewExprList(pView, pFarg, pWin!=0, 0); 629 } 630 #ifndef SQLITE_OMIT_WINDOWFUNC 631 if( pWin ){ 632 sqlite3TreeViewWindow(pView, pWin, 0); 633 } 634 #endif 635 break; 636 } 637 #ifndef SQLITE_OMIT_SUBQUERY 638 case TK_EXISTS: { 639 assert( ExprUseXSelect(pExpr) ); 640 sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags); 641 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); 642 break; 643 } 644 case TK_SELECT: { 645 assert( ExprUseXSelect(pExpr) ); 646 sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags); 647 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); 648 break; 649 } 650 case TK_IN: { 651 sqlite3TreeViewLine(pView, "IN flags=0x%x", pExpr->flags); 652 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); 653 if( ExprUseXSelect(pExpr) ){ 654 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); 655 }else{ 656 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); 657 } 658 break; 659 } 660 #endif /* SQLITE_OMIT_SUBQUERY */ 661 662 /* 663 ** x BETWEEN y AND z 664 ** 665 ** This is equivalent to 666 ** 667 ** x>=y AND x<=z 668 ** 669 ** X is stored in pExpr->pLeft. 670 ** Y is stored in pExpr->pList->a[0].pExpr. 671 ** Z is stored in pExpr->pList->a[1].pExpr. 672 */ 673 case TK_BETWEEN: { 674 const Expr *pX, *pY, *pZ; 675 pX = pExpr->pLeft; 676 assert( ExprUseXList(pExpr) ); 677 assert( pExpr->x.pList->nExpr==2 ); 678 pY = pExpr->x.pList->a[0].pExpr; 679 pZ = pExpr->x.pList->a[1].pExpr; 680 sqlite3TreeViewLine(pView, "BETWEEN"); 681 sqlite3TreeViewExpr(pView, pX, 1); 682 sqlite3TreeViewExpr(pView, pY, 1); 683 sqlite3TreeViewExpr(pView, pZ, 0); 684 break; 685 } 686 case TK_TRIGGER: { 687 /* If the opcode is TK_TRIGGER, then the expression is a reference 688 ** to a column in the new.* or old.* pseudo-tables available to 689 ** trigger programs. In this case Expr.iTable is set to 1 for the 690 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn 691 ** is set to the column of the pseudo-table to read, or to -1 to 692 ** read the rowid field. 693 */ 694 sqlite3TreeViewLine(pView, "%s(%d)", 695 pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn); 696 break; 697 } 698 case TK_CASE: { 699 sqlite3TreeViewLine(pView, "CASE"); 700 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); 701 assert( ExprUseXList(pExpr) ); 702 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); 703 break; 704 } 705 #ifndef SQLITE_OMIT_TRIGGER 706 case TK_RAISE: { 707 const char *zType = "unk"; 708 switch( pExpr->affExpr ){ 709 case OE_Rollback: zType = "rollback"; break; 710 case OE_Abort: zType = "abort"; break; 711 case OE_Fail: zType = "fail"; break; 712 case OE_Ignore: zType = "ignore"; break; 713 } 714 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 715 sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken); 716 break; 717 } 718 #endif 719 case TK_MATCH: { 720 sqlite3TreeViewLine(pView, "MATCH {%d:%d}%s", 721 pExpr->iTable, pExpr->iColumn, zFlgs); 722 sqlite3TreeViewExpr(pView, pExpr->pRight, 0); 723 break; 724 } 725 case TK_VECTOR: { 726 char *z = sqlite3_mprintf("VECTOR%s",zFlgs); 727 assert( ExprUseXList(pExpr) ); 728 sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z); 729 sqlite3_free(z); 730 break; 731 } 732 case TK_SELECT_COLUMN: { 733 sqlite3TreeViewLine(pView, "SELECT-COLUMN %d of [0..%d]%s", 734 pExpr->iColumn, pExpr->iTable-1, 735 pExpr->pRight==pExpr->pLeft ? " (SELECT-owner)" : ""); 736 assert( ExprUseXSelect(pExpr->pLeft) ); 737 sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0); 738 break; 739 } 740 case TK_IF_NULL_ROW: { 741 sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable); 742 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); 743 break; 744 } 745 case TK_ERROR: { 746 Expr tmp; 747 sqlite3TreeViewLine(pView, "ERROR"); 748 tmp = *pExpr; 749 tmp.op = pExpr->op2; 750 sqlite3TreeViewExpr(pView, &tmp, 0); 751 break; 752 } 753 case TK_ROW: { 754 if( pExpr->iColumn<=0 ){ 755 sqlite3TreeViewLine(pView, "First FROM table rowid"); 756 }else{ 757 sqlite3TreeViewLine(pView, "First FROM table column %d", 758 pExpr->iColumn-1); 759 } 760 break; 761 } 762 default: { 763 sqlite3TreeViewLine(pView, "op=%d", pExpr->op); 764 break; 765 } 766 } 767 if( zBinOp ){ 768 sqlite3TreeViewLine(pView, "%s%s", zBinOp, zFlgs); 769 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); 770 sqlite3TreeViewExpr(pView, pExpr->pRight, 0); 771 }else if( zUniOp ){ 772 sqlite3TreeViewLine(pView, "%s%s", zUniOp, zFlgs); 773 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); 774 } 775 sqlite3TreeViewPop(&pView); 776 } 777 778 779 /* 780 ** Generate a human-readable explanation of an expression list. 781 */ 782 void sqlite3TreeViewBareExprList( 783 TreeView *pView, 784 const ExprList *pList, 785 const char *zLabel 786 ){ 787 if( zLabel==0 || zLabel[0]==0 ) zLabel = "LIST"; 788 if( pList==0 ){ 789 sqlite3TreeViewLine(pView, "%s (empty)", zLabel); 790 }else{ 791 int i; 792 sqlite3TreeViewLine(pView, "%s", zLabel); 793 for(i=0; i<pList->nExpr; i++){ 794 int j = pList->a[i].u.x.iOrderByCol; 795 char *zName = pList->a[i].zEName; 796 int moreToFollow = i<pList->nExpr - 1; 797 if( pList->a[i].eEName!=ENAME_NAME ) zName = 0; 798 if( j || zName ){ 799 sqlite3TreeViewPush(&pView, moreToFollow); 800 moreToFollow = 0; 801 sqlite3TreeViewLine(pView, 0); 802 if( zName ){ 803 fprintf(stdout, "AS %s ", zName); 804 } 805 if( j ){ 806 fprintf(stdout, "iOrderByCol=%d", j); 807 } 808 fprintf(stdout, "\n"); 809 fflush(stdout); 810 } 811 sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow); 812 if( j || zName ){ 813 sqlite3TreeViewPop(&pView); 814 } 815 } 816 } 817 } 818 void sqlite3TreeViewExprList( 819 TreeView *pView, 820 const ExprList *pList, 821 u8 moreToFollow, 822 const char *zLabel 823 ){ 824 sqlite3TreeViewPush(&pView, moreToFollow); 825 sqlite3TreeViewBareExprList(pView, pList, zLabel); 826 sqlite3TreeViewPop(&pView); 827 } 828 829 /* 830 ** Generate a human-readable explanation of an id-list. 831 */ 832 void sqlite3TreeViewBareIdList( 833 TreeView *pView, 834 const IdList *pList, 835 const char *zLabel 836 ){ 837 if( zLabel==0 || zLabel[0]==0 ) zLabel = "LIST"; 838 if( pList==0 ){ 839 sqlite3TreeViewLine(pView, "%s (empty)", zLabel); 840 }else{ 841 int i; 842 sqlite3TreeViewLine(pView, "%s", zLabel); 843 for(i=0; i<pList->nId; i++){ 844 char *zName = pList->a[i].zName; 845 int moreToFollow = i<pList->nId - 1; 846 if( zName==0 ) zName = "(null)"; 847 sqlite3TreeViewPush(&pView, moreToFollow); 848 sqlite3TreeViewLine(pView, 0); 849 fprintf(stdout, "%s (%d)\n", zName, pList->a[i].idx); 850 sqlite3TreeViewPop(&pView); 851 } 852 } 853 } 854 void sqlite3TreeViewIdList( 855 TreeView *pView, 856 const IdList *pList, 857 u8 moreToFollow, 858 const char *zLabel 859 ){ 860 sqlite3TreeViewPush(&pView, moreToFollow); 861 sqlite3TreeViewBareIdList(pView, pList, zLabel); 862 sqlite3TreeViewPop(&pView); 863 } 864 865 /* 866 ** Generate a human-readable explanation of a list of Upsert objects 867 */ 868 void sqlite3TreeViewUpsert( 869 TreeView *pView, 870 const Upsert *pUpsert, 871 u8 moreToFollow 872 ){ 873 if( pUpsert==0 ) return; 874 sqlite3TreeViewPush(&pView, moreToFollow); 875 while( pUpsert ){ 876 int n; 877 sqlite3TreeViewPush(&pView, pUpsert->pNextUpsert!=0 || moreToFollow); 878 sqlite3TreeViewLine(pView, "ON CONFLICT DO %s", 879 pUpsert->isDoUpdate ? "UPDATE" : "NOTHING"); 880 n = (pUpsert->pUpsertSet!=0) + (pUpsert->pUpsertWhere!=0); 881 sqlite3TreeViewExprList(pView, pUpsert->pUpsertTarget, (n--)>0, "TARGET"); 882 sqlite3TreeViewExprList(pView, pUpsert->pUpsertSet, (n--)>0, "SET"); 883 if( pUpsert->pUpsertWhere ){ 884 sqlite3TreeViewItem(pView, "WHERE", (n--)>0); 885 sqlite3TreeViewExpr(pView, pUpsert->pUpsertWhere, 0); 886 sqlite3TreeViewPop(&pView); 887 } 888 sqlite3TreeViewPop(&pView); 889 pUpsert = pUpsert->pNextUpsert; 890 } 891 sqlite3TreeViewPop(&pView); 892 } 893 894 /* 895 ** Generate a human-readable diagram of the data structure that go 896 ** into generating an DELETE statement. 897 */ 898 void sqlite3TreeViewDelete( 899 const With *pWith, 900 const SrcList *pTabList, 901 const Expr *pWhere, 902 const ExprList *pOrderBy, 903 const Expr *pLimit, 904 const Trigger *pTrigger 905 ){ 906 int n = 0; 907 TreeView *pView = 0; 908 sqlite3TreeViewPush(&pView, 0); 909 sqlite3TreeViewLine(pView, "DELETE"); 910 if( pWith ) n++; 911 if( pTabList ) n++; 912 if( pWhere ) n++; 913 if( pOrderBy ) n++; 914 if( pLimit ) n++; 915 if( pTrigger ) n++; 916 if( pWith ){ 917 sqlite3TreeViewPush(&pView, (--n)>0); 918 sqlite3TreeViewWith(pView, pWith, 0); 919 sqlite3TreeViewPop(&pView); 920 } 921 if( pTabList ){ 922 sqlite3TreeViewPush(&pView, (--n)>0); 923 sqlite3TreeViewLine(pView, "FROM"); 924 sqlite3TreeViewSrcList(pView, pTabList); 925 sqlite3TreeViewPop(&pView); 926 } 927 if( pWhere ){ 928 sqlite3TreeViewPush(&pView, (--n)>0); 929 sqlite3TreeViewLine(pView, "WHERE"); 930 sqlite3TreeViewExpr(pView, pWhere, 0); 931 sqlite3TreeViewPop(&pView); 932 } 933 if( pOrderBy ){ 934 sqlite3TreeViewExprList(pView, pOrderBy, (--n)>0, "ORDER-BY"); 935 } 936 if( pLimit ){ 937 sqlite3TreeViewPush(&pView, (--n)>0); 938 sqlite3TreeViewLine(pView, "LIMIT"); 939 sqlite3TreeViewExpr(pView, pLimit, 0); 940 sqlite3TreeViewPop(&pView); 941 } 942 if( pTrigger ){ 943 sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1); 944 } 945 sqlite3TreeViewPop(&pView); 946 } 947 948 /* 949 ** Generate a human-readable diagram of the data structure that go 950 ** into generating an INSERT statement. 951 */ 952 void sqlite3TreeViewInsert( 953 const With *pWith, 954 const SrcList *pTabList, 955 const IdList *pColumnList, 956 const Select *pSelect, 957 const ExprList *pExprList, 958 int onError, 959 const Upsert *pUpsert, 960 const Trigger *pTrigger 961 ){ 962 TreeView *pView = 0; 963 int n = 0; 964 const char *zLabel = "INSERT"; 965 switch( onError ){ 966 case OE_Replace: zLabel = "REPLACE"; break; 967 case OE_Ignore: zLabel = "INSERT OR IGNORE"; break; 968 case OE_Rollback: zLabel = "INSERT OR ROLLBACK"; break; 969 case OE_Abort: zLabel = "INSERT OR ABORT"; break; 970 case OE_Fail: zLabel = "INSERT OR FAIL"; break; 971 } 972 sqlite3TreeViewPush(&pView, 0); 973 sqlite3TreeViewLine(pView, zLabel); 974 if( pWith ) n++; 975 if( pTabList ) n++; 976 if( pColumnList ) n++; 977 if( pSelect ) n++; 978 if( pExprList ) n++; 979 if( pUpsert ) n++; 980 if( pTrigger ) n++; 981 if( pWith ){ 982 sqlite3TreeViewPush(&pView, (--n)>0); 983 sqlite3TreeViewWith(pView, pWith, 0); 984 sqlite3TreeViewPop(&pView); 985 } 986 if( pTabList ){ 987 sqlite3TreeViewPush(&pView, (--n)>0); 988 sqlite3TreeViewLine(pView, "INTO"); 989 sqlite3TreeViewSrcList(pView, pTabList); 990 sqlite3TreeViewPop(&pView); 991 } 992 if( pColumnList ){ 993 sqlite3TreeViewIdList(pView, pColumnList, (--n)>0, "COLUMNS"); 994 } 995 if( pSelect ){ 996 sqlite3TreeViewPush(&pView, (--n)>0); 997 sqlite3TreeViewLine(pView, "DATA-SOURCE"); 998 sqlite3TreeViewSelect(pView, pSelect, 0); 999 sqlite3TreeViewPop(&pView); 1000 } 1001 if( pExprList ){ 1002 sqlite3TreeViewExprList(pView, pExprList, (--n)>0, "VALUES"); 1003 } 1004 if( pUpsert ){ 1005 sqlite3TreeViewPush(&pView, (--n)>0); 1006 sqlite3TreeViewLine(pView, "UPSERT"); 1007 sqlite3TreeViewUpsert(pView, pUpsert, 0); 1008 sqlite3TreeViewPop(&pView); 1009 } 1010 if( pTrigger ){ 1011 sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1); 1012 } 1013 sqlite3TreeViewPop(&pView); 1014 } 1015 1016 /* 1017 ** Generate a human-readable diagram of the data structure that go 1018 ** into generating an UPDATE statement. 1019 */ 1020 void sqlite3TreeViewUpdate( 1021 const With *pWith, 1022 const SrcList *pTabList, 1023 const ExprList *pChanges, 1024 const Expr *pWhere, 1025 int onError, 1026 const ExprList *pOrderBy, 1027 const Expr *pLimit, 1028 const Upsert *pUpsert, 1029 const Trigger *pTrigger 1030 ){ 1031 int n = 0; 1032 TreeView *pView = 0; 1033 const char *zLabel = "UPDATE"; 1034 switch( onError ){ 1035 case OE_Replace: zLabel = "UPDATE OR REPLACE"; break; 1036 case OE_Ignore: zLabel = "UPDATE OR IGNORE"; break; 1037 case OE_Rollback: zLabel = "UPDATE OR ROLLBACK"; break; 1038 case OE_Abort: zLabel = "UPDATE OR ABORT"; break; 1039 case OE_Fail: zLabel = "UPDATE OR FAIL"; break; 1040 } 1041 sqlite3TreeViewPush(&pView, 0); 1042 sqlite3TreeViewLine(pView, zLabel); 1043 if( pWith ) n++; 1044 if( pTabList ) n++; 1045 if( pChanges ) n++; 1046 if( pWhere ) n++; 1047 if( pOrderBy ) n++; 1048 if( pLimit ) n++; 1049 if( pUpsert ) n++; 1050 if( pTrigger ) n++; 1051 if( pWith ){ 1052 sqlite3TreeViewPush(&pView, (--n)>0); 1053 sqlite3TreeViewWith(pView, pWith, 0); 1054 sqlite3TreeViewPop(&pView); 1055 } 1056 if( pTabList ){ 1057 sqlite3TreeViewPush(&pView, (--n)>0); 1058 sqlite3TreeViewLine(pView, "FROM"); 1059 sqlite3TreeViewSrcList(pView, pTabList); 1060 sqlite3TreeViewPop(&pView); 1061 } 1062 if( pChanges ){ 1063 sqlite3TreeViewExprList(pView, pChanges, (--n)>0, "SET"); 1064 } 1065 if( pWhere ){ 1066 sqlite3TreeViewPush(&pView, (--n)>0); 1067 sqlite3TreeViewLine(pView, "WHERE"); 1068 sqlite3TreeViewExpr(pView, pWhere, 0); 1069 sqlite3TreeViewPop(&pView); 1070 } 1071 if( pOrderBy ){ 1072 sqlite3TreeViewExprList(pView, pOrderBy, (--n)>0, "ORDER-BY"); 1073 } 1074 if( pLimit ){ 1075 sqlite3TreeViewPush(&pView, (--n)>0); 1076 sqlite3TreeViewLine(pView, "LIMIT"); 1077 sqlite3TreeViewExpr(pView, pLimit, 0); 1078 sqlite3TreeViewPop(&pView); 1079 } 1080 if( pUpsert ){ 1081 sqlite3TreeViewPush(&pView, (--n)>0); 1082 sqlite3TreeViewLine(pView, "UPSERT"); 1083 sqlite3TreeViewUpsert(pView, pUpsert, 0); 1084 sqlite3TreeViewPop(&pView); 1085 } 1086 if( pTrigger ){ 1087 sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1); 1088 } 1089 sqlite3TreeViewPop(&pView); 1090 } 1091 1092 #ifndef SQLITE_OMIT_TRIGGER 1093 /* 1094 ** Show a human-readable graph of a TriggerStep 1095 */ 1096 void sqlite3TreeViewTriggerStep( 1097 TreeView *pView, 1098 const TriggerStep *pStep, 1099 u8 moreToFollow, 1100 u8 showFullList 1101 ){ 1102 int cnt = 0; 1103 if( pStep==0 ) return; 1104 sqlite3TreeViewPush(&pView, 1105 moreToFollow || (showFullList && pStep->pNext!=0)); 1106 do{ 1107 if( cnt++ && pStep->pNext==0 ){ 1108 sqlite3TreeViewPop(&pView); 1109 sqlite3TreeViewPush(&pView, 0); 1110 } 1111 sqlite3TreeViewLine(pView, "%s", pStep->zSpan ? pStep->zSpan : "RETURNING"); 1112 }while( showFullList && (pStep = pStep->pNext)!=0 ); 1113 sqlite3TreeViewPop(&pView); 1114 } 1115 1116 /* 1117 ** Show a human-readable graph of a Trigger 1118 */ 1119 void sqlite3TreeViewTrigger( 1120 TreeView *pView, 1121 const Trigger *pTrigger, 1122 u8 moreToFollow, 1123 u8 showFullList 1124 ){ 1125 int cnt = 0; 1126 if( pTrigger==0 ) return; 1127 sqlite3TreeViewPush(&pView, 1128 moreToFollow || (showFullList && pTrigger->pNext!=0)); 1129 do{ 1130 if( cnt++ && pTrigger->pNext==0 ){ 1131 sqlite3TreeViewPop(&pView); 1132 sqlite3TreeViewPush(&pView, 0); 1133 } 1134 sqlite3TreeViewLine(pView, "TRIGGER %s", pTrigger->zName); 1135 sqlite3TreeViewPush(&pView, 0); 1136 sqlite3TreeViewTriggerStep(pView, pTrigger->step_list, 0, 1); 1137 sqlite3TreeViewPop(&pView); 1138 }while( showFullList && (pTrigger = pTrigger->pNext)!=0 ); 1139 sqlite3TreeViewPop(&pView); 1140 } 1141 #endif /* SQLITE_OMIT_TRIGGER */ 1142 1143 1144 /* 1145 ** These simplified versions of the tree-view routines omit unnecessary 1146 ** parameters. These variants are intended to be used from a symbolic 1147 ** debugger, such as "gdb", during interactive debugging sessions. 1148 ** 1149 ** This routines are given external linkage so that they will always be 1150 ** accessible to the debugging, and to avoid warnings about unused 1151 ** functions. But these routines only exist in debugging builds, so they 1152 ** do not contaminate the interface. 1153 */ 1154 void sqlite3ShowExpr(const Expr *p){ sqlite3TreeViewExpr(0,p,0); } 1155 void sqlite3ShowExprList(const ExprList *p){ sqlite3TreeViewExprList(0,p,0,0);} 1156 void sqlite3ShowIdList(const IdList *p){ sqlite3TreeViewIdList(0,p,0,0); } 1157 void sqlite3ShowSrcList(const SrcList *p){ sqlite3TreeViewSrcList(0,p); } 1158 void sqlite3ShowSelect(const Select *p){ sqlite3TreeViewSelect(0,p,0); } 1159 void sqlite3ShowWith(const With *p){ sqlite3TreeViewWith(0,p,0); } 1160 void sqlite3ShowUpsert(const Upsert *p){ sqlite3TreeViewUpsert(0,p,0); } 1161 #ifndef SQLITE_OMIT_TRIGGER 1162 void sqlite3ShowTriggerStep(const TriggerStep *p){ 1163 sqlite3TreeViewTriggerStep(0,p,0,0); 1164 } 1165 void sqlite3ShowTriggerStepList(const TriggerStep *p){ 1166 sqlite3TreeViewTriggerStep(0,p,0,1); 1167 } 1168 void sqlite3ShowTrigger(const Trigger *p){ sqlite3TreeViewTrigger(0,p,0,0); } 1169 void sqlite3ShowTriggerList(const Trigger *p){ sqlite3TreeViewTrigger(0,p,0,1);} 1170 #endif 1171 #ifndef SQLITE_OMIT_WINDOWFUNC 1172 void sqlite3ShowWindow(const Window *p){ sqlite3TreeViewWindow(0,p,0); } 1173 void sqlite3ShowWinFunc(const Window *p){ sqlite3TreeViewWinFunc(0,p,0); } 1174 #endif 1175 1176 #endif /* SQLITE_DEBUG */ 1177