src/vdbetrace.c

   1 /*
   2 ** 2009 November 25
   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 code used to insert the values of host parameters
  14 ** (aka "wildcards") into the SQL text output by sqlite3_trace().
  15 **
  16 ** The Vdbe parse-tree explainer is also found here.
  17 */
  18 #include "sqliteInt.h"
  19 #include "vdbeInt.h"
  20
  21 #ifndef SQLITE_OMIT_TRACE
  22
  23 /*
  24 ** zSql is a zero-terminated string of UTF-8 SQL text.  Return the number of
  25 ** bytes in this text up to but excluding the first character in
  26 ** a host parameter.  If the text contains no host parameters, return
  27 ** the total number of bytes in the text.
  28 */
  29 static int findNextHostParameter(const char *zSql, int *pnToken){
  30   int tokenType;
  31   int nTotal = 0;
  32   int n;
  33
  34   *pnToken = 0;
  35   while( zSql[0] ){
  36     n = sqlite3GetToken((u8*)zSql, &tokenType);
  37     assert( n>0 && tokenType!=TK_ILLEGAL );
  38     if( tokenType==TK_VARIABLE ){
  39       *pnToken = n;
  40       break;
  41     }
  42     nTotal += n;
  43     zSql += n;
  44   }
  45   return nTotal;
  46 }
  47
  48 /*
  49 ** This function returns a pointer to a nul-terminated string in memory
  50 ** obtained from sqlite3DbMalloc(). If sqlite3.nVdbeExec is 1, then the
  51 ** string contains a copy of zRawSql but with host parameters expanded to
  52 ** their current bindings. Or, if sqlite3.nVdbeExec is greater than 1,
  53 ** then the returned string holds a copy of zRawSql with "-- " prepended
  54 ** to each line of text.
  55 **
  56 ** If the SQLITE_TRACE_SIZE_LIMIT macro is defined to an integer, then
  57 ** then long strings and blobs are truncated to that many bytes.  This
  58 ** can be used to prevent unreasonably large trace strings when dealing
  59 ** with large (multi-megabyte) strings and blobs.
  60 **
  61 ** The calling function is responsible for making sure the memory returned
  62 ** is eventually freed.
  63 **
  64 ** ALGORITHM:  Scan the input string looking for host parameters in any of
  65 ** these forms:  ?, ?N, $A, @A, :A.  Take care to avoid text within
  66 ** string literals, quoted identifier names, and comments.  For text forms,
  67 ** the host parameter index is found by scanning the prepared
  68 ** statement for the corresponding OP_Variable opcode.  Once the host
  69 ** parameter index is known, locate the value in p->aVar[].  Then render
  70 ** the value as a literal in place of the host parameter name.
  71 */
  72 char *sqlite3VdbeExpandSql(
  73   Vdbe *p,                 /* The prepared statement being evaluated */
  74   const char *zRawSql      /* Raw text of the SQL statement */
  75 ){
  76   sqlite3 *db;             /* The database connection */
  77   int idx = 0;             /* Index of a host parameter */
  78   int nextIndex = 1;       /* Index of next ? host parameter */
  79   int n;                   /* Length of a token prefix */
  80   int nToken;              /* Length of the parameter token */
  81   int i;                   /* Loop counter */
  82   Mem *pVar;               /* Value of a host parameter */
  83   StrAccum out;            /* Accumulate the output here */
  84 #ifndef SQLITE_OMIT_UTF16
  85   Mem utf8;                /* Used to convert UTF16 into UTF8 for display */
  86 #endif
  87   char zBase[100];         /* Initial working space */
  88
  89   db = p->db;
  90   sqlite3StrAccumInit(&out, 0, zBase, sizeof(zBase),
  91                       db->aLimit[SQLITE_LIMIT_LENGTH]);
  92   if( db->nVdbeExec>1 ){
  93     while( *zRawSql ){
  94       const char *zStart = zRawSql;
  95       while( *(zRawSql++)!='\n' && *zRawSql );
  96       sqlite3StrAccumAppend(&out, "-- ", 3);
  97       assert( (zRawSql - zStart) > 0 );
  98       sqlite3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart));
  99     }
 100   }else if( p->nVar==0 ){
 101     sqlite3StrAccumAppend(&out, zRawSql, sqlite3Strlen30(zRawSql));
 102   }else{
 103     while( zRawSql[0] ){
 104       n = findNextHostParameter(zRawSql, &nToken);
 105       assert( n>0 );
 106       sqlite3StrAccumAppend(&out, zRawSql, n);
 107       zRawSql += n;
 108       assert( zRawSql[0] || nToken==0 );
 109       if( nToken==0 ) break;
 110       if( zRawSql[0]=='?' ){
 111         if( nToken>1 ){
 112           assert( sqlite3Isdigit(zRawSql[1]) );
 113           sqlite3GetInt32(&zRawSql[1], &idx);
 114         }else{
 115           idx = nextIndex;
 116         }
 117       }else{
 118         assert( zRawSql[0]==':' || zRawSql[0]=='$' ||
 119                 zRawSql[0]=='@' || zRawSql[0]=='#' );
 120         testcase( zRawSql[0]==':' );
 121         testcase( zRawSql[0]=='$' );
 122         testcase( zRawSql[0]=='@' );
 123         testcase( zRawSql[0]=='#' );
 124         idx = sqlite3VdbeParameterIndex(p, zRawSql, nToken);
 125         assert( idx>0 );
 126       }
 127       zRawSql += nToken;
 128       nextIndex = idx + 1;
 129       assert( idx>0 && idx<=p->nVar );
 130       pVar = &p->aVar[idx-1];
 131       if( pVar->flags & MEM_Null ){
 132         sqlite3StrAccumAppend(&out, "NULL", 4);
 133       }else if( pVar->flags & MEM_Int ){
 134         sqlite3XPrintf(&out, "%lld", pVar->u.i);
 135       }else if( pVar->flags & MEM_Real ){
 136         sqlite3XPrintf(&out, "%!.15g", pVar->u.r);
 137       }else if( pVar->flags & MEM_Str ){
 138         int nOut;  /* Number of bytes of the string text to include in output */
 139 #ifndef SQLITE_OMIT_UTF16
 140         u8 enc = ENC(db);
 141         if( enc!=SQLITE_UTF8 ){
 142           memset(&utf8, 0, sizeof(utf8));
 143           utf8.db = db;
 144           sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC);
 145           if( SQLITE_NOMEM==sqlite3VdbeChangeEncoding(&utf8, SQLITE_UTF8) ){
 146             out.accError = STRACCUM_NOMEM;
 147             out.nAlloc = 0;
 148           }
 149           pVar = &utf8;
 150         }
 151 #endif
 152         nOut = pVar->n;
 153 #ifdef SQLITE_TRACE_SIZE_LIMIT
 154         if( nOut>SQLITE_TRACE_SIZE_LIMIT ){
 155           nOut = SQLITE_TRACE_SIZE_LIMIT;
 156           while( nOut<pVar->n && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; }
 157         }
 158 #endif
 159         sqlite3XPrintf(&out, "'%.*q'", nOut, pVar->z);
 160 #ifdef SQLITE_TRACE_SIZE_LIMIT
 161         if( nOut<pVar->n ){
 162           sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-nOut);
 163         }
 164 #endif
 165 #ifndef SQLITE_OMIT_UTF16
 166         if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8);
 167 #endif
 168       }else if( pVar->flags & MEM_Zero ){
 169         sqlite3XPrintf(&out, "zeroblob(%d)", pVar->u.nZero);
 170       }else{
 171         int nOut;  /* Number of bytes of the blob to include in output */
 172         assert( pVar->flags & MEM_Blob );
 173         sqlite3StrAccumAppend(&out, "x'", 2);
 174         nOut = pVar->n;
 175 #ifdef SQLITE_TRACE_SIZE_LIMIT
 176         if( nOut>SQLITE_TRACE_SIZE_LIMIT ) nOut = SQLITE_TRACE_SIZE_LIMIT;
 177 #endif
 178         for(i=0; i<nOut; i++){
 179           sqlite3XPrintf(&out, "%02x", pVar->z[i]&0xff);
 180         }
 181         sqlite3StrAccumAppend(&out, "'", 1);
 182 #ifdef SQLITE_TRACE_SIZE_LIMIT
 183         if( nOut<pVar->n ){
 184           sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-nOut);
 185         }
 186 #endif
 187       }
 188     }
 189   }
 190   if( out.accError ) sqlite3StrAccumReset(&out);
 191   return sqlite3StrAccumFinish(&out);
 192 }
 193
 194 #endif /* #ifndef SQLITE_OMIT_TRACE */