third_party/sqlite/sqlite-src-3070603/src/test_func.c

   1 /*
   2 ** 2008 March 19
   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 ** implements new SQL functions used by the test scripts.
  14 */
  15 #include "sqlite3.h"
  16 #include "tcl.h"
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <assert.h>
  20
  21
  22 /*
  23 ** Allocate nByte bytes of space using sqlite3_malloc(). If the
  24 ** allocation fails, call sqlite3_result_error_nomem() to notify
  25 ** the database handle that malloc() has failed.
  26 */
  27 static void *testContextMalloc(sqlite3_context *context, int nByte){
  28   char *z = sqlite3_malloc(nByte);
  29   if( !z && nByte>0 ){
  30     sqlite3_result_error_nomem(context);
  31   }
  32   return z;
  33 }
  34
  35 /*
  36 ** This function generates a string of random characters.  Used for
  37 ** generating test data.
  38 */
  39 static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){
  40   static const unsigned char zSrc[] =
  41      "abcdefghijklmnopqrstuvwxyz"
  42      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  43      "0123456789"
  44      ".-!,:*^+=_|?/<> ";
  45   int iMin, iMax, n, r, i;
  46   unsigned char zBuf[1000];
  47
  48   /* It used to be possible to call randstr() with any number of arguments,
  49   ** but now it is registered with SQLite as requiring exactly 2.
  50   */
  51   assert(argc==2);
  52
  53   iMin = sqlite3_value_int(argv[0]);
  54   if( iMin<0 ) iMin = 0;
  55   if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1;
  56   iMax = sqlite3_value_int(argv[1]);
  57   if( iMax<iMin ) iMax = iMin;
  58   if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1;
  59   n = iMin;
  60   if( iMax>iMin ){
  61     sqlite3_randomness(sizeof(r), &r);
  62     r &= 0x7fffffff;
  63     n += r%(iMax + 1 - iMin);
  64   }
  65   assert( n<sizeof(zBuf) );
  66   sqlite3_randomness(n, zBuf);
  67   for(i=0; i<n; i++){
  68     zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)];
  69   }
  70   zBuf[n] = 0;
  71   sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT);
  72 }
  73
  74 /*
  75 ** The following two SQL functions are used to test returning a text
  76 ** result with a destructor. Function 'test_destructor' takes one argument
  77 ** and returns the same argument interpreted as TEXT. A destructor is
  78 ** passed with the sqlite3_result_text() call.
  79 **
  80 ** SQL function 'test_destructor_count' returns the number of outstanding
  81 ** allocations made by 'test_destructor';
  82 **
  83 ** WARNING: Not threadsafe.
  84 */
  85 static int test_destructor_count_var = 0;
  86 static void destructor(void *p){
  87   char *zVal = (char *)p;
  88   assert(zVal);
  89   zVal--;
  90   sqlite3_free(zVal);
  91   test_destructor_count_var--;
  92 }
  93 static void test_destructor(
  94   sqlite3_context *pCtx,
  95   int nArg,
  96   sqlite3_value **argv
  97 ){
  98   char *zVal;
  99   int len;
 100
 101   test_destructor_count_var++;
 102   assert( nArg==1 );
 103   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
 104   len = sqlite3_value_bytes(argv[0]);
 105   zVal = testContextMalloc(pCtx, len+3);
 106   if( !zVal ){
 107     return;
 108   }
 109   zVal[len+1] = 0;
 110   zVal[len+2] = 0;
 111   zVal++;
 112   memcpy(zVal, sqlite3_value_text(argv[0]), len);
 113   sqlite3_result_text(pCtx, zVal, -1, destructor);
 114 }
 115 #ifndef SQLITE_OMIT_UTF16
 116 static void test_destructor16(
 117   sqlite3_context *pCtx,
 118   int nArg,
 119   sqlite3_value **argv
 120 ){
 121   char *zVal;
 122   int len;
 123
 124   test_destructor_count_var++;
 125   assert( nArg==1 );
 126   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
 127   len = sqlite3_value_bytes16(argv[0]);
 128   zVal = testContextMalloc(pCtx, len+3);
 129   if( !zVal ){
 130     return;
 131   }
 132   zVal[len+1] = 0;
 133   zVal[len+2] = 0;
 134   zVal++;
 135   memcpy(zVal, sqlite3_value_text16(argv[0]), len);
 136   sqlite3_result_text16(pCtx, zVal, -1, destructor);
 137 }
 138 #endif
 139 static void test_destructor_count(
 140   sqlite3_context *pCtx,
 141   int nArg,
 142   sqlite3_value **argv
 143 ){
 144   sqlite3_result_int(pCtx, test_destructor_count_var);
 145 }
 146
 147 /*
 148 ** The following aggregate function, test_agg_errmsg16(), takes zero
 149 ** arguments. It returns the text value returned by the sqlite3_errmsg16()
 150 ** API function.
 151 */
 152 #ifndef SQLITE_OMIT_BUILTIN_TEST
 153 void sqlite3BeginBenignMalloc(void);
 154 void sqlite3EndBenignMalloc(void);
 155 #else
 156   #define sqlite3BeginBenignMalloc()
 157   #define sqlite3EndBenignMalloc()
 158 #endif
 159 static void test_agg_errmsg16_step(sqlite3_context *a, int b,sqlite3_value **c){
 160 }
 161 static void test_agg_errmsg16_final(sqlite3_context *ctx){
 162 #ifndef SQLITE_OMIT_UTF16
 163   const void *z;
 164   sqlite3 * db = sqlite3_context_db_handle(ctx);
 165   sqlite3_aggregate_context(ctx, 2048);
 166   sqlite3BeginBenignMalloc();
 167   z = sqlite3_errmsg16(db);
 168   sqlite3EndBenignMalloc();
 169   sqlite3_result_text16(ctx, z, -1, SQLITE_TRANSIENT);
 170 #endif
 171 }
 172
 173 /*
 174 ** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata()
 175 ** interface.
 176 **
 177 ** The test_auxdata() SQL function attempts to register each of its arguments
 178 ** as auxiliary data.  If there are no prior registrations of aux data for
 179 ** that argument (meaning the argument is not a constant or this is its first
 180 ** call) then the result for that argument is 0.  If there is a prior
 181 ** registration, the result for that argument is 1.  The overall result
 182 ** is the individual argument results separated by spaces.
 183 */
 184 static void free_test_auxdata(void *p) {sqlite3_free(p);}
 185 static void test_auxdata(
 186   sqlite3_context *pCtx,
 187   int nArg,
 188   sqlite3_value **argv
 189 ){
 190   int i;
 191   char *zRet = testContextMalloc(pCtx, nArg*2);
 192   if( !zRet ) return;
 193   memset(zRet, 0, nArg*2);
 194   for(i=0; i<nArg; i++){
 195     char const *z = (char*)sqlite3_value_text(argv[i]);
 196     if( z ){
 197       int n;
 198       char *zAux = sqlite3_get_auxdata(pCtx, i);
 199       if( zAux ){
 200         zRet[i*2] = '1';
 201         assert( strcmp(zAux,z)==0 );
 202       }else {
 203         zRet[i*2] = '0';
 204       }
 205       n = strlen(z) + 1;
 206       zAux = testContextMalloc(pCtx, n);
 207       if( zAux ){
 208         memcpy(zAux, z, n);
 209         sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata);
 210       }
 211       zRet[i*2+1] = ' ';
 212     }
 213   }
 214   sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata);
 215 }
 216
 217 /*
 218 ** A function to test error reporting from user functions. This function
 219 ** returns a copy of its first argument as the error message.  If the
 220 ** second argument exists, it becomes the error code.
 221 */
 222 static void test_error(
 223   sqlite3_context *pCtx,
 224   int nArg,
 225   sqlite3_value **argv
 226 ){
 227   sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), -1);
 228   if( nArg==2 ){
 229     sqlite3_result_error_code(pCtx, sqlite3_value_int(argv[1]));
 230   }
 231 }
 232
 233 /*
 234 ** Implementation of the counter(X) function.  If X is an integer
 235 ** constant, then the first invocation will return X.  The second X+1.
 236 ** and so forth.  Can be used (for example) to provide a sequence number
 237 ** in a result set.
 238 */
 239 static void counterFunc(
 240   sqlite3_context *pCtx,   /* Function context */
 241   int nArg,                /* Number of function arguments */
 242   sqlite3_value **argv     /* Values for all function arguments */
 243 ){
 244   int *pCounter = (int*)sqlite3_get_auxdata(pCtx, 0);
 245   if( pCounter==0 ){
 246     pCounter = sqlite3_malloc( sizeof(*pCounter) );
 247     if( pCounter==0 ){
 248       sqlite3_result_error_nomem(pCtx);
 249       return;
 250     }
 251     *pCounter = sqlite3_value_int(argv[0]);
 252     sqlite3_set_auxdata(pCtx, 0, pCounter, sqlite3_free);
 253   }else{
 254     ++*pCounter;
 255   }
 256   sqlite3_result_int(pCtx, *pCounter);
 257 }
 258
 259
 260 /*
 261 ** This function takes two arguments.  It performance UTF-8/16 type
 262 ** conversions on the first argument then returns a copy of the second
 263 ** argument.
 264 **
 265 ** This function is used in cases such as the following:
 266 **
 267 **      SELECT test_isolation(x,x) FROM t1;
 268 **
 269 ** We want to verify that the type conversions that occur on the
 270 ** first argument do not invalidate the second argument.
 271 */
 272 static void test_isolation(
 273   sqlite3_context *pCtx,
 274   int nArg,
 275   sqlite3_value **argv
 276 ){
 277 #ifndef SQLITE_OMIT_UTF16
 278   sqlite3_value_text16(argv[0]);
 279   sqlite3_value_text(argv[0]);
 280   sqlite3_value_text16(argv[0]);
 281   sqlite3_value_text(argv[0]);
 282 #endif
 283   sqlite3_result_value(pCtx, argv[1]);
 284 }
 285
 286 /*
 287 ** Invoke an SQL statement recursively.  The function result is the
 288 ** first column of the first row of the result set.
 289 */
 290 static void test_eval(
 291   sqlite3_context *pCtx,
 292   int nArg,
 293   sqlite3_value **argv
 294 ){
 295   sqlite3_stmt *pStmt;
 296   int rc;
 297   sqlite3 *db = sqlite3_context_db_handle(pCtx);
 298   const char *zSql;
 299
 300   zSql = (char*)sqlite3_value_text(argv[0]);
 301   rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
 302   if( rc==SQLITE_OK ){
 303     rc = sqlite3_step(pStmt);
 304     if( rc==SQLITE_ROW ){
 305       sqlite3_result_value(pCtx, sqlite3_column_value(pStmt, 0));
 306     }
 307     rc = sqlite3_finalize(pStmt);
 308   }
 309   if( rc ){
 310     char *zErr;
 311     assert( pStmt==0 );
 312     zErr = sqlite3_mprintf("sqlite3_prepare_v2() error: %s",sqlite3_errmsg(db));
 313     sqlite3_result_text(pCtx, zErr, -1, sqlite3_free);
 314     sqlite3_result_error_code(pCtx, rc);
 315   }
 316 }
 317
 318
 319 /*
 320 ** convert one character from hex to binary
 321 */
 322 static int testHexChar(char c){
 323   if( c>='0' && c<='9' ){
 324     return c - '0';
 325   }else if( c>='a' && c<='f' ){
 326     return c - 'a' + 10;
 327   }else if( c>='A' && c<='F' ){
 328     return c - 'A' + 10;
 329   }
 330   return 0;
 331 }
 332
 333 /*
 334 ** Convert hex to binary.
 335 */
 336 static void testHexToBin(const char *zIn, char *zOut){
 337   while( zIn[0] && zIn[1] ){
 338     *(zOut++) = (testHexChar(zIn[0])<<4) + testHexChar(zIn[1]);
 339     zIn += 2;
 340   }
 341 }
 342
 343 /*
 344 **      hex_to_utf16be(HEX)
 345 **
 346 ** Convert the input string from HEX into binary.  Then return the
 347 ** result using sqlite3_result_text16le().
 348 */
 349 #ifndef SQLITE_OMIT_UTF16
 350 static void testHexToUtf16be(
 351   sqlite3_context *pCtx,
 352   int nArg,
 353   sqlite3_value **argv
 354 ){
 355   int n;
 356   const char *zIn;
 357   char *zOut;
 358   assert( nArg==1 );
 359   n = sqlite3_value_bytes(argv[0]);
 360   zIn = (const char*)sqlite3_value_text(argv[0]);
 361   zOut = sqlite3_malloc( n/2 );
 362   if( zOut==0 ){
 363     sqlite3_result_error_nomem(pCtx);
 364   }else{
 365     testHexToBin(zIn, zOut);
 366     sqlite3_result_text16be(pCtx, zOut, n/2, sqlite3_free);
 367   }
 368 }
 369 #endif
 370
 371 /*
 372 **      hex_to_utf8(HEX)
 373 **
 374 ** Convert the input string from HEX into binary.  Then return the
 375 ** result using sqlite3_result_text16le().
 376 */
 377 static void testHexToUtf8(
 378   sqlite3_context *pCtx,
 379   int nArg,
 380   sqlite3_value **argv
 381 ){
 382   int n;
 383   const char *zIn;
 384   char *zOut;
 385   assert( nArg==1 );
 386   n = sqlite3_value_bytes(argv[0]);
 387   zIn = (const char*)sqlite3_value_text(argv[0]);
 388   zOut = sqlite3_malloc( n/2 );
 389   if( zOut==0 ){
 390     sqlite3_result_error_nomem(pCtx);
 391   }else{
 392     testHexToBin(zIn, zOut);
 393     sqlite3_result_text(pCtx, zOut, n/2, sqlite3_free);
 394   }
 395 }
 396
 397 /*
 398 **      hex_to_utf16le(HEX)
 399 **
 400 ** Convert the input string from HEX into binary.  Then return the
 401 ** result using sqlite3_result_text16le().
 402 */
 403 #ifndef SQLITE_OMIT_UTF16
 404 static void testHexToUtf16le(
 405   sqlite3_context *pCtx,
 406   int nArg,
 407   sqlite3_value **argv
 408 ){
 409   int n;
 410   const char *zIn;
 411   char *zOut;
 412   assert( nArg==1 );
 413   n = sqlite3_value_bytes(argv[0]);
 414   zIn = (const char*)sqlite3_value_text(argv[0]);
 415   zOut = sqlite3_malloc( n/2 );
 416   if( zOut==0 ){
 417     sqlite3_result_error_nomem(pCtx);
 418   }else{
 419     testHexToBin(zIn, zOut);
 420     sqlite3_result_text16le(pCtx, zOut, n/2, sqlite3_free);
 421   }
 422 }
 423 #endif
 424
 425 static int registerTestFunctions(sqlite3 *db){
 426   static const struct {
 427      char *zName;
 428      signed char nArg;
 429      unsigned char eTextRep; /* 1: UTF-16.  0: UTF-8 */
 430      void (*xFunc)(sqlite3_context*,int,sqlite3_value **);
 431   } aFuncs[] = {
 432     { "randstr",               2, SQLITE_UTF8, randStr    },
 433     { "test_destructor",       1, SQLITE_UTF8, test_destructor},
 434 #ifndef SQLITE_OMIT_UTF16
 435     { "test_destructor16",     1, SQLITE_UTF8, test_destructor16},
 436     { "hex_to_utf16be",        1, SQLITE_UTF8, testHexToUtf16be},
 437     { "hex_to_utf16le",        1, SQLITE_UTF8, testHexToUtf16le},
 438 #endif
 439     { "hex_to_utf8",           1, SQLITE_UTF8, testHexToUtf8},
 440     { "test_destructor_count", 0, SQLITE_UTF8, test_destructor_count},
 441     { "test_auxdata",         -1, SQLITE_UTF8, test_auxdata},
 442     { "test_error",            1, SQLITE_UTF8, test_error},
 443     { "test_error",            2, SQLITE_UTF8, test_error},
 444     { "test_eval",             1, SQLITE_UTF8, test_eval},
 445     { "test_isolation",        2, SQLITE_UTF8, test_isolation},
 446     { "test_counter",          1, SQLITE_UTF8, counterFunc},
 447   };
 448   int i;
 449
 450   for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
 451     sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg,
 452         aFuncs[i].eTextRep, 0, aFuncs[i].xFunc, 0, 0);
 453   }
 454
 455   sqlite3_create_function(db, "test_agg_errmsg16", 0, SQLITE_ANY, 0, 0,
 456       test_agg_errmsg16_step, test_agg_errmsg16_final);
 457
 458   return SQLITE_OK;
 459 }
 460
 461 /*
 462 ** TCLCMD:  autoinstall_test_functions
 463 **
 464 ** Invoke this TCL command to use sqlite3_auto_extension() to cause
 465 ** the standard set of test functions to be loaded into each new
 466 ** database connection.
 467 */
 468 static int autoinstall_test_funcs(
 469   void * clientData,
 470   Tcl_Interp *interp,
 471   int objc,
 472   Tcl_Obj *CONST objv[]
 473 ){
 474   extern int Md5_Register(sqlite3*);
 475   int rc = sqlite3_auto_extension((void*)registerTestFunctions);
 476   if( rc==SQLITE_OK ){
 477     rc = sqlite3_auto_extension((void*)Md5_Register);
 478   }
 479   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
 480   return TCL_OK;
 481 }
 482
 483 /*
 484 ** A bogus step function and finalizer function.
 485 */
 486 static void tStep(sqlite3_context *a, int b, sqlite3_value **c){}
 487 static void tFinal(sqlite3_context *a){}
 488
 489
 490 /*
 491 ** tclcmd:  abuse_create_function
 492 **
 493 ** Make various calls to sqlite3_create_function that do not have valid
 494 ** parameters.  Verify that the error condition is detected and reported.
 495 */
 496 static int abuse_create_function(
 497   void * clientData,
 498   Tcl_Interp *interp,
 499   int objc,
 500   Tcl_Obj *CONST objv[]
 501 ){
 502   extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
 503   sqlite3 *db;
 504   int rc;
 505   int mxArg;
 506
 507   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
 508
 509   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep,tStep,tFinal);
 510   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 511
 512   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, tStep, 0);
 513   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 514
 515   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, 0, tFinal);
 516   if( rc!=SQLITE_MISUSE) goto abuse_err;
 517
 518   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, 0, tFinal);
 519   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 520
 521   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, tStep, 0);
 522   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 523
 524   rc = sqlite3_create_function(db, "tx", -2, SQLITE_UTF8, 0, tStep, 0, 0);
 525   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 526
 527   rc = sqlite3_create_function(db, "tx", 128, SQLITE_UTF8, 0, tStep, 0, 0);
 528   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 529
 530   rc = sqlite3_create_function(db, "funcxx"
 531        "_123456789_123456789_123456789_123456789_123456789"
 532        "_123456789_123456789_123456789_123456789_123456789"
 533        "_123456789_123456789_123456789_123456789_123456789"
 534        "_123456789_123456789_123456789_123456789_123456789"
 535        "_123456789_123456789_123456789_123456789_123456789",
 536        1, SQLITE_UTF8, 0, tStep, 0, 0);
 537   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 538
 539   /* This last function registration should actually work.  Generate
 540   ** a no-op function (that always returns NULL) and which has the
 541   ** maximum-length function name and the maximum number of parameters.
 542   */
 543   sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, 10000);
 544   mxArg = sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, -1);
 545   rc = sqlite3_create_function(db, "nullx"
 546        "_123456789_123456789_123456789_123456789_123456789"
 547        "_123456789_123456789_123456789_123456789_123456789"
 548        "_123456789_123456789_123456789_123456789_123456789"
 549        "_123456789_123456789_123456789_123456789_123456789"
 550        "_123456789_123456789_123456789_123456789_123456789",
 551        mxArg, SQLITE_UTF8, 0, tStep, 0, 0);
 552   if( rc!=SQLITE_OK ) goto abuse_err;
 553
 554   return TCL_OK;
 555
 556 abuse_err:
 557   Tcl_AppendResult(interp, "sqlite3_create_function abused test failed",
 558                    (char*)0);
 559   return TCL_ERROR;
 560 }
 561
 562 /*
 563 ** Register commands with the TCL interpreter.
 564 */
 565 int Sqlitetest_func_Init(Tcl_Interp *interp){
 566   static struct {
 567      char *zName;
 568      Tcl_ObjCmdProc *xProc;
 569   } aObjCmd[] = {
 570      { "autoinstall_test_functions",    autoinstall_test_funcs },
 571      { "abuse_create_function",         abuse_create_function  },
 572   };
 573   int i;
 574   extern int Md5_Register(sqlite3*);
 575
 576   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
 577     Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
 578   }
 579   sqlite3_initialize();
 580   sqlite3_auto_extension((void*)registerTestFunctions);
 581   sqlite3_auto_extension((void*)Md5_Register);
 582   return TCL_OK;
 583 }