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