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