xref: /sqlite-3.40.0/src/treeview.c (revision 67f70bea) 
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==0 ) fprintf(stdout, "(unused) ");
814               break;
815             case ENAME_SPAN:
816               fprintf(stdout, "SPAN(\"%s\") ", zName);
817               break;
818           }
819         }
820         if( j ){
821           fprintf(stdout, "iOrderByCol=%d", j);
822         }
823         fprintf(stdout, "\n");
824         fflush(stdout);
825       }
826       sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow);
827       if( j || zName ){
828         sqlite3TreeViewPop(&pView);
829       }
830     }
831   }
832 }
833 void sqlite3TreeViewExprList(
834   TreeView *pView,
835   const ExprList *pList,
836   u8 moreToFollow,
837   const char *zLabel
838 ){
839   sqlite3TreeViewPush(&pView, moreToFollow);
840   sqlite3TreeViewBareExprList(pView, pList, zLabel);
841   sqlite3TreeViewPop(&pView);
842 }
843 
844 /*
845 ** Generate a human-readable explanation of an id-list.
846 */
847 void sqlite3TreeViewBareIdList(
848   TreeView *pView,
849   const IdList *pList,
850   const char *zLabel
851 ){
852   if( zLabel==0 || zLabel[0]==0 ) zLabel = "LIST";
853   if( pList==0 ){
854     sqlite3TreeViewLine(pView, "%s (empty)", zLabel);
855   }else{
856     int i;
857     sqlite3TreeViewLine(pView, "%s", zLabel);
858     for(i=0; i<pList->nId; i++){
859       char *zName = pList->a[i].zName;
860       int moreToFollow = i<pList->nId - 1;
861       if( zName==0 ) zName = "(null)";
862       sqlite3TreeViewPush(&pView, moreToFollow);
863       sqlite3TreeViewLine(pView, 0);
864       if( pList->eU4==EU4_NONE ){
865         fprintf(stdout, "%s\n", zName);
866       }else if( pList->eU4==EU4_IDX ){
867         fprintf(stdout, "%s (%d)\n", zName, pList->a[i].u4.idx);
868       }else{
869         assert( pList->eU4==EU4_EXPR );
870         if( pList->a[i].u4.pExpr==0 ){
871           fprintf(stdout, "%s (pExpr=NULL)\n", zName);
872         }else{
873           fprintf(stdout, "%s\n", zName);
874           sqlite3TreeViewPush(&pView, i<pList->nId-1);
875           sqlite3TreeViewExpr(pView, pList->a[i].u4.pExpr, 0);
876           sqlite3TreeViewPop(&pView);
877         }
878       }
879       sqlite3TreeViewPop(&pView);
880     }
881   }
882 }
883 void sqlite3TreeViewIdList(
884   TreeView *pView,
885   const IdList *pList,
886   u8 moreToFollow,
887   const char *zLabel
888 ){
889   sqlite3TreeViewPush(&pView, moreToFollow);
890   sqlite3TreeViewBareIdList(pView, pList, zLabel);
891   sqlite3TreeViewPop(&pView);
892 }
893 
894 /*
895 ** Generate a human-readable explanation of a list of Upsert objects
896 */
897 void sqlite3TreeViewUpsert(
898   TreeView *pView,
899   const Upsert *pUpsert,
900   u8 moreToFollow
901 ){
902   if( pUpsert==0 ) return;
903   sqlite3TreeViewPush(&pView, moreToFollow);
904   while( pUpsert ){
905     int n;
906     sqlite3TreeViewPush(&pView, pUpsert->pNextUpsert!=0 || moreToFollow);
907     sqlite3TreeViewLine(pView, "ON CONFLICT DO %s",
908          pUpsert->isDoUpdate ? "UPDATE" : "NOTHING");
909     n = (pUpsert->pUpsertSet!=0) + (pUpsert->pUpsertWhere!=0);
910     sqlite3TreeViewExprList(pView, pUpsert->pUpsertTarget, (n--)>0, "TARGET");
911     sqlite3TreeViewExprList(pView, pUpsert->pUpsertSet, (n--)>0, "SET");
912     if( pUpsert->pUpsertWhere ){
913       sqlite3TreeViewItem(pView, "WHERE", (n--)>0);
914       sqlite3TreeViewExpr(pView, pUpsert->pUpsertWhere, 0);
915       sqlite3TreeViewPop(&pView);
916     }
917     sqlite3TreeViewPop(&pView);
918     pUpsert = pUpsert->pNextUpsert;
919   }
920   sqlite3TreeViewPop(&pView);
921 }
922 
923 /*
924 ** Generate a human-readable diagram of the data structure that go
925 ** into generating an DELETE statement.
926 */
927 void sqlite3TreeViewDelete(
928   const With *pWith,
929   const SrcList *pTabList,
930   const Expr *pWhere,
931   const ExprList *pOrderBy,
932   const Expr *pLimit,
933   const Trigger *pTrigger
934 ){
935   int n = 0;
936   TreeView *pView = 0;
937   sqlite3TreeViewPush(&pView, 0);
938   sqlite3TreeViewLine(pView, "DELETE");
939   if( pWith ) n++;
940   if( pTabList ) n++;
941   if( pWhere ) n++;
942   if( pOrderBy ) n++;
943   if( pLimit ) n++;
944   if( pTrigger ) n++;
945   if( pWith ){
946     sqlite3TreeViewPush(&pView, (--n)>0);
947     sqlite3TreeViewWith(pView, pWith, 0);
948     sqlite3TreeViewPop(&pView);
949   }
950   if( pTabList ){
951     sqlite3TreeViewPush(&pView, (--n)>0);
952     sqlite3TreeViewLine(pView, "FROM");
953     sqlite3TreeViewSrcList(pView, pTabList);
954     sqlite3TreeViewPop(&pView);
955   }
956   if( pWhere ){
957     sqlite3TreeViewPush(&pView, (--n)>0);
958     sqlite3TreeViewLine(pView, "WHERE");
959     sqlite3TreeViewExpr(pView, pWhere, 0);
960     sqlite3TreeViewPop(&pView);
961   }
962   if( pOrderBy ){
963     sqlite3TreeViewExprList(pView, pOrderBy, (--n)>0, "ORDER-BY");
964   }
965   if( pLimit ){
966     sqlite3TreeViewPush(&pView, (--n)>0);
967     sqlite3TreeViewLine(pView, "LIMIT");
968     sqlite3TreeViewExpr(pView, pLimit, 0);
969     sqlite3TreeViewPop(&pView);
970   }
971   if( pTrigger ){
972     sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1);
973   }
974   sqlite3TreeViewPop(&pView);
975 }
976 
977 /*
978 ** Generate a human-readable diagram of the data structure that go
979 ** into generating an INSERT statement.
980 */
981 void sqlite3TreeViewInsert(
982   const With *pWith,
983   const SrcList *pTabList,
984   const IdList *pColumnList,
985   const Select *pSelect,
986   const ExprList *pExprList,
987   int onError,
988   const Upsert *pUpsert,
989   const Trigger *pTrigger
990 ){
991   TreeView *pView = 0;
992   int n = 0;
993   const char *zLabel = "INSERT";
994   switch( onError ){
995     case OE_Replace:  zLabel = "REPLACE";             break;
996     case OE_Ignore:   zLabel = "INSERT OR IGNORE";    break;
997     case OE_Rollback: zLabel = "INSERT OR ROLLBACK";  break;
998     case OE_Abort:    zLabel = "INSERT OR ABORT";     break;
999     case OE_Fail:     zLabel = "INSERT OR FAIL";      break;
1000   }
1001   sqlite3TreeViewPush(&pView, 0);
1002   sqlite3TreeViewLine(pView, zLabel);
1003   if( pWith ) n++;
1004   if( pTabList ) n++;
1005   if( pColumnList ) n++;
1006   if( pSelect ) n++;
1007   if( pExprList ) n++;
1008   if( pUpsert ) n++;
1009   if( pTrigger ) n++;
1010   if( pWith ){
1011     sqlite3TreeViewPush(&pView, (--n)>0);
1012     sqlite3TreeViewWith(pView, pWith, 0);
1013     sqlite3TreeViewPop(&pView);
1014   }
1015   if( pTabList ){
1016     sqlite3TreeViewPush(&pView, (--n)>0);
1017     sqlite3TreeViewLine(pView, "INTO");
1018     sqlite3TreeViewSrcList(pView, pTabList);
1019     sqlite3TreeViewPop(&pView);
1020   }
1021   if( pColumnList ){
1022     sqlite3TreeViewIdList(pView, pColumnList, (--n)>0, "COLUMNS");
1023   }
1024   if( pSelect ){
1025     sqlite3TreeViewPush(&pView, (--n)>0);
1026     sqlite3TreeViewLine(pView, "DATA-SOURCE");
1027     sqlite3TreeViewSelect(pView, pSelect, 0);
1028     sqlite3TreeViewPop(&pView);
1029   }
1030   if( pExprList ){
1031     sqlite3TreeViewExprList(pView, pExprList, (--n)>0, "VALUES");
1032   }
1033   if( pUpsert ){
1034     sqlite3TreeViewPush(&pView, (--n)>0);
1035     sqlite3TreeViewLine(pView, "UPSERT");
1036     sqlite3TreeViewUpsert(pView, pUpsert, 0);
1037     sqlite3TreeViewPop(&pView);
1038   }
1039   if( pTrigger ){
1040     sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1);
1041   }
1042   sqlite3TreeViewPop(&pView);
1043 }
1044 
1045 /*
1046 ** Generate a human-readable diagram of the data structure that go
1047 ** into generating an UPDATE statement.
1048 */
1049 void sqlite3TreeViewUpdate(
1050   const With *pWith,
1051   const SrcList *pTabList,
1052   const ExprList *pChanges,
1053   const Expr *pWhere,
1054   int onError,
1055   const ExprList *pOrderBy,
1056   const Expr *pLimit,
1057   const Upsert *pUpsert,
1058   const Trigger *pTrigger
1059 ){
1060   int n = 0;
1061   TreeView *pView = 0;
1062   const char *zLabel = "UPDATE";
1063   switch( onError ){
1064     case OE_Replace:  zLabel = "UPDATE OR REPLACE";   break;
1065     case OE_Ignore:   zLabel = "UPDATE OR IGNORE";    break;
1066     case OE_Rollback: zLabel = "UPDATE OR ROLLBACK";  break;
1067     case OE_Abort:    zLabel = "UPDATE OR ABORT";     break;
1068     case OE_Fail:     zLabel = "UPDATE OR FAIL";      break;
1069   }
1070   sqlite3TreeViewPush(&pView, 0);
1071   sqlite3TreeViewLine(pView, zLabel);
1072   if( pWith ) n++;
1073   if( pTabList ) n++;
1074   if( pChanges ) n++;
1075   if( pWhere ) n++;
1076   if( pOrderBy ) n++;
1077   if( pLimit ) n++;
1078   if( pUpsert ) n++;
1079   if( pTrigger ) n++;
1080   if( pWith ){
1081     sqlite3TreeViewPush(&pView, (--n)>0);
1082     sqlite3TreeViewWith(pView, pWith, 0);
1083     sqlite3TreeViewPop(&pView);
1084   }
1085   if( pTabList ){
1086     sqlite3TreeViewPush(&pView, (--n)>0);
1087     sqlite3TreeViewLine(pView, "FROM");
1088     sqlite3TreeViewSrcList(pView, pTabList);
1089     sqlite3TreeViewPop(&pView);
1090   }
1091   if( pChanges ){
1092     sqlite3TreeViewExprList(pView, pChanges, (--n)>0, "SET");
1093   }
1094   if( pWhere ){
1095     sqlite3TreeViewPush(&pView, (--n)>0);
1096     sqlite3TreeViewLine(pView, "WHERE");
1097     sqlite3TreeViewExpr(pView, pWhere, 0);
1098     sqlite3TreeViewPop(&pView);
1099   }
1100   if( pOrderBy ){
1101     sqlite3TreeViewExprList(pView, pOrderBy, (--n)>0, "ORDER-BY");
1102   }
1103   if( pLimit ){
1104     sqlite3TreeViewPush(&pView, (--n)>0);
1105     sqlite3TreeViewLine(pView, "LIMIT");
1106     sqlite3TreeViewExpr(pView, pLimit, 0);
1107     sqlite3TreeViewPop(&pView);
1108   }
1109   if( pUpsert ){
1110     sqlite3TreeViewPush(&pView, (--n)>0);
1111     sqlite3TreeViewLine(pView, "UPSERT");
1112     sqlite3TreeViewUpsert(pView, pUpsert, 0);
1113     sqlite3TreeViewPop(&pView);
1114   }
1115   if( pTrigger ){
1116     sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1);
1117   }
1118   sqlite3TreeViewPop(&pView);
1119 }
1120 
1121 #ifndef SQLITE_OMIT_TRIGGER
1122 /*
1123 ** Show a human-readable graph of a TriggerStep
1124 */
1125 void sqlite3TreeViewTriggerStep(
1126   TreeView *pView,
1127   const TriggerStep *pStep,
1128   u8 moreToFollow,
1129   u8 showFullList
1130 ){
1131   int cnt = 0;
1132   if( pStep==0 ) return;
1133   sqlite3TreeViewPush(&pView,
1134       moreToFollow || (showFullList && pStep->pNext!=0));
1135   do{
1136     if( cnt++ && pStep->pNext==0 ){
1137       sqlite3TreeViewPop(&pView);
1138       sqlite3TreeViewPush(&pView, 0);
1139     }
1140     sqlite3TreeViewLine(pView, "%s", pStep->zSpan ? pStep->zSpan : "RETURNING");
1141   }while( showFullList && (pStep = pStep->pNext)!=0 );
1142   sqlite3TreeViewPop(&pView);
1143 }
1144 
1145 /*
1146 ** Show a human-readable graph of a Trigger
1147 */
1148 void sqlite3TreeViewTrigger(
1149   TreeView *pView,
1150   const Trigger *pTrigger,
1151   u8 moreToFollow,
1152   u8 showFullList
1153 ){
1154   int cnt = 0;
1155   if( pTrigger==0 ) return;
1156   sqlite3TreeViewPush(&pView,
1157      moreToFollow || (showFullList && pTrigger->pNext!=0));
1158   do{
1159     if( cnt++ && pTrigger->pNext==0 ){
1160       sqlite3TreeViewPop(&pView);
1161       sqlite3TreeViewPush(&pView, 0);
1162     }
1163     sqlite3TreeViewLine(pView, "TRIGGER %s", pTrigger->zName);
1164     sqlite3TreeViewPush(&pView, 0);
1165     sqlite3TreeViewTriggerStep(pView, pTrigger->step_list, 0, 1);
1166     sqlite3TreeViewPop(&pView);
1167   }while( showFullList && (pTrigger = pTrigger->pNext)!=0 );
1168   sqlite3TreeViewPop(&pView);
1169 }
1170 #endif /* SQLITE_OMIT_TRIGGER */
1171 
1172 
1173 /*
1174 ** These simplified versions of the tree-view routines omit unnecessary
1175 ** parameters.  These variants are intended to be used from a symbolic
1176 ** debugger, such as "gdb", during interactive debugging sessions.
1177 **
1178 ** This routines are given external linkage so that they will always be
1179 ** accessible to the debugging, and to avoid warnings about unused
1180 ** functions.  But these routines only exist in debugging builds, so they
1181 ** do not contaminate the interface.
1182 */
1183 void sqlite3ShowExpr(const Expr *p){ sqlite3TreeViewExpr(0,p,0); }
1184 void sqlite3ShowExprList(const ExprList *p){ sqlite3TreeViewExprList(0,p,0,0);}
1185 void sqlite3ShowIdList(const IdList *p){ sqlite3TreeViewIdList(0,p,0,0); }
1186 void sqlite3ShowSrcList(const SrcList *p){ sqlite3TreeViewSrcList(0,p); }
1187 void sqlite3ShowSelect(const Select *p){ sqlite3TreeViewSelect(0,p,0); }
1188 void sqlite3ShowWith(const With *p){ sqlite3TreeViewWith(0,p,0); }
1189 void sqlite3ShowUpsert(const Upsert *p){ sqlite3TreeViewUpsert(0,p,0); }
1190 #ifndef SQLITE_OMIT_TRIGGER
1191 void sqlite3ShowTriggerStep(const TriggerStep *p){
1192   sqlite3TreeViewTriggerStep(0,p,0,0);
1193 }
1194 void sqlite3ShowTriggerStepList(const TriggerStep *p){
1195   sqlite3TreeViewTriggerStep(0,p,0,1);
1196 }
1197 void sqlite3ShowTrigger(const Trigger *p){ sqlite3TreeViewTrigger(0,p,0,0); }
1198 void sqlite3ShowTriggerList(const Trigger *p){ sqlite3TreeViewTrigger(0,p,0,1);}
1199 #endif
1200 #ifndef SQLITE_OMIT_WINDOWFUNC
1201 void sqlite3ShowWindow(const Window *p){ sqlite3TreeViewWindow(0,p,0); }
1202 void sqlite3ShowWinFunc(const Window *p){ sqlite3TreeViewWinFunc(0,p,0); }
1203 #endif
1204 
1205 #endif /* SQLITE_DEBUG */
1206