1 /*

     2 ** 2004 May 26

     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 use to implement APIs that are part of the

    14 ** VDBE.

    15 **

    16 ** $Id: vdbeapi.c,v 1.141 2008/09/04 12:03:43 shane Exp $

    17 */

    18 #include "sqliteInt.h"

    19 #include "vdbeInt.h"

    20 

    21 #if 0 && defined(SQLITE_ENABLE_MEMORY_MANAGEMENT)

    22 /*

    23 ** The following structure contains pointers to the end points of a

    24 ** doubly-linked list of all compiled SQL statements that may be holding

    25 ** buffers eligible for release when the sqlite3_release_memory() interface is

    26 ** invoked. Access to this list is protected by the SQLITE_MUTEX_STATIC_LRU2

    27 ** mutex.

    28 **

    29 ** Statements are added to the end of this list when sqlite3_reset() is

    30 ** called. They are removed either when sqlite3_step() or sqlite3_finalize()

    31 ** is called. When statements are added to this list, the associated 

    32 ** register array (p->aMem[1..p->nMem]) may contain dynamic buffers that

    33 ** can be freed using sqlite3VdbeReleaseMemory().

    34 **

    35 ** When statements are added or removed from this list, the mutex

    36 ** associated with the Vdbe being added or removed (Vdbe.db->mutex) is

    37 ** already held. The LRU2 mutex is then obtained, blocking if necessary,

    38 ** the linked-list pointers manipulated and the LRU2 mutex relinquished.

    39 */

    40 struct StatementLruList {

    41   Vdbe *pFirst;

    42   Vdbe *pLast;

    43 };

    44 static struct StatementLruList sqlite3LruStatements;

    45 

    46 /*

    47 ** Check that the list looks to be internally consistent. This is used

    48 ** as part of an assert() statement as follows:

    49 **

    50 **   assert( stmtLruCheck() );

    51 */

    52 #ifndef NDEBUG

    53 static int stmtLruCheck(){

    54   Vdbe *p;

    55   for(p=sqlite3LruStatements.pFirst; p; p=p->pLruNext){

    56     assert(p->pLruNext || p==sqlite3LruStatements.pLast);

    57     assert(!p->pLruNext || p->pLruNext->pLruPrev==p);

    58     assert(p->pLruPrev || p==sqlite3LruStatements.pFirst);

    59     assert(!p->pLruPrev || p->pLruPrev->pLruNext==p);

    60   }

    61   return 1;

    62 }

    63 #endif

    64 

    65 /*

    66 ** Add vdbe p to the end of the statement lru list. It is assumed that

    67 ** p is not already part of the list when this is called. The lru list

    68 ** is protected by the SQLITE_MUTEX_STATIC_LRU mutex.

    69 */

    70 static void stmtLruAdd(Vdbe *p){

    71   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

    72 

    73   if( p->pLruPrev || p->pLruNext || sqlite3LruStatements.pFirst==p ){

    74     sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

    75     return;

    76   }

    77 

    78   assert( stmtLruCheck() );

    79 

    80   if( !sqlite3LruStatements.pFirst ){

    81     assert( !sqlite3LruStatements.pLast );

    82     sqlite3LruStatements.pFirst = p;

    83     sqlite3LruStatements.pLast = p;

    84   }else{

    85     assert( !sqlite3LruStatements.pLast->pLruNext );

    86     p->pLruPrev = sqlite3LruStatements.pLast;

    87     sqlite3LruStatements.pLast->pLruNext = p;

    88     sqlite3LruStatements.pLast = p;

    89   }

    90 

    91   assert( stmtLruCheck() );

    92 

    93   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

    94 }

    95 

    96 /*

    97 ** Assuming the SQLITE_MUTEX_STATIC_LRU2 mutext is already held, remove

    98 ** statement p from the least-recently-used statement list. If the 

    99 ** statement is not currently part of the list, this call is a no-op.

   100 */

   101 static void stmtLruRemoveNomutex(Vdbe *p){

   102   if( p->pLruPrev || p->pLruNext || p==sqlite3LruStatements.pFirst ){

   103     assert( stmtLruCheck() );

   104     if( p->pLruNext ){

   105       p->pLruNext->pLruPrev = p->pLruPrev;

   106     }else{

   107       sqlite3LruStatements.pLast = p->pLruPrev;

   108     }

   109     if( p->pLruPrev ){

   110       p->pLruPrev->pLruNext = p->pLruNext;

   111     }else{

   112       sqlite3LruStatements.pFirst = p->pLruNext;

   113     }

   114     p->pLruNext = 0;

   115     p->pLruPrev = 0;

   116     assert( stmtLruCheck() );

   117   }

   118 }

   119 

   120 /*

   121 ** Assuming the SQLITE_MUTEX_STATIC_LRU2 mutext is not held, remove

   122 ** statement p from the least-recently-used statement list. If the 

   123 ** statement is not currently part of the list, this call is a no-op.

   124 */

   125 static void stmtLruRemove(Vdbe *p){

   126   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

   127   stmtLruRemoveNomutex(p);

   128   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

   129 }

   130 

   131 /*

   132 ** Try to release n bytes of memory by freeing buffers associated 

   133 ** with the memory registers of currently unused vdbes.

   134 */

   135 int sqlite3VdbeReleaseMemory(int n){

   136   Vdbe *p;

   137   Vdbe *pNext;

   138   int nFree = 0;

   139 

   140   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

   141   for(p=sqlite3LruStatements.pFirst; p && nFree<n; p=pNext){

   142     pNext = p->pLruNext;

   143 

   144     /* For each statement handle in the lru list, attempt to obtain the

   145     ** associated database mutex. If it cannot be obtained, continue

   146     ** to the next statement handle. It is not possible to block on

   147     ** the database mutex - that could cause deadlock.

   148     */

   149     if( SQLITE_OK==sqlite3_mutex_try(p->db->mutex) ){

   150       nFree += sqlite3VdbeReleaseBuffers(p);

   151       stmtLruRemoveNomutex(p);

   152       sqlite3_mutex_leave(p->db->mutex);

   153     }

   154   }

   155   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

   156 

   157   return nFree;

   158 }

   159 

   160 /*

   161 ** Call sqlite3Reprepare() on the statement. Remove it from the

   162 ** lru list before doing so, as Reprepare() will free all the

   163 ** memory register buffers anyway.

   164 */

   165 int vdbeReprepare(Vdbe *p){

   166   stmtLruRemove(p);

   167   return sqlite3Reprepare(p);

   168 }

   169 

   170 #else       /* !SQLITE_ENABLE_MEMORY_MANAGEMENT */

   171   #define stmtLruRemove(x)

   172   #define stmtLruAdd(x)

   173   #define vdbeReprepare(x) sqlite3Reprepare(x)

   174 #endif

   175 

   176 

   177 /*

   178 ** Return TRUE (non-zero) of the statement supplied as an argument needs

   179 ** to be recompiled.  A statement needs to be recompiled whenever the

   180 ** execution environment changes in a way that would alter the program

   181 ** that sqlite3_prepare() generates.  For example, if new functions or

   182 ** collating sequences are registered or if an authorizer function is

   183 ** added or changed.

   184 */

   185 SQLITE_EXPORT int sqlite3_expired(sqlite3_stmt *pStmt){

   186   Vdbe *p = (Vdbe*)pStmt;

   187   return p==0 || p->expired;

   188 }

   189 

   190 /*

   191 ** The following routine destroys a virtual machine that is created by

   192 ** the sqlite3_compile() routine. The integer returned is an SQLITE_

   193 ** success/failure code that describes the result of executing the virtual

   194 ** machine.

   195 **

   196 ** This routine sets the error code and string returned by

   197 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().

   198 */

   199 SQLITE_EXPORT int sqlite3_finalize(sqlite3_stmt *pStmt){

   200   int rc;

   201   if( pStmt==0 ){

   202     rc = SQLITE_OK;

   203   }else{

   204     Vdbe *v = (Vdbe*)pStmt;

   205 #ifndef SQLITE_MUTEX_NOOP

   206     sqlite3_mutex *mutex = v->db->mutex;

   207 #endif

   208     sqlite3_mutex_enter(mutex);

   209     stmtLruRemove(v);

   210     rc = sqlite3VdbeFinalize(v);

   211     sqlite3_mutex_leave(mutex);

   212   }

   213   return rc;

   214 }

   215 

   216 /*

   217 ** Terminate the current execution of an SQL statement and reset it

   218 ** back to its starting state so that it can be reused. A success code from

   219 ** the prior execution is returned.

   220 **

   221 ** This routine sets the error code and string returned by

   222 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().

   223 */

   224 SQLITE_EXPORT int sqlite3_reset(sqlite3_stmt *pStmt){

   225   int rc;

   226   if( pStmt==0 ){

   227     rc = SQLITE_OK;

   228   }else{

   229     Vdbe *v = (Vdbe*)pStmt;

   230     sqlite3_mutex_enter(v->db->mutex);

   231     rc = sqlite3VdbeReset(v);

   232     stmtLruAdd(v);

   233     sqlite3VdbeMakeReady(v, -1, 0, 0, 0);

   234     assert( (rc & (v->db->errMask))==rc );

   235     sqlite3_mutex_leave(v->db->mutex);

   236   }

   237   return rc;

   238 }

   239 

   240 /*

   241 ** Set all the parameters in the compiled SQL statement to NULL.

   242 */

   243 SQLITE_EXPORT int sqlite3_clear_bindings(sqlite3_stmt *pStmt){

   244   int i;

   245   int rc = SQLITE_OK;

   246   Vdbe *p = (Vdbe*)pStmt;

   247 #ifndef SQLITE_MUTEX_NOOP

   248   sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;

   249 #endif

   250   sqlite3_mutex_enter(mutex);

   251   for(i=0; i<p->nVar; i++){

   252     sqlite3VdbeMemRelease(&p->aVar[i]);

   253     p->aVar[i].flags = MEM_Null;

   254   }

   255   sqlite3_mutex_leave(mutex);

   256   return rc;

   257 }

   258 

   259 

   260 /**************************** sqlite3_value_  *******************************

   261 ** The following routines extract information from a Mem or sqlite3_value

   262 ** structure.

   263 */

   264 SQLITE_EXPORT const void *sqlite3_value_blob(sqlite3_value *pVal){

   265   Mem *p = (Mem*)pVal;

   266   if( p->flags & (MEM_Blob|MEM_Str) ){

   267     sqlite3VdbeMemExpandBlob(p);

   268     p->flags &= ~MEM_Str;

   269     p->flags |= MEM_Blob;

   270     return p->z;

   271   }else{

   272     return sqlite3_value_text(pVal);

   273   }

   274 }

   275 SQLITE_EXPORT int sqlite3_value_bytes(sqlite3_value *pVal){

   276   return sqlite3ValueBytes(pVal, SQLITE_UTF8);

   277 }

   278 SQLITE_EXPORT int sqlite3_value_bytes16(sqlite3_value *pVal){

   279   return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);

   280 }

   281 SQLITE_EXPORT double sqlite3_value_double(sqlite3_value *pVal){

   282   return sqlite3VdbeRealValue((Mem*)pVal);

   283 }

   284 SQLITE_EXPORT int sqlite3_value_int(sqlite3_value *pVal){

   285   return sqlite3VdbeIntValue((Mem*)pVal);

   286 }

   287 SQLITE_EXPORT sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){

   288   return sqlite3VdbeIntValue((Mem*)pVal);

   289 }

   290 SQLITE_EXPORT const unsigned char *sqlite3_value_text(sqlite3_value *pVal){

   291   return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);

   292 }

   293 #ifndef SQLITE_OMIT_UTF16

   294 SQLITE_EXPORT const void *sqlite3_value_text16(sqlite3_value* pVal){

   295   return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);

   296 }

   297 SQLITE_EXPORT const void *sqlite3_value_text16be(sqlite3_value *pVal){

   298   return sqlite3ValueText(pVal, SQLITE_UTF16BE);

   299 }

   300 SQLITE_EXPORT const void *sqlite3_value_text16le(sqlite3_value *pVal){

   301   return sqlite3ValueText(pVal, SQLITE_UTF16LE);

   302 }

   303 #endif /* SQLITE_OMIT_UTF16 */

   304 SQLITE_EXPORT int sqlite3_value_type(sqlite3_value* pVal){

   305   return pVal->type;

   306 }

   307 

   308 /**************************** sqlite3_result_  *******************************

   309 ** The following routines are used by user-defined functions to specify

   310 ** the function result.

   311 */

   312 SQLITE_EXPORT void sqlite3_result_blob(

   313   sqlite3_context *pCtx, 

   314   const void *z, 

   315   int n, 

   316   void (*xDel)(void *)

   317 ){

   318   assert( n>=0 );

   319   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   320   sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, xDel);

   321 }

   322 SQLITE_EXPORT void sqlite3_result_double(sqlite3_context *pCtx, double rVal){

   323   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   324   sqlite3VdbeMemSetDouble(&pCtx->s, rVal);

   325 }

   326 SQLITE_EXPORT void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){

   327   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   328   pCtx->isError = SQLITE_ERROR;

   329   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);

   330 }

   331 #ifndef SQLITE_OMIT_UTF16

   332 SQLITE_EXPORT void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){

   333   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   334   pCtx->isError = SQLITE_ERROR;

   335   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);

   336 }

   337 #endif

   338 SQLITE_EXPORT void sqlite3_result_int(sqlite3_context *pCtx, int iVal){

   339   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   340   sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);

   341 }

   342 SQLITE_EXPORT void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){

   343   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   344   sqlite3VdbeMemSetInt64(&pCtx->s, iVal);

   345 }

   346 SQLITE_EXPORT void sqlite3_result_null(sqlite3_context *pCtx){

   347   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   348   sqlite3VdbeMemSetNull(&pCtx->s);

   349 }

   350 SQLITE_EXPORT void sqlite3_result_text(

   351   sqlite3_context *pCtx, 

   352   const char *z, 

   353   int n,

   354   void (*xDel)(void *)

   355 ){

   356   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   357   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, xDel);

   358 }

   359 #ifndef SQLITE_OMIT_UTF16

   360 SQLITE_EXPORT void sqlite3_result_text16(

   361   sqlite3_context *pCtx, 

   362   const void *z, 

   363   int n, 

   364   void (*xDel)(void *)

   365 ){

   366   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   367   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel);

   368 }

   369 SQLITE_EXPORT void sqlite3_result_text16be(

   370   sqlite3_context *pCtx, 

   371   const void *z, 

   372   int n, 

   373   void (*xDel)(void *)

   374 ){

   375   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   376   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16BE, xDel);

   377 }

   378 SQLITE_EXPORT void sqlite3_result_text16le(

   379   sqlite3_context *pCtx, 

   380   const void *z, 

   381   int n, 

   382   void (*xDel)(void *)

   383 ){

   384   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   385   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel);

   386 }

   387 #endif /* SQLITE_OMIT_UTF16 */

   388 SQLITE_EXPORT void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){

   389   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   390   sqlite3VdbeMemCopy(&pCtx->s, pValue);

   391 }

   392 SQLITE_EXPORT void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){

   393   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   394   sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);

   395 }

   396 SQLITE_EXPORT void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){

   397   pCtx->isError = errCode;

   398 }

   399 

   400 /* Force an SQLITE_TOOBIG error. */

   401 SQLITE_EXPORT void sqlite3_result_error_toobig(sqlite3_context *pCtx){

   402   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   403   pCtx->isError = SQLITE_TOOBIG;

   404   sqlite3VdbeMemSetStr(&pCtx->s, "string or blob too big", -1, 

   405                        SQLITE_UTF8, SQLITE_STATIC);

   406 }

   407 

   408 /* An SQLITE_NOMEM error. */

   409 SQLITE_EXPORT void sqlite3_result_error_nomem(sqlite3_context *pCtx){

   410   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   411   sqlite3VdbeMemSetNull(&pCtx->s);

   412   pCtx->isError = SQLITE_NOMEM;

   413   pCtx->s.db->mallocFailed = 1;

   414 }

   415 

   416 /*

   417 ** Execute the statement pStmt, either until a row of data is ready, the

   418 ** statement is completely executed or an error occurs.

   419 **

   420 ** This routine implements the bulk of the logic behind the sqlite_step()

   421 ** API.  The only thing omitted is the automatic recompile if a 

   422 ** schema change has occurred.  That detail is handled by the

   423 ** outer sqlite3_step() wrapper procedure.

   424 */

   425 static int sqlite3Step(Vdbe *p){

   426   sqlite3 *db;

   427   int rc;

   428 

   429   assert(p);

   430   if( p->magic!=VDBE_MAGIC_RUN ){

   431     return SQLITE_MISUSE;

   432   }

   433 

   434   /* Assert that malloc() has not failed */

   435   db = p->db;

   436   if( db->mallocFailed ){

   437     return SQLITE_NOMEM;

   438   }

   439 

   440   if( p->pc<=0 && p->expired ){

   441     if( p->rc==SQLITE_OK ){

   442       p->rc = SQLITE_SCHEMA;

   443     }

   444     rc = SQLITE_ERROR;

   445     goto end_of_step;

   446   }

   447   if( sqlite3SafetyOn(db) ){

   448     p->rc = SQLITE_MISUSE;

   449     return SQLITE_MISUSE;

   450   }

   451   if( p->pc<0 ){

   452     /* If there are no other statements currently running, then

   453     ** reset the interrupt flag.  This prevents a call to sqlite3_interrupt

   454     ** from interrupting a statement that has not yet started.

   455     */

   456     if( db->activeVdbeCnt==0 ){

   457       db->u1.isInterrupted = 0;

   458     }

   459 

   460 #ifndef SQLITE_OMIT_TRACE

   461     if( db->xProfile && !db->init.busy ){

   462       double rNow;

   463       sqlite3OsCurrentTime(db->pVfs, &rNow);

   464       p->startTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0;

   465     }

   466 #endif

   467 

   468     db->activeVdbeCnt++;

   469     p->pc = 0;

   470     stmtLruRemove(p);

   471   }

   472 #ifndef SQLITE_OMIT_EXPLAIN

   473   if( p->explain ){

   474     rc = sqlite3VdbeList(p);

   475   }else

   476 #endif /* SQLITE_OMIT_EXPLAIN */

   477   {

   478     rc = sqlite3VdbeExec(p);

   479   }

   480 

   481   if( sqlite3SafetyOff(db) ){

   482     rc = SQLITE_MISUSE;

   483   }

   484 

   485 #ifndef SQLITE_OMIT_TRACE

   486   /* Invoke the profile callback if there is one

   487   */

   488   if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->nOp>0

   489            && p->aOp[0].opcode==OP_Trace && p->aOp[0].p4.z!=0 ){

   490     double rNow;

   491     u64 elapseTime;

   492 

   493     sqlite3OsCurrentTime(db->pVfs, &rNow);

   494     elapseTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0 - p->startTime;

   495     db->xProfile(db->pProfileArg, p->aOp[0].p4.z, elapseTime);

   496   }

   497 #endif

   498 

   499   db->errCode = rc;

   500   /*sqlite3Error(p->db, rc, 0);*/

   501   p->rc = sqlite3ApiExit(p->db, p->rc);

   502 end_of_step:

   503   assert( (rc&0xff)==rc );

   504   if( p->zSql && (rc&0xff)<SQLITE_ROW ){

   505     /* This behavior occurs if sqlite3_prepare_v2() was used to build

   506     ** the prepared statement.  Return error codes directly */

   507     p->db->errCode = p->rc;

   508     /* sqlite3Error(p->db, p->rc, 0); */

   509     return p->rc;

   510   }else{

   511     /* This is for legacy sqlite3_prepare() builds and when the code

   512     ** is SQLITE_ROW or SQLITE_DONE */

   513     return rc;

   514   }

   515 }

   516 

   517 /*

   518 ** This is the top-level implementation of sqlite3_step().  Call

   519 ** sqlite3Step() to do most of the work.  If a schema error occurs,

   520 ** call sqlite3Reprepare() and try again.

   521 */

   522 #ifdef SQLITE_OMIT_PARSER

   523 int sqlite3_step(sqlite3_stmt *pStmt){

   524   int rc = SQLITE_MISUSE;

   525   if( pStmt ){

   526     Vdbe *v;

   527     v = (Vdbe*)pStmt;

   528     sqlite3_mutex_enter(v->db->mutex);

   529     rc = sqlite3Step(v);

   530     sqlite3_mutex_leave(v->db->mutex);

   531   }

   532   return rc;

   533 }

   534 #else

   535 SQLITE_EXPORT int sqlite3_step(sqlite3_stmt *pStmt){

   536   int rc = SQLITE_MISUSE;

   537   if( pStmt ){

   538     int cnt = 0;

   539     Vdbe *v = (Vdbe*)pStmt;

   540     sqlite3 *db = v->db;

   541     sqlite3_mutex_enter(db->mutex);

   542     while( (rc = sqlite3Step(v))==SQLITE_SCHEMA

   543            && cnt++ < 5

   544            && vdbeReprepare(v) ){

   545       sqlite3_reset(pStmt);

   546       v->expired = 0;

   547     }

   548     if( rc==SQLITE_SCHEMA && v->zSql && db->pErr ){

   549       /* This case occurs after failing to recompile an sql statement. 

   550       ** The error message from the SQL compiler has already been loaded 

   551       ** into the database handle. This block copies the error message 

   552       ** from the database handle into the statement and sets the statement

   553       ** program counter to 0 to ensure that when the statement is 

   554       ** finalized or reset the parser error message is available via

   555       ** sqlite3_errmsg() and sqlite3_errcode().

   556       */

   557       const char *zErr = (const char *)sqlite3_value_text(db->pErr); 

   558       sqlite3DbFree(db, v->zErrMsg);

   559       if( !db->mallocFailed ){

   560         v->zErrMsg = sqlite3DbStrDup(db, zErr);

   561       } else {

   562         v->zErrMsg = 0;

   563         v->rc = SQLITE_NOMEM;

   564       }

   565     }

   566     rc = sqlite3ApiExit(db, rc);

   567     sqlite3_mutex_leave(db->mutex);

   568   }

   569   return rc;

   570 }

   571 #endif

   572 

   573 /*

   574 ** Extract the user data from a sqlite3_context structure and return a

   575 ** pointer to it.

   576 */

   577 SQLITE_EXPORT void *sqlite3_user_data(sqlite3_context *p){

   578   assert( p && p->pFunc );

   579   return p->pFunc->pUserData;

   580 }

   581 

   582 /*

   583 ** Extract the user data from a sqlite3_context structure and return a

   584 ** pointer to it.

   585 */

   586 SQLITE_EXPORT sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){

   587   assert( p && p->pFunc );

   588   return p->s.db;

   589 }

   590 

   591 /*

   592 ** The following is the implementation of an SQL function that always

   593 ** fails with an error message stating that the function is used in the

   594 ** wrong context.  The sqlite3_overload_function() API might construct

   595 ** SQL function that use this routine so that the functions will exist

   596 ** for name resolution but are actually overloaded by the xFindFunction

   597 ** method of virtual tables.

   598 */

   599 void sqlite3InvalidFunction(

   600   sqlite3_context *context,  /* The function calling context */

   601   int argc,                  /* Number of arguments to the function */

   602   sqlite3_value **argv       /* Value of each argument */

   603 ){

   604   const char *zName = context->pFunc->zName;

   605   char *zErr;

   606   zErr = sqlite3MPrintf(0,

   607       "unable to use function %s in the requested context", zName);

   608   sqlite3_result_error(context, zErr, -1);

   609   sqlite3_free(zErr);

   610 }

   611 

   612 /*

   613 ** Allocate or return the aggregate context for a user function.  A new

   614 ** context is allocated on the first call.  Subsequent calls return the

   615 ** same context that was returned on prior calls.

   616 */

   617 SQLITE_EXPORT void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){

   618   Mem *pMem;

   619   assert( p && p->pFunc && p->pFunc->xStep );

   620   assert( sqlite3_mutex_held(p->s.db->mutex) );

   621   pMem = p->pMem;

   622   if( (pMem->flags & MEM_Agg)==0 ){

   623     if( nByte==0 ){

   624       sqlite3VdbeMemReleaseExternal(pMem);

   625       pMem->flags = MEM_Null;

   626       pMem->z = 0;

   627     }else{

   628       sqlite3VdbeMemGrow(pMem, nByte, 0);

   629       pMem->flags = MEM_Agg;

   630       pMem->u.pDef = p->pFunc;

   631       if( pMem->z ){

   632         memset(pMem->z, 0, nByte);

   633       }

   634     }

   635   }

   636   return (void*)pMem->z;

   637 }

   638 

   639 /*

   640 ** Return the auxilary data pointer, if any, for the iArg'th argument to

   641 ** the user-function defined by pCtx.

   642 */

   643 SQLITE_EXPORT void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){

   644   VdbeFunc *pVdbeFunc;

   645 

   646   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   647   pVdbeFunc = pCtx->pVdbeFunc;

   648   if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){

   649     return 0;

   650   }

   651   return pVdbeFunc->apAux[iArg].pAux;

   652 }

   653 

   654 /*

   655 ** Set the auxilary data pointer and delete function, for the iArg'th

   656 ** argument to the user-function defined by pCtx. Any previous value is

   657 ** deleted by calling the delete function specified when it was set.

   658 */

   659 SQLITE_EXPORT void sqlite3_set_auxdata(

   660   sqlite3_context *pCtx, 

   661   int iArg, 

   662   void *pAux, 

   663   void (*xDelete)(void*)

   664 ){

   665   struct AuxData *pAuxData;

   666   VdbeFunc *pVdbeFunc;

   667   if( iArg<0 ) goto failed;

   668 

   669   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   670   pVdbeFunc = pCtx->pVdbeFunc;

   671   if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){

   672     int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);

   673     int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;

   674     pVdbeFunc = sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);

   675     if( !pVdbeFunc ){

   676       goto failed;

   677     }

   678     pCtx->pVdbeFunc = pVdbeFunc;

   679     memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));

   680     pVdbeFunc->nAux = iArg+1;

   681     pVdbeFunc->pFunc = pCtx->pFunc;

   682   }

   683 

   684   pAuxData = &pVdbeFunc->apAux[iArg];

   685   if( pAuxData->pAux && pAuxData->xDelete ){

   686     pAuxData->xDelete(pAuxData->pAux);

   687   }

   688   pAuxData->pAux = pAux;

   689   pAuxData->xDelete = xDelete;

   690   return;

   691 

   692 failed:

   693   if( xDelete ){

   694     xDelete(pAux);

   695   }

   696 }

   697 

   698 /*

   699 ** Return the number of times the Step function of a aggregate has been 

   700 ** called.

   701 **

   702 ** This function is deprecated.  Do not use it for new code.  It is

   703 ** provide only to avoid breaking legacy code.  New aggregate function

   704 ** implementations should keep their own counts within their aggregate

   705 ** context.

   706 */

   707 SQLITE_EXPORT int sqlite3_aggregate_count(sqlite3_context *p){

   708   assert( p && p->pFunc && p->pFunc->xStep );

   709   return p->pMem->n;

   710 }

   711 

   712 /*

   713 ** Return the number of columns in the result set for the statement pStmt.

   714 */

   715 SQLITE_EXPORT int sqlite3_column_count(sqlite3_stmt *pStmt){

   716   Vdbe *pVm = (Vdbe *)pStmt;

   717   return pVm ? pVm->nResColumn : 0;

   718 }

   719 

   720 /*

   721 ** Return the number of values available from the current row of the

   722 ** currently executing statement pStmt.

   723 */

   724 SQLITE_EXPORT int sqlite3_data_count(sqlite3_stmt *pStmt){

   725   Vdbe *pVm = (Vdbe *)pStmt;

   726   if( pVm==0 || pVm->pResultSet==0 ) return 0;

   727   return pVm->nResColumn;

   728 }

   729 

   730 

   731 /*

   732 ** Check to see if column iCol of the given statement is valid.  If

   733 ** it is, return a pointer to the Mem for the value of that column.

   734 ** If iCol is not valid, return a pointer to a Mem which has a value

   735 ** of NULL.

   736 */

   737 static Mem *columnMem(sqlite3_stmt *pStmt, int i){

   738   Vdbe *pVm;

   739   int vals;

   740   Mem *pOut;

   741 

   742   pVm = (Vdbe *)pStmt;

   743   if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){

   744     sqlite3_mutex_enter(pVm->db->mutex);

   745     vals = sqlite3_data_count(pStmt);

   746     pOut = &pVm->pResultSet[i];

   747   }else{

   748     static const Mem nullMem = {{0}, 0.0, 0, "", 0, MEM_Null, SQLITE_NULL, 0, 0, 0 };

   749     if( pVm->db ){

   750       sqlite3_mutex_enter(pVm->db->mutex);

   751       sqlite3Error(pVm->db, SQLITE_RANGE, 0);

   752     }

   753     pOut = (Mem*)&nullMem;

   754   }

   755   return pOut;

   756 }

   757 

   758 /*

   759 ** This function is called after invoking an sqlite3_value_XXX function on a 

   760 ** column value (i.e. a value returned by evaluating an SQL expression in the

   761 ** select list of a SELECT statement) that may cause a malloc() failure. If 

   762 ** malloc() has failed, the threads mallocFailed flag is cleared and the result

   763 ** code of statement pStmt set to SQLITE_NOMEM.

   764 **

   765 ** Specifically, this is called from within:

   766 **

   767 **     sqlite3_column_int()

   768 **     sqlite3_column_int64()

   769 **     sqlite3_column_text()

   770 **     sqlite3_column_text16()

   771 **     sqlite3_column_real()

   772 **     sqlite3_column_bytes()

   773 **     sqlite3_column_bytes16()

   774 **

   775 ** But not for sqlite3_column_blob(), which never calls malloc().

   776 */

   777 static void columnMallocFailure(sqlite3_stmt *pStmt)

   778 {

   779   /* If malloc() failed during an encoding conversion within an

   780   ** sqlite3_column_XXX API, then set the return code of the statement to

   781   ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR

   782   ** and _finalize() will return NOMEM.

   783   */

   784   Vdbe *p = (Vdbe *)pStmt;

   785   if( p ){

   786     p->rc = sqlite3ApiExit(p->db, p->rc);

   787     sqlite3_mutex_leave(p->db->mutex);

   788   }

   789 }

   790 

   791 /**************************** sqlite3_column_  *******************************

   792 ** The following routines are used to access elements of the current row

   793 ** in the result set.

   794 */

   795 SQLITE_EXPORT const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){

   796   const void *val;

   797   val = sqlite3_value_blob( columnMem(pStmt,i) );

   798   /* Even though there is no encoding conversion, value_blob() might

   799   ** need to call malloc() to expand the result of a zeroblob() 

   800   ** expression. 

   801   */

   802   columnMallocFailure(pStmt);

   803   return val;

   804 }

   805 SQLITE_EXPORT int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){

   806   int val = sqlite3_value_bytes( columnMem(pStmt,i) );

   807   columnMallocFailure(pStmt);

   808   return val;

   809 }

   810 SQLITE_EXPORT int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){

   811   int val = sqlite3_value_bytes16( columnMem(pStmt,i) );

   812   columnMallocFailure(pStmt);

   813   return val;

   814 }

   815 SQLITE_EXPORT double sqlite3_column_double(sqlite3_stmt *pStmt, int i){

   816   double val = sqlite3_value_double( columnMem(pStmt,i) );

   817   columnMallocFailure(pStmt);

   818   return val;

   819 }

   820 SQLITE_EXPORT int sqlite3_column_int(sqlite3_stmt *pStmt, int i){

   821   int val = sqlite3_value_int( columnMem(pStmt,i) );

   822   columnMallocFailure(pStmt);

   823   return val;

   824 }

   825 SQLITE_EXPORT sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){

   826   sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );

   827   columnMallocFailure(pStmt);

   828   return val;

   829 }

   830 SQLITE_EXPORT const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){

   831   const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );

   832   columnMallocFailure(pStmt);

   833   return val;

   834 }

   835 SQLITE_EXPORT sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){

   836   sqlite3_value *pOut = columnMem(pStmt, i);

   837   columnMallocFailure(pStmt);

   838   return pOut;

   839 }

   840 #ifndef SQLITE_OMIT_UTF16

   841 SQLITE_EXPORT const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){

   842   const void *val = sqlite3_value_text16( columnMem(pStmt,i) );

   843   columnMallocFailure(pStmt);

   844   return val;

   845 }

   846 #endif /* SQLITE_OMIT_UTF16 */

   847 SQLITE_EXPORT int sqlite3_column_type(sqlite3_stmt *pStmt, int i){

   848   int iType = sqlite3_value_type( columnMem(pStmt,i) );

   849   columnMallocFailure(pStmt);

   850   return iType;

   851 }

   852 

   853 /* The following function is experimental and subject to change or

   854 ** removal */

   855 /*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){

   856 **  return sqlite3_value_numeric_type( columnMem(pStmt,i) );

   857 **}

   858 */

   859 

   860 /*

   861 ** Convert the N-th element of pStmt->pColName[] into a string using

   862 ** xFunc() then return that string.  If N is out of range, return 0.

   863 **

   864 ** There are up to 5 names for each column.  useType determines which

   865 ** name is returned.  Here are the names:

   866 **

   867 **    0      The column name as it should be displayed for output

   868 **    1      The datatype name for the column

   869 **    2      The name of the database that the column derives from

   870 **    3      The name of the table that the column derives from

   871 **    4      The name of the table column that the result column derives from

   872 **

   873 ** If the result is not a simple column reference (if it is an expression

   874 ** or a constant) then useTypes 2, 3, and 4 return NULL.

   875 */

   876 static const void *columnName(

   877   sqlite3_stmt *pStmt,

   878   int N,

   879   const void *(*xFunc)(Mem*),

   880   int useType

   881 ){

   882   const void *ret = 0;

   883   Vdbe *p = (Vdbe *)pStmt;

   884   int n;

   885   

   886 

   887   if( p!=0 ){

   888     n = sqlite3_column_count(pStmt);

   889     if( N<n && N>=0 ){

   890       N += useType*n;

   891       sqlite3_mutex_enter(p->db->mutex);

   892       ret = xFunc(&p->aColName[N]);

   893 

   894       /* A malloc may have failed inside of the xFunc() call. If this

   895       ** is the case, clear the mallocFailed flag and return NULL.

   896       */

   897       if( p->db && p->db->mallocFailed ){

   898         p->db->mallocFailed = 0;

   899         ret = 0;

   900       }

   901       sqlite3_mutex_leave(p->db->mutex);

   902     }

   903   }

   904   return ret;

   905 }

   906 

   907 /*

   908 ** Return the name of the Nth column of the result set returned by SQL

   909 ** statement pStmt.

   910 */

   911 SQLITE_EXPORT const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){

   912   return columnName(

   913       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);

   914 }

   915 #ifndef SQLITE_OMIT_UTF16

   916 SQLITE_EXPORT const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){

   917   return columnName(

   918       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);

   919 }

   920 #endif

   921 

   922 /*

   923 ** Constraint:  If you have ENABLE_COLUMN_METADATA then you must

   924 ** not define OMIT_DECLTYPE.

   925 */

   926 #if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)

   927 # error "Must not define both SQLITE_OMIT_DECLTYPE \

   928          and SQLITE_ENABLE_COLUMN_METADATA"

   929 #endif

   930 

   931 #ifndef SQLITE_OMIT_DECLTYPE

   932 /*

   933 ** Return the column declaration type (if applicable) of the 'i'th column

   934 ** of the result set of SQL statement pStmt.

   935 */

   936 SQLITE_EXPORT const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){

   937   return columnName(

   938       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);

   939 }

   940 #ifndef SQLITE_OMIT_UTF16

   941 SQLITE_EXPORT const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){

   942   return columnName(

   943       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);

   944 }

   945 #endif /* SQLITE_OMIT_UTF16 */

   946 #endif /* SQLITE_OMIT_DECLTYPE */

   947 

   948 #ifdef SQLITE_ENABLE_COLUMN_METADATA

   949 /*

   950 ** Return the name of the database from which a result column derives.

   951 ** NULL is returned if the result column is an expression or constant or

   952 ** anything else which is not an unabiguous reference to a database column.

   953 */

   954 const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){

   955   return columnName(

   956       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);

   957 }

   958 #ifndef SQLITE_OMIT_UTF16

   959 const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){

   960   return columnName(

   961       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);

   962 }

   963 #endif /* SQLITE_OMIT_UTF16 */

   964 

   965 /*

   966 ** Return the name of the table from which a result column derives.

   967 ** NULL is returned if the result column is an expression or constant or

   968 ** anything else which is not an unabiguous reference to a database column.

   969 */

   970 const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){

   971   return columnName(

   972       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);

   973 }

   974 #ifndef SQLITE_OMIT_UTF16

   975 const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){

   976   return columnName(

   977       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);

   978 }

   979 #endif /* SQLITE_OMIT_UTF16 */

   980 

   981 /*

   982 ** Return the name of the table column from which a result column derives.

   983 ** NULL is returned if the result column is an expression or constant or

   984 ** anything else which is not an unabiguous reference to a database column.

   985 */

   986 const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){

   987   return columnName(

   988       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);

   989 }

   990 #ifndef SQLITE_OMIT_UTF16

   991 const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){

   992   return columnName(

   993       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);

   994 }

   995 #endif /* SQLITE_OMIT_UTF16 */

   996 #endif /* SQLITE_ENABLE_COLUMN_METADATA */

   997 

   998 

   999 /******************************* sqlite3_bind_  ***************************

  1000 ** 

  1001 ** Routines used to attach values to wildcards in a compiled SQL statement.

  1002 */

  1003 /*

  1004 ** Unbind the value bound to variable i in virtual machine p. This is the 

  1005 ** the same as binding a NULL value to the column. If the "i" parameter is

  1006 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.

  1007 **

  1008 ** The error code stored in database p->db is overwritten with the return

  1009 ** value in any case.

  1010 */

  1011 static int vdbeUnbind(Vdbe *p, int i){

  1012   Mem *pVar;

  1013   if( p==0 || p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){

  1014     if( p ) sqlite3Error(p->db, SQLITE_MISUSE, 0);

  1015     return SQLITE_MISUSE;

  1016   }

  1017   if( i<1 || i>p->nVar ){

  1018     sqlite3Error(p->db, SQLITE_RANGE, 0);

  1019     return SQLITE_RANGE;

  1020   }

  1021   i--;

  1022   pVar = &p->aVar[i];

  1023   sqlite3VdbeMemRelease(pVar);

  1024   pVar->flags = MEM_Null;

  1025   sqlite3Error(p->db, SQLITE_OK, 0);

  1026   return SQLITE_OK;

  1027 }

  1028 

  1029 /*

  1030 ** Bind a text or BLOB value.

  1031 */

  1032 static int bindText(

  1033   sqlite3_stmt *pStmt,   /* The statement to bind against */

  1034   int i,                 /* Index of the parameter to bind */

  1035   const void *zData,     /* Pointer to the data to be bound */

  1036   int nData,             /* Number of bytes of data to be bound */

  1037   void (*xDel)(void*),   /* Destructor for the data */

  1038   int encoding           /* Encoding for the data */

  1039 ){

  1040   Vdbe *p = (Vdbe *)pStmt;

  1041   Mem *pVar;

  1042   int rc;

  1043 

  1044   if( p==0 ){

  1045     return SQLITE_MISUSE;

  1046   }

  1047   sqlite3_mutex_enter(p->db->mutex);

  1048   rc = vdbeUnbind(p, i);

  1049   if( rc==SQLITE_OK && zData!=0 ){

  1050     pVar = &p->aVar[i-1];

  1051     rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);

  1052     if( rc==SQLITE_OK && encoding!=0 ){

  1053       rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));

  1054     }

  1055     sqlite3Error(p->db, rc, 0);

  1056     rc = sqlite3ApiExit(p->db, rc);

  1057   }

  1058   sqlite3_mutex_leave(p->db->mutex);

  1059   return rc;

  1060 }

  1061 

  1062 

  1063 /*

  1064 ** Bind a blob value to an SQL statement variable.

  1065 */

  1066 SQLITE_EXPORT int sqlite3_bind_blob(

  1067   sqlite3_stmt *pStmt, 

  1068   int i, 

  1069   const void *zData, 

  1070   int nData, 

  1071   void (*xDel)(void*)

  1072 ){

  1073   return bindText(pStmt, i, zData, nData, xDel, 0);

  1074 }

  1075 SQLITE_EXPORT int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){

  1076   int rc;

  1077   Vdbe *p = (Vdbe *)pStmt;

  1078   sqlite3_mutex_enter(p->db->mutex);

  1079   rc = vdbeUnbind(p, i);

  1080   if( rc==SQLITE_OK ){

  1081     sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);

  1082   }

  1083   sqlite3_mutex_leave(p->db->mutex);

  1084   return rc;

  1085 }

  1086 SQLITE_EXPORT int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){

  1087   return sqlite3_bind_int64(p, i, (i64)iValue);

  1088 }

  1089 SQLITE_EXPORT int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){

  1090   int rc;

  1091   Vdbe *p = (Vdbe *)pStmt;

  1092   sqlite3_mutex_enter(p->db->mutex);

  1093   rc = vdbeUnbind(p, i);

  1094   if( rc==SQLITE_OK ){

  1095     sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);

  1096   }

  1097   sqlite3_mutex_leave(p->db->mutex);

  1098   return rc;

  1099 }

  1100 SQLITE_EXPORT int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){

  1101   int rc;

  1102   Vdbe *p = (Vdbe*)pStmt;

  1103   sqlite3_mutex_enter(p->db->mutex);

  1104   rc = vdbeUnbind(p, i);

  1105   sqlite3_mutex_leave(p->db->mutex);

  1106   return rc;

  1107 }

  1108 SQLITE_EXPORT int sqlite3_bind_text( 

  1109   sqlite3_stmt *pStmt, 

  1110   int i, 

  1111   const char *zData, 

  1112   int nData, 

  1113   void (*xDel)(void*)

  1114 ){

  1115   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);

  1116 }

  1117 #ifndef SQLITE_OMIT_UTF16

  1118 SQLITE_EXPORT int sqlite3_bind_text16(

  1119   sqlite3_stmt *pStmt, 

  1120   int i, 

  1121   const void *zData, 

  1122   int nData, 

  1123   void (*xDel)(void*)

  1124 ){

  1125   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);

  1126 }

  1127 #endif /* SQLITE_OMIT_UTF16 */

  1128 SQLITE_EXPORT int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){

  1129   int rc;

  1130   Vdbe *p = (Vdbe *)pStmt;

  1131   sqlite3_mutex_enter(p->db->mutex);

  1132   rc = vdbeUnbind(p, i);

  1133   if( rc==SQLITE_OK ){

  1134     rc = sqlite3VdbeMemCopy(&p->aVar[i-1], pValue);

  1135     if( rc==SQLITE_OK ){