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 parameters 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 */ 195