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 char zBase[100]; /* Initial working space */ 85 86 db = p->db; 87 sqlite3StrAccumInit(&out, db, zBase, sizeof(zBase), 88 db->aLimit[SQLITE_LIMIT_LENGTH]); 89 if( db->nVdbeExec>1 ){ 90 while( *zRawSql ){ 91 const char *zStart = zRawSql; 92 while( *(zRawSql++)!='\n' && *zRawSql ); 93 sqlite3StrAccumAppend(&out, "-- ", 3); 94 assert( (zRawSql - zStart) > 0 ); 95 sqlite3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart)); 96 } 97 }else if( p->nVar==0 ){ 98 sqlite3StrAccumAppend(&out, zRawSql, sqlite3Strlen30(zRawSql)); 99 }else{ 100 while( zRawSql[0] ){ 101 n = findNextHostParameter(zRawSql, &nToken); 102 assert( n>0 ); 103 sqlite3StrAccumAppend(&out, zRawSql, n); 104 zRawSql += n; 105 assert( zRawSql[0] || nToken==0 ); 106 if( nToken==0 ) break; 107 if( zRawSql[0]=='?' ){ 108 if( nToken>1 ){ 109 assert( sqlite3Isdigit(zRawSql[1]) ); 110 sqlite3GetInt32(&zRawSql[1], &idx); 111 }else{ 112 idx = nextIndex; 113 } 114 }else{ 115 assert( zRawSql[0]==':' || zRawSql[0]=='$' || 116 zRawSql[0]=='@' || zRawSql[0]=='#' ); 117 testcase( zRawSql[0]==':' ); 118 testcase( zRawSql[0]=='$' ); 119 testcase( zRawSql[0]=='@' ); 120 testcase( zRawSql[0]=='#' ); 121 idx = sqlite3VdbeParameterIndex(p, zRawSql, nToken); 122 assert( idx>0 ); 123 } 124 zRawSql += nToken; 125 nextIndex = idx + 1; 126 assert( idx>0 && idx<=p->nVar ); 127 pVar = &p->aVar[idx-1]; 128 if( pVar->flags & MEM_Null ){ 129 sqlite3StrAccumAppend(&out, "NULL", 4); 130 }else if( pVar->flags & MEM_Int ){ 131 sqlite3XPrintf(&out, "%lld", pVar->u.i); 132 }else if( pVar->flags & MEM_Real ){ 133 sqlite3XPrintf(&out, "%!.15g", pVar->u.r); 134 }else if( pVar->flags & MEM_Str ){ 135 int nOut; /* Number of bytes of the string text to include in output */ 136 #ifndef SQLITE_OMIT_UTF16 137 u8 enc = ENC(db); 138 Mem utf8; 139 if( enc!=SQLITE_UTF8 ){ 140 memset(&utf8, 0, sizeof(utf8)); 141 utf8.db = db; 142 sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC); 143 sqlite3VdbeChangeEncoding(&utf8, SQLITE_UTF8); 144 pVar = &utf8; 145 } 146 #endif 147 nOut = pVar->n; 148 #ifdef SQLITE_TRACE_SIZE_LIMIT 149 if( nOut>SQLITE_TRACE_SIZE_LIMIT ){ 150 nOut = SQLITE_TRACE_SIZE_LIMIT; 151 while( nOut<pVar->n && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; } 152 } 153 #endif 154 sqlite3XPrintf(&out, "'%.*q'", nOut, pVar->z); 155 #ifdef SQLITE_TRACE_SIZE_LIMIT 156 if( nOut<pVar->n ){ 157 sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-nOut); 158 } 159 #endif 160 #ifndef SQLITE_OMIT_UTF16 161 if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8); 162 #endif 163 }else if( pVar->flags & MEM_Zero ){ 164 sqlite3XPrintf(&out, "zeroblob(%d)", pVar->u.nZero); 165 }else{ 166 int nOut; /* Number of bytes of the blob to include in output */ 167 assert( pVar->flags & MEM_Blob ); 168 sqlite3StrAccumAppend(&out, "x'", 2); 169 nOut = pVar->n; 170 #ifdef SQLITE_TRACE_SIZE_LIMIT 171 if( nOut>SQLITE_TRACE_SIZE_LIMIT ) nOut = SQLITE_TRACE_SIZE_LIMIT; 172 #endif 173 for(i=0; i<nOut; i++){ 174 sqlite3XPrintf(&out, "%02x", pVar->z[i]&0xff); 175 } 176 sqlite3StrAccumAppend(&out, "'", 1); 177 #ifdef SQLITE_TRACE_SIZE_LIMIT 178 if( nOut<pVar->n ){ 179 sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-nOut); 180 } 181 #endif 182 } 183 } 184 } 185 return sqlite3StrAccumFinish(&out); 186 } 187 188 #endif /* #ifndef SQLITE_OMIT_TRACE */ 189