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