| OLD | NEW |
|---|
| (Empty) |
| 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, 0, "%lld", pVar->u.i); | |
| 132 }else if( pVar->flags & MEM_Real ){ | |
| 133 sqlite3XPrintf(&out, 0, "%!.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, 0, "'%.*q'", nOut, pVar->z); | |
| 155 #ifdef SQLITE_TRACE_SIZE_LIMIT | |
| 156 if( nOut<pVar->n ){ | |
| 157 sqlite3XPrintf(&out, 0, "/*+%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, 0, "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, 0, "%02x", pVar->z[i]&0xff); | |
| 175 } | |
| 176 sqlite3StrAccumAppend(&out, "'", 1); | |
| 177 #ifdef SQLITE_TRACE_SIZE_LIMIT | |
| 178 if( nOut<pVar->n ){ | |
| 179 sqlite3XPrintf(&out, 0, "/*+%d bytes*/", pVar->n-nOut); | |
| 180 } | |
| 181 #endif | |
| 182 } | |
| 183 } | |
| 184 } | |
| 185 return sqlite3StrAccumFinish(&out); | |
| 186 } | |
| 187 | |
| 188 #endif /* #ifndef SQLITE_OMIT_TRACE */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2846743003:
[sql] Remove SQLite 3.10.2 reference directory. (Closed)
