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 #if defined(INCLUDE_SQLITE_TCL_H)
  17 #  include "sqlite_tcl.h"
  18 #else
  19 #  include "tcl.h"
  20 #endif
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <assert.h>
  24
  25 #include "sqliteInt.h"
  26 #include "vdbeInt.h"
  27
  28 /*
  29 ** Allocate nByte bytes of space using sqlite3_malloc(). If the
  30 ** allocation fails, call sqlite3_result_error_nomem() to notify
  31 ** the database handle that malloc() has failed.
  32 */
  33 static void *testContextMalloc(sqlite3_context *context, int nByte){
  34   char *z = sqlite3_malloc(nByte);
  35   if( !z && nByte>0 ){
  36     sqlite3_result_error_nomem(context);
  37   }
  38   return z;
  39 }
  40
  41 /*
  42 ** This function generates a string of random characters.  Used for
  43 ** generating test data.
  44 */
  45 static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){
  46   static const unsigned char zSrc[] =
  47      "abcdefghijklmnopqrstuvwxyz"
  48      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  49      "0123456789"
  50      ".-!,:*^+=_|?/<> ";
  51   int iMin, iMax, n, r, i;
  52   unsigned char zBuf[1000];
  53
  54   /* It used to be possible to call randstr() with any number of arguments,
  55   ** but now it is registered with SQLite as requiring exactly 2.
  56   */
  57   assert(argc==2);
  58
  59   iMin = sqlite3_value_int(argv[0]);
  60   if( iMin<0 ) iMin = 0;
  61   if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1;
  62   iMax = sqlite3_value_int(argv[1]);
  63   if( iMax<iMin ) iMax = iMin;
  64   if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1;
  65   n = iMin;
  66   if( iMax>iMin ){
  67     sqlite3_randomness(sizeof(r), &r);
  68     r &= 0x7fffffff;
  69     n += r%(iMax + 1 - iMin);
  70   }
  71   assert( n<sizeof(zBuf) );
  72   sqlite3_randomness(n, zBuf);
  73   for(i=0; i<n; i++){
  74     zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)];
  75   }
  76   zBuf[n] = 0;
  77   sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT);
  78 }
  79
  80 /*
  81 ** The following two SQL functions are used to test returning a text
  82 ** result with a destructor. Function 'test_destructor' takes one argument
  83 ** and returns the same argument interpreted as TEXT. A destructor is
  84 ** passed with the sqlite3_result_text() call.
  85 **
  86 ** SQL function 'test_destructor_count' returns the number of outstanding
  87 ** allocations made by 'test_destructor';
  88 **
  89 ** WARNING: Not threadsafe.
  90 */
  91 static int test_destructor_count_var = 0;
  92 static void destructor(void *p){
  93   char *zVal = (char *)p;
  94   assert(zVal);
  95   zVal--;
  96   sqlite3_free(zVal);
  97   test_destructor_count_var--;
  98 }
  99 static void test_destructor(
 100   sqlite3_context *pCtx,
 101   int nArg,
 102   sqlite3_value **argv
 103 ){
 104   char *zVal;
 105   int len;
 106
 107   test_destructor_count_var++;
 108   assert( nArg==1 );
 109   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
 110   len = sqlite3_value_bytes(argv[0]);
 111   zVal = testContextMalloc(pCtx, len+3);
 112   if( !zVal ){
 113     return;
 114   }
 115   zVal[len+1] = 0;
 116   zVal[len+2] = 0;
 117   zVal++;
 118   memcpy(zVal, sqlite3_value_text(argv[0]), len);
 119   sqlite3_result_text(pCtx, zVal, -1, destructor);
 120 }
 121 #ifndef SQLITE_OMIT_UTF16
 122 static void test_destructor16(
 123   sqlite3_context *pCtx,
 124   int nArg,
 125   sqlite3_value **argv
 126 ){
 127   char *zVal;
 128   int len;
 129
 130   test_destructor_count_var++;
 131   assert( nArg==1 );
 132   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
 133   len = sqlite3_value_bytes16(argv[0]);
 134   zVal = testContextMalloc(pCtx, len+3);
 135   if( !zVal ){
 136     return;
 137   }
 138   zVal[len+1] = 0;
 139   zVal[len+2] = 0;
 140   zVal++;
 141   memcpy(zVal, sqlite3_value_text16(argv[0]), len);
 142   sqlite3_result_text16(pCtx, zVal, -1, destructor);
 143 }
 144 #endif
 145 static void test_destructor_count(
 146   sqlite3_context *pCtx,
 147   int nArg,
 148   sqlite3_value **argv
 149 ){
 150   sqlite3_result_int(pCtx, test_destructor_count_var);
 151 }
 152
 153 /*
 154 ** The following aggregate function, test_agg_errmsg16(), takes zero
 155 ** arguments. It returns the text value returned by the sqlite3_errmsg16()
 156 ** API function.
 157 */
 158 #ifndef SQLITE_UNTESTABLE
 159 void sqlite3BeginBenignMalloc(void);
 160 void sqlite3EndBenignMalloc(void);
 161 #else
 162   #define sqlite3BeginBenignMalloc()
 163   #define sqlite3EndBenignMalloc()
 164 #endif
 165 static void test_agg_errmsg16_step(sqlite3_context *a, int b,sqlite3_value **c){
 166 }
 167 static void test_agg_errmsg16_final(sqlite3_context *ctx){
 168 #ifndef SQLITE_OMIT_UTF16
 169   const void *z;
 170   sqlite3 * db = sqlite3_context_db_handle(ctx);
 171   sqlite3_aggregate_context(ctx, 2048);
 172   z = sqlite3_errmsg16(db);
 173   sqlite3_result_text16(ctx, z, -1, SQLITE_TRANSIENT);
 174 #endif
 175 }
 176
 177 /*
 178 ** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata()
 179 ** interface.
 180 **
 181 ** The test_auxdata() SQL function attempts to register each of its arguments
 182 ** as auxiliary data.  If there are no prior registrations of aux data for
 183 ** that argument (meaning the argument is not a constant or this is its first
 184 ** call) then the result for that argument is 0.  If there is a prior
 185 ** registration, the result for that argument is 1.  The overall result
 186 ** is the individual argument results separated by spaces.
 187 */
 188 static void free_test_auxdata(void *p) {sqlite3_free(p);}
 189 static void test_auxdata(
 190   sqlite3_context *pCtx,
 191   int nArg,
 192   sqlite3_value **argv
 193 ){
 194   int i;
 195   char *zRet = testContextMalloc(pCtx, nArg*2);
 196   if( !zRet ) return;
 197   memset(zRet, 0, nArg*2);
 198   for(i=0; i<nArg; i++){
 199     char const *z = (char*)sqlite3_value_text(argv[i]);
 200     if( z ){
 201       int n;
 202       char *zAux = sqlite3_get_auxdata(pCtx, i);
 203       if( zAux ){
 204         zRet[i*2] = '1';
 205         assert( strcmp(zAux,z)==0 );
 206       }else {
 207         zRet[i*2] = '0';
 208       }
 209       n = (int)strlen(z) + 1;
 210       zAux = testContextMalloc(pCtx, n);
 211       if( zAux ){
 212         memcpy(zAux, z, n);
 213         sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata);
 214       }
 215       zRet[i*2+1] = ' ';
 216     }
 217   }
 218   sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata);
 219 }
 220
 221 /*
 222 ** A function to test error reporting from user functions. This function
 223 ** returns a copy of its first argument as the error message.  If the
 224 ** second argument exists, it becomes the error code.
 225 */
 226 static void test_error(
 227   sqlite3_context *pCtx,
 228   int nArg,
 229   sqlite3_value **argv
 230 ){
 231   sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), -1);
 232   if( nArg==2 ){
 233     sqlite3_result_error_code(pCtx, sqlite3_value_int(argv[1]));
 234   }
 235 }
 236
 237 /*
 238 ** Implementation of the counter(X) function.  If X is an integer
 239 ** constant, then the first invocation will return X.  The second X+1.
 240 ** and so forth.  Can be used (for example) to provide a sequence number
 241 ** in a result set.
 242 */
 243 static void counterFunc(
 244   sqlite3_context *pCtx,   /* Function context */
 245   int nArg,                /* Number of function arguments */
 246   sqlite3_value **argv     /* Values for all function arguments */
 247 ){
 248   int *pCounter = (int*)sqlite3_get_auxdata(pCtx, 0);
 249   if( pCounter==0 ){
 250     pCounter = sqlite3_malloc( sizeof(*pCounter) );
 251     if( pCounter==0 ){
 252       sqlite3_result_error_nomem(pCtx);
 253       return;
 254     }
 255     *pCounter = sqlite3_value_int(argv[0]);
 256     sqlite3_set_auxdata(pCtx, 0, pCounter, sqlite3_free);
 257   }else{
 258     ++*pCounter;
 259   }
 260   sqlite3_result_int(pCtx, *pCounter);
 261 }
 262
 263
 264 /*
 265 ** This function takes two arguments.  It performance UTF-8/16 type
 266 ** conversions on the first argument then returns a copy of the second
 267 ** argument.
 268 **
 269 ** This function is used in cases such as the following:
 270 **
 271 **      SELECT test_isolation(x,x) FROM t1;
 272 **
 273 ** We want to verify that the type conversions that occur on the
 274 ** first argument do not invalidate the second argument.
 275 */
 276 static void test_isolation(
 277   sqlite3_context *pCtx,
 278   int nArg,
 279   sqlite3_value **argv
 280 ){
 281 #ifndef SQLITE_OMIT_UTF16
 282   sqlite3_value_text16(argv[0]);
 283   sqlite3_value_text(argv[0]);
 284   sqlite3_value_text16(argv[0]);
 285   sqlite3_value_text(argv[0]);
 286 #endif
 287   sqlite3_result_value(pCtx, argv[1]);
 288 }
 289
 290 /*
 291 ** Invoke an SQL statement recursively.  The function result is the
 292 ** first column of the first row of the result set.
 293 */
 294 static void test_eval(
 295   sqlite3_context *pCtx,
 296   int nArg,
 297   sqlite3_value **argv
 298 ){
 299   sqlite3_stmt *pStmt;
 300   int rc;
 301   sqlite3 *db = sqlite3_context_db_handle(pCtx);
 302   const char *zSql;
 303
 304   zSql = (char*)sqlite3_value_text(argv[0]);
 305   rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
 306   if( rc==SQLITE_OK ){
 307     rc = sqlite3_step(pStmt);
 308     if( rc==SQLITE_ROW ){
 309       sqlite3_result_value(pCtx, sqlite3_column_value(pStmt, 0));
 310     }
 311     rc = sqlite3_finalize(pStmt);
 312   }
 313   if( rc ){
 314     char *zErr;
 315     assert( pStmt==0 );
 316     zErr = sqlite3_mprintf("sqlite3_prepare_v2() error: %s",sqlite3_errmsg(db));
 317     sqlite3_result_text(pCtx, zErr, -1, sqlite3_free);
 318     sqlite3_result_error_code(pCtx, rc);
 319   }
 320 }
 321
 322
 323 /*
 324 ** convert one character from hex to binary
 325 */
 326 static int testHexChar(char c){
 327   if( c>='0' && c<='9' ){
 328     return c - '0';
 329   }else if( c>='a' && c<='f' ){
 330     return c - 'a' + 10;
 331   }else if( c>='A' && c<='F' ){
 332     return c - 'A' + 10;
 333   }
 334   return 0;
 335 }
 336
 337 /*
 338 ** Convert hex to binary.
 339 */
 340 static void testHexToBin(const char *zIn, char *zOut){
 341   while( zIn[0] && zIn[1] ){
 342     *(zOut++) = (testHexChar(zIn[0])<<4) + testHexChar(zIn[1]);
 343     zIn += 2;
 344   }
 345 }
 346
 347 /*
 348 **      hex_to_utf16be(HEX)
 349 **
 350 ** Convert the input string from HEX into binary.  Then return the
 351 ** result using sqlite3_result_text16le().
 352 */
 353 #ifndef SQLITE_OMIT_UTF16
 354 static void testHexToUtf16be(
 355   sqlite3_context *pCtx,
 356   int nArg,
 357   sqlite3_value **argv
 358 ){
 359   int n;
 360   const char *zIn;
 361   char *zOut;
 362   assert( nArg==1 );
 363   n = sqlite3_value_bytes(argv[0]);
 364   zIn = (const char*)sqlite3_value_text(argv[0]);
 365   zOut = sqlite3_malloc( n/2 );
 366   if( zOut==0 ){
 367     sqlite3_result_error_nomem(pCtx);
 368   }else{
 369     testHexToBin(zIn, zOut);
 370     sqlite3_result_text16be(pCtx, zOut, n/2, sqlite3_free);
 371   }
 372 }
 373 #endif
 374
 375 /*
 376 **      hex_to_utf8(HEX)
 377 **
 378 ** Convert the input string from HEX into binary.  Then return the
 379 ** result using sqlite3_result_text16le().
 380 */
 381 static void testHexToUtf8(
 382   sqlite3_context *pCtx,
 383   int nArg,
 384   sqlite3_value **argv
 385 ){
 386   int n;
 387   const char *zIn;
 388   char *zOut;
 389   assert( nArg==1 );
 390   n = sqlite3_value_bytes(argv[0]);
 391   zIn = (const char*)sqlite3_value_text(argv[0]);
 392   zOut = sqlite3_malloc( n/2 );
 393   if( zOut==0 ){
 394     sqlite3_result_error_nomem(pCtx);
 395   }else{
 396     testHexToBin(zIn, zOut);
 397     sqlite3_result_text(pCtx, zOut, n/2, sqlite3_free);
 398   }
 399 }
 400
 401 /*
 402 **      hex_to_utf16le(HEX)
 403 **
 404 ** Convert the input string from HEX into binary.  Then return the
 405 ** result using sqlite3_result_text16le().
 406 */
 407 #ifndef SQLITE_OMIT_UTF16
 408 static void testHexToUtf16le(
 409   sqlite3_context *pCtx,
 410   int nArg,
 411   sqlite3_value **argv
 412 ){
 413   int n;
 414   const char *zIn;
 415   char *zOut;
 416   assert( nArg==1 );
 417   n = sqlite3_value_bytes(argv[0]);
 418   zIn = (const char*)sqlite3_value_text(argv[0]);
 419   zOut = sqlite3_malloc( n/2 );
 420   if( zOut==0 ){
 421     sqlite3_result_error_nomem(pCtx);
 422   }else{
 423     testHexToBin(zIn, zOut);
 424     sqlite3_result_text16le(pCtx, zOut, n/2, sqlite3_free);
 425   }
 426 }
 427 #endif
 428
 429 /*
 430 ** SQL function:   real2hex(X)
 431 **
 432 ** If argument X is a real number, then convert it into a string which is
 433 ** the big-endian hexadecimal representation of the ieee754 encoding of
 434 ** that number.  If X is not a real number, return NULL.
 435 */
 436 static void real2hex(
 437   sqlite3_context *context,
 438   int argc,
 439   sqlite3_value **argv
 440 ){
 441   union {
 442     sqlite3_uint64 i;
 443     double r;
 444     unsigned char x[8];
 445   } v;
 446   char zOut[20];
 447   int i;
 448   int bigEndian;
 449   v.i = 1;
 450   bigEndian = v.x[0]==0;
 451   v.r = sqlite3_value_double(argv[0]);
 452   for(i=0; i<8; i++){
 453     if( bigEndian ){
 454       zOut[i*2]   = "0123456789abcdef"[v.x[i]>>4];
 455       zOut[i*2+1] = "0123456789abcdef"[v.x[i]&0xf];
 456     }else{
 457       zOut[14-i*2]   = "0123456789abcdef"[v.x[i]>>4];
 458       zOut[14-i*2+1] = "0123456789abcdef"[v.x[i]&0xf];
 459     }
 460   }
 461   zOut[16] = 0;
 462   sqlite3_result_text(context, zOut, -1, SQLITE_TRANSIENT);
 463 }
 464
 465 /*
 466 **     test_extract(record, field)
 467 **
 468 ** This function implements an SQL user-function that accepts a blob
 469 ** containing a formatted database record as the first argument. The
 470 ** second argument is the index of the field within that record to
 471 ** extract and return.
 472 */
 473 static void test_extract(
 474   sqlite3_context *context,
 475   int argc,
 476   sqlite3_value **argv
 477 ){
 478   sqlite3 *db = sqlite3_context_db_handle(context);
 479   u8 *pRec;
 480   u8 *pEndHdr;                    /* Points to one byte past record header */
 481   u8 *pHdr;                       /* Current point in record header */
 482   u8 *pBody;                      /* Current point in record data */
 483   u64 nHdr;                       /* Bytes in record header */
 484   int iIdx;                       /* Required field */
 485   int iCurrent = 0;               /* Current field */
 486
 487   assert( argc==2 );
 488   pRec = (u8*)sqlite3_value_blob(argv[0]);
 489   iIdx = sqlite3_value_int(argv[1]);
 490
 491   pHdr = pRec + sqlite3GetVarint(pRec, &nHdr);
 492   pBody = pEndHdr = &pRec[nHdr];
 493
 494   for(iCurrent=0; pHdr<pEndHdr && iCurrent<=iIdx; iCurrent++){
 495     u64 iSerialType;
 496     Mem mem;
 497
 498     memset(&mem, 0, sizeof(mem));
 499     mem.db = db;
 500     mem.enc = ENC(db);
 501     pHdr += sqlite3GetVarint(pHdr, &iSerialType);
 502     pBody += sqlite3VdbeSerialGet(pBody, (u32)iSerialType, &mem);
 503
 504     if( iCurrent==iIdx ){
 505       sqlite3_result_value(context, &mem);
 506     }
 507
 508     if( mem.szMalloc ) sqlite3DbFree(db, mem.zMalloc);
 509   }
 510 }
 511
 512 /*
 513 **      test_decode(record)
 514 **
 515 ** This function implements an SQL user-function that accepts a blob
 516 ** containing a formatted database record as its only argument. It returns
 517 ** a tcl list (type SQLITE_TEXT) containing each of the values stored
 518 ** in the record.
 519 */
 520 static void test_decode(
 521   sqlite3_context *context,
 522   int argc,
 523   sqlite3_value **argv
 524 ){
 525   sqlite3 *db = sqlite3_context_db_handle(context);
 526   u8 *pRec;
 527   u8 *pEndHdr;                    /* Points to one byte past record header */
 528   u8 *pHdr;                       /* Current point in record header */
 529   u8 *pBody;                      /* Current point in record data */
 530   u64 nHdr;                       /* Bytes in record header */
 531   Tcl_Obj *pRet;                  /* Return value */
 532
 533   pRet = Tcl_NewObj();
 534   Tcl_IncrRefCount(pRet);
 535
 536   assert( argc==1 );
 537   pRec = (u8*)sqlite3_value_blob(argv[0]);
 538
 539   pHdr = pRec + sqlite3GetVarint(pRec, &nHdr);
 540   pBody = pEndHdr = &pRec[nHdr];
 541   while( pHdr<pEndHdr ){
 542     Tcl_Obj *pVal = 0;
 543     u64 iSerialType;
 544     Mem mem;
 545
 546     memset(&mem, 0, sizeof(mem));
 547     mem.db = db;
 548     mem.enc = ENC(db);
 549     pHdr += sqlite3GetVarint(pHdr, &iSerialType);
 550     pBody += sqlite3VdbeSerialGet(pBody, (u32)iSerialType, &mem);
 551
 552     switch( sqlite3_value_type(&mem) ){
 553       case SQLITE_TEXT:
 554         pVal = Tcl_NewStringObj((const char*)sqlite3_value_text(&mem), -1);
 555         break;
 556
 557       case SQLITE_BLOB: {
 558         char hexdigit[] = {
 559           '0', '1', '2', '3', '4', '5', '6', '7',
 560           '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
 561         };
 562         int n = sqlite3_value_bytes(&mem);
 563         u8 *z = (u8*)sqlite3_value_blob(&mem);
 564         int i;
 565         pVal = Tcl_NewStringObj("x'", -1);
 566         for(i=0; i<n; i++){
 567           char hex[3];
 568           hex[0] = hexdigit[((z[i] >> 4) & 0x0F)];
 569           hex[1] = hexdigit[(z[i] & 0x0F)];
 570           hex[2] = '\0';
 571           Tcl_AppendStringsToObj(pVal, hex, 0);
 572         }
 573         Tcl_AppendStringsToObj(pVal, "'", 0);
 574         break;
 575       }
 576
 577       case SQLITE_FLOAT:
 578         pVal = Tcl_NewDoubleObj(sqlite3_value_double(&mem));
 579         break;
 580
 581       case SQLITE_INTEGER:
 582         pVal = Tcl_NewWideIntObj(sqlite3_value_int64(&mem));
 583         break;
 584
 585       case SQLITE_NULL:
 586         pVal = Tcl_NewStringObj("NULL", -1);
 587         break;
 588
 589       default:
 590         assert( 0 );
 591     }
 592
 593     Tcl_ListObjAppendElement(0, pRet, pVal);
 594
 595     if( mem.szMalloc ){
 596       sqlite3DbFree(db, mem.zMalloc);
 597     }
 598   }
 599
 600   sqlite3_result_text(context, Tcl_GetString(pRet), -1, SQLITE_TRANSIENT);
 601   Tcl_DecrRefCount(pRet);
 602 }
 603
 604 /*
 605 **       test_zeroblob(N)
 606 **
 607 ** The implementation of scalar SQL function "test_zeroblob()". This is
 608 ** similar to the built-in zeroblob() function, except that it does not
 609 ** check that the integer parameter is within range before passing it
 610 ** to sqlite3_result_zeroblob().
 611 */
 612 static void test_zeroblob(
 613   sqlite3_context *context,
 614   int argc,
 615   sqlite3_value **argv
 616 ){
 617   int nZero = sqlite3_value_int(argv[0]);
 618   sqlite3_result_zeroblob(context, nZero);
 619 }
 620
 621 /*         test_getsubtype(V)
 622 **
 623 ** Return the subtype for value V.
 624 */
 625 static void test_getsubtype(
 626   sqlite3_context *context,
 627   int argc,
 628   sqlite3_value **argv
 629 ){
 630   sqlite3_result_int(context, (int)sqlite3_value_subtype(argv[0]));
 631 }
 632
 633 /*         test_setsubtype(V, T)
 634 **
 635 ** Return the value V with its subtype changed to T
 636 */
 637 static void test_setsubtype(
 638   sqlite3_context *context,
 639   int argc,
 640   sqlite3_value **argv
 641 ){
 642   sqlite3_result_value(context, argv[0]);
 643   sqlite3_result_subtype(context, (unsigned int)sqlite3_value_int(argv[1]));
 644 }
 645
 646 static int registerTestFunctions(
 647   sqlite3 *db,
 648   char **pzErrMsg,
 649   const sqlite3_api_routines *pThunk
 650 ){
 651   static const struct {
 652      char *zName;
 653      signed char nArg;
 654      unsigned int eTextRep; /* 1: UTF-16.  0: UTF-8 */
 655      void (*xFunc)(sqlite3_context*,int,sqlite3_value **);
 656   } aFuncs[] = {
 657     { "randstr",               2, SQLITE_UTF8, randStr    },
 658     { "test_destructor",       1, SQLITE_UTF8, test_destructor},
 659 #ifndef SQLITE_OMIT_UTF16
 660     { "test_destructor16",     1, SQLITE_UTF8, test_destructor16},
 661     { "hex_to_utf16be",        1, SQLITE_UTF8, testHexToUtf16be},
 662     { "hex_to_utf16le",        1, SQLITE_UTF8, testHexToUtf16le},
 663 #endif
 664     { "hex_to_utf8",           1, SQLITE_UTF8, testHexToUtf8},
 665     { "test_destructor_count", 0, SQLITE_UTF8, test_destructor_count},
 666     { "test_auxdata",         -1, SQLITE_UTF8, test_auxdata},
 667     { "test_error",            1, SQLITE_UTF8, test_error},
 668     { "test_error",            2, SQLITE_UTF8, test_error},
 669     { "test_eval",             1, SQLITE_UTF8, test_eval},
 670     { "test_isolation",        2, SQLITE_UTF8, test_isolation},
 671     { "test_counter",          1, SQLITE_UTF8, counterFunc},
 672     { "real2hex",              1, SQLITE_UTF8, real2hex},
 673     { "test_decode",           1, SQLITE_UTF8, test_decode},
 674     { "test_extract",          2, SQLITE_UTF8, test_extract},
 675     { "test_zeroblob",  1, SQLITE_UTF8|SQLITE_DETERMINISTIC, test_zeroblob},
 676     { "test_getsubtype",       1, SQLITE_UTF8, test_getsubtype},
 677     { "test_setsubtype",       2, SQLITE_UTF8, test_setsubtype},
 678   };
 679   int i;
 680
 681   for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
 682     sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg,
 683         aFuncs[i].eTextRep, 0, aFuncs[i].xFunc, 0, 0);
 684   }
 685
 686   sqlite3_create_function(db, "test_agg_errmsg16", 0, SQLITE_ANY, 0, 0,
 687       test_agg_errmsg16_step, test_agg_errmsg16_final);
 688
 689   return SQLITE_OK;
 690 }
 691
 692 /*
 693 ** TCLCMD:  autoinstall_test_functions
 694 **
 695 ** Invoke this TCL command to use sqlite3_auto_extension() to cause
 696 ** the standard set of test functions to be loaded into each new
 697 ** database connection.
 698 */
 699 static int SQLITE_TCLAPI autoinstall_test_funcs(
 700   void * clientData,
 701   Tcl_Interp *interp,
 702   int objc,
 703   Tcl_Obj *CONST objv[]
 704 ){
 705   extern int Md5_Register(sqlite3 *, char **, const sqlite3_api_routines *);
 706   int rc = sqlite3_auto_extension((void(*)(void))registerTestFunctions);
 707   if( rc==SQLITE_OK ){
 708     rc = sqlite3_auto_extension((void(*)(void))Md5_Register);
 709   }
 710   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
 711   return TCL_OK;
 712 }
 713
 714 /*
 715 ** A bogus step function and finalizer function.
 716 */
 717 static void tStep(sqlite3_context *a, int b, sqlite3_value **c){}
 718 static void tFinal(sqlite3_context *a){}
 719
 720
 721 /*
 722 ** tclcmd:  abuse_create_function
 723 **
 724 ** Make various calls to sqlite3_create_function that do not have valid
 725 ** parameters.  Verify that the error condition is detected and reported.
 726 */
 727 static int SQLITE_TCLAPI abuse_create_function(
 728   void * clientData,
 729   Tcl_Interp *interp,
 730   int objc,
 731   Tcl_Obj *CONST objv[]
 732 ){
 733   extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
 734   sqlite3 *db;
 735   int rc;
 736   int mxArg;
 737
 738   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
 739
 740   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep,tStep,tFinal);
 741   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 742
 743   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, tStep, 0);
 744   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 745
 746   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, 0, tFinal);
 747   if( rc!=SQLITE_MISUSE) goto abuse_err;
 748
 749   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, 0, tFinal);
 750   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 751
 752   rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, tStep, 0);
 753   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 754
 755   rc = sqlite3_create_function(db, "tx", -2, SQLITE_UTF8, 0, tStep, 0, 0);
 756   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 757
 758   rc = sqlite3_create_function(db, "tx", 128, SQLITE_UTF8, 0, tStep, 0, 0);
 759   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 760
 761   rc = sqlite3_create_function(db, "funcxx"
 762        "_123456789_123456789_123456789_123456789_123456789"
 763        "_123456789_123456789_123456789_123456789_123456789"
 764        "_123456789_123456789_123456789_123456789_123456789"
 765        "_123456789_123456789_123456789_123456789_123456789"
 766        "_123456789_123456789_123456789_123456789_123456789",
 767        1, SQLITE_UTF8, 0, tStep, 0, 0);
 768   if( rc!=SQLITE_MISUSE ) goto abuse_err;
 769
 770   /* This last function registration should actually work.  Generate
 771   ** a no-op function (that always returns NULL) and which has the
 772   ** maximum-length function name and the maximum number of parameters.
 773   */
 774   sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, 10000);
 775   mxArg = sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, -1);
 776   rc = sqlite3_create_function(db, "nullx"
 777        "_123456789_123456789_123456789_123456789_123456789"
 778        "_123456789_123456789_123456789_123456789_123456789"
 779        "_123456789_123456789_123456789_123456789_123456789"
 780        "_123456789_123456789_123456789_123456789_123456789"
 781        "_123456789_123456789_123456789_123456789_123456789",
 782        mxArg, SQLITE_UTF8, 0, tStep, 0, 0);
 783   if( rc!=SQLITE_OK ) goto abuse_err;
 784
 785   return TCL_OK;
 786
 787 abuse_err:
 788   Tcl_AppendResult(interp, "sqlite3_create_function abused test failed",
 789                    (char*)0);
 790   return TCL_ERROR;
 791 }
 792
 793
 794 /*
 795 ** SQLite user defined function to use with matchinfo() to calculate the
 796 ** relevancy of an FTS match. The value returned is the relevancy score
 797 ** (a real value greater than or equal to zero). A larger value indicates
 798 ** a more relevant document.
 799 **
 800 ** The overall relevancy returned is the sum of the relevancies of each
 801 ** column value in the FTS table. The relevancy of a column value is the
 802 ** sum of the following for each reportable phrase in the FTS query:
 803 **
 804 **   (<hit count> / <global hit count>) * <column weight>
 805 **
 806 ** where <hit count> is the number of instances of the phrase in the
 807 ** column value of the current row and <global hit count> is the number
 808 ** of instances of the phrase in the same column of all rows in the FTS
 809 ** table. The <column weight> is a weighting factor assigned to each
 810 ** column by the caller (see below).
 811 **
 812 ** The first argument to this function must be the return value of the FTS
 813 ** matchinfo() function. Following this must be one argument for each column
 814 ** of the FTS table containing a numeric weight factor for the corresponding
 815 ** column. Example:
 816 **
 817 **     CREATE VIRTUAL TABLE documents USING fts3(title, content)
 818 **
 819 ** The following query returns the docids of documents that match the full-text
 820 ** query <query> sorted from most to least relevant. When calculating
 821 ** relevance, query term instances in the 'title' column are given twice the
 822 ** weighting of those in the 'content' column.
 823 **
 824 **     SELECT docid FROM documents
 825 **     WHERE documents MATCH <query>
 826 **     ORDER BY rank(matchinfo(documents), 1.0, 0.5) DESC
 827 */
 828 static void rankfunc(sqlite3_context *pCtx, int nVal, sqlite3_value **apVal){
 829   int *aMatchinfo;                /* Return value of matchinfo() */
 830   int nMatchinfo;                 /* Number of elements in aMatchinfo[] */
 831   int nCol = 0;                   /* Number of columns in the table */
 832   int nPhrase = 0;                /* Number of phrases in the query */
 833   int iPhrase;                    /* Current phrase */
 834   double score = 0.0;             /* Value to return */
 835
 836   assert( sizeof(int)==4 );
 837
 838   /* Check that the number of arguments passed to this function is correct.
 839   ** If not, jump to wrong_number_args. Set aMatchinfo to point to the array
 840   ** of unsigned integer values returned by FTS function matchinfo. Set
 841   ** nPhrase to contain the number of reportable phrases in the users full-text
 842   ** query, and nCol to the number of columns in the table. Then check that the
 843   ** size of the matchinfo blob is as expected. Return an error if it is not.
 844   */
 845   if( nVal<1 ) goto wrong_number_args;
 846   aMatchinfo = (int*)sqlite3_value_blob(apVal[0]);
 847   nMatchinfo = sqlite3_value_bytes(apVal[0]) / sizeof(int);
 848   if( nMatchinfo>=2 ){
 849     nPhrase = aMatchinfo[0];
 850     nCol = aMatchinfo[1];
 851   }
 852   if( nMatchinfo!=(2+3*nCol*nPhrase) ){
 853     sqlite3_result_error(pCtx,
 854         "invalid matchinfo blob passed to function rank()", -1);
 855     return;
 856   }
 857   if( nVal!=(1+nCol) ) goto wrong_number_args;
 858
 859   /* Iterate through each phrase in the users query. */
 860   for(iPhrase=0; iPhrase<nPhrase; iPhrase++){
 861     int iCol;                     /* Current column */
 862
 863     /* Now iterate through each column in the users query. For each column,
 864     ** increment the relevancy score by:
 865     **
 866     **   (<hit count> / <global hit count>) * <column weight>
 867     **
 868     ** aPhraseinfo[] points to the start of the data for phrase iPhrase. So
 869     ** the hit count and global hit counts for each column are found in
 870     ** aPhraseinfo[iCol*3] and aPhraseinfo[iCol*3+1], respectively.
 871     */
 872     int *aPhraseinfo = &aMatchinfo[2 + iPhrase*nCol*3];
 873     for(iCol=0; iCol<nCol; iCol++){
 874       int nHitCount = aPhraseinfo[3*iCol];
 875       int nGlobalHitCount = aPhraseinfo[3*iCol+1];
 876       double weight = sqlite3_value_double(apVal[iCol+1]);
 877       if( nHitCount>0 ){
 878         score += ((double)nHitCount / (double)nGlobalHitCount) * weight;
 879       }
 880     }
 881   }
 882
 883   sqlite3_result_double(pCtx, score);
 884   return;
 885
 886   /* Jump here if the wrong number of arguments are passed to this function */
 887 wrong_number_args:
 888   sqlite3_result_error(pCtx, "wrong number of arguments to function rank()", -1);
 889 }
 890
 891 static int SQLITE_TCLAPI install_fts3_rank_function(
 892   void * clientData,
 893   Tcl_Interp *interp,
 894   int objc,
 895   Tcl_Obj *CONST objv[]
 896 ){
 897   extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
 898   sqlite3 *db;
 899
 900   if( objc!=2 ){
 901     Tcl_WrongNumArgs(interp, 1, objv, "DB");
 902     return TCL_ERROR;
 903   }
 904
 905   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
 906   sqlite3_create_function(db, "rank", -1, SQLITE_UTF8, 0, rankfunc, 0, 0);
 907   return TCL_OK;
 908 }
 909
 910
 911 /*
 912 ** Register commands with the TCL interpreter.
 913 */
 914 int Sqlitetest_func_Init(Tcl_Interp *interp){
 915   static struct {
 916      char *zName;
 917      Tcl_ObjCmdProc *xProc;
 918   } aObjCmd[] = {
 919      { "autoinstall_test_functions",    autoinstall_test_funcs },
 920      { "abuse_create_function",         abuse_create_function  },
 921      { "install_fts3_rank_function",    install_fts3_rank_function  },
 922   };
 923   int i;
 924   extern int Md5_Register(sqlite3 *, char **, const sqlite3_api_routines *);
 925
 926   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
 927     Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
 928   }
 929   sqlite3_initialize();
 930   sqlite3_auto_extension((void(*)(void))registerTestFunctions);
 931   sqlite3_auto_extension((void(*)(void))Md5_Register);
 932   return TCL_OK;
 933 }