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