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