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*/ 27static 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*/ 39static 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*/ 85static int test_destructor_count_var = 0; 86static void destructor(void *p){ 87 char *zVal = (char *)p; 88 assert(zVal); 89 zVal--; 90 sqlite3_free(zVal); 91 test_destructor_count_var--; 92} 93static 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 116static 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 139static 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 153void sqlite3BeginBenignMalloc(void); 154void sqlite3EndBenignMalloc(void); 155#else 156 #define sqlite3BeginBenignMalloc() 157 #define sqlite3EndBenignMalloc() 158#endif 159static void test_agg_errmsg16_step(sqlite3_context *a, int b,sqlite3_value **c){ 160} 161static 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*/ 184static void free_test_auxdata(void *p) {sqlite3_free(p);} 185static 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*/ 222static 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*/ 239static 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*/ 272static 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*/ 290static 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*/ 322static 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*/ 336static 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 350static 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*/ 377static 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 404static 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 425static 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*/ 468static 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*/ 486static void tStep(sqlite3_context *a, int b, sqlite3_value **c){} 487static 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*/ 496static 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 556abuse_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*/ 565int 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} 584