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 #include "sqliteInt.h"

    17 #include "vdbeInt.h"

    18 

    19 /*

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

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

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

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

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

    25 ** added or changed.

    26 */

    27 EXPORT_C int sqlite3_expired(sqlite3_stmt *pStmt){

    28   Vdbe *p = (Vdbe*)pStmt;

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

    30 }

    31 

    32 /*

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

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

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

    36 ** machine.

    37 **

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

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

    40 */

    41 EXPORT_C int sqlite3_finalize(sqlite3_stmt *pStmt){

    42   int rc;

    43   if( pStmt==0 ){

    44     rc = SQLITE_OK;

    45   }else{

    46     Vdbe *v = (Vdbe*)pStmt;

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

    48     sqlite3_mutex_enter(mutex);

    49     rc = sqlite3VdbeFinalize(v);

    50     sqlite3_mutex_leave(mutex);

    51   }

    52   return rc;

    53 }

    54 

    55 /*

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

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

    58 ** the prior execution is returned.

    59 **

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

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

    62 */

    63 EXPORT_C int sqlite3_reset(sqlite3_stmt *pStmt){

    64   int rc;

    65   if( pStmt==0 ){

    66     rc = SQLITE_OK;

    67   }else{

    68     Vdbe *v = (Vdbe*)pStmt;

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

    70     rc = sqlite3VdbeReset(v);

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

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

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

    74   }

    75   return rc;

    76 }

    77 

    78 /*

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

    80 */

    81 EXPORT_C int sqlite3_clear_bindings(sqlite3_stmt *pStmt){

    82   int i;

    83   int rc = SQLITE_OK;

    84   Vdbe *v = (Vdbe*)pStmt;

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

    86   for(i=1; rc==SQLITE_OK && i<=sqlite3_bind_parameter_count(pStmt); i++){

    87     rc = sqlite3_bind_null(pStmt, i);

    88   }

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

    90   return rc;

    91 }

    92 

    93 

    94 /**************************** sqlite3_value_  *******************************

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

    96 ** structure.

    97 */

    98 EXPORT_C const void *sqlite3_value_blob(sqlite3_value *pVal){

    99   Mem *p = (Mem*)pVal;

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

   101     sqlite3VdbeMemExpandBlob(p);

   102     p->flags &= ~MEM_Str;

   103     p->flags |= MEM_Blob;

   104     return p->z;

   105   }else{

   106     return sqlite3_value_text(pVal);

   107   }

   108 }

   109 EXPORT_C int sqlite3_value_bytes(sqlite3_value *pVal){

   110   return sqlite3ValueBytes(pVal, SQLITE_UTF8);

   111 }

   112 EXPORT_C int sqlite3_value_bytes16(sqlite3_value *pVal){

   113   return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);

   114 }

   115 EXPORT_C double sqlite3_value_double(sqlite3_value *pVal){

   116   return sqlite3VdbeRealValue((Mem*)pVal);

   117 }

   118 EXPORT_C int sqlite3_value_int(sqlite3_value *pVal){

   119   return sqlite3VdbeIntValue((Mem*)pVal);

   120 }

   121 EXPORT_C sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){

   122   return sqlite3VdbeIntValue((Mem*)pVal);

   123 }

   124 EXPORT_C const unsigned char *sqlite3_value_text(sqlite3_value *pVal){

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

   126 }

   127 #ifndef SQLITE_OMIT_UTF16

   128 EXPORT_C const void *sqlite3_value_text16(sqlite3_value* pVal){

   129   return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);

   130 }

   131 EXPORT_C const void *sqlite3_value_text16be(sqlite3_value *pVal){

   132   return sqlite3ValueText(pVal, SQLITE_UTF16BE);

   133 }

   134 EXPORT_C const void *sqlite3_value_text16le(sqlite3_value *pVal){

   135   return sqlite3ValueText(pVal, SQLITE_UTF16LE);

   136 }

   137 #endif /* SQLITE_OMIT_UTF16 */

   138 EXPORT_C int sqlite3_value_type(sqlite3_value* pVal){

   139   return pVal->type;

   140 }

   141 

   142 /**************************** sqlite3_result_  *******************************

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

   144 ** the function result.

   145 */

   146 EXPORT_C void sqlite3_result_blob(

   147   sqlite3_context *pCtx, 

   148   const void *z, 

   149   int n, 

   150   void (*xDel)(void *)

   151 ){

   152   assert( n>=0 );

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

   154   sqlite3VdbeMemSetStr(&pCtx->s, (const char*)z, n, 0, xDel);

   155 }

   156 EXPORT_C void sqlite3_result_double(sqlite3_context *pCtx, double rVal){

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

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

   159 }

   160 EXPORT_C void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){

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

   162   pCtx->isError = 1;

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

   164 }

   165 #ifndef SQLITE_OMIT_UTF16

   166 EXPORT_C void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){

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

   168   pCtx->isError = 1;

   169   sqlite3VdbeMemSetStr(&pCtx->s, (const char*)z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);

   170 }

   171 #endif

   172 EXPORT_C void sqlite3_result_int(sqlite3_context *pCtx, int iVal){

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

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

   175 }

   176 EXPORT_C void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){

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

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

   179 }

   180 EXPORT_C void sqlite3_result_null(sqlite3_context *pCtx){

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

   182   sqlite3VdbeMemSetNull(&pCtx->s);

   183 }

   184 EXPORT_C void sqlite3_result_text(

   185   sqlite3_context *pCtx, 

   186   const char *z, 

   187   int n,

   188   void (*xDel)(void *)

   189 ){

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

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

   192 }

   193 #ifndef SQLITE_OMIT_UTF16

   194 EXPORT_C void sqlite3_result_text16(

   195   sqlite3_context *pCtx, 

   196   const void *z, 

   197   int n, 

   198   void (*xDel)(void *)

   199 ){

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

   201   sqlite3VdbeMemSetStr(&pCtx->s, (const char*)z, n, SQLITE_UTF16NATIVE, xDel);

   202 }

   203 EXPORT_C void sqlite3_result_text16be(

   204   sqlite3_context *pCtx, 

   205   const void *z, 

   206   int n, 

   207   void (*xDel)(void *)

   208 ){

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

   210   sqlite3VdbeMemSetStr(&pCtx->s, (const char*)z, n, SQLITE_UTF16BE, xDel);

   211 }

   212 EXPORT_C void sqlite3_result_text16le(

   213   sqlite3_context *pCtx, 

   214   const void *z, 

   215   int n, 

   216   void (*xDel)(void *)

   217 ){

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

   219   sqlite3VdbeMemSetStr(&pCtx->s, (const char*)z, n, SQLITE_UTF16LE, xDel);

   220 }

   221 #endif /* SQLITE_OMIT_UTF16 */

   222 EXPORT_C void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){

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

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

   225 }

   226 EXPORT_C void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){

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

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

   229 }

   230 

   231 /* Force an SQLITE_TOOBIG error. */

   232 EXPORT_C void sqlite3_result_error_toobig(sqlite3_context *pCtx){

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

   234   sqlite3VdbeMemSetZeroBlob(&pCtx->s, SQLITE_MAX_LENGTH+1);

   235 }

   236 

   237 /* An SQLITE_NOMEM error. */

   238 EXPORT_C void sqlite3_result_error_nomem(sqlite3_context *pCtx){

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

   240   sqlite3VdbeMemSetNull(&pCtx->s);

   241   pCtx->isError = 1;

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

   243 }

   244 

   245 /*

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

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

   248 **

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

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

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

   252 ** outer sqlite3_step() wrapper procedure.

   253 */

   254 static int sqlite3Step(Vdbe *p){

   255   sqlite3 *db;

   256   int rc;

   257 

   258   assert(p);

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

   260     return SQLITE_MISUSE;

   261   }

   262 

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

   264   db = p->db;

   265   assert( !db->mallocFailed );

   266 

   267   if( p->aborted ){

   268     return SQLITE_ABORT;

   269   }

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

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

   272       p->rc = SQLITE_SCHEMA;

   273     }

   274     rc = SQLITE_ERROR;

   275     goto end_of_step;

   276   }

   277   if( sqlite3SafetyOn(db) ){

   278     p->rc = SQLITE_MISUSE;

   279     return SQLITE_MISUSE;

   280   }

   281   if( p->pc<0 ){

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

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

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

   285     */

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

   287       db->u1.isInterrupted = 0;

   288     }

   289 

   290 #ifndef SQLITE_OMIT_TRACE

   291     /* Invoke the trace callback if there is one

   292     */

   293     if( db->xTrace && !db->init.busy ){

   294       assert( p->nOp>0 );

   295       assert( p->aOp[p->nOp-1].opcode==OP_Noop );

   296       assert( p->aOp[p->nOp-1].p3!=0 );

   297       assert( p->aOp[p->nOp-1].p3type==P3_DYNAMIC );

   298       sqlite3SafetyOff(db);

   299       db->xTrace(db->pTraceArg, p->aOp[p->nOp-1].p3);

   300       if( sqlite3SafetyOn(db) ){

   301         p->rc = SQLITE_MISUSE;

   302         return SQLITE_MISUSE;

   303       }

   304     }

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

   306       double rNow;

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

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

   309     }

   310 #endif

   311 

   312     /* Print a copy of SQL as it is executed if the SQL_TRACE pragma is turned

   313     ** on in debugging mode.

   314     */

   315 #ifdef SQLITE_DEBUG

   316     if( (db->flags & SQLITE_SqlTrace)!=0 ){

   317       sqlite3DebugPrintf("SQL-trace: %s\n", p->aOp[p->nOp-1].p3);

   318     }

   319 #endif /* SQLITE_DEBUG */

   320 

   321     db->activeVdbeCnt++;

   322     p->pc = 0;

   323   }

   324 #ifndef SQLITE_OMIT_EXPLAIN

   325   if( p->explain ){

   326     rc = sqlite3VdbeList(p);

   327   }else

   328 #endif /* SQLITE_OMIT_EXPLAIN */

   329   {

   330     rc = sqlite3VdbeExec(p);

   331   }

   332 

   333   if( sqlite3SafetyOff(db) ){

   334     rc = SQLITE_MISUSE;

   335   }

   336 

   337 #ifndef SQLITE_OMIT_TRACE

   338   /* Invoke the profile callback if there is one

   339   */

   340   if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy ){

   341     double rNow;

   342     u64 elapseTime;

   343 

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

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

   346     assert( p->nOp>0 );

   347     assert( p->aOp[p->nOp-1].opcode==OP_Noop );

   348     assert( p->aOp[p->nOp-1].p3!=0 );

   349     assert( p->aOp[p->nOp-1].p3type==P3_DYNAMIC );

   350     db->xProfile(db->pProfileArg, p->aOp[p->nOp-1].p3, elapseTime);

   351   }

   352 #endif

   353 

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

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

   356 end_of_step:

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

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

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

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

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

   362     return p->rc;

   363   }else{

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

   365     ** is SQLITE_ROW or SQLITE_DONE */

   366     return rc;

   367   }

   368 }

   369 

   370 /*

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

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

   373 ** call sqlite3Reprepare() and try again.

   374 */

   375 #ifdef SQLITE_OMIT_PARSER

   376 int sqlite3_step(sqlite3_stmt *pStmt){

   377   int rc = SQLITE_MISUSE;

   378   if( pStmt ){

   379     Vdbe *v;

   380     v = (Vdbe*)pStmt;

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

   382     rc = sqlite3Step(v);

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

   384   }

   385   return rc;

   386 }

   387 #else

   388 EXPORT_C int sqlite3_step(sqlite3_stmt *pStmt){

   389   int rc = SQLITE_MISUSE;

   390   if( pStmt ){

   391     int cnt = 0;

   392     Vdbe *v = (Vdbe*)pStmt;

   393     sqlite3 *db = v->db;

   394     sqlite3_mutex_enter(db->mutex);

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

   396            && cnt++ < 5

   397            && sqlite3Reprepare(v) ){

   398       sqlite3_reset(pStmt);

   399       v->expired = 0;

   400     }

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

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

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

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

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

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

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

   408       ** sqlite3_errmsg() and sqlite3_errcode().

   409       */

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

   411       sqlite3_free(v->zErrMsg);

   412       if( !db->mallocFailed ){

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

   414       } else {

   415         v->zErrMsg = 0;

   416         v->rc = SQLITE_NOMEM;

   417       }

   418     }

   419     rc = sqlite3ApiExit(db, rc);

   420     sqlite3_mutex_leave(db->mutex);

   421   }

   422   return rc;

   423 }

   424 #endif

   425 

   426 /*

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

   428 ** pointer to it.

   429 */

   430 EXPORT_C void *sqlite3_user_data(sqlite3_context *p){

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

   432   return p->pFunc->pUserData;

   433 }

   434 

   435 /*

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

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

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

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

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

   441 ** method of virtual tables.

   442 */

   443 void sqlite3InvalidFunction(

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

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

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

   447 ){

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

   449   char *zErr;

   450   zErr = sqlite3MPrintf(0,

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

   452   sqlite3_result_error(context, zErr, -1);

   453   sqlite3_free(zErr);

   454 }

   455 

   456 /*

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

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

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

   460 */

   461 EXPORT_C void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){

   462   Mem *pMem;

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

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

   465   pMem = p->pMem;

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

   467     if( nByte==0 ){

   468       assert( pMem->flags==MEM_Null );

   469       pMem->z = 0;

   470     }else{

   471       pMem->flags = MEM_Agg;

   472       pMem->xDel = sqlite3_free;

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

   474       pMem->z = (char*)sqlite3DbMallocZero(p->s.db, nByte);

   475     }

   476   }

   477   return (void*)pMem->z;

   478 }

   479 

   480 /*

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

   482 ** the user-function defined by pCtx.

   483 */

   484 EXPORT_C void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){

   485   VdbeFunc *pVdbeFunc;

   486 

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

   488   pVdbeFunc = pCtx->pVdbeFunc;

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

   490     return 0;

   491   }

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

   493 }

   494 

   495 /*

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

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

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

   499 */

   500 EXPORT_C void sqlite3_set_auxdata(

   501   sqlite3_context *pCtx, 

   502   int iArg, 

   503   void *pAux, 

   504   void (*xDelete)(void*)

   505 ){

   506 	VdbeFunc::AuxData *pAuxData;

   507   VdbeFunc *pVdbeFunc;

   508   if( iArg<0 ) goto failed;

   509 

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

   511   pVdbeFunc = pCtx->pVdbeFunc;

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

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

   514 	int nMalloc = sizeof(VdbeFunc) + sizeof(VdbeFunc::AuxData)*iArg;

   515     pVdbeFunc = (VdbeFunc*)sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);

   516     if( !pVdbeFunc ){

   517       goto failed;

   518     }

   519     pCtx->pVdbeFunc = pVdbeFunc;

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

   521     pVdbeFunc->nAux = iArg+1;

   522     pVdbeFunc->pFunc = pCtx->pFunc;

   523   }

   524 

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

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

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

   528   }

   529   pAuxData->pAux = pAux;

   530   pAuxData->xDelete = xDelete;

   531   return;

   532 

   533 failed:

   534   if( xDelete ){

   535     xDelete(pAux);

   536   }

   537 }

   538 

   539 /*

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

   541 ** called.

   542 **

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

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

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

   546 ** context.

   547 */

   548 EXPORT_C int sqlite3_aggregate_count(sqlite3_context *p){

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

   550   return p->pMem->n;

   551 }

   552 

   553 /*

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

   555 */

   556 EXPORT_C int sqlite3_column_count(sqlite3_stmt *pStmt){

   557   Vdbe *pVm = (Vdbe *)pStmt;

   558   return pVm ? pVm->nResColumn : 0;

   559 }

   560 

   561 /*

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

   563 ** currently executing statement pStmt.

   564 */

   565 EXPORT_C int sqlite3_data_count(sqlite3_stmt *pStmt){

   566   Vdbe *pVm = (Vdbe *)pStmt;

   567   if( pVm==0 || !pVm->resOnStack ) return 0;

   568   return pVm->nResColumn;

   569 }

   570 

   571 

   572 /*

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

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

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

   576 ** of NULL.

   577 */

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

   579   Vdbe *pVm;

   580   int vals;

   581   Mem *pOut;

   582 

   583   pVm = (Vdbe *)pStmt;

   584   if( pVm && pVm->resOnStack && i<pVm->nResColumn && i>=0 ){

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

   586     vals = sqlite3_data_count(pStmt);

   587     pOut = &pVm->pTos[(1-vals)+i];

   588   }else{

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

   590     if( pVm->db ){

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

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

   593     }

   594     pOut = (Mem*)&nullMem;

   595   }

   596   return pOut;

   597 }

   598 

   599 /*

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

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

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

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

   604 ** code of statement pStmt set to SQLITE_NOMEM.

   605 **

   606 ** Specifically, this is called from within:

   607 **

   608 **     sqlite3_column_int()

   609 **     sqlite3_column_int64()

   610 **     sqlite3_column_text()

   611 **     sqlite3_column_text16()

   612 **     sqlite3_column_real()

   613 **     sqlite3_column_bytes()

   614 **     sqlite3_column_bytes16()

   615 **

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

   617 */

   618 static void columnMallocFailure(sqlite3_stmt *pStmt)

   619 {

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

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

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

   623   ** and _finalize() will return NOMEM.

   624   */

   625   Vdbe *p = (Vdbe *)pStmt;

   626   if( p ){

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

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

   629   }

   630 }

   631 

   632 /**************************** sqlite3_column_  *******************************

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

   634 ** in the result set.

   635 */

   636 EXPORT_C const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){

   637   const void *val;

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

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

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

   641   ** expression. 

   642   */

   643   columnMallocFailure(pStmt);

   644   return val;

   645 }

   646 EXPORT_C int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){

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

   648   columnMallocFailure(pStmt);

   649   return val;

   650 }

   651 EXPORT_C int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){

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

   653   columnMallocFailure(pStmt);

   654   return val;

   655 }

   656 EXPORT_C double sqlite3_column_double(sqlite3_stmt *pStmt, int i){

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

   658   columnMallocFailure(pStmt);

   659   return val;

   660 }

   661 EXPORT_C int sqlite3_column_int(sqlite3_stmt *pStmt, int i){

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

   663   columnMallocFailure(pStmt);

   664   return val;

   665 }

   666 EXPORT_C sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){

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

   668   columnMallocFailure(pStmt);

   669   return val;

   670 }

   671 EXPORT_C const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){

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

   673   columnMallocFailure(pStmt);

   674   return val;

   675 }

   676 EXPORT_C sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){

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

   678   columnMallocFailure(pStmt);

   679   return pOut;

   680 }

   681 #ifndef SQLITE_OMIT_UTF16

   682 EXPORT_C const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){

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

   684   columnMallocFailure(pStmt);

   685   return val;

   686 }

   687 #endif /* SQLITE_OMIT_UTF16 */

   688 EXPORT_C int sqlite3_column_type(sqlite3_stmt *pStmt, int i){

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

   690   columnMallocFailure(pStmt);

   691   return iType;

   692 }

   693 

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

   695 ** removal */

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

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

   698 **}

   699 */

   700 

   701 /*

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

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

   704 **

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

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

   707 **

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

   709 **    1      The datatype name for the column

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

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

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

   713 **

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

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

   716 */

   717 static const void *columnName(

   718   sqlite3_stmt *pStmt,

   719   int N,

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

   721   int useType

   722 ){

   723   const void *ret = 0;

   724   Vdbe *p = (Vdbe *)pStmt;

   725   int n;

   726   

   727 

   728   if( p!=0 ){

   729     n = sqlite3_column_count(pStmt);

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

   731       N += useType*n;

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

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

   734 

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

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

   737       */

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

   739         p->db->mallocFailed = 0;

   740         ret = 0;

   741       }

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

   743     }

   744   }

   745   return ret;

   746 }

   747 

   748 /*

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

   750 ** statement pStmt.

   751 */

   752 EXPORT_C const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){

   753   return (const char*)columnName(

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

   755 }

   756 #ifndef SQLITE_OMIT_UTF16

   757 EXPORT_C const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){

   758   return columnName(

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

   760 }

   761 #endif

   762 

   763 /*

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

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

   766 */

   767 EXPORT_C const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){

   768   return (const char*)columnName(

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

   770 }

   771 #ifndef SQLITE_OMIT_UTF16

   772 EXPORT_C const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){

   773   return columnName(

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

   775 }

   776 #endif /* SQLITE_OMIT_UTF16 */

   777 

   778 #ifdef SQLITE_ENABLE_COLUMN_METADATA

   779 /*

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

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

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

   783 */

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

   785   return columnName(

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

   787 }

   788 #ifndef SQLITE_OMIT_UTF16

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

   790   return columnName(

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

   792 }

   793 #endif /* SQLITE_OMIT_UTF16 */

   794 

   795 /*

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

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

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

   799 */

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

   801   return columnName(

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

   803 }

   804 #ifndef SQLITE_OMIT_UTF16

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

   806   return columnName(

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

   808 }

   809 #endif /* SQLITE_OMIT_UTF16 */

   810 

   811 /*

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

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

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

   815 */

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

   817   return columnName(

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

   819 }

   820 #ifndef SQLITE_OMIT_UTF16

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

   822   return columnName(

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

   824 }

   825 #endif /* SQLITE_OMIT_UTF16 */

   826 #endif /* SQLITE_ENABLE_COLUMN_METADATA */

   827 

   828 

   829 /******************************* sqlite3_bind_  ***************************

   830 ** 

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

   832 */

   833 /*

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

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

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

   837 **

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

   839 ** value in any case.

   840 */

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

   842   Mem *pVar;

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

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

   845     return SQLITE_MISUSE;

   846   }

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

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

   849     return SQLITE_RANGE;

   850   }

   851   i--;

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

   853   sqlite3VdbeMemRelease(pVar);

   854   pVar->flags = MEM_Null;

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

   856   return SQLITE_OK;

   857 }

   858 

   859 /*

   860 ** Bind a text or BLOB value.

   861 */

   862 static int bindText(

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

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

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

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

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

   868   int encoding           /* Encoding for the data */

   869 ){

   870   Vdbe *p = (Vdbe *)pStmt;

   871   Mem *pVar;

   872   int rc;

   873 

   874   if( p==0 ){

   875     return SQLITE_MISUSE;

   876   }

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

   878   rc = vdbeUnbind(p, i);

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

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

   881     rc = sqlite3VdbeMemSetStr(pVar, (const char*)zData, nData, encoding, xDel);

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

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

   884     }

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

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

   887   }

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

   889   return rc;

   890 }

   891 

   892 

   893 /*

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

   895 */

   896 EXPORT_C int sqlite3_bind_blob(

   897   sqlite3_stmt *pStmt, 

   898   int i, 

   899   const void *zData, 

   900   int nData, 

   901   void (*xDel)(void*)

   902 ){

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

   904 }

   905 EXPORT_C int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){

   906   int rc;

   907   Vdbe *p = (Vdbe *)pStmt;

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

   909   rc = vdbeUnbind(p, i);

   910   if( rc==SQLITE_OK ){

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

   912   }

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

   914   return rc;

   915 }

   916 EXPORT_C int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){

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

   918 }

   919 EXPORT_C int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){

   920   int rc;

   921   Vdbe *p = (Vdbe *)pStmt;

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

   923   rc = vdbeUnbind(p, i);

   924   if( rc==SQLITE_OK ){

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

   926   }

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

   928   return rc;

   929 }

   930 EXPORT_C int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){

   931   int rc;

   932   Vdbe *p = (Vdbe*)pStmt;

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

   934   rc = vdbeUnbind(p, i);

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

   936   return rc;

   937 }

   938 EXPORT_C int sqlite3_bind_text( 

   939   sqlite3_stmt *pStmt, 

   940   int i, 

   941   const char *zData, 

   942   int nData, 

   943   void (*xDel)(void*)

   944 ){

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

   946 }

   947 #ifndef SQLITE_OMIT_UTF16

   948 EXPORT_C int sqlite3_bind_text16(

   949   sqlite3_stmt *pStmt, 

   950   int i, 

   951   const void *zData, 

   952   int nData, 

   953   void (*xDel)(void*)

   954 ){

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

   956 }

   957 #endif /* SQLITE_OMIT_UTF16 */

   958 EXPORT_C int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){

   959   int rc;

   960   Vdbe *p = (Vdbe *)pStmt;

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

   962   rc = vdbeUnbind(p, i);

   963   if( rc==SQLITE_OK ){

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

   965   }

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

   967   return rc;

   968 }

   969 EXPORT_C int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){

   970   int rc;

   971   Vdbe *p = (Vdbe *)pStmt;

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

   973   rc = vdbeUnbind(p, i);

   974   if( rc==SQLITE_OK ){

   975     sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);

   976   }

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

   978   return rc;

   979 }

   980 

   981 /*

   982 ** Return the number of wildcards that can be potentially bound to.

   983 ** This routine is added to support DBD::SQLite.  

   984 */

   985 EXPORT_C int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){

   986   Vdbe *p = (Vdbe*)pStmt;

   987   return p ? p->nVar : 0;

   988 }

   989 

   990 /*

   991 ** Create a mapping from variable numbers to variable names

   992 ** in the Vdbe.azVar[] array, if such a mapping does not already

   993 ** exist.

   994 */

   995 static void createVarMap(Vdbe *p){

   996   if( !p->okVar ){

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

   998     if( !p->okVar ){

   999       int j;

  1000       Op *pOp;

  1001       for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){

  1002         if( pOp->opcode==OP_Variable ){

  1003           assert( pOp->p1>0 && pOp->p1<=p->nVar );

  1004           p->azVar[pOp->p1-1] = pOp->p3;

  1005         }

  1006       }

  1007       p->okVar = 1;

  1008     }

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

  1010   }

  1011 }

  1012 

  1013 /*

  1014 ** Return the name of a wildcard parameter.  Return NULL if the index

  1015 ** is out of range or if the wildcard is unnamed.

  1016 **

  1017 ** The result is always UTF-8.

  1018 */

  1019 EXPORT_C const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){

  1020   Vdbe *p = (Vdbe*)pStmt;

  1021   if( p==0 || i<1 || i>p->nVar ){

  1022     return 0;

  1023   }

  1024   createVarMap(p);

  1025   return p->azVar[i-1];

  1026 }

  1027 

  1028 /*

  1029 ** Given a wildcard parameter name, return the index of the variable

  1030 ** with that name.  If there is no variable with the given name,

  1031 ** return 0.

  1032 */

  1033 EXPORT_C int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){

  1034   Vdbe *p = (Vdbe*)pStmt;

  1035   int i;

  1036   if( p==0 ){

  1037     return 0;

  1038   }

  1039   createVarMap(p); 

  1040   if( zName ){

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

  1042       const char *z = p->azVar[i];

  1043       if( z && strcmp(z,zName)==0 ){

  1044         return i+1;

  1045       }

  1046     }

  1047   }

  1048   return 0;

  1049 }

  1050 

  1051 /*

  1052 ** Transfer all bindings from the first statement over to the second.

  1053 ** If the two statements contain a different number of bindings, then

  1054 ** an SQLITE_ERROR is returned.

  1055 */

  1056 EXPORT_C int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){

  1057   Vdbe *pFrom = (Vdbe*)pFromStmt;

  1058   Vdbe *pTo = (Vdbe*)pToStmt;

  1059   int i, rc = SQLITE_OK;

  1060   if( (pFrom->magic!=VDBE_MAGIC_RUN && pFrom->magic!=VDBE_MAGIC_HALT)

  1061     || (pTo->magic!=VDBE_MAGIC_RUN && pTo->magic!=VDBE_MAGIC_HALT)

  1062     || pTo->db!=pFrom->db ){

  1063     return SQLITE_MISUSE;

  1064   }

  1065   if( pFrom->nVar!=pTo->nVar ){

  1066     return SQLITE_ERROR;

  1067   }

  1068   sqlite3_mutex_enter(pTo->db->mutex);

  1069   for(i=0; rc==SQLITE_OK && i<pFrom->nVar; i++){

  1070     sqlite3MallocDisallow();

  1071     rc = sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);

  1072     sqlite3MallocAllow();

  1073   }

  1074   sqlite3_mutex_leave(pTo->db->mutex);

  1075   assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );

  1076   return rc;

  1077 }

  1078 

  1079 /*

  1080 ** Return the sqlite3* database handle to which the prepared statement given

  1081 ** in the argument belongs.  This is the same database handle that was

  1082 ** the first argument to the sqlite3_prepare() that was used to create

  1083 ** the statement in the first place.

  1084 */

  1085 EXPORT_C sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){

  1086   return pStmt ? ((Vdbe*)pStmt)->db : 0;

  1087 }