1 /*

     2 ** 2001 September 15

     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 ** Code for testing all sorts of SQLite interfaces.  This code

    13 ** is not included in the SQLite library.  It is used for automated

    14 ** testing of the SQLite library.

    15 **

    16 ** $Id: test1.c,v 1.326 2008/10/02 14:49:02 danielk1977 Exp $

    17 */

    18 #include "sqliteInt.h"

    19 #include "tcl.h"

    20 #include <stdlib.h>

    21 #include <string.h>

    22 

    23 /*

    24 ** This is a copy of the first part of the SqliteDb structure in 

    25 ** tclsqlite.c.  We need it here so that the get_sqlite_pointer routine

    26 ** can extract the sqlite3* pointer from an existing Tcl SQLite

    27 ** connection.

    28 */

    29 struct SqliteDb {

    30   sqlite3 *db;

    31 };

    32 

    33 /*

    34 ** Convert text generated by the "%p" conversion format back into

    35 ** a pointer.

    36 */

    37 static int testHexToInt(int h){

    38   if( h>='0' && h<='9' ){

    39     return h - '0';

    40   }else if( h>='a' && h<='f' ){

    41     return h - 'a' + 10;

    42   }else{

    43     assert( h>='A' && h<='F' );

    44     return h - 'A' + 10;

    45   }

    46 }

    47 void *sqlite3TestTextToPtr(const char *z){

    48   void *p;

    49   u64 v;

    50   u32 v2;

    51   if( z[0]=='0' && z[1]=='x' ){

    52     z += 2;

    53   }

    54   v = 0;

    55   while( *z ){

    56     v = (v<<4) + testHexToInt(*z);

    57     z++;

    58   }

    59   if( sizeof(p)==sizeof(v) ){

    60     memcpy(&p, &v, sizeof(p));

    61   }else{

    62     assert( sizeof(p)==sizeof(v2) );

    63     v2 = (u32)v;

    64     memcpy(&p, &v2, sizeof(p));

    65   }

    66   return p;

    67 }

    68 

    69 

    70 /*

    71 ** A TCL command that returns the address of the sqlite* pointer

    72 ** for an sqlite connection instance.  Bad things happen if the

    73 ** input is not an sqlite connection.

    74 */

    75 static int get_sqlite_pointer(

    76   void * clientData,

    77   Tcl_Interp *interp,

    78   int objc,

    79   Tcl_Obj *CONST objv[]

    80 ){

    81   struct SqliteDb *p;

    82   Tcl_CmdInfo cmdInfo;

    83   char zBuf[100];

    84   if( objc!=2 ){

    85     Tcl_WrongNumArgs(interp, 1, objv, "SQLITE-CONNECTION");

    86     return TCL_ERROR;

    87   }

    88   if( !Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){

    89     Tcl_AppendResult(interp, "command not found: ",

    90            Tcl_GetString(objv[1]), (char*)0);

    91     return TCL_ERROR;

    92   }

    93   p = (struct SqliteDb*)cmdInfo.objClientData;

    94   sprintf(zBuf, "%p", p->db);

    95   if( strncmp(zBuf,"0x",2) ){

    96     sprintf(zBuf, "0x%p", p->db);

    97   }

    98   Tcl_AppendResult(interp, zBuf, 0);

    99   return TCL_OK;

   100 }

   101 

   102 /*

   103 ** Decode a pointer to an sqlite3 object.

   104 */

   105 int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb){

   106   struct SqliteDb *p;

   107   Tcl_CmdInfo cmdInfo;

   108   if( Tcl_GetCommandInfo(interp, zA, &cmdInfo) ){

   109     p = (struct SqliteDb*)cmdInfo.objClientData;

   110     *ppDb = p->db;

   111   }else{

   112     *ppDb = (sqlite3*)sqlite3TestTextToPtr(zA);

   113   }

   114   return TCL_OK;

   115 }

   116 

   117 

   118 const char *sqlite3TestErrorName(int rc){

   119   const char *zName = 0;

   120   switch( rc & 0xff ){

   121     case SQLITE_OK:         zName = "SQLITE_OK";          break;

   122     case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;

   123     case SQLITE_PERM:       zName = "SQLITE_PERM";        break;

   124     case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;

   125     case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;

   126     case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;

   127     case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;

   128     case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;

   129     case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;

   130     case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;

   131     case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;

   132     case SQLITE_FULL:       zName = "SQLITE_FULL";        break;

   133     case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;

   134     case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;

   135     case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;

   136     case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;

   137     case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;

   138     case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;

   139     case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;

   140     case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;

   141     case SQLITE_AUTH:       zName = "SQLITE_AUTH";        break;

   142     case SQLITE_FORMAT:     zName = "SQLITE_FORMAT";      break;

   143     case SQLITE_RANGE:      zName = "SQLITE_RANGE";       break;

   144     case SQLITE_ROW:        zName = "SQLITE_ROW";         break;

   145     case SQLITE_DONE:       zName = "SQLITE_DONE";        break;

   146     case SQLITE_NOTADB:     zName = "SQLITE_NOTADB";      break;

   147     case SQLITE_TOOBIG:     zName = "SQLITE_TOOBIG";      break;

   148     default:                zName = "SQLITE_Unknown";     break;

   149   }

   150   return zName;

   151 }

   152 #define t1ErrorName sqlite3TestErrorName

   153 

   154 /*

   155 ** Convert an sqlite3_stmt* into an sqlite3*.  This depends on the

   156 ** fact that the sqlite3* is the first field in the Vdbe structure.

   157 */

   158 #define StmtToDb(X)   sqlite3_db_handle(X)

   159 

   160 /*

   161 ** Check a return value to make sure it agrees with the results

   162 ** from sqlite3_errcode.

   163 */

   164 int sqlite3TestErrCode(Tcl_Interp *interp, sqlite3 *db, int rc){

   165   if( rc!=SQLITE_MISUSE && rc!=SQLITE_OK && sqlite3_errcode(db)!=rc ){

   166     char zBuf[200];

   167     int r2 = sqlite3_errcode(db);

   168     sprintf(zBuf, "error code %s (%d) does not match sqlite3_errcode %s (%d)",

   169        t1ErrorName(rc), rc, t1ErrorName(r2), r2);

   170     Tcl_ResetResult(interp);

   171     Tcl_AppendResult(interp, zBuf, 0);

   172     return 1;

   173   }

   174   return 0;

   175 }

   176 

   177 /*

   178 ** Decode a pointer to an sqlite3_stmt object.

   179 */

   180 static int getStmtPointer(

   181   Tcl_Interp *interp, 

   182   const char *zArg,  

   183   sqlite3_stmt **ppStmt

   184 ){

   185   *ppStmt = (sqlite3_stmt*)sqlite3TestTextToPtr(zArg);

   186   return TCL_OK;

   187 }

   188 

   189 /*

   190 ** Generate a text representation of a pointer that can be understood

   191 ** by the getDbPointer and getVmPointer routines above.

   192 **

   193 ** The problem is, on some machines (Solaris) if you do a printf with

   194 ** "%p" you cannot turn around and do a scanf with the same "%p" and

   195 ** get your pointer back.  You have to prepend a "0x" before it will

   196 ** work.  Or at least that is what is reported to me (drh).  But this

   197 ** behavior varies from machine to machine.  The solution used her is

   198 ** to test the string right after it is generated to see if it can be

   199 ** understood by scanf, and if not, try prepending an "0x" to see if

   200 ** that helps.  If nothing works, a fatal error is generated.

   201 */

   202 int sqlite3TestMakePointerStr(Tcl_Interp *interp, char *zPtr, void *p){

   203   sqlite3_snprintf(100, zPtr, "%p", p);

   204   return TCL_OK;

   205 }

   206 

   207 /*

   208 ** The callback routine for sqlite3_exec_printf().

   209 */

   210 static int exec_printf_cb(void *pArg, int argc, char **argv, char **name){

   211   Tcl_DString *str = (Tcl_DString*)pArg;

   212   int i;

   213 

   214   if( Tcl_DStringLength(str)==0 ){

   215     for(i=0; i<argc; i++){

   216       Tcl_DStringAppendElement(str, name[i] ? name[i] : "NULL");

   217     }

   218   }

   219   for(i=0; i<argc; i++){

   220     Tcl_DStringAppendElement(str, argv[i] ? argv[i] : "NULL");

   221   }

   222   return 0;

   223 }

   224 

   225 /*

   226 ** The I/O tracing callback.

   227 */

   228 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)

   229 static FILE *iotrace_file = 0;

   230 static void io_trace_callback(const char *zFormat, ...){

   231   va_list ap;

   232   va_start(ap, zFormat);

   233   vfprintf(iotrace_file, zFormat, ap);

   234   va_end(ap);

   235   fflush(iotrace_file);

   236 }

   237 #endif

   238 

   239 /*

   240 ** Usage:  io_trace FILENAME

   241 **

   242 ** Turn I/O tracing on or off.  If FILENAME is not an empty string,

   243 ** I/O tracing begins going into FILENAME. If FILENAME is an empty

   244 ** string, I/O tracing is turned off.

   245 */

   246 static int test_io_trace(

   247   void *NotUsed,

   248   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   249   int argc,              /* Number of arguments */

   250   char **argv            /* Text of each argument */

   251 ){

   252 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)

   253   if( argc!=2 ){

   254     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

   255           " FILENAME\"", 0);

   256     return TCL_ERROR;

   257   }

   258   if( iotrace_file ){

   259     if( iotrace_file!=stdout && iotrace_file!=stderr ){

   260       fclose(iotrace_file);

   261     }

   262     iotrace_file = 0;

   263     sqlite3IoTrace = 0;

   264   }

   265   if( argv[1][0] ){

   266     if( strcmp(argv[1],"stdout")==0 ){

   267       iotrace_file = stdout;

   268     }else if( strcmp(argv[1],"stderr")==0 ){

   269       iotrace_file = stderr;

   270     }else{

   271       iotrace_file = fopen(argv[1], "w");

   272     }

   273     sqlite3IoTrace = io_trace_callback;

   274   }

   275 #endif

   276   return TCL_OK;

   277 }

   278 

   279 

   280 /*

   281 ** Usage:  sqlite3_exec_printf  DB  FORMAT  STRING

   282 **

   283 ** Invoke the sqlite3_exec_printf() interface using the open database

   284 ** DB.  The SQL is the string FORMAT.  The format string should contain

   285 ** one %s or %q.  STRING is the value inserted into %s or %q.

   286 */

   287 static int test_exec_printf(

   288   void *NotUsed,

   289   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   290   int argc,              /* Number of arguments */

   291   char **argv            /* Text of each argument */

   292 ){

   293   sqlite3 *db;

   294   Tcl_DString str;

   295   int rc;

   296   char *zErr = 0;

   297   char *zSql;

   298   char zBuf[30];

   299   if( argc!=4 ){

   300     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 

   301        " DB FORMAT STRING", 0);

   302     return TCL_ERROR;

   303   }

   304   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

   305   Tcl_DStringInit(&str);

   306   zSql = sqlite3_mprintf(argv[2], argv[3]);

   307   rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);

   308   sqlite3_free(zSql);

   309   sprintf(zBuf, "%d", rc);

   310   Tcl_AppendElement(interp, zBuf);

   311   Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);

   312   Tcl_DStringFree(&str);

   313   if( zErr ) sqlite3_free(zErr);

   314   if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;

   315   return TCL_OK;

   316 }

   317 

   318 /*

   319 ** Usage:  db_enter DB

   320 **         db_leave DB

   321 **

   322 ** Enter or leave the mutex on a database connection.

   323 */

   324 static int db_enter(

   325   void *NotUsed,

   326   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   327   int argc,              /* Number of arguments */

   328   char **argv            /* Text of each argument */

   329 ){

   330   sqlite3 *db;

   331   if( argc!=2 ){

   332     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 

   333        " DB", 0);

   334     return TCL_ERROR;

   335   }

   336   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

   337   sqlite3_mutex_enter(db->mutex);

   338   return TCL_OK;

   339 }

   340 static int db_leave(

   341   void *NotUsed,

   342   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   343   int argc,              /* Number of arguments */

   344   char **argv            /* Text of each argument */

   345 ){

   346   sqlite3 *db;

   347   if( argc!=2 ){

   348     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 

   349        " DB", 0);

   350     return TCL_ERROR;

   351   }

   352   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

   353   sqlite3_mutex_leave(db->mutex);

   354   return TCL_OK;

   355 }

   356 

   357 /*

   358 ** Usage:  sqlite3_exec  DB  SQL

   359 **

   360 ** Invoke the sqlite3_exec interface using the open database DB

   361 */

   362 static int test_exec(

   363   void *NotUsed,

   364   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   365   int argc,              /* Number of arguments */

   366   char **argv            /* Text of each argument */

   367 ){

   368   sqlite3 *db;

   369   Tcl_DString str;

   370   int rc;

   371   char *zErr = 0;

   372   char *zSql;

   373   int i, j;

   374   char zBuf[30];

   375   if( argc!=3 ){

   376     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 

   377        " DB SQL", 0);

   378     return TCL_ERROR;

   379   }

   380   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

   381   Tcl_DStringInit(&str);

   382   zSql = sqlite3_mprintf("%s", argv[2]);

   383   for(i=j=0; zSql[i];){

   384     if( zSql[i]=='%' ){

   385       zSql[j++] = (testHexToInt(zSql[i+1])<<4) + testHexToInt(zSql[i+2]);

   386       i += 3;

   387     }else{

   388       zSql[j++] = zSql[i++];

   389     }

   390   }

   391   zSql[j] = 0;

   392   rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);

   393   sqlite3_free(zSql);

   394   sprintf(zBuf, "%d", rc);

   395   Tcl_AppendElement(interp, zBuf);

   396   Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);

   397   Tcl_DStringFree(&str);

   398   if( zErr ) sqlite3_free(zErr);

   399   if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;

   400   return TCL_OK;

   401 }

   402 

   403 /*

   404 ** Usage:  sqlite3_exec_nr  DB  SQL

   405 **

   406 ** Invoke the sqlite3_exec interface using the open database DB.  Discard

   407 ** all results

   408 */

   409 static int test_exec_nr(

   410   void *NotUsed,

   411   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   412   int argc,              /* Number of arguments */

   413   char **argv            /* Text of each argument */

   414 ){

   415   sqlite3 *db;

   416   int rc;

   417   char *zErr = 0;

   418   if( argc!=3 ){

   419     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 

   420        " DB SQL", 0);

   421     return TCL_ERROR;

   422   }

   423   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

   424   rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);

   425   if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;

   426   return TCL_OK;

   427 }

   428 

   429 /*

   430 ** Usage:  sqlite3_mprintf_z_test  SEPARATOR  ARG0  ARG1 ...

   431 **

   432 ** Test the %z format of sqliteMPrintf().  Use multiple mprintf() calls to 

   433 ** concatenate arg0 through argn using separator as the separator.

   434 ** Return the result.

   435 */

   436 static int test_mprintf_z(

   437   void *NotUsed,

   438   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   439   int argc,              /* Number of arguments */

   440   char **argv            /* Text of each argument */

   441 ){

   442   char *zResult = 0;

   443   int i;

   444 

   445   for(i=2; i<argc && (i==2 || zResult); i++){

   446     zResult = sqlite3MPrintf(0, "%z%s%s", zResult, argv[1], argv[i]);

   447   }

   448   Tcl_AppendResult(interp, zResult, 0);

   449   sqlite3_free(zResult);

   450   return TCL_OK;

   451 }

   452 

   453 /*

   454 ** Usage:  sqlite3_mprintf_n_test  STRING

   455 **

   456 ** Test the %n format of sqliteMPrintf().  Return the length of the

   457 ** input string.

   458 */

   459 static int test_mprintf_n(

   460   void *NotUsed,

   461   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   462   int argc,              /* Number of arguments */

   463   char **argv            /* Text of each argument */

   464 ){

   465   char *zStr;

   466   int n = 0;

   467   zStr = sqlite3MPrintf(0, "%s%n", argv[1], &n);

   468   sqlite3_free(zStr);

   469   Tcl_SetObjResult(interp, Tcl_NewIntObj(n));

   470   return TCL_OK;

   471 }

   472 

   473 /*

   474 ** Usage:  sqlite3_snprintf_int  SIZE FORMAT  INT

   475 **

   476 ** Test the of sqlite3_snprintf() routine.  SIZE is the size of the

   477 ** output buffer in bytes.  The maximum size is 100.  FORMAT is the

   478 ** format string.  INT is a single integer argument.  The FORMAT

   479 ** string must require no more than this one integer argument.  If

   480 ** You pass in a format string that requires more than one argument,

   481 ** bad things will happen.

   482 */

   483 static int test_snprintf_int(

   484   void *NotUsed,

   485   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   486   int argc,              /* Number of arguments */

   487   char **argv            /* Text of each argument */

   488 ){

   489   char zStr[100];

   490   int n = atoi(argv[1]);

   491   const char *zFormat = argv[2];

   492   int a1 = atoi(argv[3]);

   493   if( n>sizeof(zStr) ) n = sizeof(zStr);

   494   sqlite3_snprintf(sizeof(zStr), zStr, "abcdefghijklmnopqrstuvwxyz");

   495   sqlite3_snprintf(n, zStr, zFormat, a1);

   496   Tcl_AppendResult(interp, zStr, 0);

   497   return TCL_OK;

   498 }

   499 

   500 #ifndef SQLITE_OMIT_GET_TABLE

   501 

   502 /*

   503 ** Usage:  sqlite3_get_table_printf  DB  FORMAT  STRING  ?--no-counts?

   504 **

   505 ** Invoke the sqlite3_get_table_printf() interface using the open database

   506 ** DB.  The SQL is the string FORMAT.  The format string should contain

   507 ** one %s or %q.  STRING is the value inserted into %s or %q.

   508 */

   509 static int test_get_table_printf(

   510   void *NotUsed,

   511   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   512   int argc,              /* Number of arguments */

   513   char **argv            /* Text of each argument */

   514 ){

   515   sqlite3 *db;

   516   Tcl_DString str;

   517   int rc;

   518   char *zErr = 0;

   519   int nRow, nCol;

   520   char **aResult;

   521   int i;

   522   char zBuf[30];

   523   char *zSql;

   524   int resCount = -1;

   525   if( argc==5 ){

   526     if( Tcl_GetInt(interp, argv[4], &resCount) ) return TCL_ERROR;

   527   }

   528   if( argc!=4 && argc!=5 ){

   529     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 

   530        " DB FORMAT STRING ?COUNT?", 0);

   531     return TCL_ERROR;

   532   }

   533   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

   534   Tcl_DStringInit(&str);

   535   zSql = sqlite3_mprintf(argv[2],argv[3]);

   536   if( argc==5 ){

   537     rc = sqlite3_get_table(db, zSql, &aResult, 0, 0, &zErr);

   538   }else{

   539     rc = sqlite3_get_table(db, zSql, &aResult, &nRow, &nCol, &zErr);

   540     resCount = (nRow+1)*nCol;

   541   }

   542   sqlite3_free(zSql);

   543   sprintf(zBuf, "%d", rc);

   544   Tcl_AppendElement(interp, zBuf);

   545   if( rc==SQLITE_OK ){

   546     if( argc==4 ){

   547       sprintf(zBuf, "%d", nRow);

   548       Tcl_AppendElement(interp, zBuf);

   549       sprintf(zBuf, "%d", nCol);

   550       Tcl_AppendElement(interp, zBuf);

   551     }

   552     for(i=0; i<resCount; i++){

   553       Tcl_AppendElement(interp, aResult[i] ? aResult[i] : "NULL");

   554     }

   555   }else{

   556     Tcl_AppendElement(interp, zErr);

   557   }

   558   sqlite3_free_table(aResult);

   559   if( zErr ) sqlite3_free(zErr);

   560   if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;

   561   return TCL_OK;

   562 }

   563 

   564 #endif /* SQLITE_OMIT_GET_TABLE */

   565 

   566 

   567 /*

   568 ** Usage:  sqlite3_last_insert_rowid DB

   569 **

   570 ** Returns the integer ROWID of the most recent insert.

   571 */

   572 static int test_last_rowid(

   573   void *NotUsed,

   574   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   575   int argc,              /* Number of arguments */

   576   char **argv            /* Text of each argument */

   577 ){

   578   sqlite3 *db;

   579   char zBuf[30];

   580 

   581   if( argc!=2 ){

   582     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB\"", 0);

   583     return TCL_ERROR;

   584   }

   585   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

   586   sprintf(zBuf, "%lld", sqlite3_last_insert_rowid(db));

   587   Tcl_AppendResult(interp, zBuf, 0);

   588   return SQLITE_OK;

   589 }

   590 

   591 /*

   592 ** Usage:  sqlite3_key DB KEY

   593 **

   594 ** Set the codec key.

   595 */

   596 static int test_key(

   597   void *NotUsed,

   598   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   599   int argc,              /* Number of arguments */

   600   char **argv            /* Text of each argument */

   601 ){

   602   sqlite3 *db;

   603   const char *zKey;

   604   int nKey;

   605   if( argc!=3 ){

   606     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

   607        " FILENAME\"", 0);

   608     return TCL_ERROR;

   609   }

   610   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

   611   zKey = argv[2];

   612   nKey = strlen(zKey);

   613 #ifdef SQLITE_HAS_CODEC

   614   sqlite3_key(db, zKey, nKey);

   615 #endif

   616   return TCL_OK;

   617 }

   618 

   619 /*

   620 ** Usage:  sqlite3_rekey DB KEY

   621 **

   622 ** Change the codec key.

   623 */

   624 static int test_rekey(

   625   void *NotUsed,

   626   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   627   int argc,              /* Number of arguments */

   628   char **argv            /* Text of each argument */

   629 ){

   630   sqlite3 *db;

   631   const char *zKey;

   632   int nKey;

   633   if( argc!=3 ){

   634     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

   635        " FILENAME\"", 0);

   636     return TCL_ERROR;

   637   }

   638   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

   639   zKey = argv[2];

   640   nKey = strlen(zKey);

   641 #ifdef SQLITE_HAS_CODEC

   642   sqlite3_rekey(db, zKey, nKey);

   643 #endif

   644   return TCL_OK;

   645 }

   646 

   647 /*

   648 ** Usage:  sqlite3_close DB

   649 **

   650 ** Closes the database opened by sqlite3_open.

   651 */

   652 static int sqlite_test_close(

   653   void *NotUsed,

   654   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   655   int argc,              /* Number of arguments */

   656   char **argv            /* Text of each argument */

   657 ){

   658   sqlite3 *db;

   659   int rc;

   660   if( argc!=2 ){

   661     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

   662        " FILENAME\"", 0);

   663     return TCL_ERROR;

   664   }

   665   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

   666   rc = sqlite3_close(db);

   667   Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);

   668   return TCL_OK;

   669 }

   670 

   671 /*

   672 ** Implementation of the x_coalesce() function.

   673 ** Return the first argument non-NULL argument.

   674 */

   675 static void t1_ifnullFunc(

   676   sqlite3_context *context,

   677   int argc,

   678   sqlite3_value **argv

   679 ){

   680   int i;

   681   for(i=0; i<argc; i++){

   682     if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){

   683       int n = sqlite3_value_bytes(argv[i]);

   684       sqlite3_result_text(context, (char*)sqlite3_value_text(argv[i]),

   685           n, SQLITE_TRANSIENT);

   686       break;

   687     }

   688   }

   689 }

   690 

   691 /*

   692 ** These are test functions.    hex8() interprets its argument as

   693 ** UTF8 and returns a hex encoding.  hex16le() interprets its argument

   694 ** as UTF16le and returns a hex encoding.

   695 */

   696 static void hex8Func(sqlite3_context *p, int argc, sqlite3_value **argv){

   697   const unsigned char *z;

   698   int i;

   699   char zBuf[200];

   700   z = sqlite3_value_text(argv[0]);

   701   for(i=0; i<sizeof(zBuf)/2 - 2 && z[i]; i++){

   702     sprintf(&zBuf[i*2], "%02x", z[i]&0xff);

   703   }

   704   zBuf[i*2] = 0;

   705   sqlite3_result_text(p, (char*)zBuf, -1, SQLITE_TRANSIENT);

   706 }

   707 #ifndef SQLITE_OMIT_UTF16

   708 static void hex16Func(sqlite3_context *p, int argc, sqlite3_value **argv){

   709   const unsigned short int *z;

   710   int i;

   711   char zBuf[400];

   712   z = sqlite3_value_text16(argv[0]);

   713   for(i=0; i<sizeof(zBuf)/4 - 4 && z[i]; i++){

   714     sprintf(&zBuf[i*4], "%04x", z[i]&0xff);

   715   }

   716   zBuf[i*4] = 0;

   717   sqlite3_result_text(p, (char*)zBuf, -1, SQLITE_TRANSIENT);

   718 }

   719 #endif

   720 

   721 /*

   722 ** A structure into which to accumulate text.

   723 */

   724 struct dstr {

   725   int nAlloc;  /* Space allocated */

   726   int nUsed;   /* Space used */

   727   char *z;     /* The space */

   728 };

   729 

   730 /*

   731 ** Append text to a dstr

   732 */

   733 static void dstrAppend(struct dstr *p, const char *z, int divider){

   734   int n = strlen(z);

   735   if( p->nUsed + n + 2 > p->nAlloc ){

   736     char *zNew;

   737     p->nAlloc = p->nAlloc*2 + n + 200;

   738     zNew = sqlite3_realloc(p->z, p->nAlloc);

   739     if( zNew==0 ){

   740       sqlite3_free(p->z);

   741       memset(p, 0, sizeof(*p));

   742       return;

   743     }

   744     p->z = zNew;

   745   }

   746   if( divider && p->nUsed>0 ){

   747     p->z[p->nUsed++] = divider;

   748   }

   749   memcpy(&p->z[p->nUsed], z, n+1);

   750   p->nUsed += n;

   751 }

   752 

   753 /*

   754 ** Invoked for each callback from sqlite3ExecFunc

   755 */

   756 static int execFuncCallback(void *pData, int argc, char **argv, char **NotUsed){

   757   struct dstr *p = (struct dstr*)pData;

   758   int i;

   759   for(i=0; i<argc; i++){

   760     if( argv[i]==0 ){

   761       dstrAppend(p, "NULL", ' ');

   762     }else{

   763       dstrAppend(p, argv[i], ' ');

   764     }

   765   }

   766   return 0;

   767 }

   768 

   769 /*

   770 ** Implementation of the x_sqlite_exec() function.  This function takes

   771 ** a single argument and attempts to execute that argument as SQL code.

   772 ** This is illegal and should set the SQLITE_MISUSE flag on the database.

   773 **

   774 ** 2004-Jan-07:  We have changed this to make it legal to call sqlite3_exec()

   775 ** from within a function call.  

   776 ** 

   777 ** This routine simulates the effect of having two threads attempt to

   778 ** use the same database at the same time.

   779 */

   780 static void sqlite3ExecFunc(

   781   sqlite3_context *context, 

   782   int argc,  

   783   sqlite3_value **argv

   784 ){

   785   struct dstr x;

   786   memset(&x, 0, sizeof(x));

   787   (void)sqlite3_exec((sqlite3*)sqlite3_user_data(context),

   788       (char*)sqlite3_value_text(argv[0]),

   789       execFuncCallback, &x, 0);

   790   sqlite3_result_text(context, x.z, x.nUsed, SQLITE_TRANSIENT);

   791   sqlite3_free(x.z);

   792 }

   793 

   794 /*

   795 ** Implementation of tkt2213func(), a scalar function that takes exactly

   796 ** one argument. It has two interesting features:

   797 **

   798 ** * It calls sqlite3_value_text() 3 times on the argument sqlite3_value*.

   799 **   If the three pointers returned are not the same an SQL error is raised.

   800 **

   801 ** * Otherwise it returns a copy of the text representation of its 

   802 **   argument in such a way as the VDBE representation is a Mem* cell 

   803 **   with the MEM_Term flag clear. 

   804 **

   805 ** Ticket #2213 can therefore be tested by evaluating the following

   806 ** SQL expression:

   807 **

   808 **   tkt2213func(tkt2213func('a string'));

   809 */

   810 static void tkt2213Function(

   811   sqlite3_context *context, 

   812   int argc,  

   813   sqlite3_value **argv

   814 ){

   815   int nText;

   816   unsigned char const *zText1;

   817   unsigned char const *zText2;

   818   unsigned char const *zText3;

   819 

   820   nText = sqlite3_value_bytes(argv[0]);

   821   zText1 = sqlite3_value_text(argv[0]);

   822   zText2 = sqlite3_value_text(argv[0]);

   823   zText3 = sqlite3_value_text(argv[0]);

   824 

   825   if( zText1!=zText2 || zText2!=zText3 ){

   826     sqlite3_result_error(context, "tkt2213 is not fixed", -1);

   827   }else{

   828     char *zCopy = (char *)sqlite3_malloc(nText);

   829     memcpy(zCopy, zText1, nText);

   830     sqlite3_result_text(context, zCopy, nText, sqlite3_free);

   831   }

   832 }

   833 

   834 /*

   835 ** The following SQL function takes 4 arguments.  The 2nd and

   836 ** 4th argument must be one of these strings:  'text', 'text16',

   837 ** or 'blob' corresponding to API functions

   838 **

   839 **      sqlite3_value_text()

   840 **      sqlite3_value_text16()

   841 **      sqlite3_value_blob()

   842 **

   843 ** The third argument is a string, either 'bytes' or 'bytes16' or 'noop',

   844 ** corresponding to APIs:

   845 **

   846 **      sqlite3_value_bytes()

   847 **      sqlite3_value_bytes16()

   848 **      noop

   849 **

   850 ** The APIs designated by the 2nd through 4th arguments are applied

   851 ** to the first argument in order.  If the pointers returned by the

   852 ** second and fourth are different, this routine returns 1.  Otherwise,

   853 ** this routine returns 0.

   854 **

   855 ** This function is used to test to see when returned pointers from

   856 ** the _text(), _text16() and _blob() APIs become invalidated.

   857 */

   858 static void ptrChngFunction(

   859   sqlite3_context *context, 

   860   int argc,  

   861   sqlite3_value **argv

   862 ){

   863   const void *p1, *p2;

   864   const char *zCmd;

   865   if( argc!=4 ) return;

   866   zCmd = (const char*)sqlite3_value_text(argv[1]);

   867   if( zCmd==0 ) return;

   868   if( strcmp(zCmd,"text")==0 ){

   869     p1 = (const void*)sqlite3_value_text(argv[0]);

   870 #ifndef SQLITE_OMIT_UTF16

   871   }else if( strcmp(zCmd, "text16")==0 ){

   872     p1 = (const void*)sqlite3_value_text16(argv[0]);

   873 #endif

   874   }else if( strcmp(zCmd, "blob")==0 ){

   875     p1 = (const void*)sqlite3_value_blob(argv[0]);

   876   }else{

   877     return;

   878   }

   879   zCmd = (const char*)sqlite3_value_text(argv[2]);

   880   if( zCmd==0 ) return;

   881   if( strcmp(zCmd,"bytes")==0 ){

   882     sqlite3_value_bytes(argv[0]);

   883 #ifndef SQLITE_OMIT_UTF16

   884   }else if( strcmp(zCmd, "bytes16")==0 ){

   885     sqlite3_value_bytes16(argv[0]);

   886 #endif

   887   }else if( strcmp(zCmd, "noop")==0 ){

   888     /* do nothing */

   889   }else{

   890     return;

   891   }

   892   zCmd = (const char*)sqlite3_value_text(argv[3]);

   893   if( zCmd==0 ) return;

   894   if( strcmp(zCmd,"text")==0 ){

   895     p2 = (const void*)sqlite3_value_text(argv[0]);

   896 #ifndef SQLITE_OMIT_UTF16

   897   }else if( strcmp(zCmd, "text16")==0 ){

   898     p2 = (const void*)sqlite3_value_text16(argv[0]);

   899 #endif

   900   }else if( strcmp(zCmd, "blob")==0 ){

   901     p2 = (const void*)sqlite3_value_blob(argv[0]);

   902   }else{

   903     return;

   904   }

   905   sqlite3_result_int(context, p1!=p2);

   906 }

   907 

   908 

   909 /*

   910 ** Usage:  sqlite_test_create_function DB

   911 **

   912 ** Call the sqlite3_create_function API on the given database in order

   913 ** to create a function named "x_coalesce".  This function does the same thing

   914 ** as the "coalesce" function.  This function also registers an SQL function

   915 ** named "x_sqlite_exec" that invokes sqlite3_exec().  Invoking sqlite3_exec()

   916 ** in this way is illegal recursion and should raise an SQLITE_MISUSE error.

   917 ** The effect is similar to trying to use the same database connection from

   918 ** two threads at the same time.

   919 **

   920 ** The original motivation for this routine was to be able to call the

   921 ** sqlite3_create_function function while a query is in progress in order

   922 ** to test the SQLITE_MISUSE detection logic.

   923 */

   924 static int test_create_function(

   925   void *NotUsed,

   926   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   927   int argc,              /* Number of arguments */

   928   char **argv            /* Text of each argument */

   929 ){

   930   int rc;

   931   sqlite3 *db;

   932 

   933   if( argc!=2 ){

   934     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

   935        " DB\"", 0);

   936     return TCL_ERROR;

   937   }

   938   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

   939   rc = sqlite3_create_function(db, "x_coalesce", -1, SQLITE_ANY, 0, 

   940         t1_ifnullFunc, 0, 0);

   941   if( rc==SQLITE_OK ){

   942     rc = sqlite3_create_function(db, "hex8", 1, SQLITE_ANY, 0, 

   943           hex8Func, 0, 0);

   944   }

   945 #ifndef SQLITE_OMIT_UTF16

   946   if( rc==SQLITE_OK ){

   947     rc = sqlite3_create_function(db, "hex16", 1, SQLITE_ANY, 0, 

   948           hex16Func, 0, 0);

   949   }

   950 #endif

   951   if( rc==SQLITE_OK ){

   952     rc = sqlite3_create_function(db, "tkt2213func", 1, SQLITE_ANY, 0, 

   953           tkt2213Function, 0, 0);

   954   }

   955   if( rc==SQLITE_OK ){

   956     rc = sqlite3_create_function(db, "pointer_change", 4, SQLITE_ANY, 0, 

   957           ptrChngFunction, 0, 0);

   958   }

   959 

   960 #ifndef SQLITE_OMIT_UTF16

   961   /* Use the sqlite3_create_function16() API here. Mainly for fun, but also 

   962   ** because it is not tested anywhere else. */

   963   if( rc==SQLITE_OK ){

   964     const void *zUtf16;

   965     sqlite3_value *pVal;

   966     sqlite3_mutex_enter(db->mutex);

   967     pVal = sqlite3ValueNew(db);

   968     sqlite3ValueSetStr(pVal, -1, "x_sqlite_exec", SQLITE_UTF8, SQLITE_STATIC);

   969     zUtf16 = sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);

   970     if( db->mallocFailed ){

   971       rc = SQLITE_NOMEM;

   972     }else{

   973       rc = sqlite3_create_function16(db, zUtf16, 

   974                 1, SQLITE_UTF16, db, sqlite3ExecFunc, 0, 0);

   975     }

   976     sqlite3ValueFree(pVal);

   977     sqlite3_mutex_leave(db->mutex);

   978   }

   979 #endif

   980 

   981   if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;

   982   Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);

   983   return TCL_OK;

   984 }

   985 

   986 /*

   987 ** Routines to implement the x_count() aggregate function.

   988 **

   989 ** x_count() counts the number of non-null arguments.  But there are

   990 ** some twists for testing purposes.

   991 **

   992 ** If the argument to x_count() is 40 then a UTF-8 error is reported

   993 ** on the step function.  If x_count(41) is seen, then a UTF-16 error

   994 ** is reported on the step function.  If the total count is 42, then

   995 ** a UTF-8 error is reported on the finalize function.

   996 */

   997 typedef struct t1CountCtx t1CountCtx;

   998 struct t1CountCtx {

   999   int n;

  1000 };

  1001 static void t1CountStep(

  1002   sqlite3_context *context,

  1003   int argc,

  1004   sqlite3_value **argv

  1005 ){

  1006   t1CountCtx *p;

  1007   p = sqlite3_aggregate_context(context, sizeof(*p));

  1008   if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0]) ) && p ){

  1009     p->n++;

  1010   }

  1011   if( argc>0 ){

  1012     int v = sqlite3_value_int(argv[0]);

  1013     if( v==40 ){

  1014       sqlite3_result_error(context, "value of 40 handed to x_count", -1);

  1015 #ifndef SQLITE_OMIT_UTF16

  1016     }else if( v==41 ){

  1017       const char zUtf16ErrMsg[] = { 0, 0x61, 0, 0x62, 0, 0x63, 0, 0, 0};

  1018       sqlite3_result_error16(context, &zUtf16ErrMsg[1-SQLITE_BIGENDIAN], -1);

  1019 #endif

  1020     }

  1021   }

  1022 }   

  1023 static void t1CountFinalize(sqlite3_context *context){

  1024   t1CountCtx *p;

  1025   p = sqlite3_aggregate_context(context, sizeof(*p));

  1026   if( p ){

  1027     if( p->n==42 ){

  1028       sqlite3_result_error(context, "x_count totals to 42", -1);

  1029     }else{

  1030       sqlite3_result_int(context, p ? p->n : 0);

  1031     }

  1032   }

  1033 }

  1034 

  1035 static void legacyCountStep(

  1036   sqlite3_context *context,

  1037   int argc,

  1038   sqlite3_value **argv

  1039 ){

  1040   /* no-op */

  1041 }

  1042 static void legacyCountFinalize(sqlite3_context *context){

  1043   sqlite3_result_int(context, sqlite3_aggregate_count(context));

  1044 }

  1045 

  1046 /*

  1047 ** Usage:  sqlite3_create_aggregate DB

  1048 **

  1049 ** Call the sqlite3_create_function API on the given database in order

  1050 ** to create a function named "x_count".  This function is similar

  1051 ** to the built-in count() function, with a few special quirks

  1052 ** for testing the sqlite3_result_error() APIs.

  1053 **

  1054 ** The original motivation for this routine was to be able to call the

  1055 ** sqlite3_create_aggregate function while a query is in progress in order

  1056 ** to test the SQLITE_MISUSE detection logic.  See misuse.test.

  1057 **

  1058 ** This routine was later extended to test the use of sqlite3_result_error()

  1059 ** within aggregate functions.

  1060 **

  1061 ** Later: It is now also extended to register the aggregate function

  1062 ** "legacy_count()" with the supplied database handle. This is used

  1063 ** to test the deprecated sqlite3_aggregate_count() API.

  1064 */

  1065 static int test_create_aggregate(

  1066   void *NotUsed,

  1067   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

  1068   int argc,              /* Number of arguments */

  1069   char **argv            /* Text of each argument */

  1070 ){

  1071   sqlite3 *db;

  1072   int rc;

  1073   if( argc!=2 ){

  1074     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

  1075        " FILENAME\"", 0);

  1076     return TCL_ERROR;

  1077   }

  1078   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;

  1079   rc = sqlite3_create_function(db, "x_count", 0, SQLITE_UTF8, 0, 0,

  1080       t1CountStep,t1CountFinalize);

  1081   if( rc==SQLITE_OK ){

  1082     rc = sqlite3_create_function(db, "x_count", 1, SQLITE_UTF8, 0, 0,

  1083         t1CountStep,t1CountFinalize);

  1084   }

  1085   if( rc==SQLITE_OK ){

  1086     rc = sqlite3_create_function(db, "legacy_count", 0, SQLITE_ANY, 0, 0,

  1087         legacyCountStep, legacyCountFinalize

  1088     );

  1089   }

  1090   if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;

  1091   Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);

  1092   return TCL_OK;

  1093 }

  1094 

  1095 

  1096 /*

  1097 ** Usage:  printf TEXT

  1098 **

  1099 ** Send output to printf.  Use this rather than puts to merge the output

  1100 ** in the correct sequence with debugging printfs inserted into C code.

  1101 ** Puts uses a separate buffer and debugging statements will be out of

  1102 ** sequence if it is used.

  1103 */

  1104 static int test_printf(

  1105   void *NotUsed,

  1106   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

  1107   int argc,              /* Number of arguments */

  1108   char **argv            /* Text of each argument */

  1109 ){

  1110   if( argc!=2 ){

  1111     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

  1112        " TEXT\"", 0);

  1113     return TCL_ERROR;

  1114   }

  1115   printf("%s\n", argv[1]);

  1116   return TCL_OK;

  1117 }

  1118 

  1119 

  1120 

  1121 /*

  1122 ** Usage:  sqlite3_mprintf_int FORMAT INTEGER INTEGER INTEGER

  1123 **

  1124 ** Call mprintf with three integer arguments

  1125 */

  1126 static int sqlite3_mprintf_int(

  1127   void *NotUsed,

  1128   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

  1129   int argc,              /* Number of arguments */

  1130   char **argv            /* Text of each argument */

  1131 ){

  1132   int a[3], i;

  1133   char *z;

  1134   if( argc!=5 ){

  1135     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],