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