| OLD | NEW |
|---|
| (Empty) |
| 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.16 2009/07/22 07:27:57 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 #ifndef SQLITE_OMIT_UTF16 | |
| 160 const void *z; | |
| 161 sqlite3 * db = sqlite3_context_db_handle(ctx); | |
| 162 sqlite3_aggregate_context(ctx, 2048); | |
| 163 sqlite3BeginBenignMalloc(); | |
| 164 z = sqlite3_errmsg16(db); | |
| 165 sqlite3EndBenignMalloc(); | |
| 166 sqlite3_result_text16(ctx, z, -1, SQLITE_TRANSIENT); | |
| 167 #endif | |
| 168 } | |
| 169 | |
| 170 /* | |
| 171 ** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata() | |
| 172 ** interface. | |
| 173 ** | |
| 174 ** The test_auxdata() SQL function attempts to register each of its arguments | |
| 175 ** as auxiliary data. If there are no prior registrations of aux data for | |
| 176 ** that argument (meaning the argument is not a constant or this is its first | |
| 177 ** call) then the result for that argument is 0. If there is a prior | |
| 178 ** registration, the result for that argument is 1. The overall result | |
| 179 ** is the individual argument results separated by spaces. | |
| 180 */ | |
| 181 static void free_test_auxdata(void *p) {sqlite3_free(p);} | |
| 182 static void test_auxdata( | |
| 183 sqlite3_context *pCtx, | |
| 184 int nArg, | |
| 185 sqlite3_value **argv | |
| 186 ){ | |
| 187 int i; | |
| 188 char *zRet = testContextMalloc(pCtx, nArg*2); | |
| 189 if( !zRet ) return; | |
| 190 memset(zRet, 0, nArg*2); | |
| 191 for(i=0; i<nArg; i++){ | |
| 192 char const *z = (char*)sqlite3_value_text(argv[i]); | |
| 193 if( z ){ | |
| 194 int n; | |
| 195 char *zAux = sqlite3_get_auxdata(pCtx, i); | |
| 196 if( zAux ){ | |
| 197 zRet[i*2] = '1'; | |
| 198 assert( strcmp(zAux,z)==0 ); | |
| 199 }else { | |
| 200 zRet[i*2] = '0'; | |
| 201 } | |
| 202 n = strlen(z) + 1; | |
| 203 zAux = testContextMalloc(pCtx, n); | |
| 204 if( zAux ){ | |
| 205 memcpy(zAux, z, n); | |
| 206 sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata); | |
| 207 } | |
| 208 zRet[i*2+1] = ' '; | |
| 209 } | |
| 210 } | |
| 211 sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata); | |
| 212 } | |
| 213 | |
| 214 /* | |
| 215 ** A function to test error reporting from user functions. This function | |
| 216 ** returns a copy of its first argument as the error message. If the | |
| 217 ** second argument exists, it becomes the error code. | |
| 218 */ | |
| 219 static void test_error( | |
| 220 sqlite3_context *pCtx, | |
| 221 int nArg, | |
| 222 sqlite3_value **argv | |
| 223 ){ | |
| 224 sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), -1); | |
| 225 if( nArg==2 ){ | |
| 226 sqlite3_result_error_code(pCtx, sqlite3_value_int(argv[1])); | |
| 227 } | |
| 228 } | |
| 229 | |
| 230 /* | |
| 231 ** Implementation of the counter(X) function. If X is an integer | |
| 232 ** constant, then the first invocation will return X. The second X+1. | |
| 233 ** and so forth. Can be used (for example) to provide a sequence number | |
| 234 ** in a result set. | |
| 235 */ | |
| 236 static void counterFunc( | |
| 237 sqlite3_context *pCtx, /* Function context */ | |
| 238 int nArg, /* Number of function arguments */ | |
| 239 sqlite3_value **argv /* Values for all function arguments */ | |
| 240 ){ | |
| 241 int *pCounter = (int*)sqlite3_get_auxdata(pCtx, 0); | |
| 242 if( pCounter==0 ){ | |
| 243 pCounter = sqlite3_malloc( sizeof(*pCounter) ); | |
| 244 if( pCounter==0 ){ | |
| 245 sqlite3_result_error_nomem(pCtx); | |
| 246 return; | |
| 247 } | |
| 248 *pCounter = sqlite3_value_int(argv[0]); | |
| 249 sqlite3_set_auxdata(pCtx, 0, pCounter, sqlite3_free); | |
| 250 }else{ | |
| 251 ++*pCounter; | |
| 252 } | |
| 253 sqlite3_result_int(pCtx, *pCounter); | |
| 254 } | |
| 255 | |
| 256 | |
| 257 /* | |
| 258 ** This function takes two arguments. It performance UTF-8/16 type | |
| 259 ** conversions on the first argument then returns a copy of the second | |
| 260 ** argument. | |
| 261 ** | |
| 262 ** This function is used in cases such as the following: | |
| 263 ** | |
| 264 ** SELECT test_isolation(x,x) FROM t1; | |
| 265 ** | |
| 266 ** We want to verify that the type conversions that occur on the | |
| 267 ** first argument do not invalidate the second argument. | |
| 268 */ | |
| 269 static void test_isolation( | |
| 270 sqlite3_context *pCtx, | |
| 271 int nArg, | |
| 272 sqlite3_value **argv | |
| 273 ){ | |
| 274 #ifndef SQLITE_OMIT_UTF16 | |
| 275 sqlite3_value_text16(argv[0]); | |
| 276 sqlite3_value_text(argv[0]); | |
| 277 sqlite3_value_text16(argv[0]); | |
| 278 sqlite3_value_text(argv[0]); | |
| 279 #endif | |
| 280 sqlite3_result_value(pCtx, argv[1]); | |
| 281 } | |
| 282 | |
| 283 /* | |
| 284 ** Invoke an SQL statement recursively. The function result is the | |
| 285 ** first column of the first row of the result set. | |
| 286 */ | |
| 287 static void test_eval( | |
| 288 sqlite3_context *pCtx, | |
| 289 int nArg, | |
| 290 sqlite3_value **argv | |
| 291 ){ | |
| 292 sqlite3_stmt *pStmt; | |
| 293 int rc; | |
| 294 sqlite3 *db = sqlite3_context_db_handle(pCtx); | |
| 295 const char *zSql; | |
| 296 | |
| 297 zSql = (char*)sqlite3_value_text(argv[0]); | |
| 298 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); | |
| 299 if( rc==SQLITE_OK ){ | |
| 300 rc = sqlite3_step(pStmt); | |
| 301 if( rc==SQLITE_ROW ){ | |
| 302 sqlite3_result_value(pCtx, sqlite3_column_value(pStmt, 0)); | |
| 303 } | |
| 304 rc = sqlite3_finalize(pStmt); | |
| 305 } | |
| 306 if( rc ){ | |
| 307 char *zErr; | |
| 308 assert( pStmt==0 ); | |
| 309 zErr = sqlite3_mprintf("sqlite3_prepare_v2() error: %s",sqlite3_errmsg(db)); | |
| 310 sqlite3_result_text(pCtx, zErr, -1, sqlite3_free); | |
| 311 sqlite3_result_error_code(pCtx, rc); | |
| 312 } | |
| 313 } | |
| 314 | |
| 315 | |
| 316 static int registerTestFunctions(sqlite3 *db){ | |
| 317 static const struct { | |
| 318 char *zName; | |
| 319 signed char nArg; | |
| 320 unsigned char eTextRep; /* 1: UTF-16. 0: UTF-8 */ | |
| 321 void (*xFunc)(sqlite3_context*,int,sqlite3_value **); | |
| 322 } aFuncs[] = { | |
| 323 { "randstr", 2, SQLITE_UTF8, randStr }, | |
| 324 { "test_destructor", 1, SQLITE_UTF8, test_destructor}, | |
| 325 #ifndef SQLITE_OMIT_UTF16 | |
| 326 { "test_destructor16", 1, SQLITE_UTF8, test_destructor16}, | |
| 327 #endif | |
| 328 { "test_destructor_count", 0, SQLITE_UTF8, test_destructor_count}, | |
| 329 { "test_auxdata", -1, SQLITE_UTF8, test_auxdata}, | |
| 330 { "test_error", 1, SQLITE_UTF8, test_error}, | |
| 331 { "test_error", 2, SQLITE_UTF8, test_error}, | |
| 332 { "test_eval", 1, SQLITE_UTF8, test_eval}, | |
| 333 { "test_isolation", 2, SQLITE_UTF8, test_isolation}, | |
| 334 { "test_counter", 1, SQLITE_UTF8, counterFunc}, | |
| 335 }; | |
| 336 int i; | |
| 337 | |
| 338 for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ | |
| 339 sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg, | |
| 340 aFuncs[i].eTextRep, 0, aFuncs[i].xFunc, 0, 0); | |
| 341 } | |
| 342 | |
| 343 sqlite3_create_function(db, "test_agg_errmsg16", 0, SQLITE_ANY, 0, 0, | |
| 344 test_agg_errmsg16_step, test_agg_errmsg16_final); | |
| 345 | |
| 346 return SQLITE_OK; | |
| 347 } | |
| 348 | |
| 349 /* | |
| 350 ** TCLCMD: autoinstall_test_functions | |
| 351 ** | |
| 352 ** Invoke this TCL command to use sqlite3_auto_extension() to cause | |
| 353 ** the standard set of test functions to be loaded into each new | |
| 354 ** database connection. | |
| 355 */ | |
| 356 static int autoinstall_test_funcs( | |
| 357 void * clientData, | |
| 358 Tcl_Interp *interp, | |
| 359 int objc, | |
| 360 Tcl_Obj *CONST objv[] | |
| 361 ){ | |
| 362 extern int Md5_Register(sqlite3*); | |
| 363 int rc = sqlite3_auto_extension((void*)registerTestFunctions); | |
| 364 if( rc==SQLITE_OK ){ | |
| 365 rc = sqlite3_auto_extension((void*)Md5_Register); | |
| 366 } | |
| 367 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); | |
| 368 return TCL_OK; | |
| 369 } | |
| 370 | |
| 371 /* | |
| 372 ** A bogus step function and finalizer function. | |
| 373 */ | |
| 374 static void tStep(sqlite3_context *a, int b, sqlite3_value **c){} | |
| 375 static void tFinal(sqlite3_context *a){} | |
| 376 | |
| 377 | |
| 378 /* | |
| 379 ** tclcmd: abuse_create_function | |
| 380 ** | |
| 381 ** Make various calls to sqlite3_create_function that do not have valid | |
| 382 ** parameters. Verify that the error condition is detected and reported. | |
| 383 */ | |
| 384 static int abuse_create_function( | |
| 385 void * clientData, | |
| 386 Tcl_Interp *interp, | |
| 387 int objc, | |
| 388 Tcl_Obj *CONST objv[] | |
| 389 ){ | |
| 390 extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**); | |
| 391 sqlite3 *db; | |
| 392 int rc; | |
| 393 int mxArg; | |
| 394 | |
| 395 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; | |
| 396 | |
| 397 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep,tStep,tFinal); | |
| 398 if( rc!=SQLITE_MISUSE ) goto abuse_err; | |
| 399 | |
| 400 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, tStep, 0); | |
| 401 if( rc!=SQLITE_MISUSE ) goto abuse_err; | |
| 402 | |
| 403 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, 0, tFinal); | |
| 404 if( rc!=SQLITE_MISUSE) goto abuse_err; | |
| 405 | |
| 406 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, 0, tFinal); | |
| 407 if( rc!=SQLITE_MISUSE ) goto abuse_err; | |
| 408 | |
| 409 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, tStep, 0); | |
| 410 if( rc!=SQLITE_MISUSE ) goto abuse_err; | |
| 411 | |
| 412 rc = sqlite3_create_function(db, "tx", -2, SQLITE_UTF8, 0, tStep, 0, 0); | |
| 413 if( rc!=SQLITE_MISUSE ) goto abuse_err; | |
| 414 | |
| 415 rc = sqlite3_create_function(db, "tx", 128, SQLITE_UTF8, 0, tStep, 0, 0); | |
| 416 if( rc!=SQLITE_MISUSE ) goto abuse_err; | |
| 417 | |
| 418 rc = sqlite3_create_function(db, "funcxx" | |
| 419 "_123456789_123456789_123456789_123456789_123456789" | |
| 420 "_123456789_123456789_123456789_123456789_123456789" | |
| 421 "_123456789_123456789_123456789_123456789_123456789" | |
| 422 "_123456789_123456789_123456789_123456789_123456789" | |
| 423 "_123456789_123456789_123456789_123456789_123456789", | |
| 424 1, SQLITE_UTF8, 0, tStep, 0, 0); | |
| 425 if( rc!=SQLITE_MISUSE ) goto abuse_err; | |
| 426 | |
| 427 /* This last function registration should actually work. Generate | |
| 428 ** a no-op function (that always returns NULL) and which has the | |
| 429 ** maximum-length function name and the maximum number of parameters. | |
| 430 */ | |
| 431 sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, 10000); | |
| 432 mxArg = sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, -1); | |
| 433 rc = sqlite3_create_function(db, "nullx" | |
| 434 "_123456789_123456789_123456789_123456789_123456789" | |
| 435 "_123456789_123456789_123456789_123456789_123456789" | |
| 436 "_123456789_123456789_123456789_123456789_123456789" | |
| 437 "_123456789_123456789_123456789_123456789_123456789" | |
| 438 "_123456789_123456789_123456789_123456789_123456789", | |
| 439 mxArg, SQLITE_UTF8, 0, tStep, 0, 0); | |
| 440 if( rc!=SQLITE_OK ) goto abuse_err; | |
| 441 | |
| 442 return TCL_OK; | |
| 443 | |
| 444 abuse_err: | |
| 445 Tcl_AppendResult(interp, "sqlite3_create_function abused test failed", | |
| 446 (char*)0); | |
| 447 return TCL_ERROR; | |
| 448 } | |
| 449 | |
| 450 | |
| 451 | |
| 452 /* | |
| 453 ** Register commands with the TCL interpreter. | |
| 454 */ | |
| 455 int Sqlitetest_func_Init(Tcl_Interp *interp){ | |
| 456 static struct { | |
| 457 char *zName; | |
| 458 Tcl_ObjCmdProc *xProc; | |
| 459 } aObjCmd[] = { | |
| 460 { "autoinstall_test_functions", autoinstall_test_funcs }, | |
| 461 { "abuse_create_function", abuse_create_function }, | |
| 462 }; | |
| 463 int i; | |
| 464 extern int Md5_Register(sqlite3*); | |
| 465 | |
| 466 for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ | |
| 467 Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0); | |
| 468 } | |
| 469 sqlite3_initialize(); | |
| 470 sqlite3_auto_extension((void*)registerTestFunctions); | |
| 471 sqlite3_auto_extension((void*)Md5_Register); | |
| 472 return TCL_OK; | |
| 473 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3108030:
Move bundled copy of sqlite one level deeper to better separate it... (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/