Annotation of embedaddon/sqlite3/src/vdbetrace.c, revision 1.1
1.1 ! misho 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.vdbeExecCnt is 1, then the
! 51: ** string contains a copy of zRawSql but with host parameters expanded to
! 52: ** their current bindings. Or, if sqlite3.vdbeExecCnt is greater than 1,
! 53: ** then the returned string holds a copy of zRawSql with "-- " prepended
! 54: ** to each line of text.
! 55: **
! 56: ** The calling function is responsible for making sure the memory returned
! 57: ** is eventually freed.
! 58: **
! 59: ** ALGORITHM: Scan the input string looking for host parameters in any of
! 60: ** these forms: ?, ?N, $A, @A, :A. Take care to avoid text within
! 61: ** string literals, quoted identifier names, and comments. For text forms,
! 62: ** the host parameter index is found by scanning the perpared
! 63: ** statement for the corresponding OP_Variable opcode. Once the host
! 64: ** parameter index is known, locate the value in p->aVar[]. Then render
! 65: ** the value as a literal in place of the host parameter name.
! 66: */
! 67: char *sqlite3VdbeExpandSql(
! 68: Vdbe *p, /* The prepared statement being evaluated */
! 69: const char *zRawSql /* Raw text of the SQL statement */
! 70: ){
! 71: sqlite3 *db; /* The database connection */
! 72: int idx = 0; /* Index of a host parameter */
! 73: int nextIndex = 1; /* Index of next ? host parameter */
! 74: int n; /* Length of a token prefix */
! 75: int nToken; /* Length of the parameter token */
! 76: int i; /* Loop counter */
! 77: Mem *pVar; /* Value of a host parameter */
! 78: StrAccum out; /* Accumulate the output here */
! 79: char zBase[100]; /* Initial working space */
! 80:
! 81: db = p->db;
! 82: sqlite3StrAccumInit(&out, zBase, sizeof(zBase),
! 83: db->aLimit[SQLITE_LIMIT_LENGTH]);
! 84: out.db = db;
! 85: if( db->vdbeExecCnt>1 ){
! 86: while( *zRawSql ){
! 87: const char *zStart = zRawSql;
! 88: while( *(zRawSql++)!='\n' && *zRawSql );
! 89: sqlite3StrAccumAppend(&out, "-- ", 3);
! 90: sqlite3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart));
! 91: }
! 92: }else{
! 93: while( zRawSql[0] ){
! 94: n = findNextHostParameter(zRawSql, &nToken);
! 95: assert( n>0 );
! 96: sqlite3StrAccumAppend(&out, zRawSql, n);
! 97: zRawSql += n;
! 98: assert( zRawSql[0] || nToken==0 );
! 99: if( nToken==0 ) break;
! 100: if( zRawSql[0]=='?' ){
! 101: if( nToken>1 ){
! 102: assert( sqlite3Isdigit(zRawSql[1]) );
! 103: sqlite3GetInt32(&zRawSql[1], &idx);
! 104: }else{
! 105: idx = nextIndex;
! 106: }
! 107: }else{
! 108: assert( zRawSql[0]==':' || zRawSql[0]=='$' || zRawSql[0]=='@' );
! 109: testcase( zRawSql[0]==':' );
! 110: testcase( zRawSql[0]=='$' );
! 111: testcase( zRawSql[0]=='@' );
! 112: idx = sqlite3VdbeParameterIndex(p, zRawSql, nToken);
! 113: assert( idx>0 );
! 114: }
! 115: zRawSql += nToken;
! 116: nextIndex = idx + 1;
! 117: assert( idx>0 && idx<=p->nVar );
! 118: pVar = &p->aVar[idx-1];
! 119: if( pVar->flags & MEM_Null ){
! 120: sqlite3StrAccumAppend(&out, "NULL", 4);
! 121: }else if( pVar->flags & MEM_Int ){
! 122: sqlite3XPrintf(&out, "%lld", pVar->u.i);
! 123: }else if( pVar->flags & MEM_Real ){
! 124: sqlite3XPrintf(&out, "%!.15g", pVar->r);
! 125: }else if( pVar->flags & MEM_Str ){
! 126: #ifndef SQLITE_OMIT_UTF16
! 127: u8 enc = ENC(db);
! 128: if( enc!=SQLITE_UTF8 ){
! 129: Mem utf8;
! 130: memset(&utf8, 0, sizeof(utf8));
! 131: utf8.db = db;
! 132: sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC);
! 133: sqlite3VdbeChangeEncoding(&utf8, SQLITE_UTF8);
! 134: sqlite3XPrintf(&out, "'%.*q'", utf8.n, utf8.z);
! 135: sqlite3VdbeMemRelease(&utf8);
! 136: }else
! 137: #endif
! 138: {
! 139: sqlite3XPrintf(&out, "'%.*q'", pVar->n, pVar->z);
! 140: }
! 141: }else if( pVar->flags & MEM_Zero ){
! 142: sqlite3XPrintf(&out, "zeroblob(%d)", pVar->u.nZero);
! 143: }else{
! 144: assert( pVar->flags & MEM_Blob );
! 145: sqlite3StrAccumAppend(&out, "x'", 2);
! 146: for(i=0; i<pVar->n; i++){
! 147: sqlite3XPrintf(&out, "%02x", pVar->z[i]&0xff);
! 148: }
! 149: sqlite3StrAccumAppend(&out, "'", 1);
! 150: }
! 151: }
! 152: }
! 153: return sqlite3StrAccumFinish(&out);
! 154: }
! 155:
! 156: #endif /* #ifndef SQLITE_OMIT_TRACE */
! 157:
! 158: /*****************************************************************************
! 159: ** The following code implements the data-structure explaining logic
! 160: ** for the Vdbe.
! 161: */
! 162:
! 163: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
! 164:
! 165: /*
! 166: ** Allocate a new Explain object
! 167: */
! 168: void sqlite3ExplainBegin(Vdbe *pVdbe){
! 169: if( pVdbe ){
! 170: sqlite3BeginBenignMalloc();
! 171: Explain *p = sqlite3_malloc( sizeof(Explain) );
! 172: if( p ){
! 173: memset(p, 0, sizeof(*p));
! 174: p->pVdbe = pVdbe;
! 175: sqlite3_free(pVdbe->pExplain);
! 176: pVdbe->pExplain = p;
! 177: sqlite3StrAccumInit(&p->str, p->zBase, sizeof(p->zBase),
! 178: SQLITE_MAX_LENGTH);
! 179: p->str.useMalloc = 2;
! 180: }else{
! 181: sqlite3EndBenignMalloc();
! 182: }
! 183: }
! 184: }
! 185:
! 186: /*
! 187: ** Return true if the Explain ends with a new-line.
! 188: */
! 189: static int endsWithNL(Explain *p){
! 190: return p && p->str.zText && p->str.nChar
! 191: && p->str.zText[p->str.nChar-1]=='\n';
! 192: }
! 193:
! 194: /*
! 195: ** Append text to the indentation
! 196: */
! 197: void sqlite3ExplainPrintf(Vdbe *pVdbe, const char *zFormat, ...){
! 198: Explain *p;
! 199: if( pVdbe && (p = pVdbe->pExplain)!=0 ){
! 200: va_list ap;
! 201: if( p->nIndent && endsWithNL(p) ){
! 202: int n = p->nIndent;
! 203: if( n>ArraySize(p->aIndent) ) n = ArraySize(p->aIndent);
! 204: sqlite3AppendSpace(&p->str, p->aIndent[n-1]);
! 205: }
! 206: va_start(ap, zFormat);
! 207: sqlite3VXPrintf(&p->str, 1, zFormat, ap);
! 208: va_end(ap);
! 209: }
! 210: }
! 211:
! 212: /*
! 213: ** Append a '\n' if there is not already one.
! 214: */
! 215: void sqlite3ExplainNL(Vdbe *pVdbe){
! 216: Explain *p;
! 217: if( pVdbe && (p = pVdbe->pExplain)!=0 && !endsWithNL(p) ){
! 218: sqlite3StrAccumAppend(&p->str, "\n", 1);
! 219: }
! 220: }
! 221:
! 222: /*
! 223: ** Push a new indentation level. Subsequent lines will be indented
! 224: ** so that they begin at the current cursor position.
! 225: */
! 226: void sqlite3ExplainPush(Vdbe *pVdbe){
! 227: Explain *p;
! 228: if( pVdbe && (p = pVdbe->pExplain)!=0 ){
! 229: if( p->str.zText && p->nIndent<ArraySize(p->aIndent) ){
! 230: const char *z = p->str.zText;
! 231: int i = p->str.nChar-1;
! 232: int x;
! 233: while( i>=0 && z[i]!='\n' ){ i--; }
! 234: x = (p->str.nChar - 1) - i;
! 235: if( p->nIndent && x<p->aIndent[p->nIndent-1] ){
! 236: x = p->aIndent[p->nIndent-1];
! 237: }
! 238: p->aIndent[p->nIndent] = x;
! 239: }
! 240: p->nIndent++;
! 241: }
! 242: }
! 243:
! 244: /*
! 245: ** Pop the indentation stack by one level.
! 246: */
! 247: void sqlite3ExplainPop(Vdbe *p){
! 248: if( p && p->pExplain ) p->pExplain->nIndent--;
! 249: }
! 250:
! 251: /*
! 252: ** Free the indentation structure
! 253: */
! 254: void sqlite3ExplainFinish(Vdbe *pVdbe){
! 255: if( pVdbe && pVdbe->pExplain ){
! 256: sqlite3_free(pVdbe->zExplain);
! 257: sqlite3ExplainNL(pVdbe);
! 258: pVdbe->zExplain = sqlite3StrAccumFinish(&pVdbe->pExplain->str);
! 259: sqlite3_free(pVdbe->pExplain);
! 260: pVdbe->pExplain = 0;
! 261: sqlite3EndBenignMalloc();
! 262: }
! 263: }
! 264:
! 265: /*
! 266: ** Return the explanation of a virtual machine.
! 267: */
! 268: const char *sqlite3VdbeExplanation(Vdbe *pVdbe){
! 269: return (pVdbe && pVdbe->zExplain) ? pVdbe->zExplain : 0;
! 270: }
! 271: #endif /* defined(SQLITE_DEBUG) */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to vdbetrace.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src