1 /* 2 ** 2001 September 15 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 ** is not included in the SQLite library. It is used for automated 14 ** testing of the SQLite library. 15 */ 16 #include "sqliteInt.h" 17 #if SQLITE_OS_WIN 18 # include "os_win.h" 19 #endif 20 21 #include "vdbeInt.h" 22 #if defined(INCLUDE_SQLITE_TCL_H) 23 # include "sqlite_tcl.h" 24 #else 25 # include "tcl.h" 26 #endif 27 #include <stdlib.h> 28 #include <string.h> 29 30 /* 31 ** This is a copy of the first part of the SqliteDb structure in 32 ** tclsqlite.c. We need it here so that the get_sqlite_pointer routine 33 ** can extract the sqlite3* pointer from an existing Tcl SQLite 34 ** connection. 35 */ 36 struct SqliteDb { 37 sqlite3 *db; 38 }; 39 40 /* 41 ** Convert text generated by the "%p" conversion format back into 42 ** a pointer. 43 */ 44 static int testHexToInt(int h){ 45 if( h>='0' && h<='9' ){ 46 return h - '0'; 47 }else if( h>='a' && h<='f' ){ 48 return h - 'a' + 10; 49 }else{ 50 assert( h>='A' && h<='F' ); 51 return h - 'A' + 10; 52 } 53 } 54 void *sqlite3TestTextToPtr(const char *z){ 55 void *p; 56 u64 v; 57 u32 v2; 58 if( z[0]=='0' && z[1]=='x' ){ 59 z += 2; 60 } 61 v = 0; 62 while( *z ){ 63 v = (v<<4) + testHexToInt(*z); 64 z++; 65 } 66 if( sizeof(p)==sizeof(v) ){ 67 memcpy(&p, &v, sizeof(p)); 68 }else{ 69 assert( sizeof(p)==sizeof(v2) ); 70 v2 = (u32)v; 71 memcpy(&p, &v2, sizeof(p)); 72 } 73 return p; 74 } 75 76 77 /* 78 ** A TCL command that returns the address of the sqlite* pointer 79 ** for an sqlite connection instance. Bad things happen if the 80 ** input is not an sqlite connection. 81 */ 82 static int SQLITE_TCLAPI get_sqlite_pointer( 83 void * clientData, 84 Tcl_Interp *interp, 85 int objc, 86 Tcl_Obj *CONST objv[] 87 ){ 88 struct SqliteDb *p; 89 Tcl_CmdInfo cmdInfo; 90 char zBuf[100]; 91 if( objc!=2 ){ 92 Tcl_WrongNumArgs(interp, 1, objv, "SQLITE-CONNECTION"); 93 return TCL_ERROR; 94 } 95 if( !Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){ 96 Tcl_AppendResult(interp, "command not found: ", 97 Tcl_GetString(objv[1]), (char*)0); 98 return TCL_ERROR; 99 } 100 p = (struct SqliteDb*)cmdInfo.objClientData; 101 sqlite3_snprintf(sizeof(zBuf), zBuf, "%p", p->db); 102 Tcl_AppendResult(interp, zBuf, 0); 103 return TCL_OK; 104 } 105 106 /* 107 ** Decode a pointer to an sqlite3 object. 108 */ 109 int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb){ 110 struct SqliteDb *p; 111 Tcl_CmdInfo cmdInfo; 112 if( Tcl_GetCommandInfo(interp, zA, &cmdInfo) ){ 113 p = (struct SqliteDb*)cmdInfo.objClientData; 114 *ppDb = p->db; 115 }else{ 116 *ppDb = (sqlite3*)sqlite3TestTextToPtr(zA); 117 } 118 return TCL_OK; 119 } 120 121 #if SQLITE_OS_WIN 122 /* 123 ** Decode a Win32 HANDLE object. 124 */ 125 int getWin32Handle(Tcl_Interp *interp, const char *zA, LPHANDLE phFile){ 126 *phFile = (HANDLE)sqlite3TestTextToPtr(zA); 127 return TCL_OK; 128 } 129 #endif 130 131 extern const char *sqlite3ErrName(int); 132 #define t1ErrorName sqlite3ErrName 133 134 /* 135 ** Convert an sqlite3_stmt* into an sqlite3*. This depends on the 136 ** fact that the sqlite3* is the first field in the Vdbe structure. 137 */ 138 #define StmtToDb(X) sqlite3_db_handle(X) 139 140 /* 141 ** Check a return value to make sure it agrees with the results 142 ** from sqlite3_errcode. 143 */ 144 int sqlite3TestErrCode(Tcl_Interp *interp, sqlite3 *db, int rc){ 145 if( sqlite3_threadsafe()==0 && rc!=SQLITE_MISUSE && rc!=SQLITE_OK 146 && sqlite3_errcode(db)!=rc ){ 147 char zBuf[200]; 148 int r2 = sqlite3_errcode(db); 149 sqlite3_snprintf(sizeof(zBuf), zBuf, 150 "error code %s (%d) does not match sqlite3_errcode %s (%d)", 151 t1ErrorName(rc), rc, t1ErrorName(r2), r2); 152 Tcl_ResetResult(interp); 153 Tcl_AppendResult(interp, zBuf, 0); 154 return 1; 155 } 156 return 0; 157 } 158 159 /* 160 ** Decode a pointer to an sqlite3_stmt object. 161 */ 162 static int getStmtPointer( 163 Tcl_Interp *interp, 164 const char *zArg, 165 sqlite3_stmt **ppStmt 166 ){ 167 *ppStmt = (sqlite3_stmt*)sqlite3TestTextToPtr(zArg); 168 return TCL_OK; 169 } 170 171 /* 172 ** Generate a text representation of a pointer that can be understood 173 ** by the getDbPointer and getVmPointer routines above. 174 ** 175 ** The problem is, on some machines (Solaris) if you do a printf with 176 ** "%p" you cannot turn around and do a scanf with the same "%p" and 177 ** get your pointer back. You have to prepend a "0x" before it will 178 ** work. Or at least that is what is reported to me (drh). But this 179 ** behavior varies from machine to machine. The solution used her is 180 ** to test the string right after it is generated to see if it can be 181 ** understood by scanf, and if not, try prepending an "0x" to see if 182 ** that helps. If nothing works, a fatal error is generated. 183 */ 184 int sqlite3TestMakePointerStr(Tcl_Interp *interp, char *zPtr, void *p){ 185 sqlite3_snprintf(100, zPtr, "%p", p); 186 return TCL_OK; 187 } 188 189 /* 190 ** The callback routine for sqlite3_exec_printf(). 191 */ 192 static int exec_printf_cb(void *pArg, int argc, char **argv, char **name){ 193 Tcl_DString *str = (Tcl_DString*)pArg; 194 int i; 195 196 if( Tcl_DStringLength(str)==0 ){ 197 for(i=0; i<argc; i++){ 198 Tcl_DStringAppendElement(str, name[i] ? name[i] : "NULL"); 199 } 200 } 201 for(i=0; i<argc; i++){ 202 Tcl_DStringAppendElement(str, argv[i] ? argv[i] : "NULL"); 203 } 204 return 0; 205 } 206 207 /* 208 ** The I/O tracing callback. 209 */ 210 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE) 211 static FILE *iotrace_file = 0; 212 static void io_trace_callback(const char *zFormat, ...){ 213 va_list ap; 214 va_start(ap, zFormat); 215 vfprintf(iotrace_file, zFormat, ap); 216 va_end(ap); 217 fflush(iotrace_file); 218 } 219 #endif 220 221 /* 222 ** Usage: io_trace FILENAME 223 ** 224 ** Turn I/O tracing on or off. If FILENAME is not an empty string, 225 ** I/O tracing begins going into FILENAME. If FILENAME is an empty 226 ** string, I/O tracing is turned off. 227 */ 228 static int SQLITE_TCLAPI test_io_trace( 229 void *NotUsed, 230 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 231 int argc, /* Number of arguments */ 232 char **argv /* Text of each argument */ 233 ){ 234 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE) 235 if( argc!=2 ){ 236 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 237 " FILENAME\"", 0); 238 return TCL_ERROR; 239 } 240 if( iotrace_file ){ 241 if( iotrace_file!=stdout && iotrace_file!=stderr ){ 242 fclose(iotrace_file); 243 } 244 iotrace_file = 0; 245 sqlite3IoTrace = 0; 246 } 247 if( argv[1][0] ){ 248 if( strcmp(argv[1],"stdout")==0 ){ 249 iotrace_file = stdout; 250 }else if( strcmp(argv[1],"stderr")==0 ){ 251 iotrace_file = stderr; 252 }else{ 253 iotrace_file = fopen(argv[1], "w"); 254 } 255 sqlite3IoTrace = io_trace_callback; 256 } 257 #endif 258 return TCL_OK; 259 } 260 261 /* 262 ** Usage: clang_sanitize_address 263 ** 264 ** Returns true if the program was compiled using clang with the 265 ** -fsanitize=address switch on the command line. False otherwise. 266 ** 267 ** Also return true if the OMIT_MISUSE environment variable exists. 268 */ 269 static int SQLITE_TCLAPI clang_sanitize_address( 270 void *NotUsed, 271 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 272 int argc, /* Number of arguments */ 273 char **argv /* Text of each argument */ 274 ){ 275 int res = 0; 276 #if defined(__has_feature) 277 # if __has_feature(address_sanitizer) 278 res = 1; 279 # endif 280 #endif 281 #ifdef __SANITIZE_ADDRESS__ 282 res = 1; 283 #endif 284 if( res==0 && getenv("OMIT_MISUSE")!=0 ) res = 1; 285 Tcl_SetObjResult(interp, Tcl_NewIntObj(res)); 286 return TCL_OK; 287 } 288 289 /* 290 ** Usage: sqlite3_exec_printf DB FORMAT STRING 291 ** 292 ** Invoke the sqlite3_exec_printf() interface using the open database 293 ** DB. The SQL is the string FORMAT. The format string should contain 294 ** one %s or %q. STRING is the value inserted into %s or %q. 295 */ 296 static int SQLITE_TCLAPI test_exec_printf( 297 void *NotUsed, 298 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 299 int argc, /* Number of arguments */ 300 char **argv /* Text of each argument */ 301 ){ 302 sqlite3 *db; 303 Tcl_DString str; 304 int rc; 305 char *zErr = 0; 306 char *zSql; 307 char zBuf[30]; 308 if( argc!=4 ){ 309 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 310 " DB FORMAT STRING", 0); 311 return TCL_ERROR; 312 } 313 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 314 Tcl_DStringInit(&str); 315 zSql = sqlite3_mprintf(argv[2], argv[3]); 316 rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr); 317 sqlite3_free(zSql); 318 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", rc); 319 Tcl_AppendElement(interp, zBuf); 320 Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr); 321 Tcl_DStringFree(&str); 322 if( zErr ) sqlite3_free(zErr); 323 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 324 return TCL_OK; 325 } 326 327 /* 328 ** Usage: sqlite3_exec_hex DB HEX 329 ** 330 ** Invoke the sqlite3_exec() on a string that is obtained by translating 331 ** HEX into ASCII. Most characters are translated as is. %HH becomes 332 ** a hex character. 333 */ 334 static int SQLITE_TCLAPI test_exec_hex( 335 void *NotUsed, 336 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 337 int argc, /* Number of arguments */ 338 char **argv /* Text of each argument */ 339 ){ 340 sqlite3 *db; 341 Tcl_DString str; 342 int rc, i, j; 343 char *zErr = 0; 344 char *zHex; 345 char zSql[501]; 346 char zBuf[30]; 347 if( argc!=3 ){ 348 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 349 " DB HEX", 0); 350 return TCL_ERROR; 351 } 352 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 353 zHex = argv[2]; 354 for(i=j=0; i<(sizeof(zSql)-1) && zHex[j]; i++, j++){ 355 if( zHex[j]=='%' && zHex[j+2] && zHex[j+2] ){ 356 zSql[i] = (testHexToInt(zHex[j+1])<<4) + testHexToInt(zHex[j+2]); 357 j += 2; 358 }else{ 359 zSql[i] = zHex[j]; 360 } 361 } 362 zSql[i] = 0; 363 Tcl_DStringInit(&str); 364 rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr); 365 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", rc); 366 Tcl_AppendElement(interp, zBuf); 367 Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr); 368 Tcl_DStringFree(&str); 369 if( zErr ) sqlite3_free(zErr); 370 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 371 return TCL_OK; 372 } 373 374 /* 375 ** Usage: db_enter DB 376 ** db_leave DB 377 ** 378 ** Enter or leave the mutex on a database connection. 379 */ 380 static int SQLITE_TCLAPI db_enter( 381 void *NotUsed, 382 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 383 int argc, /* Number of arguments */ 384 char **argv /* Text of each argument */ 385 ){ 386 sqlite3 *db; 387 if( argc!=2 ){ 388 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 389 " DB", 0); 390 return TCL_ERROR; 391 } 392 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 393 sqlite3_mutex_enter(db->mutex); 394 return TCL_OK; 395 } 396 static int SQLITE_TCLAPI db_leave( 397 void *NotUsed, 398 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 399 int argc, /* Number of arguments */ 400 char **argv /* Text of each argument */ 401 ){ 402 sqlite3 *db; 403 if( argc!=2 ){ 404 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 405 " DB", 0); 406 return TCL_ERROR; 407 } 408 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 409 sqlite3_mutex_leave(db->mutex); 410 return TCL_OK; 411 } 412 413 /* 414 ** Usage: sqlite3_exec DB SQL 415 ** 416 ** Invoke the sqlite3_exec interface using the open database DB 417 */ 418 static int SQLITE_TCLAPI test_exec( 419 void *NotUsed, 420 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 421 int argc, /* Number of arguments */ 422 char **argv /* Text of each argument */ 423 ){ 424 sqlite3 *db; 425 Tcl_DString str; 426 int rc; 427 char *zErr = 0; 428 char *zSql; 429 int i, j; 430 char zBuf[30]; 431 if( argc!=3 ){ 432 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 433 " DB SQL", 0); 434 return TCL_ERROR; 435 } 436 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 437 Tcl_DStringInit(&str); 438 zSql = sqlite3_mprintf("%s", argv[2]); 439 for(i=j=0; zSql[i];){ 440 if( zSql[i]=='%' ){ 441 zSql[j++] = (testHexToInt(zSql[i+1])<<4) + testHexToInt(zSql[i+2]); 442 i += 3; 443 }else{ 444 zSql[j++] = zSql[i++]; 445 } 446 } 447 zSql[j] = 0; 448 rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr); 449 sqlite3_free(zSql); 450 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", rc); 451 Tcl_AppendElement(interp, zBuf); 452 Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr); 453 Tcl_DStringFree(&str); 454 if( zErr ) sqlite3_free(zErr); 455 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 456 return TCL_OK; 457 } 458 459 /* 460 ** Usage: sqlite3_exec_nr DB SQL 461 ** 462 ** Invoke the sqlite3_exec interface using the open database DB. Discard 463 ** all results 464 */ 465 static int SQLITE_TCLAPI test_exec_nr( 466 void *NotUsed, 467 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 468 int argc, /* Number of arguments */ 469 char **argv /* Text of each argument */ 470 ){ 471 sqlite3 *db; 472 int rc; 473 char *zErr = 0; 474 if( argc!=3 ){ 475 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 476 " DB SQL", 0); 477 return TCL_ERROR; 478 } 479 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 480 rc = sqlite3_exec(db, argv[2], 0, 0, &zErr); 481 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 482 return TCL_OK; 483 } 484 485 /* 486 ** Usage: sqlite3_mprintf_z_test SEPARATOR ARG0 ARG1 ... 487 ** 488 ** Test the %z format of sqlite_mprintf(). Use multiple mprintf() calls to 489 ** concatenate arg0 through argn using separator as the separator. 490 ** Return the result. 491 */ 492 static int SQLITE_TCLAPI test_mprintf_z( 493 void *NotUsed, 494 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 495 int argc, /* Number of arguments */ 496 char **argv /* Text of each argument */ 497 ){ 498 char *zResult = 0; 499 int i; 500 501 for(i=2; i<argc && (i==2 || zResult); i++){ 502 zResult = sqlite3_mprintf("%z%s%s", zResult, argv[1], argv[i]); 503 } 504 Tcl_AppendResult(interp, zResult, 0); 505 sqlite3_free(zResult); 506 return TCL_OK; 507 } 508 509 /* 510 ** Usage: sqlite3_mprintf_n_test STRING 511 ** 512 ** Test the %n format of sqlite_mprintf(). Return the length of the 513 ** input string. 514 */ 515 static int SQLITE_TCLAPI test_mprintf_n( 516 void *NotUsed, 517 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 518 int argc, /* Number of arguments */ 519 char **argv /* Text of each argument */ 520 ){ 521 char *zStr; 522 int n = 0; 523 zStr = sqlite3_mprintf("%s%n", argv[1], &n); 524 sqlite3_free(zStr); 525 Tcl_SetObjResult(interp, Tcl_NewIntObj(n)); 526 return TCL_OK; 527 } 528 529 /* 530 ** Usage: sqlite3_snprintf_int SIZE FORMAT INT 531 ** 532 ** Test the of sqlite3_snprintf() routine. SIZE is the size of the 533 ** output buffer in bytes. The maximum size is 100. FORMAT is the 534 ** format string. INT is a single integer argument. The FORMAT 535 ** string must require no more than this one integer argument. If 536 ** You pass in a format string that requires more than one argument, 537 ** bad things will happen. 538 */ 539 static int SQLITE_TCLAPI test_snprintf_int( 540 void *NotUsed, 541 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 542 int argc, /* Number of arguments */ 543 char **argv /* Text of each argument */ 544 ){ 545 char zStr[100]; 546 int n = atoi(argv[1]); 547 const char *zFormat = argv[2]; 548 int a1 = atoi(argv[3]); 549 if( n>sizeof(zStr) ) n = sizeof(zStr); 550 sqlite3_snprintf(sizeof(zStr), zStr, "abcdefghijklmnopqrstuvwxyz"); 551 sqlite3_snprintf(n, zStr, zFormat, a1); 552 Tcl_AppendResult(interp, zStr, 0); 553 return TCL_OK; 554 } 555 556 #ifndef SQLITE_OMIT_GET_TABLE 557 558 /* 559 ** Usage: sqlite3_get_table_printf DB FORMAT STRING ?--no-counts? 560 ** 561 ** Invoke the sqlite3_get_table_printf() interface using the open database 562 ** DB. The SQL is the string FORMAT. The format string should contain 563 ** one %s or %q. STRING is the value inserted into %s or %q. 564 */ 565 static int SQLITE_TCLAPI test_get_table_printf( 566 void *NotUsed, 567 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 568 int argc, /* Number of arguments */ 569 char **argv /* Text of each argument */ 570 ){ 571 sqlite3 *db; 572 Tcl_DString str; 573 int rc; 574 char *zErr = 0; 575 int nRow = 0, nCol = 0; 576 char **aResult; 577 int i; 578 char zBuf[30]; 579 char *zSql; 580 int resCount = -1; 581 if( argc==5 ){ 582 if( Tcl_GetInt(interp, argv[4], &resCount) ) return TCL_ERROR; 583 } 584 if( argc!=4 && argc!=5 ){ 585 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 586 " DB FORMAT STRING ?COUNT?", 0); 587 return TCL_ERROR; 588 } 589 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 590 Tcl_DStringInit(&str); 591 zSql = sqlite3_mprintf(argv[2],argv[3]); 592 if( argc==5 ){ 593 rc = sqlite3_get_table(db, zSql, &aResult, 0, 0, &zErr); 594 }else{ 595 rc = sqlite3_get_table(db, zSql, &aResult, &nRow, &nCol, &zErr); 596 resCount = (nRow+1)*nCol; 597 } 598 sqlite3_free(zSql); 599 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", rc); 600 Tcl_AppendElement(interp, zBuf); 601 if( rc==SQLITE_OK ){ 602 if( argc==4 ){ 603 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", nRow); 604 Tcl_AppendElement(interp, zBuf); 605 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", nCol); 606 Tcl_AppendElement(interp, zBuf); 607 } 608 for(i=0; i<resCount; i++){ 609 Tcl_AppendElement(interp, aResult[i] ? aResult[i] : "NULL"); 610 } 611 }else{ 612 Tcl_AppendElement(interp, zErr); 613 } 614 sqlite3_free_table(aResult); 615 if( zErr ) sqlite3_free(zErr); 616 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 617 return TCL_OK; 618 } 619 620 #endif /* SQLITE_OMIT_GET_TABLE */ 621 622 623 /* 624 ** Usage: sqlite3_last_insert_rowid DB 625 ** 626 ** Returns the integer ROWID of the most recent insert. 627 */ 628 static int SQLITE_TCLAPI test_last_rowid( 629 void *NotUsed, 630 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 631 int argc, /* Number of arguments */ 632 char **argv /* Text of each argument */ 633 ){ 634 sqlite3 *db; 635 char zBuf[30]; 636 637 if( argc!=2 ){ 638 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB\"", 0); 639 return TCL_ERROR; 640 } 641 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 642 sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", sqlite3_last_insert_rowid(db)); 643 Tcl_AppendResult(interp, zBuf, 0); 644 return SQLITE_OK; 645 } 646 647 /* 648 ** Usage: sqlite3_key DB KEY 649 ** 650 ** Set the codec key. 651 */ 652 static int SQLITE_TCLAPI test_key( 653 void *NotUsed, 654 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 655 int argc, /* Number of arguments */ 656 char **argv /* Text of each argument */ 657 ){ 658 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL) 659 sqlite3 *db; 660 const char *zKey; 661 int nKey; 662 if( argc!=3 ){ 663 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 664 " FILENAME\"", 0); 665 return TCL_ERROR; 666 } 667 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 668 zKey = argv[2]; 669 nKey = strlen(zKey); 670 sqlite3_key(db, zKey, nKey); 671 #endif 672 return TCL_OK; 673 } 674 675 /* 676 ** Usage: sqlite3_rekey DB KEY 677 ** 678 ** Change the codec key. 679 */ 680 static int SQLITE_TCLAPI test_rekey( 681 void *NotUsed, 682 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 683 int argc, /* Number of arguments */ 684 char **argv /* Text of each argument */ 685 ){ 686 #ifdef SQLITE_HAS_CODEC 687 sqlite3 *db; 688 const char *zKey; 689 int nKey; 690 if( argc!=3 ){ 691 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 692 " FILENAME\"", 0); 693 return TCL_ERROR; 694 } 695 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 696 zKey = argv[2]; 697 nKey = strlen(zKey); 698 sqlite3_rekey(db, zKey, nKey); 699 #endif 700 return TCL_OK; 701 } 702 703 /* 704 ** Usage: sqlite3_close DB 705 ** 706 ** Closes the database opened by sqlite3_open. 707 */ 708 static int SQLITE_TCLAPI sqlite_test_close( 709 void *NotUsed, 710 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 711 int argc, /* Number of arguments */ 712 char **argv /* Text of each argument */ 713 ){ 714 sqlite3 *db; 715 int rc; 716 if( argc!=2 ){ 717 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 718 " FILENAME\"", 0); 719 return TCL_ERROR; 720 } 721 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 722 rc = sqlite3_close(db); 723 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 724 return TCL_OK; 725 } 726 727 /* 728 ** Usage: sqlite3_close_v2 DB 729 ** 730 ** Closes the database opened by sqlite3_open. 731 */ 732 static int SQLITE_TCLAPI sqlite_test_close_v2( 733 void *NotUsed, 734 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 735 int argc, /* Number of arguments */ 736 char **argv /* Text of each argument */ 737 ){ 738 sqlite3 *db; 739 int rc; 740 if( argc!=2 ){ 741 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 742 " FILENAME\"", 0); 743 return TCL_ERROR; 744 } 745 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 746 rc = sqlite3_close_v2(db); 747 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 748 return TCL_OK; 749 } 750 751 /* 752 ** Implementation of the x_coalesce() function. 753 ** Return the first argument non-NULL argument. 754 */ 755 static void t1_ifnullFunc( 756 sqlite3_context *context, 757 int argc, 758 sqlite3_value **argv 759 ){ 760 int i; 761 for(i=0; i<argc; i++){ 762 if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){ 763 int n = sqlite3_value_bytes(argv[i]); 764 sqlite3_result_text(context, (char*)sqlite3_value_text(argv[i]), 765 n, SQLITE_TRANSIENT); 766 break; 767 } 768 } 769 } 770 771 /* 772 ** These are test functions. hex8() interprets its argument as 773 ** UTF8 and returns a hex encoding. hex16le() interprets its argument 774 ** as UTF16le and returns a hex encoding. 775 */ 776 static void hex8Func(sqlite3_context *p, int argc, sqlite3_value **argv){ 777 const unsigned char *z; 778 int i; 779 char zBuf[200]; 780 z = sqlite3_value_text(argv[0]); 781 for(i=0; i<sizeof(zBuf)/2 - 2 && z[i]; i++){ 782 sqlite3_snprintf(sizeof(zBuf)-i*2, &zBuf[i*2], "%02x", z[i]); 783 } 784 zBuf[i*2] = 0; 785 sqlite3_result_text(p, (char*)zBuf, -1, SQLITE_TRANSIENT); 786 } 787 #ifndef SQLITE_OMIT_UTF16 788 static void hex16Func(sqlite3_context *p, int argc, sqlite3_value **argv){ 789 const unsigned short int *z; 790 int i; 791 char zBuf[400]; 792 z = sqlite3_value_text16(argv[0]); 793 for(i=0; i<sizeof(zBuf)/4 - 4 && z[i]; i++){ 794 sqlite3_snprintf(sizeof(zBuf)-i*4, &zBuf[i*4],"%04x", z[i]&0xff); 795 } 796 zBuf[i*4] = 0; 797 sqlite3_result_text(p, (char*)zBuf, -1, SQLITE_TRANSIENT); 798 } 799 #endif 800 801 /* 802 ** A structure into which to accumulate text. 803 */ 804 struct dstr { 805 int nAlloc; /* Space allocated */ 806 int nUsed; /* Space used */ 807 char *z; /* The space */ 808 }; 809 810 /* 811 ** Append text to a dstr 812 */ 813 static void dstrAppend(struct dstr *p, const char *z, int divider){ 814 int n = (int)strlen(z); 815 if( p->nUsed + n + 2 > p->nAlloc ){ 816 char *zNew; 817 p->nAlloc = p->nAlloc*2 + n + 200; 818 zNew = sqlite3_realloc(p->z, p->nAlloc); 819 if( zNew==0 ){ 820 sqlite3_free(p->z); 821 memset(p, 0, sizeof(*p)); 822 return; 823 } 824 p->z = zNew; 825 } 826 if( divider && p->nUsed>0 ){ 827 p->z[p->nUsed++] = divider; 828 } 829 memcpy(&p->z[p->nUsed], z, n+1); 830 p->nUsed += n; 831 } 832 833 /* 834 ** Invoked for each callback from sqlite3ExecFunc 835 */ 836 static int execFuncCallback(void *pData, int argc, char **argv, char **NotUsed){ 837 struct dstr *p = (struct dstr*)pData; 838 int i; 839 for(i=0; i<argc; i++){ 840 if( argv[i]==0 ){ 841 dstrAppend(p, "NULL", ' '); 842 }else{ 843 dstrAppend(p, argv[i], ' '); 844 } 845 } 846 return 0; 847 } 848 849 /* 850 ** Implementation of the x_sqlite_exec() function. This function takes 851 ** a single argument and attempts to execute that argument as SQL code. 852 ** This is illegal and should set the SQLITE_MISUSE flag on the database. 853 ** 854 ** 2004-Jan-07: We have changed this to make it legal to call sqlite3_exec() 855 ** from within a function call. 856 ** 857 ** This routine simulates the effect of having two threads attempt to 858 ** use the same database at the same time. 859 */ 860 static void sqlite3ExecFunc( 861 sqlite3_context *context, 862 int argc, 863 sqlite3_value **argv 864 ){ 865 struct dstr x; 866 memset(&x, 0, sizeof(x)); 867 (void)sqlite3_exec((sqlite3*)sqlite3_user_data(context), 868 (char*)sqlite3_value_text(argv[0]), 869 execFuncCallback, &x, 0); 870 sqlite3_result_text(context, x.z, x.nUsed, SQLITE_TRANSIENT); 871 sqlite3_free(x.z); 872 } 873 874 /* 875 ** Implementation of tkt2213func(), a scalar function that takes exactly 876 ** one argument. It has two interesting features: 877 ** 878 ** * It calls sqlite3_value_text() 3 times on the argument sqlite3_value*. 879 ** If the three pointers returned are not the same an SQL error is raised. 880 ** 881 ** * Otherwise it returns a copy of the text representation of its 882 ** argument in such a way as the VDBE representation is a Mem* cell 883 ** with the MEM_Term flag clear. 884 ** 885 ** Ticket #2213 can therefore be tested by evaluating the following 886 ** SQL expression: 887 ** 888 ** tkt2213func(tkt2213func('a string')); 889 */ 890 static void tkt2213Function( 891 sqlite3_context *context, 892 int argc, 893 sqlite3_value **argv 894 ){ 895 int nText; 896 unsigned char const *zText1; 897 unsigned char const *zText2; 898 unsigned char const *zText3; 899 900 nText = sqlite3_value_bytes(argv[0]); 901 zText1 = sqlite3_value_text(argv[0]); 902 zText2 = sqlite3_value_text(argv[0]); 903 zText3 = sqlite3_value_text(argv[0]); 904 905 if( zText1!=zText2 || zText2!=zText3 ){ 906 sqlite3_result_error(context, "tkt2213 is not fixed", -1); 907 }else{ 908 char *zCopy = (char *)sqlite3_malloc(nText); 909 memcpy(zCopy, zText1, nText); 910 sqlite3_result_text(context, zCopy, nText, sqlite3_free); 911 } 912 } 913 914 /* 915 ** The following SQL function takes 4 arguments. The 2nd and 916 ** 4th argument must be one of these strings: 'text', 'text16', 917 ** or 'blob' corresponding to API functions 918 ** 919 ** sqlite3_value_text() 920 ** sqlite3_value_text16() 921 ** sqlite3_value_blob() 922 ** 923 ** The third argument is a string, either 'bytes' or 'bytes16' or 'noop', 924 ** corresponding to APIs: 925 ** 926 ** sqlite3_value_bytes() 927 ** sqlite3_value_bytes16() 928 ** noop 929 ** 930 ** The APIs designated by the 2nd through 4th arguments are applied 931 ** to the first argument in order. If the pointers returned by the 932 ** second and fourth are different, this routine returns 1. Otherwise, 933 ** this routine returns 0. 934 ** 935 ** This function is used to test to see when returned pointers from 936 ** the _text(), _text16() and _blob() APIs become invalidated. 937 */ 938 static void ptrChngFunction( 939 sqlite3_context *context, 940 int argc, 941 sqlite3_value **argv 942 ){ 943 const void *p1, *p2; 944 const char *zCmd; 945 if( argc!=4 ) return; 946 zCmd = (const char*)sqlite3_value_text(argv[1]); 947 if( zCmd==0 ) return; 948 if( strcmp(zCmd,"text")==0 ){ 949 p1 = (const void*)sqlite3_value_text(argv[0]); 950 #ifndef SQLITE_OMIT_UTF16 951 }else if( strcmp(zCmd, "text16")==0 ){ 952 p1 = (const void*)sqlite3_value_text16(argv[0]); 953 #endif 954 }else if( strcmp(zCmd, "blob")==0 ){ 955 p1 = (const void*)sqlite3_value_blob(argv[0]); 956 }else{ 957 return; 958 } 959 zCmd = (const char*)sqlite3_value_text(argv[2]); 960 if( zCmd==0 ) return; 961 if( strcmp(zCmd,"bytes")==0 ){ 962 sqlite3_value_bytes(argv[0]); 963 #ifndef SQLITE_OMIT_UTF16 964 }else if( strcmp(zCmd, "bytes16")==0 ){ 965 sqlite3_value_bytes16(argv[0]); 966 #endif 967 }else if( strcmp(zCmd, "noop")==0 ){ 968 /* do nothing */ 969 }else{ 970 return; 971 } 972 zCmd = (const char*)sqlite3_value_text(argv[3]); 973 if( zCmd==0 ) return; 974 if( strcmp(zCmd,"text")==0 ){ 975 p2 = (const void*)sqlite3_value_text(argv[0]); 976 #ifndef SQLITE_OMIT_UTF16 977 }else if( strcmp(zCmd, "text16")==0 ){ 978 p2 = (const void*)sqlite3_value_text16(argv[0]); 979 #endif 980 }else if( strcmp(zCmd, "blob")==0 ){ 981 p2 = (const void*)sqlite3_value_blob(argv[0]); 982 }else{ 983 return; 984 } 985 sqlite3_result_int(context, p1!=p2); 986 } 987 988 /* 989 ** This SQL function returns a different answer each time it is called, even if 990 ** the arguments are the same. 991 */ 992 static void nondeterministicFunction( 993 sqlite3_context *context, 994 int argc, 995 sqlite3_value **argv 996 ){ 997 static int cnt = 0; 998 sqlite3_result_int(context, cnt++); 999 } 1000 1001 /* 1002 ** This SQL function returns the integer value of its argument as a MEM_IntReal 1003 ** value. 1004 */ 1005 static void intrealFunction( 1006 sqlite3_context *context, 1007 int argc, 1008 sqlite3_value **argv 1009 ){ 1010 sqlite3_int64 v = sqlite3_value_int64(argv[0]); 1011 sqlite3_result_int64(context, v); 1012 sqlite3_test_control(SQLITE_TESTCTRL_RESULT_INTREAL, context); 1013 } 1014 1015 /* 1016 ** Usage: sqlite3_create_function DB 1017 ** 1018 ** Call the sqlite3_create_function API on the given database in order 1019 ** to create a function named "x_coalesce". This function does the same thing 1020 ** as the "coalesce" function. This function also registers an SQL function 1021 ** named "x_sqlite_exec" that invokes sqlite3_exec(). Invoking sqlite3_exec() 1022 ** in this way is illegal recursion and should raise an SQLITE_MISUSE error. 1023 ** The effect is similar to trying to use the same database connection from 1024 ** two threads at the same time. 1025 ** 1026 ** The original motivation for this routine was to be able to call the 1027 ** sqlite3_create_function function while a query is in progress in order 1028 ** to test the SQLITE_MISUSE detection logic. 1029 */ 1030 static int SQLITE_TCLAPI test_create_function( 1031 void *NotUsed, 1032 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1033 int argc, /* Number of arguments */ 1034 char **argv /* Text of each argument */ 1035 ){ 1036 int rc; 1037 sqlite3 *db; 1038 1039 if( argc!=2 ){ 1040 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1041 " DB\"", 0); 1042 return TCL_ERROR; 1043 } 1044 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 1045 rc = sqlite3_create_function(db, "x_coalesce", -1, SQLITE_UTF8, 0, 1046 t1_ifnullFunc, 0, 0); 1047 if( rc==SQLITE_OK ){ 1048 rc = sqlite3_create_function(db, "hex8", 1, SQLITE_UTF8 | SQLITE_DETERMINISTIC, 1049 0, hex8Func, 0, 0); 1050 } 1051 #ifndef SQLITE_OMIT_UTF16 1052 if( rc==SQLITE_OK ){ 1053 rc = sqlite3_create_function(db, "hex16", 1, SQLITE_UTF16 | SQLITE_DETERMINISTIC, 1054 0, hex16Func, 0, 0); 1055 } 1056 #endif 1057 if( rc==SQLITE_OK ){ 1058 rc = sqlite3_create_function(db, "tkt2213func", 1, SQLITE_ANY, 0, 1059 tkt2213Function, 0, 0); 1060 } 1061 if( rc==SQLITE_OK ){ 1062 rc = sqlite3_create_function(db, "pointer_change", 4, SQLITE_ANY, 0, 1063 ptrChngFunction, 0, 0); 1064 } 1065 1066 /* Functions counter1() and counter2() have the same implementation - they 1067 ** both return an ascending integer with each call. But counter1() is marked 1068 ** as non-deterministic and counter2() is marked as deterministic. 1069 */ 1070 if( rc==SQLITE_OK ){ 1071 rc = sqlite3_create_function(db, "counter1", -1, SQLITE_UTF8, 1072 0, nondeterministicFunction, 0, 0); 1073 } 1074 if( rc==SQLITE_OK ){ 1075 rc = sqlite3_create_function(db, "counter2", -1, SQLITE_UTF8|SQLITE_DETERMINISTIC, 1076 0, nondeterministicFunction, 0, 0); 1077 } 1078 1079 /* The intreal() function converts its argument to an integer and returns 1080 ** it as a MEM_IntReal. 1081 */ 1082 if( rc==SQLITE_OK ){ 1083 rc = sqlite3_create_function(db, "intreal", 1, SQLITE_UTF8, 1084 0, intrealFunction, 0, 0); 1085 } 1086 1087 #ifndef SQLITE_OMIT_UTF16 1088 /* Use the sqlite3_create_function16() API here. Mainly for fun, but also 1089 ** because it is not tested anywhere else. */ 1090 if( rc==SQLITE_OK ){ 1091 const void *zUtf16; 1092 sqlite3_value *pVal; 1093 sqlite3_mutex_enter(db->mutex); 1094 pVal = sqlite3ValueNew(db); 1095 sqlite3ValueSetStr(pVal, -1, "x_sqlite_exec", SQLITE_UTF8, SQLITE_STATIC); 1096 zUtf16 = sqlite3ValueText(pVal, SQLITE_UTF16NATIVE); 1097 if( db->mallocFailed ){ 1098 rc = SQLITE_NOMEM; 1099 }else{ 1100 rc = sqlite3_create_function16(db, zUtf16, 1101 1, SQLITE_UTF16, db, sqlite3ExecFunc, 0, 0); 1102 } 1103 sqlite3ValueFree(pVal); 1104 sqlite3_mutex_leave(db->mutex); 1105 } 1106 #endif 1107 1108 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 1109 Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0); 1110 return TCL_OK; 1111 } 1112 1113 /* 1114 ** Usage: sqlite3_drop_modules DB ?NAME ...? 1115 ** 1116 ** Invoke the sqlite3_drop_modules(D,L) interface on database 1117 ** connection DB, in order to drop all modules except those named in 1118 ** the argument. 1119 */ 1120 static int SQLITE_TCLAPI test_drop_modules( 1121 void *NotUsed, 1122 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1123 int argc, /* Number of arguments */ 1124 char **argv /* Text of each argument */ 1125 ){ 1126 sqlite3 *db; 1127 1128 if( argc!=2 ){ 1129 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1130 " DB\"", 0); 1131 return TCL_ERROR; 1132 } 1133 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 1134 sqlite3_drop_modules(db, argc>2 ? (const char**)(argv+2) : 0); 1135 return TCL_OK; 1136 } 1137 1138 /* 1139 ** Routines to implement the x_count() aggregate function. 1140 ** 1141 ** x_count() counts the number of non-null arguments. But there are 1142 ** some twists for testing purposes. 1143 ** 1144 ** If the argument to x_count() is 40 then a UTF-8 error is reported 1145 ** on the step function. If x_count(41) is seen, then a UTF-16 error 1146 ** is reported on the step function. If the total count is 42, then 1147 ** a UTF-8 error is reported on the finalize function. 1148 */ 1149 typedef struct t1CountCtx t1CountCtx; 1150 struct t1CountCtx { 1151 int n; 1152 }; 1153 static void t1CountStep( 1154 sqlite3_context *context, 1155 int argc, 1156 sqlite3_value **argv 1157 ){ 1158 t1CountCtx *p; 1159 p = sqlite3_aggregate_context(context, sizeof(*p)); 1160 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0]) ) && p ){ 1161 p->n++; 1162 } 1163 if( argc>0 ){ 1164 int v = sqlite3_value_int(argv[0]); 1165 if( v==40 ){ 1166 sqlite3_result_error(context, "value of 40 handed to x_count", -1); 1167 #ifndef SQLITE_OMIT_UTF16 1168 }else if( v==41 ){ 1169 const char zUtf16ErrMsg[] = { 0, 0x61, 0, 0x62, 0, 0x63, 0, 0, 0}; 1170 sqlite3_result_error16(context, &zUtf16ErrMsg[1-SQLITE_BIGENDIAN], -1); 1171 #endif 1172 } 1173 } 1174 } 1175 static void t1CountFinalize(sqlite3_context *context){ 1176 t1CountCtx *p; 1177 p = sqlite3_aggregate_context(context, sizeof(*p)); 1178 if( p ){ 1179 if( p->n==42 ){ 1180 sqlite3_result_error(context, "x_count totals to 42", -1); 1181 }else{ 1182 sqlite3_result_int(context, p ? p->n : 0); 1183 } 1184 } 1185 } 1186 1187 #ifndef SQLITE_OMIT_DEPRECATED 1188 static void legacyCountStep( 1189 sqlite3_context *context, 1190 int argc, 1191 sqlite3_value **argv 1192 ){ 1193 /* no-op */ 1194 } 1195 1196 static void legacyCountFinalize(sqlite3_context *context){ 1197 sqlite3_result_int(context, sqlite3_aggregate_count(context)); 1198 } 1199 #endif 1200 1201 /* 1202 ** Usage: sqlite3_create_aggregate DB 1203 ** 1204 ** Call the sqlite3_create_function API on the given database in order 1205 ** to create a function named "x_count". This function is similar 1206 ** to the built-in count() function, with a few special quirks 1207 ** for testing the sqlite3_result_error() APIs. 1208 ** 1209 ** The original motivation for this routine was to be able to call the 1210 ** sqlite3_create_aggregate function while a query is in progress in order 1211 ** to test the SQLITE_MISUSE detection logic. See misuse.test. 1212 ** 1213 ** This routine was later extended to test the use of sqlite3_result_error() 1214 ** within aggregate functions. 1215 ** 1216 ** Later: It is now also extended to register the aggregate function 1217 ** "legacy_count()" with the supplied database handle. This is used 1218 ** to test the deprecated sqlite3_aggregate_count() API. 1219 */ 1220 static int SQLITE_TCLAPI test_create_aggregate( 1221 void *NotUsed, 1222 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1223 int argc, /* Number of arguments */ 1224 char **argv /* Text of each argument */ 1225 ){ 1226 sqlite3 *db; 1227 int rc; 1228 if( argc!=2 ){ 1229 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1230 " FILENAME\"", 0); 1231 return TCL_ERROR; 1232 } 1233 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 1234 rc = sqlite3_create_function(db, "x_count", 0, SQLITE_UTF8, 0, 0, 1235 t1CountStep,t1CountFinalize); 1236 if( rc==SQLITE_OK ){ 1237 rc = sqlite3_create_function(db, "x_count", 1, SQLITE_UTF8, 0, 0, 1238 t1CountStep,t1CountFinalize); 1239 } 1240 #ifndef SQLITE_OMIT_DEPRECATED 1241 if( rc==SQLITE_OK ){ 1242 rc = sqlite3_create_function(db, "legacy_count", 0, SQLITE_ANY, 0, 0, 1243 legacyCountStep, legacyCountFinalize 1244 ); 1245 } 1246 #endif 1247 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 1248 Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0); 1249 return TCL_OK; 1250 } 1251 1252 1253 /* 1254 ** Usage: printf TEXT 1255 ** 1256 ** Send output to printf. Use this rather than puts to merge the output 1257 ** in the correct sequence with debugging printfs inserted into C code. 1258 ** Puts uses a separate buffer and debugging statements will be out of 1259 ** sequence if it is used. 1260 */ 1261 static int SQLITE_TCLAPI test_printf( 1262 void *NotUsed, 1263 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1264 int argc, /* Number of arguments */ 1265 char **argv /* Text of each argument */ 1266 ){ 1267 if( argc!=2 ){ 1268 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1269 " TEXT\"", 0); 1270 return TCL_ERROR; 1271 } 1272 printf("%s\n", argv[1]); 1273 return TCL_OK; 1274 } 1275 1276 1277 1278 /* 1279 ** Usage: sqlite3_mprintf_int FORMAT INTEGER INTEGER INTEGER 1280 ** 1281 ** Call mprintf with three integer arguments 1282 */ 1283 static int SQLITE_TCLAPI sqlite3_mprintf_int( 1284 void *NotUsed, 1285 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1286 int argc, /* Number of arguments */ 1287 char **argv /* Text of each argument */ 1288 ){ 1289 int a[3], i; 1290 char *z; 1291 if( argc!=5 ){ 1292 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1293 " FORMAT INT INT INT\"", 0); 1294 return TCL_ERROR; 1295 } 1296 for(i=2; i<5; i++){ 1297 if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR; 1298 } 1299 z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]); 1300 Tcl_AppendResult(interp, z, 0); 1301 sqlite3_free(z); 1302 return TCL_OK; 1303 } 1304 1305 /* 1306 ** Usage: sqlite3_mprintf_int64 FORMAT INTEGER INTEGER INTEGER 1307 ** 1308 ** Call mprintf with three 64-bit integer arguments 1309 */ 1310 static int SQLITE_TCLAPI sqlite3_mprintf_int64( 1311 void *NotUsed, 1312 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1313 int argc, /* Number of arguments */ 1314 char **argv /* Text of each argument */ 1315 ){ 1316 int i; 1317 sqlite_int64 a[3]; 1318 char *z; 1319 if( argc!=5 ){ 1320 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1321 " FORMAT INT INT INT\"", 0); 1322 return TCL_ERROR; 1323 } 1324 for(i=2; i<5; i++){ 1325 if( sqlite3Atoi64(argv[i], &a[i-2], sqlite3Strlen30(argv[i]), SQLITE_UTF8) ){ 1326 Tcl_AppendResult(interp, "argument is not a valid 64-bit integer", 0); 1327 return TCL_ERROR; 1328 } 1329 } 1330 z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]); 1331 Tcl_AppendResult(interp, z, 0); 1332 sqlite3_free(z); 1333 return TCL_OK; 1334 } 1335 1336 /* 1337 ** Usage: sqlite3_mprintf_long FORMAT INTEGER INTEGER INTEGER 1338 ** 1339 ** Call mprintf with three long integer arguments. This might be the 1340 ** same as sqlite3_mprintf_int or sqlite3_mprintf_int64, depending on 1341 ** platform. 1342 */ 1343 static int SQLITE_TCLAPI sqlite3_mprintf_long( 1344 void *NotUsed, 1345 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1346 int argc, /* Number of arguments */ 1347 char **argv /* Text of each argument */ 1348 ){ 1349 int i; 1350 long int a[3]; 1351 int b[3]; 1352 char *z; 1353 if( argc!=5 ){ 1354 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1355 " FORMAT INT INT INT\"", 0); 1356 return TCL_ERROR; 1357 } 1358 for(i=2; i<5; i++){ 1359 if( Tcl_GetInt(interp, argv[i], &b[i-2]) ) return TCL_ERROR; 1360 a[i-2] = (long int)b[i-2]; 1361 a[i-2] &= (((u64)1)<<(sizeof(int)*8))-1; 1362 } 1363 z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]); 1364 Tcl_AppendResult(interp, z, 0); 1365 sqlite3_free(z); 1366 return TCL_OK; 1367 } 1368 1369 /* 1370 ** Usage: sqlite3_mprintf_str FORMAT INTEGER INTEGER STRING 1371 ** 1372 ** Call mprintf with two integer arguments and one string argument 1373 */ 1374 static int SQLITE_TCLAPI sqlite3_mprintf_str( 1375 void *NotUsed, 1376 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1377 int argc, /* Number of arguments */ 1378 char **argv /* Text of each argument */ 1379 ){ 1380 int a[3], i; 1381 char *z; 1382 if( argc<4 || argc>5 ){ 1383 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1384 " FORMAT INT INT ?STRING?\"", 0); 1385 return TCL_ERROR; 1386 } 1387 for(i=2; i<4; i++){ 1388 if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR; 1389 } 1390 z = sqlite3_mprintf(argv[1], a[0], a[1], argc>4 ? argv[4] : NULL); 1391 Tcl_AppendResult(interp, z, 0); 1392 sqlite3_free(z); 1393 return TCL_OK; 1394 } 1395 1396 /* 1397 ** Usage: sqlite3_snprintf_str INTEGER FORMAT INTEGER INTEGER STRING 1398 ** 1399 ** Call mprintf with two integer arguments and one string argument 1400 */ 1401 static int SQLITE_TCLAPI sqlite3_snprintf_str( 1402 void *NotUsed, 1403 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1404 int argc, /* Number of arguments */ 1405 char **argv /* Text of each argument */ 1406 ){ 1407 int a[3], i; 1408 int n; 1409 char *z; 1410 if( argc<5 || argc>6 ){ 1411 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1412 " INT FORMAT INT INT ?STRING?\"", 0); 1413 return TCL_ERROR; 1414 } 1415 if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR; 1416 if( n<0 ){ 1417 Tcl_AppendResult(interp, "N must be non-negative", 0); 1418 return TCL_ERROR; 1419 } 1420 for(i=3; i<5; i++){ 1421 if( Tcl_GetInt(interp, argv[i], &a[i-3]) ) return TCL_ERROR; 1422 } 1423 z = sqlite3_malloc( n+1 ); 1424 sqlite3_snprintf(n, z, argv[2], a[0], a[1], argc>4 ? argv[5] : NULL); 1425 Tcl_AppendResult(interp, z, 0); 1426 sqlite3_free(z); 1427 return TCL_OK; 1428 } 1429 1430 /* 1431 ** Usage: sqlite3_mprintf_double FORMAT INTEGER INTEGER DOUBLE 1432 ** 1433 ** Call mprintf with two integer arguments and one double argument 1434 */ 1435 static int SQLITE_TCLAPI sqlite3_mprintf_double( 1436 void *NotUsed, 1437 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1438 int argc, /* Number of arguments */ 1439 char **argv /* Text of each argument */ 1440 ){ 1441 int a[3], i; 1442 double r; 1443 char *z; 1444 if( argc!=5 ){ 1445 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1446 " FORMAT INT INT DOUBLE\"", 0); 1447 return TCL_ERROR; 1448 } 1449 for(i=2; i<4; i++){ 1450 if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR; 1451 } 1452 if( Tcl_GetDouble(interp, argv[4], &r) ) return TCL_ERROR; 1453 z = sqlite3_mprintf(argv[1], a[0], a[1], r); 1454 Tcl_AppendResult(interp, z, 0); 1455 sqlite3_free(z); 1456 return TCL_OK; 1457 } 1458 1459 /* 1460 ** Usage: sqlite3_mprintf_scaled FORMAT DOUBLE DOUBLE 1461 ** 1462 ** Call mprintf with a single double argument which is the product of the 1463 ** two arguments given above. This is used to generate overflow and underflow 1464 ** doubles to test that they are converted properly. 1465 */ 1466 static int SQLITE_TCLAPI sqlite3_mprintf_scaled( 1467 void *NotUsed, 1468 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1469 int argc, /* Number of arguments */ 1470 char **argv /* Text of each argument */ 1471 ){ 1472 int i; 1473 double r[2]; 1474 char *z; 1475 if( argc!=4 ){ 1476 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1477 " FORMAT DOUBLE DOUBLE\"", 0); 1478 return TCL_ERROR; 1479 } 1480 for(i=2; i<4; i++){ 1481 if( Tcl_GetDouble(interp, argv[i], &r[i-2]) ) return TCL_ERROR; 1482 } 1483 z = sqlite3_mprintf(argv[1], r[0]*r[1]); 1484 Tcl_AppendResult(interp, z, 0); 1485 sqlite3_free(z); 1486 return TCL_OK; 1487 } 1488 1489 /* 1490 ** Usage: sqlite3_mprintf_stronly FORMAT STRING 1491 ** 1492 ** Call mprintf with a single double argument which is the product of the 1493 ** two arguments given above. This is used to generate overflow and underflow 1494 ** doubles to test that they are converted properly. 1495 */ 1496 static int SQLITE_TCLAPI sqlite3_mprintf_stronly( 1497 void *NotUsed, 1498 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1499 int argc, /* Number of arguments */ 1500 char **argv /* Text of each argument */ 1501 ){ 1502 char *z; 1503 if( argc!=3 ){ 1504 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1505 " FORMAT STRING\"", 0); 1506 return TCL_ERROR; 1507 } 1508 z = sqlite3_mprintf(argv[1], argv[2]); 1509 Tcl_AppendResult(interp, z, 0); 1510 sqlite3_free(z); 1511 return TCL_OK; 1512 } 1513 1514 /* 1515 ** Usage: sqlite3_mprintf_hexdouble FORMAT HEX 1516 ** 1517 ** Call mprintf with a single double argument which is derived from the 1518 ** hexadecimal encoding of an IEEE double. 1519 */ 1520 static int SQLITE_TCLAPI sqlite3_mprintf_hexdouble( 1521 void *NotUsed, 1522 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1523 int argc, /* Number of arguments */ 1524 char **argv /* Text of each argument */ 1525 ){ 1526 char *z; 1527 double r; 1528 unsigned int x1, x2; 1529 sqlite_uint64 d; 1530 if( argc!=3 ){ 1531 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 1532 " FORMAT STRING\"", 0); 1533 return TCL_ERROR; 1534 } 1535 if( sscanf(argv[2], "%08x%08x", &x2, &x1)!=2 ){ 1536 Tcl_AppendResult(interp, "2nd argument should be 16-characters of hex", 0); 1537 return TCL_ERROR; 1538 } 1539 d = x2; 1540 d = (d<<32) + x1; 1541 memcpy(&r, &d, sizeof(r)); 1542 z = sqlite3_mprintf(argv[1], r); 1543 Tcl_AppendResult(interp, z, 0); 1544 sqlite3_free(z); 1545 return TCL_OK; 1546 } 1547 1548 /* 1549 ** Usage: sqlite3_enable_shared_cache ?BOOLEAN? 1550 ** 1551 */ 1552 #if !defined(SQLITE_OMIT_SHARED_CACHE) 1553 static int SQLITE_TCLAPI test_enable_shared( 1554 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 1555 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1556 int objc, /* Number of arguments */ 1557 Tcl_Obj *CONST objv[] /* Command arguments */ 1558 ){ 1559 int rc; 1560 int enable; 1561 int ret = 0; 1562 1563 if( objc!=2 && objc!=1 ){ 1564 Tcl_WrongNumArgs(interp, 1, objv, "?BOOLEAN?"); 1565 return TCL_ERROR; 1566 } 1567 ret = sqlite3GlobalConfig.sharedCacheEnabled; 1568 1569 if( objc==2 ){ 1570 if( Tcl_GetBooleanFromObj(interp, objv[1], &enable) ){ 1571 return TCL_ERROR; 1572 } 1573 rc = sqlite3_enable_shared_cache(enable); 1574 if( rc!=SQLITE_OK ){ 1575 Tcl_SetResult(interp, (char *)sqlite3ErrStr(rc), TCL_STATIC); 1576 return TCL_ERROR; 1577 } 1578 } 1579 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(ret)); 1580 return TCL_OK; 1581 } 1582 #endif 1583 1584 1585 1586 /* 1587 ** Usage: sqlite3_extended_result_codes DB BOOLEAN 1588 ** 1589 */ 1590 static int SQLITE_TCLAPI test_extended_result_codes( 1591 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 1592 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1593 int objc, /* Number of arguments */ 1594 Tcl_Obj *CONST objv[] /* Command arguments */ 1595 ){ 1596 int enable; 1597 sqlite3 *db; 1598 1599 if( objc!=3 ){ 1600 Tcl_WrongNumArgs(interp, 1, objv, "DB BOOLEAN"); 1601 return TCL_ERROR; 1602 } 1603 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 1604 if( Tcl_GetBooleanFromObj(interp, objv[2], &enable) ) return TCL_ERROR; 1605 sqlite3_extended_result_codes(db, enable); 1606 return TCL_OK; 1607 } 1608 1609 /* 1610 ** Usage: sqlite3_libversion_number 1611 ** 1612 */ 1613 static int SQLITE_TCLAPI test_libversion_number( 1614 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 1615 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1616 int objc, /* Number of arguments */ 1617 Tcl_Obj *CONST objv[] /* Command arguments */ 1618 ){ 1619 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_libversion_number())); 1620 return TCL_OK; 1621 } 1622 1623 /* 1624 ** Usage: sqlite3_table_column_metadata DB dbname tblname colname 1625 ** 1626 */ 1627 static int SQLITE_TCLAPI test_table_column_metadata( 1628 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 1629 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1630 int objc, /* Number of arguments */ 1631 Tcl_Obj *CONST objv[] /* Command arguments */ 1632 ){ 1633 sqlite3 *db; 1634 const char *zDb; 1635 const char *zTbl; 1636 const char *zCol; 1637 int rc; 1638 Tcl_Obj *pRet; 1639 1640 const char *zDatatype; 1641 const char *zCollseq; 1642 int notnull; 1643 int primarykey; 1644 int autoincrement; 1645 1646 if( objc!=5 && objc!=4 ){ 1647 Tcl_WrongNumArgs(interp, 1, objv, "DB dbname tblname colname"); 1648 return TCL_ERROR; 1649 } 1650 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 1651 zDb = Tcl_GetString(objv[2]); 1652 zTbl = Tcl_GetString(objv[3]); 1653 zCol = objc==5 ? Tcl_GetString(objv[4]) : 0; 1654 1655 if( strlen(zDb)==0 ) zDb = 0; 1656 1657 rc = sqlite3_table_column_metadata(db, zDb, zTbl, zCol, 1658 &zDatatype, &zCollseq, ¬null, &primarykey, &autoincrement); 1659 1660 if( rc!=SQLITE_OK ){ 1661 Tcl_AppendResult(interp, sqlite3_errmsg(db), 0); 1662 return TCL_ERROR; 1663 } 1664 1665 pRet = Tcl_NewObj(); 1666 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zDatatype, -1)); 1667 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zCollseq, -1)); 1668 Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(notnull)); 1669 Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(primarykey)); 1670 Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(autoincrement)); 1671 Tcl_SetObjResult(interp, pRet); 1672 1673 return TCL_OK; 1674 } 1675 1676 #ifndef SQLITE_OMIT_INCRBLOB 1677 1678 static int SQLITE_TCLAPI blobHandleFromObj( 1679 Tcl_Interp *interp, 1680 Tcl_Obj *pObj, 1681 sqlite3_blob **ppBlob 1682 ){ 1683 char *z; 1684 int n; 1685 1686 z = Tcl_GetStringFromObj(pObj, &n); 1687 if( n==0 ){ 1688 *ppBlob = 0; 1689 }else{ 1690 int notUsed; 1691 Tcl_Channel channel; 1692 ClientData instanceData; 1693 1694 channel = Tcl_GetChannel(interp, z, ¬Used); 1695 if( !channel ) return TCL_ERROR; 1696 1697 Tcl_Flush(channel); 1698 Tcl_Seek(channel, 0, SEEK_SET); 1699 1700 instanceData = Tcl_GetChannelInstanceData(channel); 1701 *ppBlob = *((sqlite3_blob **)instanceData); 1702 } 1703 1704 return TCL_OK; 1705 } 1706 1707 static int SQLITE_TCLAPI test_blob_reopen( 1708 ClientData clientData, /* Not used */ 1709 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1710 int objc, /* Number of arguments */ 1711 Tcl_Obj *CONST objv[] /* Command arguments */ 1712 ){ 1713 Tcl_WideInt iRowid; 1714 sqlite3_blob *pBlob; 1715 int rc; 1716 1717 if( objc!=3 ){ 1718 Tcl_WrongNumArgs(interp, 1, objv, "CHANNEL ROWID"); 1719 return TCL_ERROR; 1720 } 1721 1722 if( blobHandleFromObj(interp, objv[1], &pBlob) ) return TCL_ERROR; 1723 if( Tcl_GetWideIntFromObj(interp, objv[2], &iRowid) ) return TCL_ERROR; 1724 1725 rc = sqlite3_blob_reopen(pBlob, iRowid); 1726 if( rc!=SQLITE_OK ){ 1727 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE); 1728 } 1729 1730 return (rc==SQLITE_OK ? TCL_OK : TCL_ERROR); 1731 } 1732 1733 #endif 1734 1735 /* 1736 ** Usage: sqlite3_create_collation_v2 DB-HANDLE NAME CMP-PROC DEL-PROC 1737 ** 1738 ** This Tcl proc is used for testing the experimental 1739 ** sqlite3_create_collation_v2() interface. 1740 */ 1741 struct TestCollationX { 1742 Tcl_Interp *interp; 1743 Tcl_Obj *pCmp; 1744 Tcl_Obj *pDel; 1745 }; 1746 typedef struct TestCollationX TestCollationX; 1747 static void testCreateCollationDel(void *pCtx){ 1748 TestCollationX *p = (TestCollationX *)pCtx; 1749 1750 int rc = Tcl_EvalObjEx(p->interp, p->pDel, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL); 1751 if( rc!=TCL_OK ){ 1752 Tcl_BackgroundError(p->interp); 1753 } 1754 1755 Tcl_DecrRefCount(p->pCmp); 1756 Tcl_DecrRefCount(p->pDel); 1757 sqlite3_free((void *)p); 1758 } 1759 static int testCreateCollationCmp( 1760 void *pCtx, 1761 int nLeft, 1762 const void *zLeft, 1763 int nRight, 1764 const void *zRight 1765 ){ 1766 TestCollationX *p = (TestCollationX *)pCtx; 1767 Tcl_Obj *pScript = Tcl_DuplicateObj(p->pCmp); 1768 int iRes = 0; 1769 1770 Tcl_IncrRefCount(pScript); 1771 Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj((char *)zLeft, nLeft)); 1772 Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj((char *)zRight,nRight)); 1773 1774 if( TCL_OK!=Tcl_EvalObjEx(p->interp, pScript, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL) 1775 || TCL_OK!=Tcl_GetIntFromObj(p->interp, Tcl_GetObjResult(p->interp), &iRes) 1776 ){ 1777 Tcl_BackgroundError(p->interp); 1778 } 1779 Tcl_DecrRefCount(pScript); 1780 1781 return iRes; 1782 } 1783 static int SQLITE_TCLAPI test_create_collation_v2( 1784 ClientData clientData, /* Not used */ 1785 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1786 int objc, /* Number of arguments */ 1787 Tcl_Obj *CONST objv[] /* Command arguments */ 1788 ){ 1789 TestCollationX *p; 1790 sqlite3 *db; 1791 int rc; 1792 1793 if( objc!=5 ){ 1794 Tcl_WrongNumArgs(interp, 1, objv, "DB-HANDLE NAME CMP-PROC DEL-PROC"); 1795 return TCL_ERROR; 1796 } 1797 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 1798 1799 p = (TestCollationX *)sqlite3_malloc(sizeof(TestCollationX)); 1800 p->pCmp = objv[3]; 1801 p->pDel = objv[4]; 1802 p->interp = interp; 1803 Tcl_IncrRefCount(p->pCmp); 1804 Tcl_IncrRefCount(p->pDel); 1805 1806 rc = sqlite3_create_collation_v2(db, Tcl_GetString(objv[2]), 16, 1807 (void *)p, testCreateCollationCmp, testCreateCollationDel 1808 ); 1809 if( rc!=SQLITE_MISUSE ){ 1810 Tcl_AppendResult(interp, "sqlite3_create_collate_v2() failed to detect " 1811 "an invalid encoding", (char*)0); 1812 return TCL_ERROR; 1813 } 1814 rc = sqlite3_create_collation_v2(db, Tcl_GetString(objv[2]), SQLITE_UTF8, 1815 (void *)p, testCreateCollationCmp, testCreateCollationDel 1816 ); 1817 return TCL_OK; 1818 } 1819 1820 /* 1821 ** USAGE: sqlite3_create_function_v2 DB NAME NARG ENC ?SWITCHES? 1822 ** 1823 ** Available switches are: 1824 ** 1825 ** -func SCRIPT 1826 ** -step SCRIPT 1827 ** -final SCRIPT 1828 ** -destroy SCRIPT 1829 */ 1830 typedef struct CreateFunctionV2 CreateFunctionV2; 1831 struct CreateFunctionV2 { 1832 Tcl_Interp *interp; 1833 Tcl_Obj *pFunc; /* Script for function invocation */ 1834 Tcl_Obj *pStep; /* Script for agg. step invocation */ 1835 Tcl_Obj *pFinal; /* Script for agg. finalization invocation */ 1836 Tcl_Obj *pDestroy; /* Destructor script */ 1837 }; 1838 static void cf2Func(sqlite3_context *ctx, int nArg, sqlite3_value **aArg){ 1839 } 1840 static void cf2Step(sqlite3_context *ctx, int nArg, sqlite3_value **aArg){ 1841 } 1842 static void cf2Final(sqlite3_context *ctx){ 1843 } 1844 static void cf2Destroy(void *pUser){ 1845 CreateFunctionV2 *p = (CreateFunctionV2 *)pUser; 1846 1847 if( p->interp && p->pDestroy ){ 1848 int rc = Tcl_EvalObjEx(p->interp, p->pDestroy, 0); 1849 if( rc!=TCL_OK ) Tcl_BackgroundError(p->interp); 1850 } 1851 1852 if( p->pFunc ) Tcl_DecrRefCount(p->pFunc); 1853 if( p->pStep ) Tcl_DecrRefCount(p->pStep); 1854 if( p->pFinal ) Tcl_DecrRefCount(p->pFinal); 1855 if( p->pDestroy ) Tcl_DecrRefCount(p->pDestroy); 1856 sqlite3_free(p); 1857 } 1858 static int SQLITE_TCLAPI test_create_function_v2( 1859 ClientData clientData, /* Not used */ 1860 Tcl_Interp *interp, /* The invoking TCL interpreter */ 1861 int objc, /* Number of arguments */ 1862 Tcl_Obj *CONST objv[] /* Command arguments */ 1863 ){ 1864 sqlite3 *db; 1865 const char *zFunc; 1866 int nArg; 1867 int enc; 1868 CreateFunctionV2 *p; 1869 int i; 1870 int rc; 1871 1872 struct EncTable { 1873 const char *zEnc; 1874 int enc; 1875 } aEnc[] = { 1876 {"utf8", SQLITE_UTF8 }, 1877 {"utf16", SQLITE_UTF16 }, 1878 {"utf16le", SQLITE_UTF16LE }, 1879 {"utf16be", SQLITE_UTF16BE }, 1880 {"any", SQLITE_ANY }, 1881 {"0", 0 } 1882 }; 1883 1884 if( objc<5 || (objc%2)==0 ){ 1885 Tcl_WrongNumArgs(interp, 1, objv, "DB NAME NARG ENC SWITCHES..."); 1886 return TCL_ERROR; 1887 } 1888 1889 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 1890 zFunc = Tcl_GetString(objv[2]); 1891 if( Tcl_GetIntFromObj(interp, objv[3], &nArg) ) return TCL_ERROR; 1892 if( Tcl_GetIndexFromObjStruct(interp, objv[4], aEnc, sizeof(aEnc[0]), 1893 "encoding", 0, &enc) 1894 ){ 1895 return TCL_ERROR; 1896 } 1897 enc = aEnc[enc].enc; 1898 1899 p = sqlite3_malloc(sizeof(CreateFunctionV2)); 1900 assert( p ); 1901 memset(p, 0, sizeof(CreateFunctionV2)); 1902 p->interp = interp; 1903 1904 for(i=5; i<objc; i+=2){ 1905 int iSwitch; 1906 const char *azSwitch[] = {"-func", "-step", "-final", "-destroy", 0}; 1907 if( Tcl_GetIndexFromObj(interp, objv[i], azSwitch, "switch", 0, &iSwitch) ){ 1908 sqlite3_free(p); 1909 return TCL_ERROR; 1910 } 1911 1912 switch( iSwitch ){ 1913 case 0: p->pFunc = objv[i+1]; break; 1914 case 1: p->pStep = objv[i+1]; break; 1915 case 2: p->pFinal = objv[i+1]; break; 1916 case 3: p->pDestroy = objv[i+1]; break; 1917 } 1918 } 1919 if( p->pFunc ) p->pFunc = Tcl_DuplicateObj(p->pFunc); 1920 if( p->pStep ) p->pStep = Tcl_DuplicateObj(p->pStep); 1921 if( p->pFinal ) p->pFinal = Tcl_DuplicateObj(p->pFinal); 1922 if( p->pDestroy ) p->pDestroy = Tcl_DuplicateObj(p->pDestroy); 1923 1924 if( p->pFunc ) Tcl_IncrRefCount(p->pFunc); 1925 if( p->pStep ) Tcl_IncrRefCount(p->pStep); 1926 if( p->pFinal ) Tcl_IncrRefCount(p->pFinal); 1927 if( p->pDestroy ) Tcl_IncrRefCount(p->pDestroy); 1928 1929 rc = sqlite3_create_function_v2(db, zFunc, nArg, enc, (void *)p, 1930 (p->pFunc ? cf2Func : 0), 1931 (p->pStep ? cf2Step : 0), 1932 (p->pFinal ? cf2Final : 0), 1933 cf2Destroy 1934 ); 1935 if( rc!=SQLITE_OK ){ 1936 Tcl_ResetResult(interp); 1937 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0); 1938 return TCL_ERROR; 1939 } 1940 return TCL_OK; 1941 } 1942 1943 /* 1944 ** Usage: sqlite3_load_extension DB-HANDLE FILE ?PROC? 1945 */ 1946 static int SQLITE_TCLAPI test_load_extension( 1947 ClientData clientData, /* Not used */ 1948 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 1949 int objc, /* Number of arguments */ 1950 Tcl_Obj *CONST objv[] /* Command arguments */ 1951 ){ 1952 Tcl_CmdInfo cmdInfo; 1953 sqlite3 *db; 1954 int rc; 1955 char *zDb; 1956 char *zFile; 1957 char *zProc = 0; 1958 char *zErr = 0; 1959 1960 if( objc!=4 && objc!=3 ){ 1961 Tcl_WrongNumArgs(interp, 1, objv, "DB-HANDLE FILE ?PROC?"); 1962 return TCL_ERROR; 1963 } 1964 zDb = Tcl_GetString(objv[1]); 1965 zFile = Tcl_GetString(objv[2]); 1966 if( objc==4 ){ 1967 zProc = Tcl_GetString(objv[3]); 1968 } 1969 1970 /* Extract the C database handle from the Tcl command name */ 1971 if( !Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){ 1972 Tcl_AppendResult(interp, "command not found: ", zDb, (char*)0); 1973 return TCL_ERROR; 1974 } 1975 db = ((struct SqliteDb*)cmdInfo.objClientData)->db; 1976 assert(db); 1977 1978 /* Call the underlying C function. If an error occurs, set rc to 1979 ** TCL_ERROR and load any error string into the interpreter. If no 1980 ** error occurs, set rc to TCL_OK. 1981 */ 1982 #ifdef SQLITE_OMIT_LOAD_EXTENSION 1983 rc = SQLITE_ERROR; 1984 zErr = sqlite3_mprintf("this build omits sqlite3_load_extension()"); 1985 (void)zProc; 1986 (void)zFile; 1987 #else 1988 rc = sqlite3_load_extension(db, zFile, zProc, &zErr); 1989 #endif 1990 if( rc!=SQLITE_OK ){ 1991 Tcl_SetResult(interp, zErr ? zErr : "", TCL_VOLATILE); 1992 rc = TCL_ERROR; 1993 }else{ 1994 rc = TCL_OK; 1995 } 1996 sqlite3_free(zErr); 1997 1998 return rc; 1999 } 2000 2001 /* 2002 ** Usage: sqlite3_enable_load_extension DB-HANDLE ONOFF 2003 */ 2004 static int SQLITE_TCLAPI test_enable_load( 2005 ClientData clientData, /* Not used */ 2006 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 2007 int objc, /* Number of arguments */ 2008 Tcl_Obj *CONST objv[] /* Command arguments */ 2009 ){ 2010 Tcl_CmdInfo cmdInfo; 2011 sqlite3 *db; 2012 char *zDb; 2013 int onoff; 2014 2015 if( objc!=3 ){ 2016 Tcl_WrongNumArgs(interp, 1, objv, "DB-HANDLE ONOFF"); 2017 return TCL_ERROR; 2018 } 2019 zDb = Tcl_GetString(objv[1]); 2020 2021 /* Extract the C database handle from the Tcl command name */ 2022 if( !Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){ 2023 Tcl_AppendResult(interp, "command not found: ", zDb, (char*)0); 2024 return TCL_ERROR; 2025 } 2026 db = ((struct SqliteDb*)cmdInfo.objClientData)->db; 2027 assert(db); 2028 2029 /* Get the onoff parameter */ 2030 if( Tcl_GetBooleanFromObj(interp, objv[2], &onoff) ){ 2031 return TCL_ERROR; 2032 } 2033 2034 #ifdef SQLITE_OMIT_LOAD_EXTENSION 2035 Tcl_AppendResult(interp, "this build omits sqlite3_load_extension()"); 2036 return TCL_ERROR; 2037 #else 2038 sqlite3_enable_load_extension(db, onoff); 2039 return TCL_OK; 2040 #endif 2041 } 2042 2043 /* 2044 ** Usage: sqlite_abort 2045 ** 2046 ** Shutdown the process immediately. This is not a clean shutdown. 2047 ** This command is used to test the recoverability of a database in 2048 ** the event of a program crash. 2049 */ 2050 static int SQLITE_TCLAPI sqlite_abort( 2051 void *NotUsed, 2052 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 2053 int argc, /* Number of arguments */ 2054 char **argv /* Text of each argument */ 2055 ){ 2056 #if defined(_MSC_VER) 2057 /* We do this, otherwise the test will halt with a popup message 2058 * that we have to click away before the test will continue. 2059 */ 2060 _set_abort_behavior( 0, _CALL_REPORTFAULT ); 2061 #endif 2062 exit(255); 2063 assert( interp==0 ); /* This will always fail */ 2064 return TCL_OK; 2065 } 2066 2067 /* 2068 ** The following routine is a user-defined SQL function whose purpose 2069 ** is to test the sqlite_set_result() API. 2070 */ 2071 static void testFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 2072 while( argc>=2 ){ 2073 const char *zArg0 = (char*)sqlite3_value_text(argv[0]); 2074 if( zArg0 ){ 2075 if( 0==sqlite3StrICmp(zArg0, "int") ){ 2076 sqlite3_result_int(context, sqlite3_value_int(argv[1])); 2077 }else if( sqlite3StrICmp(zArg0,"int64")==0 ){ 2078 sqlite3_result_int64(context, sqlite3_value_int64(argv[1])); 2079 }else if( sqlite3StrICmp(zArg0,"string")==0 ){ 2080 sqlite3_result_text(context, (char*)sqlite3_value_text(argv[1]), -1, 2081 SQLITE_TRANSIENT); 2082 }else if( sqlite3StrICmp(zArg0,"double")==0 ){ 2083 sqlite3_result_double(context, sqlite3_value_double(argv[1])); 2084 }else if( sqlite3StrICmp(zArg0,"null")==0 ){ 2085 sqlite3_result_null(context); 2086 }else if( sqlite3StrICmp(zArg0,"value")==0 ){ 2087 sqlite3_result_value(context, argv[sqlite3_value_int(argv[1])]); 2088 }else{ 2089 goto error_out; 2090 } 2091 }else{ 2092 goto error_out; 2093 } 2094 argc -= 2; 2095 argv += 2; 2096 } 2097 return; 2098 2099 error_out: 2100 sqlite3_result_error(context,"first argument should be one of: " 2101 "int int64 string double null value", -1); 2102 } 2103 2104 /* 2105 ** Usage: sqlite_register_test_function DB NAME 2106 ** 2107 ** Register the test SQL function on the database DB under the name NAME. 2108 */ 2109 static int SQLITE_TCLAPI test_register_func( 2110 void *NotUsed, 2111 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 2112 int argc, /* Number of arguments */ 2113 char **argv /* Text of each argument */ 2114 ){ 2115 sqlite3 *db; 2116 int rc; 2117 if( argc!=3 ){ 2118 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 2119 " DB FUNCTION-NAME", 0); 2120 return TCL_ERROR; 2121 } 2122 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 2123 rc = sqlite3_create_function(db, argv[2], -1, SQLITE_UTF8, 0, 2124 testFunc, 0, 0); 2125 if( rc!=0 ){ 2126 Tcl_AppendResult(interp, sqlite3ErrStr(rc), 0); 2127 return TCL_ERROR; 2128 } 2129 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 2130 return TCL_OK; 2131 } 2132 2133 /* 2134 ** Usage: sqlite3_finalize STMT 2135 ** 2136 ** Finalize a statement handle. 2137 */ 2138 static int SQLITE_TCLAPI test_finalize( 2139 void * clientData, 2140 Tcl_Interp *interp, 2141 int objc, 2142 Tcl_Obj *CONST objv[] 2143 ){ 2144 sqlite3_stmt *pStmt; 2145 int rc; 2146 sqlite3 *db = 0; 2147 2148 if( objc!=2 ){ 2149 Tcl_AppendResult(interp, "wrong # args: should be \"", 2150 Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0); 2151 return TCL_ERROR; 2152 } 2153 2154 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2155 2156 if( pStmt ){ 2157 db = StmtToDb(pStmt); 2158 } 2159 rc = sqlite3_finalize(pStmt); 2160 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 2161 if( db && sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 2162 return TCL_OK; 2163 } 2164 2165 /* 2166 ** Usage: sqlite3_stmt_status STMT CODE RESETFLAG 2167 ** 2168 ** Get the value of a status counter from a statement. 2169 */ 2170 static int SQLITE_TCLAPI test_stmt_status( 2171 void * clientData, 2172 Tcl_Interp *interp, 2173 int objc, 2174 Tcl_Obj *CONST objv[] 2175 ){ 2176 int iValue; 2177 int i, op = 0, resetFlag; 2178 const char *zOpName; 2179 sqlite3_stmt *pStmt; 2180 2181 static const struct { 2182 const char *zName; 2183 int op; 2184 } aOp[] = { 2185 { "SQLITE_STMTSTATUS_FULLSCAN_STEP", SQLITE_STMTSTATUS_FULLSCAN_STEP }, 2186 { "SQLITE_STMTSTATUS_SORT", SQLITE_STMTSTATUS_SORT }, 2187 { "SQLITE_STMTSTATUS_AUTOINDEX", SQLITE_STMTSTATUS_AUTOINDEX }, 2188 { "SQLITE_STMTSTATUS_VM_STEP", SQLITE_STMTSTATUS_VM_STEP }, 2189 { "SQLITE_STMTSTATUS_REPREPARE", SQLITE_STMTSTATUS_REPREPARE }, 2190 { "SQLITE_STMTSTATUS_RUN", SQLITE_STMTSTATUS_RUN }, 2191 { "SQLITE_STMTSTATUS_MEMUSED", SQLITE_STMTSTATUS_MEMUSED }, 2192 }; 2193 if( objc!=4 ){ 2194 Tcl_WrongNumArgs(interp, 1, objv, "STMT PARAMETER RESETFLAG"); 2195 return TCL_ERROR; 2196 } 2197 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2198 zOpName = Tcl_GetString(objv[2]); 2199 for(i=0; i<ArraySize(aOp); i++){ 2200 if( strcmp(aOp[i].zName, zOpName)==0 ){ 2201 op = aOp[i].op; 2202 break; 2203 } 2204 } 2205 if( i>=ArraySize(aOp) ){ 2206 if( Tcl_GetIntFromObj(interp, objv[2], &op) ) return TCL_ERROR; 2207 } 2208 if( Tcl_GetBooleanFromObj(interp, objv[3], &resetFlag) ) return TCL_ERROR; 2209 iValue = sqlite3_stmt_status(pStmt, op, resetFlag); 2210 Tcl_SetObjResult(interp, Tcl_NewIntObj(iValue)); 2211 return TCL_OK; 2212 } 2213 2214 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS 2215 /* 2216 ** Usage: sqlite3_stmt_scanstatus STMT IDX 2217 */ 2218 static int SQLITE_TCLAPI test_stmt_scanstatus( 2219 void * clientData, 2220 Tcl_Interp *interp, 2221 int objc, 2222 Tcl_Obj *CONST objv[] 2223 ){ 2224 sqlite3_stmt *pStmt; /* First argument */ 2225 int idx; /* Second argument */ 2226 2227 const char *zName; 2228 const char *zExplain; 2229 sqlite3_int64 nLoop; 2230 sqlite3_int64 nVisit; 2231 double rEst; 2232 int res; 2233 2234 if( objc!=3 ){ 2235 Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX"); 2236 return TCL_ERROR; 2237 } 2238 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2239 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 2240 2241 res = sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop); 2242 if( res==0 ){ 2243 Tcl_Obj *pRet = Tcl_NewObj(); 2244 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nLoop", -1)); 2245 Tcl_ListObjAppendElement(0, pRet, Tcl_NewWideIntObj(nLoop)); 2246 sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit); 2247 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nVisit", -1)); 2248 Tcl_ListObjAppendElement(0, pRet, Tcl_NewWideIntObj(nVisit)); 2249 sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_EST, (void*)&rEst); 2250 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nEst", -1)); 2251 Tcl_ListObjAppendElement(0, pRet, Tcl_NewDoubleObj(rEst)); 2252 sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_NAME, (void*)&zName); 2253 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("zName", -1)); 2254 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zName, -1)); 2255 sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain); 2256 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("zExplain", -1)); 2257 Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zExplain, -1)); 2258 Tcl_SetObjResult(interp, pRet); 2259 }else{ 2260 Tcl_ResetResult(interp); 2261 } 2262 return TCL_OK; 2263 } 2264 2265 /* 2266 ** Usage: sqlite3_stmt_scanstatus_reset STMT 2267 */ 2268 static int SQLITE_TCLAPI test_stmt_scanstatus_reset( 2269 void * clientData, 2270 Tcl_Interp *interp, 2271 int objc, 2272 Tcl_Obj *CONST objv[] 2273 ){ 2274 sqlite3_stmt *pStmt; /* First argument */ 2275 if( objc!=2 ){ 2276 Tcl_WrongNumArgs(interp, 1, objv, "STMT"); 2277 return TCL_ERROR; 2278 } 2279 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2280 sqlite3_stmt_scanstatus_reset(pStmt); 2281 return TCL_OK; 2282 } 2283 #endif 2284 2285 #ifdef SQLITE_ENABLE_SQLLOG 2286 /* 2287 ** Usage: sqlite3_config_sqllog 2288 ** 2289 ** Zero the SQLITE_CONFIG_SQLLOG configuration 2290 */ 2291 static int SQLITE_TCLAPI test_config_sqllog( 2292 void * clientData, 2293 Tcl_Interp *interp, 2294 int objc, 2295 Tcl_Obj *CONST objv[] 2296 ){ 2297 if( objc!=1 ){ 2298 Tcl_WrongNumArgs(interp, 1, objv, ""); 2299 return TCL_ERROR; 2300 } 2301 sqlite3_config(SQLITE_CONFIG_SQLLOG, 0, 0); 2302 return TCL_OK; 2303 } 2304 #endif 2305 2306 /* 2307 ** Usage: sqlite3_config_sorterref 2308 ** 2309 ** Set the SQLITE_CONFIG_SORTERREF_SIZE configuration option 2310 */ 2311 static int SQLITE_TCLAPI test_config_sorterref( 2312 void * clientData, 2313 Tcl_Interp *interp, 2314 int objc, 2315 Tcl_Obj *CONST objv[] 2316 ){ 2317 int iVal; 2318 if( objc!=2 ){ 2319 Tcl_WrongNumArgs(interp, 1, objv, "NBYTE"); 2320 return TCL_ERROR; 2321 } 2322 if( Tcl_GetIntFromObj(interp, objv[1], &iVal) ) return TCL_ERROR; 2323 sqlite3_config(SQLITE_CONFIG_SORTERREF_SIZE, iVal); 2324 return TCL_OK; 2325 } 2326 2327 /* 2328 ** Usage: vfs_current_time_int64 2329 ** 2330 ** Return the value returned by the default VFS's xCurrentTimeInt64 method. 2331 */ 2332 static int SQLITE_TCLAPI vfsCurrentTimeInt64( 2333 void * clientData, 2334 Tcl_Interp *interp, 2335 int objc, 2336 Tcl_Obj *CONST objv[] 2337 ){ 2338 i64 t; 2339 sqlite3_vfs *pVfs = sqlite3_vfs_find(0); 2340 if( objc!=1 ){ 2341 Tcl_WrongNumArgs(interp, 1, objv, ""); 2342 return TCL_ERROR; 2343 } 2344 pVfs->xCurrentTimeInt64(pVfs, &t); 2345 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(t)); 2346 return TCL_OK; 2347 } 2348 2349 #ifdef SQLITE_ENABLE_SNAPSHOT 2350 /* 2351 ** Usage: sqlite3_snapshot_get DB DBNAME 2352 */ 2353 static int SQLITE_TCLAPI test_snapshot_get( 2354 void * clientData, 2355 Tcl_Interp *interp, 2356 int objc, 2357 Tcl_Obj *CONST objv[] 2358 ){ 2359 int rc; 2360 sqlite3 *db; 2361 char *zName; 2362 sqlite3_snapshot *pSnapshot = 0; 2363 2364 if( objc!=3 ){ 2365 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME"); 2366 return TCL_ERROR; 2367 } 2368 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 2369 zName = Tcl_GetString(objv[2]); 2370 2371 rc = sqlite3_snapshot_get(db, zName, &pSnapshot); 2372 if( rc!=SQLITE_OK ){ 2373 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); 2374 return TCL_ERROR; 2375 }else{ 2376 char zBuf[100]; 2377 if( sqlite3TestMakePointerStr(interp, zBuf, pSnapshot) ) return TCL_ERROR; 2378 Tcl_SetObjResult(interp, Tcl_NewStringObj(zBuf, -1)); 2379 } 2380 return TCL_OK; 2381 } 2382 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2383 2384 #ifdef SQLITE_ENABLE_SNAPSHOT 2385 /* 2386 ** Usage: sqlite3_snapshot_recover DB DBNAME 2387 */ 2388 static int SQLITE_TCLAPI test_snapshot_recover( 2389 void * clientData, 2390 Tcl_Interp *interp, 2391 int objc, 2392 Tcl_Obj *CONST objv[] 2393 ){ 2394 int rc; 2395 sqlite3 *db; 2396 char *zName; 2397 2398 if( objc!=3 ){ 2399 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME"); 2400 return TCL_ERROR; 2401 } 2402 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 2403 zName = Tcl_GetString(objv[2]); 2404 2405 rc = sqlite3_snapshot_recover(db, zName); 2406 if( rc!=SQLITE_OK ){ 2407 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); 2408 return TCL_ERROR; 2409 }else{ 2410 Tcl_ResetResult(interp); 2411 } 2412 return TCL_OK; 2413 } 2414 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2415 2416 #ifdef SQLITE_ENABLE_SNAPSHOT 2417 /* 2418 ** Usage: sqlite3_snapshot_open DB DBNAME SNAPSHOT 2419 */ 2420 static int SQLITE_TCLAPI test_snapshot_open( 2421 void * clientData, 2422 Tcl_Interp *interp, 2423 int objc, 2424 Tcl_Obj *CONST objv[] 2425 ){ 2426 int rc; 2427 sqlite3 *db; 2428 char *zName; 2429 sqlite3_snapshot *pSnapshot; 2430 2431 if( objc!=4 ){ 2432 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SNAPSHOT"); 2433 return TCL_ERROR; 2434 } 2435 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 2436 zName = Tcl_GetString(objv[2]); 2437 pSnapshot = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[3])); 2438 2439 rc = sqlite3_snapshot_open(db, zName, pSnapshot); 2440 if( rc!=SQLITE_OK ){ 2441 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); 2442 return TCL_ERROR; 2443 }else{ 2444 Tcl_ResetResult(interp); 2445 } 2446 return TCL_OK; 2447 } 2448 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2449 2450 #ifdef SQLITE_ENABLE_SNAPSHOT 2451 /* 2452 ** Usage: sqlite3_snapshot_free SNAPSHOT 2453 */ 2454 static int SQLITE_TCLAPI test_snapshot_free( 2455 void * clientData, 2456 Tcl_Interp *interp, 2457 int objc, 2458 Tcl_Obj *CONST objv[] 2459 ){ 2460 sqlite3_snapshot *pSnapshot; 2461 if( objc!=2 ){ 2462 Tcl_WrongNumArgs(interp, 1, objv, "SNAPSHOT"); 2463 return TCL_ERROR; 2464 } 2465 pSnapshot = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[1])); 2466 sqlite3_snapshot_free(pSnapshot); 2467 return TCL_OK; 2468 } 2469 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2470 2471 #ifdef SQLITE_ENABLE_SNAPSHOT 2472 /* 2473 ** Usage: sqlite3_snapshot_cmp SNAPSHOT1 SNAPSHOT2 2474 */ 2475 static int SQLITE_TCLAPI test_snapshot_cmp( 2476 void * clientData, 2477 Tcl_Interp *interp, 2478 int objc, 2479 Tcl_Obj *CONST objv[] 2480 ){ 2481 int res; 2482 sqlite3_snapshot *p1; 2483 sqlite3_snapshot *p2; 2484 if( objc!=3 ){ 2485 Tcl_WrongNumArgs(interp, 1, objv, "SNAPSHOT1 SNAPSHOT2"); 2486 return TCL_ERROR; 2487 } 2488 p1 = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[1])); 2489 p2 = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[2])); 2490 res = sqlite3_snapshot_cmp(p1, p2); 2491 Tcl_SetObjResult(interp, Tcl_NewIntObj(res)); 2492 return TCL_OK; 2493 } 2494 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2495 2496 #ifdef SQLITE_ENABLE_SNAPSHOT 2497 /* 2498 ** Usage: sqlite3_snapshot_get_blob DB DBNAME 2499 */ 2500 static int SQLITE_TCLAPI test_snapshot_get_blob( 2501 void * clientData, 2502 Tcl_Interp *interp, 2503 int objc, 2504 Tcl_Obj *CONST objv[] 2505 ){ 2506 int rc; 2507 sqlite3 *db; 2508 char *zName; 2509 sqlite3_snapshot *pSnapshot = 0; 2510 2511 if( objc!=3 ){ 2512 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME"); 2513 return TCL_ERROR; 2514 } 2515 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 2516 zName = Tcl_GetString(objv[2]); 2517 2518 rc = sqlite3_snapshot_get(db, zName, &pSnapshot); 2519 if( rc!=SQLITE_OK ){ 2520 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); 2521 return TCL_ERROR; 2522 }else{ 2523 Tcl_SetObjResult(interp, 2524 Tcl_NewByteArrayObj((unsigned char*)pSnapshot, sizeof(sqlite3_snapshot)) 2525 ); 2526 sqlite3_snapshot_free(pSnapshot); 2527 } 2528 return TCL_OK; 2529 } 2530 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2531 2532 #ifdef SQLITE_ENABLE_SNAPSHOT 2533 /* 2534 ** Usage: sqlite3_snapshot_open_blob DB DBNAME SNAPSHOT 2535 */ 2536 static int SQLITE_TCLAPI test_snapshot_open_blob( 2537 void * clientData, 2538 Tcl_Interp *interp, 2539 int objc, 2540 Tcl_Obj *CONST objv[] 2541 ){ 2542 int rc; 2543 sqlite3 *db; 2544 char *zName; 2545 unsigned char *pBlob; 2546 int nBlob; 2547 2548 if( objc!=4 ){ 2549 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SNAPSHOT"); 2550 return TCL_ERROR; 2551 } 2552 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 2553 zName = Tcl_GetString(objv[2]); 2554 pBlob = Tcl_GetByteArrayFromObj(objv[3], &nBlob); 2555 if( nBlob!=sizeof(sqlite3_snapshot) ){ 2556 Tcl_AppendResult(interp, "bad SNAPSHOT", 0); 2557 return TCL_ERROR; 2558 } 2559 rc = sqlite3_snapshot_open(db, zName, (sqlite3_snapshot*)pBlob); 2560 if( rc!=SQLITE_OK ){ 2561 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); 2562 return TCL_ERROR; 2563 } 2564 return TCL_OK; 2565 } 2566 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2567 2568 #ifdef SQLITE_ENABLE_SNAPSHOT 2569 /* 2570 ** Usage: sqlite3_snapshot_cmp_blob SNAPSHOT1 SNAPSHOT2 2571 */ 2572 static int SQLITE_TCLAPI test_snapshot_cmp_blob( 2573 void * clientData, 2574 Tcl_Interp *interp, 2575 int objc, 2576 Tcl_Obj *CONST objv[] 2577 ){ 2578 int res; 2579 unsigned char *p1; 2580 unsigned char *p2; 2581 int n1; 2582 int n2; 2583 2584 if( objc!=3 ){ 2585 Tcl_WrongNumArgs(interp, 1, objv, "SNAPSHOT1 SNAPSHOT2"); 2586 return TCL_ERROR; 2587 } 2588 2589 p1 = Tcl_GetByteArrayFromObj(objv[1], &n1); 2590 p2 = Tcl_GetByteArrayFromObj(objv[2], &n2); 2591 2592 if( n1!=sizeof(sqlite3_snapshot) || n1!=n2 ){ 2593 Tcl_AppendResult(interp, "bad SNAPSHOT", 0); 2594 return TCL_ERROR; 2595 } 2596 2597 res = sqlite3_snapshot_cmp((sqlite3_snapshot*)p1, (sqlite3_snapshot*)p2); 2598 Tcl_SetObjResult(interp, Tcl_NewIntObj(res)); 2599 return TCL_OK; 2600 } 2601 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2602 2603 /* 2604 ** Usage: sqlite3_delete_database FILENAME 2605 */ 2606 int sqlite3_delete_database(const char*); /* in test_delete.c */ 2607 static int SQLITE_TCLAPI test_delete_database( 2608 void * clientData, 2609 Tcl_Interp *interp, 2610 int objc, 2611 Tcl_Obj *CONST objv[] 2612 ){ 2613 int rc; 2614 const char *zFile; 2615 if( objc!=2 ){ 2616 Tcl_WrongNumArgs(interp, 1, objv, "FILE"); 2617 return TCL_ERROR; 2618 } 2619 zFile = (const char*)Tcl_GetString(objv[1]); 2620 rc = sqlite3_delete_database(zFile); 2621 2622 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); 2623 return TCL_OK; 2624 } 2625 2626 /* 2627 ** Usage: atomic_batch_write PATH 2628 */ 2629 static int SQLITE_TCLAPI test_atomic_batch_write( 2630 void * clientData, 2631 Tcl_Interp *interp, 2632 int objc, 2633 Tcl_Obj *CONST objv[] 2634 ){ 2635 char *zFile = 0; /* Path to file to test */ 2636 sqlite3 *db = 0; /* Database handle */ 2637 sqlite3_file *pFd = 0; /* SQLite fd open on zFile */ 2638 int bRes = 0; /* Integer result of this command */ 2639 int dc = 0; /* Device-characteristics mask */ 2640 int rc; /* sqlite3_open() return code */ 2641 2642 if( objc!=2 ){ 2643 Tcl_WrongNumArgs(interp, 1, objv, "PATH"); 2644 return TCL_ERROR; 2645 } 2646 zFile = Tcl_GetString(objv[1]); 2647 2648 rc = sqlite3_open(zFile, &db); 2649 if( rc!=SQLITE_OK ){ 2650 Tcl_AppendResult(interp, sqlite3_errmsg(db), 0); 2651 sqlite3_close(db); 2652 return TCL_ERROR; 2653 } 2654 2655 rc = sqlite3_file_control(db, "main", SQLITE_FCNTL_FILE_POINTER, (void*)&pFd); 2656 dc = pFd->pMethods->xDeviceCharacteristics(pFd); 2657 if( dc & SQLITE_IOCAP_BATCH_ATOMIC ){ 2658 bRes = 1; 2659 } 2660 2661 Tcl_SetObjResult(interp, Tcl_NewIntObj(bRes)); 2662 sqlite3_close(db); 2663 return TCL_OK; 2664 } 2665 2666 /* 2667 ** Usage: sqlite3_next_stmt DB STMT 2668 ** 2669 ** Return the next statment in sequence after STMT. 2670 */ 2671 static int SQLITE_TCLAPI test_next_stmt( 2672 void * clientData, 2673 Tcl_Interp *interp, 2674 int objc, 2675 Tcl_Obj *CONST objv[] 2676 ){ 2677 sqlite3_stmt *pStmt; 2678 sqlite3 *db = 0; 2679 char zBuf[50]; 2680 2681 if( objc!=3 ){ 2682 Tcl_AppendResult(interp, "wrong # args: should be \"", 2683 Tcl_GetStringFromObj(objv[0], 0), " DB STMT", 0); 2684 return TCL_ERROR; 2685 } 2686 2687 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 2688 if( getStmtPointer(interp, Tcl_GetString(objv[2]), &pStmt) ) return TCL_ERROR; 2689 pStmt = sqlite3_next_stmt(db, pStmt); 2690 if( pStmt ){ 2691 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 2692 Tcl_AppendResult(interp, zBuf, 0); 2693 } 2694 return TCL_OK; 2695 } 2696 2697 /* 2698 ** Usage: sqlite3_stmt_readonly STMT 2699 ** 2700 ** Return true if STMT is a NULL pointer or a pointer to a statement 2701 ** that is guaranteed to leave the database unmodified. 2702 */ 2703 static int SQLITE_TCLAPI test_stmt_readonly( 2704 void * clientData, 2705 Tcl_Interp *interp, 2706 int objc, 2707 Tcl_Obj *CONST objv[] 2708 ){ 2709 sqlite3_stmt *pStmt; 2710 int rc; 2711 2712 if( objc!=2 ){ 2713 Tcl_AppendResult(interp, "wrong # args: should be \"", 2714 Tcl_GetStringFromObj(objv[0], 0), " STMT", 0); 2715 return TCL_ERROR; 2716 } 2717 2718 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2719 rc = sqlite3_stmt_readonly(pStmt); 2720 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(rc)); 2721 return TCL_OK; 2722 } 2723 2724 /* 2725 ** Usage: sqlite3_stmt_isexplain STMT 2726 ** 2727 ** Return 1, 2, or 0 respectively if STMT is an EXPLAIN statement, an 2728 ** EXPLAIN QUERY PLAN statement or an ordinary statement or NULL pointer. 2729 */ 2730 static int SQLITE_TCLAPI test_stmt_isexplain( 2731 void * clientData, 2732 Tcl_Interp *interp, 2733 int objc, 2734 Tcl_Obj *CONST objv[] 2735 ){ 2736 sqlite3_stmt *pStmt; 2737 int rc; 2738 2739 if( objc!=2 ){ 2740 Tcl_AppendResult(interp, "wrong # args: should be \"", 2741 Tcl_GetStringFromObj(objv[0], 0), " STMT", 0); 2742 return TCL_ERROR; 2743 } 2744 2745 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2746 rc = sqlite3_stmt_isexplain(pStmt); 2747 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 2748 return TCL_OK; 2749 } 2750 2751 /* 2752 ** Usage: sqlite3_stmt_busy STMT 2753 ** 2754 ** Return true if STMT is a non-NULL pointer to a statement 2755 ** that has been stepped but not to completion. 2756 */ 2757 static int SQLITE_TCLAPI test_stmt_busy( 2758 void * clientData, 2759 Tcl_Interp *interp, 2760 int objc, 2761 Tcl_Obj *CONST objv[] 2762 ){ 2763 sqlite3_stmt *pStmt; 2764 int rc; 2765 2766 if( objc!=2 ){ 2767 Tcl_AppendResult(interp, "wrong # args: should be \"", 2768 Tcl_GetStringFromObj(objv[0], 0), " STMT", 0); 2769 return TCL_ERROR; 2770 } 2771 2772 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2773 rc = sqlite3_stmt_busy(pStmt); 2774 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(rc)); 2775 return TCL_OK; 2776 } 2777 2778 /* 2779 ** Usage: uses_stmt_journal STMT 2780 ** 2781 ** Return true if STMT uses a statement journal. 2782 */ 2783 static int SQLITE_TCLAPI uses_stmt_journal( 2784 void * clientData, 2785 Tcl_Interp *interp, 2786 int objc, 2787 Tcl_Obj *CONST objv[] 2788 ){ 2789 sqlite3_stmt *pStmt; 2790 2791 if( objc!=2 ){ 2792 Tcl_AppendResult(interp, "wrong # args: should be \"", 2793 Tcl_GetStringFromObj(objv[0], 0), " STMT", 0); 2794 return TCL_ERROR; 2795 } 2796 2797 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2798 sqlite3_stmt_readonly(pStmt); 2799 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(((Vdbe *)pStmt)->usesStmtJournal)); 2800 return TCL_OK; 2801 } 2802 2803 2804 /* 2805 ** Usage: sqlite3_reset STMT 2806 ** 2807 ** Reset a statement handle. 2808 */ 2809 static int SQLITE_TCLAPI test_reset( 2810 void * clientData, 2811 Tcl_Interp *interp, 2812 int objc, 2813 Tcl_Obj *CONST objv[] 2814 ){ 2815 sqlite3_stmt *pStmt; 2816 int rc; 2817 2818 if( objc!=2 ){ 2819 Tcl_AppendResult(interp, "wrong # args: should be \"", 2820 Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0); 2821 return TCL_ERROR; 2822 } 2823 2824 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2825 2826 rc = sqlite3_reset(pStmt); 2827 if( pStmt && sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ){ 2828 return TCL_ERROR; 2829 } 2830 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 2831 /* 2832 if( rc ){ 2833 return TCL_ERROR; 2834 } 2835 */ 2836 return TCL_OK; 2837 } 2838 2839 /* 2840 ** Usage: sqlite3_expired STMT 2841 ** 2842 ** Return TRUE if a recompilation of the statement is recommended. 2843 */ 2844 static int SQLITE_TCLAPI test_expired( 2845 void * clientData, 2846 Tcl_Interp *interp, 2847 int objc, 2848 Tcl_Obj *CONST objv[] 2849 ){ 2850 #ifndef SQLITE_OMIT_DEPRECATED 2851 sqlite3_stmt *pStmt; 2852 if( objc!=2 ){ 2853 Tcl_AppendResult(interp, "wrong # args: should be \"", 2854 Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0); 2855 return TCL_ERROR; 2856 } 2857 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2858 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(sqlite3_expired(pStmt))); 2859 #endif 2860 return TCL_OK; 2861 } 2862 2863 /* 2864 ** Usage: sqlite3_transfer_bindings FROMSTMT TOSTMT 2865 ** 2866 ** Transfer all bindings from FROMSTMT over to TOSTMT 2867 */ 2868 static int SQLITE_TCLAPI test_transfer_bind( 2869 void * clientData, 2870 Tcl_Interp *interp, 2871 int objc, 2872 Tcl_Obj *CONST objv[] 2873 ){ 2874 #ifndef SQLITE_OMIT_DEPRECATED 2875 sqlite3_stmt *pStmt1, *pStmt2; 2876 if( objc!=3 ){ 2877 Tcl_AppendResult(interp, "wrong # args: should be \"", 2878 Tcl_GetStringFromObj(objv[0], 0), " FROM-STMT TO-STMT", 0); 2879 return TCL_ERROR; 2880 } 2881 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt1)) return TCL_ERROR; 2882 if( getStmtPointer(interp, Tcl_GetString(objv[2]), &pStmt2)) return TCL_ERROR; 2883 Tcl_SetObjResult(interp, 2884 Tcl_NewIntObj(sqlite3_transfer_bindings(pStmt1,pStmt2))); 2885 #endif 2886 return TCL_OK; 2887 } 2888 2889 /* 2890 ** Usage: sqlite3_changes DB 2891 ** 2892 ** Return the number of changes made to the database by the last SQL 2893 ** execution. 2894 */ 2895 static int SQLITE_TCLAPI test_changes( 2896 void * clientData, 2897 Tcl_Interp *interp, 2898 int objc, 2899 Tcl_Obj *CONST objv[] 2900 ){ 2901 sqlite3 *db; 2902 if( objc!=2 ){ 2903 Tcl_AppendResult(interp, "wrong # args: should be \"", 2904 Tcl_GetString(objv[0]), " DB", 0); 2905 return TCL_ERROR; 2906 } 2907 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 2908 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_changes(db))); 2909 return TCL_OK; 2910 } 2911 2912 /* 2913 ** This is the "static_bind_value" that variables are bound to when 2914 ** the FLAG option of sqlite3_bind is "static" 2915 */ 2916 static char *sqlite_static_bind_value = 0; 2917 static int sqlite_static_bind_nbyte = 0; 2918 2919 /* 2920 ** Usage: sqlite3_bind VM IDX VALUE FLAGS 2921 ** 2922 ** Sets the value of the IDX-th occurrence of "?" in the original SQL 2923 ** string. VALUE is the new value. If FLAGS=="null" then VALUE is 2924 ** ignored and the value is set to NULL. If FLAGS=="static" then 2925 ** the value is set to the value of a static variable named 2926 ** "sqlite_static_bind_value". If FLAGS=="normal" then a copy 2927 ** of the VALUE is made. If FLAGS=="blob10" then a VALUE is ignored 2928 ** an a 10-byte blob "abc\000xyz\000pq" is inserted. 2929 */ 2930 static int SQLITE_TCLAPI test_bind( 2931 void *NotUsed, 2932 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 2933 int argc, /* Number of arguments */ 2934 char **argv /* Text of each argument */ 2935 ){ 2936 sqlite3_stmt *pStmt; 2937 int rc; 2938 int idx; 2939 if( argc!=5 ){ 2940 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 2941 " VM IDX VALUE (null|static|normal)\"", 0); 2942 return TCL_ERROR; 2943 } 2944 if( getStmtPointer(interp, argv[1], &pStmt) ) return TCL_ERROR; 2945 if( Tcl_GetInt(interp, argv[2], &idx) ) return TCL_ERROR; 2946 if( strcmp(argv[4],"null")==0 ){ 2947 rc = sqlite3_bind_null(pStmt, idx); 2948 }else if( strcmp(argv[4],"static")==0 ){ 2949 rc = sqlite3_bind_text(pStmt, idx, sqlite_static_bind_value, -1, 0); 2950 }else if( strcmp(argv[4],"static-nbytes")==0 ){ 2951 rc = sqlite3_bind_text(pStmt, idx, sqlite_static_bind_value, 2952 sqlite_static_bind_nbyte, 0); 2953 }else if( strcmp(argv[4],"normal")==0 ){ 2954 rc = sqlite3_bind_text(pStmt, idx, argv[3], -1, SQLITE_TRANSIENT); 2955 }else if( strcmp(argv[4],"blob10")==0 ){ 2956 rc = sqlite3_bind_text(pStmt, idx, "abc\000xyz\000pq", 10, SQLITE_STATIC); 2957 }else{ 2958 Tcl_AppendResult(interp, "4th argument should be " 2959 "\"null\" or \"static\" or \"normal\"", 0); 2960 return TCL_ERROR; 2961 } 2962 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 2963 if( rc ){ 2964 char zBuf[50]; 2965 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc); 2966 Tcl_AppendResult(interp, zBuf, sqlite3ErrStr(rc), 0); 2967 return TCL_ERROR; 2968 } 2969 return TCL_OK; 2970 } 2971 2972 #ifndef SQLITE_OMIT_UTF16 2973 /* 2974 ** Usage: add_test_collate <db ptr> <utf8> <utf16le> <utf16be> 2975 ** 2976 ** This function is used to test that SQLite selects the correct collation 2977 ** sequence callback when multiple versions (for different text encodings) 2978 ** are available. 2979 ** 2980 ** Calling this routine registers the collation sequence "test_collate" 2981 ** with database handle <db>. The second argument must be a list of three 2982 ** boolean values. If the first is true, then a version of test_collate is 2983 ** registered for UTF-8, if the second is true, a version is registered for 2984 ** UTF-16le, if the third is true, a UTF-16be version is available. 2985 ** Previous versions of test_collate are deleted. 2986 ** 2987 ** The collation sequence test_collate is implemented by calling the 2988 ** following TCL script: 2989 ** 2990 ** "test_collate <enc> <lhs> <rhs>" 2991 ** 2992 ** The <lhs> and <rhs> are the two values being compared, encoded in UTF-8. 2993 ** The <enc> parameter is the encoding of the collation function that 2994 ** SQLite selected to call. The TCL test script implements the 2995 ** "test_collate" proc. 2996 ** 2997 ** Note that this will only work with one interpreter at a time, as the 2998 ** interp pointer to use when evaluating the TCL script is stored in 2999 ** pTestCollateInterp. 3000 */ 3001 static Tcl_Interp* pTestCollateInterp; 3002 static int test_collate_func( 3003 void *pCtx, 3004 int nA, const void *zA, 3005 int nB, const void *zB 3006 ){ 3007 Tcl_Interp *i = pTestCollateInterp; 3008 int encin = SQLITE_PTR_TO_INT(pCtx); 3009 int res; 3010 int n; 3011 3012 sqlite3_value *pVal; 3013 Tcl_Obj *pX; 3014 3015 pX = Tcl_NewStringObj("test_collate", -1); 3016 Tcl_IncrRefCount(pX); 3017 3018 switch( encin ){ 3019 case SQLITE_UTF8: 3020 Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-8",-1)); 3021 break; 3022 case SQLITE_UTF16LE: 3023 Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-16LE",-1)); 3024 break; 3025 case SQLITE_UTF16BE: 3026 Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-16BE",-1)); 3027 break; 3028 default: 3029 assert(0); 3030 } 3031 3032 sqlite3BeginBenignMalloc(); 3033 pVal = sqlite3ValueNew(0); 3034 if( pVal ){ 3035 sqlite3ValueSetStr(pVal, nA, zA, encin, SQLITE_STATIC); 3036 n = sqlite3_value_bytes(pVal); 3037 Tcl_ListObjAppendElement(i,pX, 3038 Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n)); 3039 sqlite3ValueSetStr(pVal, nB, zB, encin, SQLITE_STATIC); 3040 n = sqlite3_value_bytes(pVal); 3041 Tcl_ListObjAppendElement(i,pX, 3042 Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n)); 3043 sqlite3ValueFree(pVal); 3044 } 3045 sqlite3EndBenignMalloc(); 3046 3047 Tcl_EvalObjEx(i, pX, 0); 3048 Tcl_DecrRefCount(pX); 3049 Tcl_GetIntFromObj(i, Tcl_GetObjResult(i), &res); 3050 return res; 3051 } 3052 static int SQLITE_TCLAPI test_collate( 3053 void * clientData, 3054 Tcl_Interp *interp, 3055 int objc, 3056 Tcl_Obj *CONST objv[] 3057 ){ 3058 sqlite3 *db; 3059 int val; 3060 sqlite3_value *pVal; 3061 int rc; 3062 3063 if( objc!=5 ) goto bad_args; 3064 pTestCollateInterp = interp; 3065 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 3066 3067 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR; 3068 rc = sqlite3_create_collation(db, "test_collate", SQLITE_UTF8, 3069 (void *)SQLITE_UTF8, val?test_collate_func:0); 3070 if( rc==SQLITE_OK ){ 3071 const void *zUtf16; 3072 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &val) ) return TCL_ERROR; 3073 rc = sqlite3_create_collation(db, "test_collate", SQLITE_UTF16LE, 3074 (void *)SQLITE_UTF16LE, val?test_collate_func:0); 3075 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[4], &val) ) return TCL_ERROR; 3076 3077 #if 0 3078 if( sqlite3_iMallocFail>0 ){ 3079 sqlite3_iMallocFail++; 3080 } 3081 #endif 3082 sqlite3_mutex_enter(db->mutex); 3083 pVal = sqlite3ValueNew(db); 3084 sqlite3ValueSetStr(pVal, -1, "test_collate", SQLITE_UTF8, SQLITE_STATIC); 3085 zUtf16 = sqlite3ValueText(pVal, SQLITE_UTF16NATIVE); 3086 if( db->mallocFailed ){ 3087 rc = SQLITE_NOMEM; 3088 }else{ 3089 rc = sqlite3_create_collation16(db, zUtf16, SQLITE_UTF16BE, 3090 (void *)SQLITE_UTF16BE, val?test_collate_func:0); 3091 } 3092 sqlite3ValueFree(pVal); 3093 sqlite3_mutex_leave(db->mutex); 3094 } 3095 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 3096 3097 if( rc!=SQLITE_OK ){ 3098 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0); 3099 return TCL_ERROR; 3100 } 3101 return TCL_OK; 3102 3103 bad_args: 3104 Tcl_AppendResult(interp, "wrong # args: should be \"", 3105 Tcl_GetStringFromObj(objv[0], 0), " <DB> <utf8> <utf16le> <utf16be>", 0); 3106 return TCL_ERROR; 3107 } 3108 3109 /* 3110 ** Usage: add_test_utf16bin_collate <db ptr> 3111 ** 3112 ** Add a utf-16 collation sequence named "utf16bin" to the database 3113 ** handle. This collation sequence compares arguments in the same way as the 3114 ** built-in collation "binary". 3115 */ 3116 static int test_utf16bin_collate_func( 3117 void *pCtx, 3118 int nA, const void *zA, 3119 int nB, const void *zB 3120 ){ 3121 int nCmp = (nA>nB ? nB : nA); 3122 int res = memcmp(zA, zB, nCmp); 3123 if( res==0 ) res = nA - nB; 3124 return res; 3125 } 3126 static int SQLITE_TCLAPI test_utf16bin_collate( 3127 void * clientData, 3128 Tcl_Interp *interp, 3129 int objc, 3130 Tcl_Obj *CONST objv[] 3131 ){ 3132 sqlite3 *db; 3133 int rc; 3134 3135 if( objc!=2 ) goto bad_args; 3136 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 3137 3138 rc = sqlite3_create_collation(db, "utf16bin", SQLITE_UTF16, 0, 3139 test_utf16bin_collate_func 3140 ); 3141 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 3142 return TCL_OK; 3143 3144 bad_args: 3145 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 3146 return TCL_ERROR; 3147 } 3148 3149 /* 3150 ** When the collation needed callback is invoked, record the name of 3151 ** the requested collating function here. The recorded name is linked 3152 ** to a TCL variable and used to make sure that the requested collation 3153 ** name is correct. 3154 */ 3155 static char zNeededCollation[200]; 3156 static char *pzNeededCollation = zNeededCollation; 3157 3158 3159 /* 3160 ** Called when a collating sequence is needed. Registered using 3161 ** sqlite3_collation_needed16(). 3162 */ 3163 static void test_collate_needed_cb( 3164 void *pCtx, 3165 sqlite3 *db, 3166 int eTextRep, 3167 const void *pName 3168 ){ 3169 int enc = ENC(db); 3170 int i; 3171 char *z; 3172 for(z = (char*)pName, i=0; *z || z[1]; z++){ 3173 if( *z ) zNeededCollation[i++] = *z; 3174 } 3175 zNeededCollation[i] = 0; 3176 sqlite3_create_collation( 3177 db, "test_collate", ENC(db), SQLITE_INT_TO_PTR(enc), test_collate_func); 3178 } 3179 3180 /* 3181 ** Usage: add_test_collate_needed DB 3182 */ 3183 static int SQLITE_TCLAPI test_collate_needed( 3184 void * clientData, 3185 Tcl_Interp *interp, 3186 int objc, 3187 Tcl_Obj *CONST objv[] 3188 ){ 3189 sqlite3 *db; 3190 int rc; 3191 3192 if( objc!=2 ) goto bad_args; 3193 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 3194 rc = sqlite3_collation_needed16(db, 0, test_collate_needed_cb); 3195 zNeededCollation[0] = 0; 3196 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 3197 return TCL_OK; 3198 3199 bad_args: 3200 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 3201 return TCL_ERROR; 3202 } 3203 3204 /* 3205 ** tclcmd: add_alignment_test_collations DB 3206 ** 3207 ** Add two new collating sequences to the database DB 3208 ** 3209 ** utf16_aligned 3210 ** utf16_unaligned 3211 ** 3212 ** Both collating sequences use the same sort order as BINARY. 3213 ** The only difference is that the utf16_aligned collating 3214 ** sequence is declared with the SQLITE_UTF16_ALIGNED flag. 3215 ** Both collating functions increment the unaligned utf16 counter 3216 ** whenever they see a string that begins on an odd byte boundary. 3217 */ 3218 static int unaligned_string_counter = 0; 3219 static int alignmentCollFunc( 3220 void *NotUsed, 3221 int nKey1, const void *pKey1, 3222 int nKey2, const void *pKey2 3223 ){ 3224 int rc, n; 3225 n = nKey1<nKey2 ? nKey1 : nKey2; 3226 if( nKey1>0 && 1==(1&(SQLITE_PTR_TO_INT(pKey1))) ) unaligned_string_counter++; 3227 if( nKey2>0 && 1==(1&(SQLITE_PTR_TO_INT(pKey2))) ) unaligned_string_counter++; 3228 rc = memcmp(pKey1, pKey2, n); 3229 if( rc==0 ){ 3230 rc = nKey1 - nKey2; 3231 } 3232 return rc; 3233 } 3234 static int SQLITE_TCLAPI add_alignment_test_collations( 3235 void * clientData, 3236 Tcl_Interp *interp, 3237 int objc, 3238 Tcl_Obj *CONST objv[] 3239 ){ 3240 sqlite3 *db; 3241 if( objc>=2 ){ 3242 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 3243 sqlite3_create_collation(db, "utf16_unaligned", SQLITE_UTF16, 3244 0, alignmentCollFunc); 3245 sqlite3_create_collation(db, "utf16_aligned", SQLITE_UTF16_ALIGNED, 3246 0, alignmentCollFunc); 3247 } 3248 return SQLITE_OK; 3249 } 3250 #endif /* !defined(SQLITE_OMIT_UTF16) */ 3251 3252 /* 3253 ** Usage: add_test_function <db ptr> <utf8> <utf16le> <utf16be> 3254 ** 3255 ** This function is used to test that SQLite selects the correct user 3256 ** function callback when multiple versions (for different text encodings) 3257 ** are available. 3258 ** 3259 ** Calling this routine registers up to three versions of the user function 3260 ** "test_function" with database handle <db>. If the second argument is 3261 ** true, then a version of test_function is registered for UTF-8, if the 3262 ** third is true, a version is registered for UTF-16le, if the fourth is 3263 ** true, a UTF-16be version is available. Previous versions of 3264 ** test_function are deleted. 3265 ** 3266 ** The user function is implemented by calling the following TCL script: 3267 ** 3268 ** "test_function <enc> <arg>" 3269 ** 3270 ** Where <enc> is one of UTF-8, UTF-16LE or UTF16BE, and <arg> is the 3271 ** single argument passed to the SQL function. The value returned by 3272 ** the TCL script is used as the return value of the SQL function. It 3273 ** is passed to SQLite using UTF-16BE for a UTF-8 test_function(), UTF-8 3274 ** for a UTF-16LE test_function(), and UTF-16LE for an implementation that 3275 ** prefers UTF-16BE. 3276 */ 3277 #ifndef SQLITE_OMIT_UTF16 3278 static void test_function_utf8( 3279 sqlite3_context *pCtx, 3280 int nArg, 3281 sqlite3_value **argv 3282 ){ 3283 Tcl_Interp *interp; 3284 Tcl_Obj *pX; 3285 sqlite3_value *pVal; 3286 interp = (Tcl_Interp *)sqlite3_user_data(pCtx); 3287 pX = Tcl_NewStringObj("test_function", -1); 3288 Tcl_IncrRefCount(pX); 3289 Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-8", -1)); 3290 Tcl_ListObjAppendElement(interp, pX, 3291 Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1)); 3292 Tcl_EvalObjEx(interp, pX, 0); 3293 Tcl_DecrRefCount(pX); 3294 sqlite3_result_text(pCtx, Tcl_GetStringResult(interp), -1, SQLITE_TRANSIENT); 3295 pVal = sqlite3ValueNew(0); 3296 sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp), 3297 SQLITE_UTF8, SQLITE_STATIC); 3298 sqlite3_result_text16be(pCtx, sqlite3_value_text16be(pVal), 3299 -1, SQLITE_TRANSIENT); 3300 sqlite3ValueFree(pVal); 3301 } 3302 static void test_function_utf16le( 3303 sqlite3_context *pCtx, 3304 int nArg, 3305 sqlite3_value **argv 3306 ){ 3307 Tcl_Interp *interp; 3308 Tcl_Obj *pX; 3309 sqlite3_value *pVal; 3310 interp = (Tcl_Interp *)sqlite3_user_data(pCtx); 3311 pX = Tcl_NewStringObj("test_function", -1); 3312 Tcl_IncrRefCount(pX); 3313 Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-16LE", -1)); 3314 Tcl_ListObjAppendElement(interp, pX, 3315 Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1)); 3316 Tcl_EvalObjEx(interp, pX, 0); 3317 Tcl_DecrRefCount(pX); 3318 pVal = sqlite3ValueNew(0); 3319 sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp), 3320 SQLITE_UTF8, SQLITE_STATIC); 3321 sqlite3_result_text(pCtx,(char*)sqlite3_value_text(pVal),-1,SQLITE_TRANSIENT); 3322 sqlite3ValueFree(pVal); 3323 } 3324 static void test_function_utf16be( 3325 sqlite3_context *pCtx, 3326 int nArg, 3327 sqlite3_value **argv 3328 ){ 3329 Tcl_Interp *interp; 3330 Tcl_Obj *pX; 3331 sqlite3_value *pVal; 3332 interp = (Tcl_Interp *)sqlite3_user_data(pCtx); 3333 pX = Tcl_NewStringObj("test_function", -1); 3334 Tcl_IncrRefCount(pX); 3335 Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-16BE", -1)); 3336 Tcl_ListObjAppendElement(interp, pX, 3337 Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1)); 3338 Tcl_EvalObjEx(interp, pX, 0); 3339 Tcl_DecrRefCount(pX); 3340 pVal = sqlite3ValueNew(0); 3341 sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp), 3342 SQLITE_UTF8, SQLITE_STATIC); 3343 sqlite3_result_text16(pCtx, sqlite3_value_text16le(pVal), 3344 -1, SQLITE_TRANSIENT); 3345 sqlite3_result_text16be(pCtx, sqlite3_value_text16le(pVal), 3346 -1, SQLITE_TRANSIENT); 3347 sqlite3_result_text16le(pCtx, sqlite3_value_text16le(pVal), 3348 -1, SQLITE_TRANSIENT); 3349 sqlite3ValueFree(pVal); 3350 } 3351 #endif /* SQLITE_OMIT_UTF16 */ 3352 static int SQLITE_TCLAPI test_function( 3353 void * clientData, 3354 Tcl_Interp *interp, 3355 int objc, 3356 Tcl_Obj *CONST objv[] 3357 ){ 3358 #ifndef SQLITE_OMIT_UTF16 3359 sqlite3 *db; 3360 int val; 3361 3362 if( objc!=5 ) goto bad_args; 3363 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 3364 3365 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR; 3366 if( val ){ 3367 sqlite3_create_function(db, "test_function", 1, SQLITE_UTF8, 3368 interp, test_function_utf8, 0, 0); 3369 } 3370 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &val) ) return TCL_ERROR; 3371 if( val ){ 3372 sqlite3_create_function(db, "test_function", 1, SQLITE_UTF16LE, 3373 interp, test_function_utf16le, 0, 0); 3374 } 3375 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[4], &val) ) return TCL_ERROR; 3376 if( val ){ 3377 sqlite3_create_function(db, "test_function", 1, SQLITE_UTF16BE, 3378 interp, test_function_utf16be, 0, 0); 3379 } 3380 3381 return TCL_OK; 3382 bad_args: 3383 Tcl_AppendResult(interp, "wrong # args: should be \"", 3384 Tcl_GetStringFromObj(objv[0], 0), " <DB> <utf8> <utf16le> <utf16be>", 0); 3385 #endif /* SQLITE_OMIT_UTF16 */ 3386 return TCL_ERROR; 3387 } 3388 3389 /* 3390 ** Usage: sqlite3_test_errstr <err code> 3391 ** 3392 ** Test that the english language string equivalents for sqlite error codes 3393 ** are sane. The parameter is an integer representing an sqlite error code. 3394 ** The result is a list of two elements, the string representation of the 3395 ** error code and the english language explanation. 3396 */ 3397 static int SQLITE_TCLAPI test_errstr( 3398 void * clientData, 3399 Tcl_Interp *interp, 3400 int objc, 3401 Tcl_Obj *CONST objv[] 3402 ){ 3403 char *zCode; 3404 int i; 3405 if( objc!=1 ){ 3406 Tcl_WrongNumArgs(interp, 1, objv, "<error code>"); 3407 } 3408 3409 zCode = Tcl_GetString(objv[1]); 3410 for(i=0; i<200; i++){ 3411 if( 0==strcmp(t1ErrorName(i), zCode) ) break; 3412 } 3413 Tcl_SetResult(interp, (char *)sqlite3ErrStr(i), 0); 3414 return TCL_OK; 3415 } 3416 3417 /* 3418 ** Usage: breakpoint 3419 ** 3420 ** This routine exists for one purpose - to provide a place to put a 3421 ** breakpoint with GDB that can be triggered using TCL code. The use 3422 ** for this is when a particular test fails on (say) the 1485th iteration. 3423 ** In the TCL test script, we can add code like this: 3424 ** 3425 ** if {$i==1485} breakpoint 3426 ** 3427 ** Then run testfixture in the debugger and wait for the breakpoint to 3428 ** fire. Then additional breakpoints can be set to trace down the bug. 3429 */ 3430 static int SQLITE_TCLAPI test_breakpoint( 3431 void *NotUsed, 3432 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 3433 int argc, /* Number of arguments */ 3434 char **argv /* Text of each argument */ 3435 ){ 3436 return TCL_OK; /* Do nothing */ 3437 } 3438 3439 /* 3440 ** Usage: sqlite3_bind_zeroblob STMT IDX N 3441 ** 3442 ** Test the sqlite3_bind_zeroblob interface. STMT is a prepared statement. 3443 ** IDX is the index of a wildcard in the prepared statement. This command 3444 ** binds a N-byte zero-filled BLOB to the wildcard. 3445 */ 3446 static int SQLITE_TCLAPI test_bind_zeroblob( 3447 void * clientData, 3448 Tcl_Interp *interp, 3449 int objc, 3450 Tcl_Obj *CONST objv[] 3451 ){ 3452 sqlite3_stmt *pStmt; 3453 int idx; 3454 int n; 3455 int rc; 3456 3457 if( objc!=4 ){ 3458 Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX N"); 3459 return TCL_ERROR; 3460 } 3461 3462 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3463 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3464 if( Tcl_GetIntFromObj(interp, objv[3], &n) ) return TCL_ERROR; 3465 3466 rc = sqlite3_bind_zeroblob(pStmt, idx, n); 3467 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3468 if( rc!=SQLITE_OK ){ 3469 return TCL_ERROR; 3470 } 3471 3472 return TCL_OK; 3473 } 3474 3475 /* 3476 ** Usage: sqlite3_bind_zeroblob64 STMT IDX N 3477 ** 3478 ** Test the sqlite3_bind_zeroblob64 interface. STMT is a prepared statement. 3479 ** IDX is the index of a wildcard in the prepared statement. This command 3480 ** binds a N-byte zero-filled BLOB to the wildcard. 3481 */ 3482 static int SQLITE_TCLAPI test_bind_zeroblob64( 3483 void * clientData, 3484 Tcl_Interp *interp, 3485 int objc, 3486 Tcl_Obj *CONST objv[] 3487 ){ 3488 sqlite3_stmt *pStmt; 3489 int idx; 3490 Tcl_WideInt n; 3491 int rc; 3492 3493 if( objc!=4 ){ 3494 Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX N"); 3495 return TCL_ERROR; 3496 } 3497 3498 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3499 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3500 if( Tcl_GetWideIntFromObj(interp, objv[3], &n) ) return TCL_ERROR; 3501 3502 rc = sqlite3_bind_zeroblob64(pStmt, idx, n); 3503 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3504 if( rc!=SQLITE_OK ){ 3505 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0); 3506 return TCL_ERROR; 3507 } 3508 3509 return TCL_OK; 3510 } 3511 3512 /* 3513 ** Usage: sqlite3_bind_int STMT N VALUE 3514 ** 3515 ** Test the sqlite3_bind_int interface. STMT is a prepared statement. 3516 ** N is the index of a wildcard in the prepared statement. This command 3517 ** binds a 32-bit integer VALUE to that wildcard. 3518 */ 3519 static int SQLITE_TCLAPI test_bind_int( 3520 void * clientData, 3521 Tcl_Interp *interp, 3522 int objc, 3523 Tcl_Obj *CONST objv[] 3524 ){ 3525 sqlite3_stmt *pStmt; 3526 int idx; 3527 int value; 3528 int rc; 3529 3530 if( objc!=4 ){ 3531 Tcl_AppendResult(interp, "wrong # args: should be \"", 3532 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0); 3533 return TCL_ERROR; 3534 } 3535 3536 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3537 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3538 if( Tcl_GetIntFromObj(interp, objv[3], &value) ) return TCL_ERROR; 3539 3540 rc = sqlite3_bind_int(pStmt, idx, value); 3541 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3542 if( rc!=SQLITE_OK ){ 3543 return TCL_ERROR; 3544 } 3545 3546 return TCL_OK; 3547 } 3548 3549 3550 /* 3551 ** Usage: intarray_addr INT ... 3552 ** 3553 ** Return the address of a C-language array of 32-bit integers. 3554 ** 3555 ** Space to hold the array is obtained from malloc(). Call this procedure once 3556 ** with no arguments in order to release memory. Each call to this procedure 3557 ** overwrites the previous array. 3558 */ 3559 static int SQLITE_TCLAPI test_intarray_addr( 3560 void * clientData, 3561 Tcl_Interp *interp, 3562 int objc, 3563 Tcl_Obj *CONST objv[] 3564 ){ 3565 int i; 3566 static int *p = 0; 3567 3568 sqlite3_free(p); 3569 p = 0; 3570 if( objc>1 ){ 3571 p = sqlite3_malloc( sizeof(p[0])*(objc-1) ); 3572 if( p==0 ) return TCL_ERROR; 3573 for(i=0; i<objc-1; i++){ 3574 if( Tcl_GetIntFromObj(interp, objv[1+i], &p[i]) ){ 3575 sqlite3_free(p); 3576 p = 0; 3577 return TCL_ERROR; 3578 } 3579 } 3580 } 3581 Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p)); 3582 return TCL_OK; 3583 } 3584 /* 3585 ** Usage: intarray_addr INT ... 3586 ** 3587 ** Return the address of a C-language array of 32-bit integers. 3588 ** 3589 ** Space to hold the array is obtained from malloc(). Call this procedure once 3590 ** with no arguments in order to release memory. Each call to this procedure 3591 ** overwrites the previous array. 3592 */ 3593 static int SQLITE_TCLAPI test_int64array_addr( 3594 void * clientData, 3595 Tcl_Interp *interp, 3596 int objc, 3597 Tcl_Obj *CONST objv[] 3598 ){ 3599 int i; 3600 static sqlite3_int64 *p = 0; 3601 3602 sqlite3_free(p); 3603 p = 0; 3604 if( objc>1 ){ 3605 p = sqlite3_malloc( sizeof(p[0])*(objc-1) ); 3606 if( p==0 ) return TCL_ERROR; 3607 for(i=0; i<objc-1; i++){ 3608 Tcl_WideInt v; 3609 if( Tcl_GetWideIntFromObj(interp, objv[1+i], &v) ){ 3610 sqlite3_free(p); 3611 p = 0; 3612 return TCL_ERROR; 3613 } 3614 p[i] = v; 3615 } 3616 } 3617 Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p)); 3618 return TCL_OK; 3619 } 3620 /* 3621 ** Usage: doublearray_addr INT ... 3622 ** 3623 ** Return the address of a C-language array of doubles. 3624 ** 3625 ** Space to hold the array is obtained from malloc(). Call this procedure once 3626 ** with no arguments in order to release memory. Each call to this procedure 3627 ** overwrites the previous array. 3628 */ 3629 static int SQLITE_TCLAPI test_doublearray_addr( 3630 void * clientData, 3631 Tcl_Interp *interp, 3632 int objc, 3633 Tcl_Obj *CONST objv[] 3634 ){ 3635 int i; 3636 static double *p = 0; 3637 3638 sqlite3_free(p); 3639 p = 0; 3640 if( objc>1 ){ 3641 p = sqlite3_malloc( sizeof(p[0])*(objc-1) ); 3642 if( p==0 ) return TCL_ERROR; 3643 for(i=0; i<objc-1; i++){ 3644 if( Tcl_GetDoubleFromObj(interp, objv[1+i], &p[i]) ){ 3645 sqlite3_free(p); 3646 p = 0; 3647 return TCL_ERROR; 3648 } 3649 } 3650 } 3651 Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p)); 3652 return TCL_OK; 3653 } 3654 /* 3655 ** Usage: textarray_addr TEXT ... 3656 ** 3657 ** Return the address of a C-language array of strings. 3658 ** 3659 ** Space to hold the array is obtained from malloc(). Call this procedure once 3660 ** with no arguments in order to release memory. Each call to this procedure 3661 ** overwrites the previous array. 3662 */ 3663 static int SQLITE_TCLAPI test_textarray_addr( 3664 void * clientData, 3665 Tcl_Interp *interp, 3666 int objc, 3667 Tcl_Obj *CONST objv[] 3668 ){ 3669 int i; 3670 static int n = 0; 3671 static char **p = 0; 3672 3673 for(i=0; i<n; i++) sqlite3_free(p[i]); 3674 sqlite3_free(p); 3675 p = 0; 3676 if( objc>1 ){ 3677 p = sqlite3_malloc( sizeof(p[0])*(objc-1) ); 3678 if( p==0 ) return TCL_ERROR; 3679 for(i=0; i<objc-1; i++){ 3680 p[i] = sqlite3_mprintf("%s", Tcl_GetString(objv[1+i])); 3681 } 3682 } 3683 n = objc-1; 3684 Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p)); 3685 return TCL_OK; 3686 } 3687 3688 3689 /* 3690 ** Usage: sqlite3_bind_int64 STMT N VALUE 3691 ** 3692 ** Test the sqlite3_bind_int64 interface. STMT is a prepared statement. 3693 ** N is the index of a wildcard in the prepared statement. This command 3694 ** binds a 64-bit integer VALUE to that wildcard. 3695 */ 3696 static int SQLITE_TCLAPI test_bind_int64( 3697 void * clientData, 3698 Tcl_Interp *interp, 3699 int objc, 3700 Tcl_Obj *CONST objv[] 3701 ){ 3702 sqlite3_stmt *pStmt; 3703 int idx; 3704 Tcl_WideInt value; 3705 int rc; 3706 3707 if( objc!=4 ){ 3708 Tcl_AppendResult(interp, "wrong # args: should be \"", 3709 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0); 3710 return TCL_ERROR; 3711 } 3712 3713 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3714 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3715 if( Tcl_GetWideIntFromObj(interp, objv[3], &value) ) return TCL_ERROR; 3716 3717 rc = sqlite3_bind_int64(pStmt, idx, value); 3718 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3719 if( rc!=SQLITE_OK ){ 3720 return TCL_ERROR; 3721 } 3722 3723 return TCL_OK; 3724 } 3725 3726 3727 /* 3728 ** Usage: sqlite3_bind_double STMT N VALUE 3729 ** 3730 ** Test the sqlite3_bind_double interface. STMT is a prepared statement. 3731 ** N is the index of a wildcard in the prepared statement. This command 3732 ** binds a 64-bit integer VALUE to that wildcard. 3733 */ 3734 static int SQLITE_TCLAPI test_bind_double( 3735 void * clientData, 3736 Tcl_Interp *interp, 3737 int objc, 3738 Tcl_Obj *CONST objv[] 3739 ){ 3740 sqlite3_stmt *pStmt; 3741 int idx; 3742 double value = 0; 3743 int rc; 3744 const char *zVal; 3745 int i; 3746 static const struct { 3747 const char *zName; /* Name of the special floating point value */ 3748 unsigned int iUpper; /* Upper 32 bits */ 3749 unsigned int iLower; /* Lower 32 bits */ 3750 } aSpecialFp[] = { 3751 { "NaN", 0x7fffffff, 0xffffffff }, 3752 { "SNaN", 0x7ff7ffff, 0xffffffff }, 3753 { "-NaN", 0xffffffff, 0xffffffff }, 3754 { "-SNaN", 0xfff7ffff, 0xffffffff }, 3755 { "+Inf", 0x7ff00000, 0x00000000 }, 3756 { "-Inf", 0xfff00000, 0x00000000 }, 3757 { "Epsilon", 0x00000000, 0x00000001 }, 3758 { "-Epsilon", 0x80000000, 0x00000001 }, 3759 { "NaN0", 0x7ff80000, 0x00000000 }, 3760 { "-NaN0", 0xfff80000, 0x00000000 }, 3761 }; 3762 3763 if( objc!=4 ){ 3764 Tcl_AppendResult(interp, "wrong # args: should be \"", 3765 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0); 3766 return TCL_ERROR; 3767 } 3768 3769 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3770 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3771 3772 /* Intercept the string "NaN" and generate a NaN value for it. 3773 ** All other strings are passed through to Tcl_GetDoubleFromObj(). 3774 ** Tcl_GetDoubleFromObj() should understand "NaN" but some versions 3775 ** contain a bug. 3776 */ 3777 zVal = Tcl_GetString(objv[3]); 3778 for(i=0; i<sizeof(aSpecialFp)/sizeof(aSpecialFp[0]); i++){ 3779 if( strcmp(aSpecialFp[i].zName, zVal)==0 ){ 3780 sqlite3_uint64 x; 3781 x = aSpecialFp[i].iUpper; 3782 x <<= 32; 3783 x |= aSpecialFp[i].iLower; 3784 assert( sizeof(value)==8 ); 3785 assert( sizeof(x)==8 ); 3786 memcpy(&value, &x, 8); 3787 break; 3788 } 3789 } 3790 if( i>=sizeof(aSpecialFp)/sizeof(aSpecialFp[0]) && 3791 Tcl_GetDoubleFromObj(interp, objv[3], &value) ){ 3792 return TCL_ERROR; 3793 } 3794 rc = sqlite3_bind_double(pStmt, idx, value); 3795 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3796 if( rc!=SQLITE_OK ){ 3797 return TCL_ERROR; 3798 } 3799 3800 return TCL_OK; 3801 } 3802 3803 /* 3804 ** Usage: sqlite3_bind_null STMT N 3805 ** 3806 ** Test the sqlite3_bind_null interface. STMT is a prepared statement. 3807 ** N is the index of a wildcard in the prepared statement. This command 3808 ** binds a NULL to the wildcard. 3809 */ 3810 static int SQLITE_TCLAPI test_bind_null( 3811 void * clientData, 3812 Tcl_Interp *interp, 3813 int objc, 3814 Tcl_Obj *CONST objv[] 3815 ){ 3816 sqlite3_stmt *pStmt; 3817 int idx; 3818 int rc; 3819 3820 if( objc!=3 ){ 3821 Tcl_AppendResult(interp, "wrong # args: should be \"", 3822 Tcl_GetStringFromObj(objv[0], 0), " STMT N", 0); 3823 return TCL_ERROR; 3824 } 3825 3826 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3827 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3828 3829 rc = sqlite3_bind_null(pStmt, idx); 3830 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3831 if( rc!=SQLITE_OK ){ 3832 return TCL_ERROR; 3833 } 3834 3835 return TCL_OK; 3836 } 3837 3838 /* 3839 ** Usage: sqlite3_bind_text STMT N STRING BYTES 3840 ** 3841 ** Test the sqlite3_bind_text interface. STMT is a prepared statement. 3842 ** N is the index of a wildcard in the prepared statement. This command 3843 ** binds a UTF-8 string STRING to the wildcard. The string is BYTES bytes 3844 ** long. 3845 */ 3846 static int SQLITE_TCLAPI test_bind_text( 3847 void * clientData, 3848 Tcl_Interp *interp, 3849 int objc, 3850 Tcl_Obj *CONST objv[] 3851 ){ 3852 sqlite3_stmt *pStmt; 3853 int idx; 3854 int bytes; 3855 char *value; 3856 int rc; 3857 3858 if( objc!=5 ){ 3859 Tcl_AppendResult(interp, "wrong # args: should be \"", 3860 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE BYTES", 0); 3861 return TCL_ERROR; 3862 } 3863 3864 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3865 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3866 value = (char*)Tcl_GetByteArrayFromObj(objv[3], &bytes); 3867 if( Tcl_GetIntFromObj(interp, objv[4], &bytes) ) return TCL_ERROR; 3868 3869 rc = sqlite3_bind_text(pStmt, idx, value, bytes, SQLITE_TRANSIENT); 3870 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3871 if( rc!=SQLITE_OK ){ 3872 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0); 3873 return TCL_ERROR; 3874 } 3875 3876 return TCL_OK; 3877 } 3878 3879 /* 3880 ** Usage: sqlite3_bind_text16 ?-static? STMT N STRING BYTES 3881 ** 3882 ** Test the sqlite3_bind_text16 interface. STMT is a prepared statement. 3883 ** N is the index of a wildcard in the prepared statement. This command 3884 ** binds a UTF-16 string STRING to the wildcard. The string is BYTES bytes 3885 ** long. 3886 */ 3887 static int SQLITE_TCLAPI test_bind_text16( 3888 void * clientData, 3889 Tcl_Interp *interp, 3890 int objc, 3891 Tcl_Obj *CONST objv[] 3892 ){ 3893 #ifndef SQLITE_OMIT_UTF16 3894 sqlite3_stmt *pStmt; 3895 int idx; 3896 int bytes; 3897 char *value; 3898 int rc; 3899 3900 void (*xDel)(void*) = (objc==6?SQLITE_STATIC:SQLITE_TRANSIENT); 3901 Tcl_Obj *oStmt = objv[objc-4]; 3902 Tcl_Obj *oN = objv[objc-3]; 3903 Tcl_Obj *oString = objv[objc-2]; 3904 Tcl_Obj *oBytes = objv[objc-1]; 3905 3906 if( objc!=5 && objc!=6){ 3907 Tcl_AppendResult(interp, "wrong # args: should be \"", 3908 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE BYTES", 0); 3909 return TCL_ERROR; 3910 } 3911 3912 if( getStmtPointer(interp, Tcl_GetString(oStmt), &pStmt) ) return TCL_ERROR; 3913 if( Tcl_GetIntFromObj(interp, oN, &idx) ) return TCL_ERROR; 3914 value = (char*)Tcl_GetByteArrayFromObj(oString, 0); 3915 if( Tcl_GetIntFromObj(interp, oBytes, &bytes) ) return TCL_ERROR; 3916 3917 rc = sqlite3_bind_text16(pStmt, idx, (void *)value, bytes, xDel); 3918 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3919 if( rc!=SQLITE_OK ){ 3920 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0); 3921 return TCL_ERROR; 3922 } 3923 3924 #endif /* SQLITE_OMIT_UTF16 */ 3925 return TCL_OK; 3926 } 3927 3928 /* 3929 ** Usage: sqlite3_bind_blob ?-static? STMT N DATA BYTES 3930 ** 3931 ** Test the sqlite3_bind_blob interface. STMT is a prepared statement. 3932 ** N is the index of a wildcard in the prepared statement. This command 3933 ** binds a BLOB to the wildcard. The BLOB is BYTES bytes in size. 3934 */ 3935 static int SQLITE_TCLAPI test_bind_blob( 3936 void * clientData, 3937 Tcl_Interp *interp, 3938 int objc, 3939 Tcl_Obj *CONST objv[] 3940 ){ 3941 sqlite3_stmt *pStmt; 3942 int len, idx; 3943 int bytes; 3944 char *value; 3945 int rc; 3946 sqlite3_destructor_type xDestructor = SQLITE_TRANSIENT; 3947 3948 if( objc!=5 && objc!=6 ){ 3949 Tcl_AppendResult(interp, "wrong # args: should be \"", 3950 Tcl_GetStringFromObj(objv[0], 0), " STMT N DATA BYTES", 0); 3951 return TCL_ERROR; 3952 } 3953 3954 if( objc==6 ){ 3955 xDestructor = SQLITE_STATIC; 3956 objv++; 3957 } 3958 3959 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3960 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3961 3962 value = (char*)Tcl_GetByteArrayFromObj(objv[3], &len); 3963 if( Tcl_GetIntFromObj(interp, objv[4], &bytes) ) return TCL_ERROR; 3964 3965 if( bytes>len ){ 3966 char zBuf[200]; 3967 sqlite3_snprintf(sizeof(zBuf), zBuf, 3968 "cannot use %d blob bytes, have %d", bytes, len); 3969 Tcl_AppendResult(interp, zBuf, -1); 3970 return TCL_ERROR; 3971 } 3972 3973 rc = sqlite3_bind_blob(pStmt, idx, value, bytes, xDestructor); 3974 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3975 if( rc!=SQLITE_OK ){ 3976 return TCL_ERROR; 3977 } 3978 3979 return TCL_OK; 3980 } 3981 3982 /* 3983 ** Usage: sqlite3_bind_parameter_count STMT 3984 ** 3985 ** Return the number of wildcards in the given statement. 3986 */ 3987 static int SQLITE_TCLAPI test_bind_parameter_count( 3988 void * clientData, 3989 Tcl_Interp *interp, 3990 int objc, 3991 Tcl_Obj *CONST objv[] 3992 ){ 3993 sqlite3_stmt *pStmt; 3994 3995 if( objc!=2 ){ 3996 Tcl_WrongNumArgs(interp, 1, objv, "STMT"); 3997 return TCL_ERROR; 3998 } 3999 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4000 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_bind_parameter_count(pStmt))); 4001 return TCL_OK; 4002 } 4003 4004 /* 4005 ** Usage: sqlite3_bind_parameter_name STMT N 4006 ** 4007 ** Return the name of the Nth wildcard. The first wildcard is 1. 4008 ** An empty string is returned if N is out of range or if the wildcard 4009 ** is nameless. 4010 */ 4011 static int SQLITE_TCLAPI test_bind_parameter_name( 4012 void * clientData, 4013 Tcl_Interp *interp, 4014 int objc, 4015 Tcl_Obj *CONST objv[] 4016 ){ 4017 sqlite3_stmt *pStmt; 4018 int i; 4019 4020 if( objc!=3 ){ 4021 Tcl_WrongNumArgs(interp, 1, objv, "STMT N"); 4022 return TCL_ERROR; 4023 } 4024 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4025 if( Tcl_GetIntFromObj(interp, objv[2], &i) ) return TCL_ERROR; 4026 Tcl_SetObjResult(interp, 4027 Tcl_NewStringObj(sqlite3_bind_parameter_name(pStmt,i),-1) 4028 ); 4029 return TCL_OK; 4030 } 4031 4032 /* 4033 ** Usage: sqlite3_bind_parameter_index STMT NAME 4034 ** 4035 ** Return the index of the wildcard called NAME. Return 0 if there is 4036 ** no such wildcard. 4037 */ 4038 static int SQLITE_TCLAPI test_bind_parameter_index( 4039 void * clientData, 4040 Tcl_Interp *interp, 4041 int objc, 4042 Tcl_Obj *CONST objv[] 4043 ){ 4044 sqlite3_stmt *pStmt; 4045 4046 if( objc!=3 ){ 4047 Tcl_WrongNumArgs(interp, 1, objv, "STMT NAME"); 4048 return TCL_ERROR; 4049 } 4050 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4051 Tcl_SetObjResult(interp, 4052 Tcl_NewIntObj( 4053 sqlite3_bind_parameter_index(pStmt,Tcl_GetString(objv[2])) 4054 ) 4055 ); 4056 return TCL_OK; 4057 } 4058 4059 /* 4060 ** Usage: sqlite3_clear_bindings STMT 4061 ** 4062 */ 4063 static int SQLITE_TCLAPI test_clear_bindings( 4064 void * clientData, 4065 Tcl_Interp *interp, 4066 int objc, 4067 Tcl_Obj *CONST objv[] 4068 ){ 4069 sqlite3_stmt *pStmt; 4070 4071 if( objc!=2 ){ 4072 Tcl_WrongNumArgs(interp, 1, objv, "STMT"); 4073 return TCL_ERROR; 4074 } 4075 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4076 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_clear_bindings(pStmt))); 4077 return TCL_OK; 4078 } 4079 4080 /* 4081 ** Usage: sqlite3_sleep MILLISECONDS 4082 */ 4083 static int SQLITE_TCLAPI test_sleep( 4084 void * clientData, 4085 Tcl_Interp *interp, 4086 int objc, 4087 Tcl_Obj *CONST objv[] 4088 ){ 4089 int ms; 4090 4091 if( objc!=2 ){ 4092 Tcl_WrongNumArgs(interp, 1, objv, "MILLISECONDS"); 4093 return TCL_ERROR; 4094 } 4095 if( Tcl_GetIntFromObj(interp, objv[1], &ms) ){ 4096 return TCL_ERROR; 4097 } 4098 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_sleep(ms))); 4099 return TCL_OK; 4100 } 4101 4102 /* 4103 ** Usage: sqlite3_extended_errcode DB 4104 ** 4105 ** Return the string representation of the most recent sqlite3_* API 4106 ** error code. e.g. "SQLITE_ERROR". 4107 */ 4108 static int SQLITE_TCLAPI test_ex_errcode( 4109 void * clientData, 4110 Tcl_Interp *interp, 4111 int objc, 4112 Tcl_Obj *CONST objv[] 4113 ){ 4114 sqlite3 *db; 4115 int rc; 4116 4117 if( objc!=2 ){ 4118 Tcl_AppendResult(interp, "wrong # args: should be \"", 4119 Tcl_GetString(objv[0]), " DB", 0); 4120 return TCL_ERROR; 4121 } 4122 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4123 rc = sqlite3_extended_errcode(db); 4124 Tcl_AppendResult(interp, (char *)t1ErrorName(rc), 0); 4125 return TCL_OK; 4126 } 4127 4128 4129 /* 4130 ** Usage: sqlite3_errcode DB 4131 ** 4132 ** Return the string representation of the most recent sqlite3_* API 4133 ** error code. e.g. "SQLITE_ERROR". 4134 */ 4135 static int SQLITE_TCLAPI test_errcode( 4136 void * clientData, 4137 Tcl_Interp *interp, 4138 int objc, 4139 Tcl_Obj *CONST objv[] 4140 ){ 4141 sqlite3 *db; 4142 int rc; 4143 4144 if( objc!=2 ){ 4145 Tcl_AppendResult(interp, "wrong # args: should be \"", 4146 Tcl_GetString(objv[0]), " DB", 0); 4147 return TCL_ERROR; 4148 } 4149 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4150 rc = sqlite3_errcode(db); 4151 Tcl_AppendResult(interp, (char *)t1ErrorName(rc), 0); 4152 return TCL_OK; 4153 } 4154 4155 /* 4156 ** Usage: sqlite3_errmsg DB 4157 ** 4158 ** Returns the UTF-8 representation of the error message string for the 4159 ** most recent sqlite3_* API call. 4160 */ 4161 static int SQLITE_TCLAPI test_errmsg( 4162 void * clientData, 4163 Tcl_Interp *interp, 4164 int objc, 4165 Tcl_Obj *CONST objv[] 4166 ){ 4167 sqlite3 *db; 4168 const char *zErr; 4169 4170 if( objc!=2 ){ 4171 Tcl_AppendResult(interp, "wrong # args: should be \"", 4172 Tcl_GetString(objv[0]), " DB", 0); 4173 return TCL_ERROR; 4174 } 4175 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4176 4177 zErr = sqlite3_errmsg(db); 4178 Tcl_SetObjResult(interp, Tcl_NewStringObj(zErr, -1)); 4179 return TCL_OK; 4180 } 4181 4182 /* 4183 ** Usage: test_errmsg16 DB 4184 ** 4185 ** Returns the UTF-16 representation of the error message string for the 4186 ** most recent sqlite3_* API call. This is a byte array object at the TCL 4187 ** level, and it includes the 0x00 0x00 terminator bytes at the end of the 4188 ** UTF-16 string. 4189 */ 4190 static int SQLITE_TCLAPI test_errmsg16( 4191 void * clientData, 4192 Tcl_Interp *interp, 4193 int objc, 4194 Tcl_Obj *CONST objv[] 4195 ){ 4196 #ifndef SQLITE_OMIT_UTF16 4197 sqlite3 *db; 4198 const void *zErr; 4199 const char *z; 4200 int bytes = 0; 4201 4202 if( objc!=2 ){ 4203 Tcl_AppendResult(interp, "wrong # args: should be \"", 4204 Tcl_GetString(objv[0]), " DB", 0); 4205 return TCL_ERROR; 4206 } 4207 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4208 4209 zErr = sqlite3_errmsg16(db); 4210 if( zErr ){ 4211 z = zErr; 4212 for(bytes=0; z[bytes] || z[bytes+1]; bytes+=2){} 4213 } 4214 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(zErr, bytes)); 4215 #endif /* SQLITE_OMIT_UTF16 */ 4216 return TCL_OK; 4217 } 4218 4219 /* 4220 ** Usage: sqlite3_prepare DB sql bytes ?tailvar? 4221 ** 4222 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using 4223 ** database handle <DB>. The parameter <tailval> is the name of a global 4224 ** variable that is set to the unused portion of <sql> (if any). A 4225 ** STMT handle is returned. 4226 */ 4227 static int SQLITE_TCLAPI test_prepare( 4228 void * clientData, 4229 Tcl_Interp *interp, 4230 int objc, 4231 Tcl_Obj *CONST objv[] 4232 ){ 4233 sqlite3 *db; 4234 const char *zSql; 4235 int bytes; 4236 const char *zTail = 0; 4237 sqlite3_stmt *pStmt = 0; 4238 char zBuf[50]; 4239 int rc; 4240 4241 if( objc!=5 && objc!=4 ){ 4242 Tcl_AppendResult(interp, "wrong # args: should be \"", 4243 Tcl_GetString(objv[0]), " DB sql bytes ?tailvar?", 0); 4244 return TCL_ERROR; 4245 } 4246 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4247 zSql = Tcl_GetString(objv[2]); 4248 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR; 4249 4250 rc = sqlite3_prepare(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0); 4251 Tcl_ResetResult(interp); 4252 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 4253 if( zTail && objc>=5 ){ 4254 if( bytes>=0 ){ 4255 bytes = bytes - (int)(zTail-zSql); 4256 } 4257 if( (int)strlen(zTail)<bytes ){ 4258 bytes = (int)strlen(zTail); 4259 } 4260 Tcl_ObjSetVar2(interp, objv[4], 0, Tcl_NewStringObj(zTail, bytes), 0); 4261 } 4262 if( rc!=SQLITE_OK ){ 4263 assert( pStmt==0 ); 4264 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc); 4265 Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0); 4266 return TCL_ERROR; 4267 } 4268 4269 if( pStmt ){ 4270 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 4271 Tcl_AppendResult(interp, zBuf, 0); 4272 } 4273 return TCL_OK; 4274 } 4275 4276 /* 4277 ** Usage: sqlite3_prepare_v2 DB sql bytes ?tailvar? 4278 ** 4279 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using 4280 ** database handle <DB>. The parameter <tailval> is the name of a global 4281 ** variable that is set to the unused portion of <sql> (if any). A 4282 ** STMT handle is returned. 4283 */ 4284 static int SQLITE_TCLAPI test_prepare_v2( 4285 void * clientData, 4286 Tcl_Interp *interp, 4287 int objc, 4288 Tcl_Obj *CONST objv[] 4289 ){ 4290 sqlite3 *db; 4291 const char *zSql; 4292 char *zCopy = 0; /* malloc() copy of zSql */ 4293 int bytes; 4294 const char *zTail = 0; 4295 const char **pzTail; 4296 sqlite3_stmt *pStmt = 0; 4297 char zBuf[50]; 4298 int rc; 4299 4300 if( objc!=5 && objc!=4 ){ 4301 Tcl_AppendResult(interp, "wrong # args: should be \"", 4302 Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0); 4303 return TCL_ERROR; 4304 } 4305 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4306 zSql = Tcl_GetString(objv[2]); 4307 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR; 4308 4309 /* Instead of using zSql directly, make a copy into a buffer obtained 4310 ** directly from malloc(). The idea is to make it easier for valgrind 4311 ** to spot buffer overreads. */ 4312 if( bytes>=0 ){ 4313 zCopy = malloc(bytes); 4314 memcpy(zCopy, zSql, bytes); 4315 }else{ 4316 int n = (int)strlen(zSql) + 1; 4317 zCopy = malloc(n); 4318 memcpy(zCopy, zSql, n); 4319 } 4320 pzTail = objc>=5 ? &zTail : 0; 4321 rc = sqlite3_prepare_v2(db, zCopy, bytes, &pStmt, pzTail); 4322 if( objc>=5 ){ 4323 zTail = &zSql[(zTail - zCopy)]; 4324 } 4325 free(zCopy); 4326 4327 assert(rc==SQLITE_OK || pStmt==0); 4328 Tcl_ResetResult(interp); 4329 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 4330 if( rc==SQLITE_OK && objc>=5 && zTail ){ 4331 if( bytes>=0 ){ 4332 bytes = bytes - (int)(zTail-zSql); 4333 } 4334 Tcl_ObjSetVar2(interp, objv[4], 0, Tcl_NewStringObj(zTail, bytes), 0); 4335 } 4336 if( rc!=SQLITE_OK ){ 4337 assert( pStmt==0 ); 4338 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc); 4339 Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0); 4340 return TCL_ERROR; 4341 } 4342 4343 if( pStmt ){ 4344 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 4345 Tcl_AppendResult(interp, zBuf, 0); 4346 } 4347 return TCL_OK; 4348 } 4349 4350 /* 4351 ** Usage: sqlite3_prepare_v3 DB sql bytes flags ?tailvar? 4352 ** 4353 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using 4354 ** database handle <DB> and flags <flags>. The parameter <tailval> is 4355 ** the name of a global variable that is set to the unused portion of 4356 ** <sql> (if any). A STMT handle is returned. 4357 */ 4358 static int SQLITE_TCLAPI test_prepare_v3( 4359 void * clientData, 4360 Tcl_Interp *interp, 4361 int objc, 4362 Tcl_Obj *CONST objv[] 4363 ){ 4364 sqlite3 *db; 4365 const char *zSql; 4366 char *zCopy = 0; /* malloc() copy of zSql */ 4367 int bytes, flags; 4368 const char *zTail = 0; 4369 const char **pzTail; 4370 sqlite3_stmt *pStmt = 0; 4371 char zBuf[50]; 4372 int rc; 4373 4374 if( objc!=6 && objc!=5 ){ 4375 Tcl_AppendResult(interp, "wrong # args: should be \"", 4376 Tcl_GetString(objv[0]), " DB sql bytes flags tailvar", 0); 4377 return TCL_ERROR; 4378 } 4379 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4380 zSql = Tcl_GetString(objv[2]); 4381 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR; 4382 if( Tcl_GetIntFromObj(interp, objv[4], &flags) ) return TCL_ERROR; 4383 4384 /* Instead of using zSql directly, make a copy into a buffer obtained 4385 ** directly from malloc(). The idea is to make it easier for valgrind 4386 ** to spot buffer overreads. */ 4387 if( bytes>=0 ){ 4388 zCopy = malloc(bytes); 4389 memcpy(zCopy, zSql, bytes); 4390 }else{ 4391 int n = (int)strlen(zSql) + 1; 4392 zCopy = malloc(n); 4393 memcpy(zCopy, zSql, n); 4394 } 4395 pzTail = objc>=6 ? &zTail : 0; 4396 rc = sqlite3_prepare_v3(db, zCopy, bytes, (unsigned int)flags,&pStmt,pzTail); 4397 free(zCopy); 4398 zTail = &zSql[(zTail - zCopy)]; 4399 4400 assert(rc==SQLITE_OK || pStmt==0); 4401 Tcl_ResetResult(interp); 4402 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 4403 if( rc==SQLITE_OK && zTail && objc>=6 ){ 4404 if( bytes>=0 ){ 4405 bytes = bytes - (int)(zTail-zSql); 4406 } 4407 Tcl_ObjSetVar2(interp, objv[5], 0, Tcl_NewStringObj(zTail, bytes), 0); 4408 } 4409 if( rc!=SQLITE_OK ){ 4410 assert( pStmt==0 ); 4411 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc); 4412 Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0); 4413 return TCL_ERROR; 4414 } 4415 4416 if( pStmt ){ 4417 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 4418 Tcl_AppendResult(interp, zBuf, 0); 4419 } 4420 return TCL_OK; 4421 } 4422 4423 /* 4424 ** Usage: sqlite3_prepare_tkt3134 DB 4425 ** 4426 ** Generate a prepared statement for a zero-byte string as a test 4427 ** for ticket #3134. The string should be preceded by a zero byte. 4428 */ 4429 static int SQLITE_TCLAPI test_prepare_tkt3134( 4430 void * clientData, 4431 Tcl_Interp *interp, 4432 int objc, 4433 Tcl_Obj *CONST objv[] 4434 ){ 4435 sqlite3 *db; 4436 static const char zSql[] = "\000SELECT 1"; 4437 sqlite3_stmt *pStmt = 0; 4438 char zBuf[50]; 4439 int rc; 4440 4441 if( objc!=2 ){ 4442 Tcl_AppendResult(interp, "wrong # args: should be \"", 4443 Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0); 4444 return TCL_ERROR; 4445 } 4446 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4447 rc = sqlite3_prepare_v2(db, &zSql[1], 0, &pStmt, 0); 4448 assert(rc==SQLITE_OK || pStmt==0); 4449 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 4450 if( rc!=SQLITE_OK ){ 4451 assert( pStmt==0 ); 4452 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc); 4453 Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0); 4454 return TCL_ERROR; 4455 } 4456 4457 if( pStmt ){ 4458 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 4459 Tcl_AppendResult(interp, zBuf, 0); 4460 } 4461 return TCL_OK; 4462 } 4463 4464 /* 4465 ** Usage: sqlite3_prepare16 DB sql bytes tailvar 4466 ** 4467 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using 4468 ** database handle <DB>. The parameter <tailval> is the name of a global 4469 ** variable that is set to the unused portion of <sql> (if any). A 4470 ** STMT handle is returned. 4471 */ 4472 static int SQLITE_TCLAPI test_prepare16( 4473 void * clientData, 4474 Tcl_Interp *interp, 4475 int objc, 4476 Tcl_Obj *CONST objv[] 4477 ){ 4478 #ifndef SQLITE_OMIT_UTF16 4479 sqlite3 *db; 4480 const void *zSql; 4481 const void *zTail = 0; 4482 Tcl_Obj *pTail = 0; 4483 sqlite3_stmt *pStmt = 0; 4484 char zBuf[50]; 4485 int rc; 4486 int bytes; /* The integer specified as arg 3 */ 4487 int objlen; /* The byte-array length of arg 2 */ 4488 4489 if( objc!=5 && objc!=4 ){ 4490 Tcl_AppendResult(interp, "wrong # args: should be \"", 4491 Tcl_GetString(objv[0]), " DB sql bytes ?tailvar?", 0); 4492 return TCL_ERROR; 4493 } 4494 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4495 zSql = Tcl_GetByteArrayFromObj(objv[2], &objlen); 4496 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR; 4497 4498 rc = sqlite3_prepare16(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0); 4499 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 4500 if( rc ){ 4501 return TCL_ERROR; 4502 } 4503 4504 if( objc>=5 ){ 4505 if( zTail ){ 4506 objlen = objlen - (int)((u8 *)zTail-(u8 *)zSql); 4507 }else{ 4508 objlen = 0; 4509 } 4510 pTail = Tcl_NewByteArrayObj((u8 *)zTail, objlen); 4511 Tcl_IncrRefCount(pTail); 4512 Tcl_ObjSetVar2(interp, objv[4], 0, pTail, 0); 4513 Tcl_DecrRefCount(pTail); 4514 } 4515 4516 if( pStmt ){ 4517 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 4518 } 4519 Tcl_AppendResult(interp, zBuf, 0); 4520 #endif /* SQLITE_OMIT_UTF16 */ 4521 return TCL_OK; 4522 } 4523 4524 /* 4525 ** Usage: sqlite3_prepare16_v2 DB sql bytes ?tailvar? 4526 ** 4527 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using 4528 ** database handle <DB>. The parameter <tailval> is the name of a global 4529 ** variable that is set to the unused portion of <sql> (if any). A 4530 ** STMT handle is returned. 4531 */ 4532 static int SQLITE_TCLAPI test_prepare16_v2( 4533 void * clientData, 4534 Tcl_Interp *interp, 4535 int objc, 4536 Tcl_Obj *CONST objv[] 4537 ){ 4538 #ifndef SQLITE_OMIT_UTF16 4539 sqlite3 *db; 4540 const void *zSql; 4541 const void *zTail = 0; 4542 Tcl_Obj *pTail = 0; 4543 sqlite3_stmt *pStmt = 0; 4544 char zBuf[50]; 4545 int rc; 4546 int bytes; /* The integer specified as arg 3 */ 4547 int objlen; /* The byte-array length of arg 2 */ 4548 4549 if( objc!=5 && objc!=4 ){ 4550 Tcl_AppendResult(interp, "wrong # args: should be \"", 4551 Tcl_GetString(objv[0]), " DB sql bytes ?tailvar?", 0); 4552 return TCL_ERROR; 4553 } 4554 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4555 zSql = Tcl_GetByteArrayFromObj(objv[2], &objlen); 4556 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR; 4557 4558 rc = sqlite3_prepare16_v2(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0); 4559 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 4560 if( rc ){ 4561 return TCL_ERROR; 4562 } 4563 4564 if( objc>=5 ){ 4565 if( zTail ){ 4566 objlen = objlen - (int)((u8 *)zTail-(u8 *)zSql); 4567 }else{ 4568 objlen = 0; 4569 } 4570 pTail = Tcl_NewByteArrayObj((u8 *)zTail, objlen); 4571 Tcl_IncrRefCount(pTail); 4572 Tcl_ObjSetVar2(interp, objv[4], 0, pTail, 0); 4573 Tcl_DecrRefCount(pTail); 4574 } 4575 4576 if( pStmt ){ 4577 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 4578 } 4579 Tcl_AppendResult(interp, zBuf, 0); 4580 #endif /* SQLITE_OMIT_UTF16 */ 4581 return TCL_OK; 4582 } 4583 4584 /* 4585 ** Usage: sqlite3_open filename ?options-list? 4586 */ 4587 static int SQLITE_TCLAPI test_open( 4588 void * clientData, 4589 Tcl_Interp *interp, 4590 int objc, 4591 Tcl_Obj *CONST objv[] 4592 ){ 4593 const char *zFilename; 4594 sqlite3 *db; 4595 char zBuf[100]; 4596 4597 if( objc!=3 && objc!=2 && objc!=1 ){ 4598 Tcl_AppendResult(interp, "wrong # args: should be \"", 4599 Tcl_GetString(objv[0]), " filename options-list", 0); 4600 return TCL_ERROR; 4601 } 4602 4603 zFilename = objc>1 ? Tcl_GetString(objv[1]) : 0; 4604 sqlite3_open(zFilename, &db); 4605 4606 if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR; 4607 Tcl_AppendResult(interp, zBuf, 0); 4608 return TCL_OK; 4609 } 4610 4611 /* 4612 ** Usage: sqlite3_open_v2 FILENAME FLAGS VFS 4613 */ 4614 static int SQLITE_TCLAPI test_open_v2( 4615 void * clientData, 4616 Tcl_Interp *interp, 4617 int objc, 4618 Tcl_Obj *CONST objv[] 4619 ){ 4620 const char *zFilename; 4621 const char *zVfs; 4622 int flags = 0; 4623 sqlite3 *db; 4624 int rc; 4625 char zBuf[100]; 4626 4627 int nFlag; 4628 Tcl_Obj **apFlag; 4629 int i; 4630 4631 if( objc!=4 ){ 4632 Tcl_WrongNumArgs(interp, 1, objv, "FILENAME FLAGS VFS"); 4633 return TCL_ERROR; 4634 } 4635 zFilename = Tcl_GetString(objv[1]); 4636 zVfs = Tcl_GetString(objv[3]); 4637 if( zVfs[0]==0x00 ) zVfs = 0; 4638 4639 rc = Tcl_ListObjGetElements(interp, objv[2], &nFlag, &apFlag); 4640 if( rc!=TCL_OK ) return rc; 4641 for(i=0; i<nFlag; i++){ 4642 int iFlag; 4643 struct OpenFlag { 4644 const char *zFlag; 4645 int flag; 4646 } aFlag[] = { 4647 { "SQLITE_OPEN_READONLY", SQLITE_OPEN_READONLY }, 4648 { "SQLITE_OPEN_READWRITE", SQLITE_OPEN_READWRITE }, 4649 { "SQLITE_OPEN_CREATE", SQLITE_OPEN_CREATE }, 4650 { "SQLITE_OPEN_DELETEONCLOSE", SQLITE_OPEN_DELETEONCLOSE }, 4651 { "SQLITE_OPEN_EXCLUSIVE", SQLITE_OPEN_EXCLUSIVE }, 4652 { "SQLITE_OPEN_AUTOPROXY", SQLITE_OPEN_AUTOPROXY }, 4653 { "SQLITE_OPEN_MAIN_DB", SQLITE_OPEN_MAIN_DB }, 4654 { "SQLITE_OPEN_TEMP_DB", SQLITE_OPEN_TEMP_DB }, 4655 { "SQLITE_OPEN_TRANSIENT_DB", SQLITE_OPEN_TRANSIENT_DB }, 4656 { "SQLITE_OPEN_MAIN_JOURNAL", SQLITE_OPEN_MAIN_JOURNAL }, 4657 { "SQLITE_OPEN_TEMP_JOURNAL", SQLITE_OPEN_TEMP_JOURNAL }, 4658 { "SQLITE_OPEN_SUBJOURNAL", SQLITE_OPEN_SUBJOURNAL }, 4659 { "SQLITE_OPEN_MASTER_JOURNAL", SQLITE_OPEN_MASTER_JOURNAL }, 4660 { "SQLITE_OPEN_NOMUTEX", SQLITE_OPEN_NOMUTEX }, 4661 { "SQLITE_OPEN_FULLMUTEX", SQLITE_OPEN_FULLMUTEX }, 4662 { "SQLITE_OPEN_SHAREDCACHE", SQLITE_OPEN_SHAREDCACHE }, 4663 { "SQLITE_OPEN_PRIVATECACHE", SQLITE_OPEN_PRIVATECACHE }, 4664 { "SQLITE_OPEN_WAL", SQLITE_OPEN_WAL }, 4665 { "SQLITE_OPEN_URI", SQLITE_OPEN_URI }, 4666 { 0, 0 } 4667 }; 4668 rc = Tcl_GetIndexFromObjStruct(interp, apFlag[i], aFlag, sizeof(aFlag[0]), 4669 "flag", 0, &iFlag 4670 ); 4671 if( rc!=TCL_OK ) return rc; 4672 flags |= aFlag[iFlag].flag; 4673 } 4674 4675 rc = sqlite3_open_v2(zFilename, &db, flags, zVfs); 4676 if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR; 4677 Tcl_AppendResult(interp, zBuf, 0); 4678 return TCL_OK; 4679 } 4680 4681 /* 4682 ** Usage: sqlite3_open16 filename options 4683 */ 4684 static int SQLITE_TCLAPI test_open16( 4685 void * clientData, 4686 Tcl_Interp *interp, 4687 int objc, 4688 Tcl_Obj *CONST objv[] 4689 ){ 4690 #ifndef SQLITE_OMIT_UTF16 4691 const void *zFilename; 4692 sqlite3 *db; 4693 char zBuf[100]; 4694 4695 if( objc!=3 ){ 4696 Tcl_AppendResult(interp, "wrong # args: should be \"", 4697 Tcl_GetString(objv[0]), " filename options-list", 0); 4698 return TCL_ERROR; 4699 } 4700 4701 zFilename = Tcl_GetByteArrayFromObj(objv[1], 0); 4702 sqlite3_open16(zFilename, &db); 4703 4704 if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR; 4705 Tcl_AppendResult(interp, zBuf, 0); 4706 #endif /* SQLITE_OMIT_UTF16 */ 4707 return TCL_OK; 4708 } 4709 4710 /* 4711 ** Usage: sqlite3_complete16 <UTF-16 string> 4712 ** 4713 ** Return 1 if the supplied argument is a complete SQL statement, or zero 4714 ** otherwise. 4715 */ 4716 static int SQLITE_TCLAPI test_complete16( 4717 void * clientData, 4718 Tcl_Interp *interp, 4719 int objc, 4720 Tcl_Obj *CONST objv[] 4721 ){ 4722 #if !defined(SQLITE_OMIT_COMPLETE) && !defined(SQLITE_OMIT_UTF16) 4723 char *zBuf; 4724 4725 if( objc!=2 ){ 4726 Tcl_WrongNumArgs(interp, 1, objv, "<utf-16 sql>"); 4727 return TCL_ERROR; 4728 } 4729 4730 zBuf = (char*)Tcl_GetByteArrayFromObj(objv[1], 0); 4731 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_complete16(zBuf))); 4732 #endif /* SQLITE_OMIT_COMPLETE && SQLITE_OMIT_UTF16 */ 4733 return TCL_OK; 4734 } 4735 4736 /* 4737 ** Usage: sqlite3_normalize SQL 4738 ** 4739 ** Return the normalized value for an SQL statement. 4740 */ 4741 static int SQLITE_TCLAPI test_normalize( 4742 void * clientData, 4743 Tcl_Interp *interp, 4744 int objc, 4745 Tcl_Obj *CONST objv[] 4746 ){ 4747 char *zSql; 4748 char *zNorm; 4749 extern char *sqlite3_normalize(const char*); 4750 4751 if( objc!=2 ){ 4752 Tcl_WrongNumArgs(interp, 1, objv, "SQL"); 4753 return TCL_ERROR; 4754 } 4755 4756 zSql = (char*)Tcl_GetString(objv[1]); 4757 zNorm = sqlite3_normalize(zSql); 4758 if( zNorm ){ 4759 Tcl_SetObjResult(interp, Tcl_NewStringObj(zNorm, -1)); 4760 sqlite3_free(zNorm); 4761 } 4762 return TCL_OK; 4763 } 4764 4765 /* 4766 ** Usage: sqlite3_step STMT 4767 ** 4768 ** Advance the statement to the next row. 4769 */ 4770 static int SQLITE_TCLAPI test_step( 4771 void * clientData, 4772 Tcl_Interp *interp, 4773 int objc, 4774 Tcl_Obj *CONST objv[] 4775 ){ 4776 sqlite3_stmt *pStmt; 4777 int rc; 4778 4779 if( objc!=2 ){ 4780 Tcl_AppendResult(interp, "wrong # args: should be \"", 4781 Tcl_GetString(objv[0]), " STMT", 0); 4782 return TCL_ERROR; 4783 } 4784 4785 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4786 rc = sqlite3_step(pStmt); 4787 4788 /* if( rc!=SQLITE_DONE && rc!=SQLITE_ROW ) return TCL_ERROR; */ 4789 Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0); 4790 return TCL_OK; 4791 } 4792 4793 static int SQLITE_TCLAPI test_sql( 4794 void * clientData, 4795 Tcl_Interp *interp, 4796 int objc, 4797 Tcl_Obj *CONST objv[] 4798 ){ 4799 sqlite3_stmt *pStmt; 4800 4801 if( objc!=2 ){ 4802 Tcl_WrongNumArgs(interp, 1, objv, "STMT"); 4803 return TCL_ERROR; 4804 } 4805 4806 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4807 Tcl_SetResult(interp, (char *)sqlite3_sql(pStmt), TCL_VOLATILE); 4808 return TCL_OK; 4809 } 4810 static int SQLITE_TCLAPI test_ex_sql( 4811 void * clientData, 4812 Tcl_Interp *interp, 4813 int objc, 4814 Tcl_Obj *CONST objv[] 4815 ){ 4816 sqlite3_stmt *pStmt; 4817 char *z; 4818 4819 if( objc!=2 ){ 4820 Tcl_WrongNumArgs(interp, 1, objv, "STMT"); 4821 return TCL_ERROR; 4822 } 4823 4824 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4825 z = sqlite3_expanded_sql(pStmt); 4826 Tcl_SetResult(interp, z, TCL_VOLATILE); 4827 sqlite3_free(z); 4828 return TCL_OK; 4829 } 4830 #ifdef SQLITE_ENABLE_NORMALIZE 4831 static int SQLITE_TCLAPI test_norm_sql( 4832 void * clientData, 4833 Tcl_Interp *interp, 4834 int objc, 4835 Tcl_Obj *CONST objv[] 4836 ){ 4837 sqlite3_stmt *pStmt; 4838 4839 if( objc!=2 ){ 4840 Tcl_WrongNumArgs(interp, 1, objv, "STMT"); 4841 return TCL_ERROR; 4842 } 4843 4844 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4845 Tcl_SetResult(interp, (char *)sqlite3_normalized_sql(pStmt), TCL_VOLATILE); 4846 return TCL_OK; 4847 } 4848 #endif /* SQLITE_ENABLE_NORMALIZE */ 4849 4850 /* 4851 ** Usage: sqlite3_column_count STMT 4852 ** 4853 ** Return the number of columns returned by the sql statement STMT. 4854 */ 4855 static int SQLITE_TCLAPI test_column_count( 4856 void * clientData, 4857 Tcl_Interp *interp, 4858 int objc, 4859 Tcl_Obj *CONST objv[] 4860 ){ 4861 sqlite3_stmt *pStmt; 4862 4863 if( objc!=2 ){ 4864 Tcl_AppendResult(interp, "wrong # args: should be \"", 4865 Tcl_GetString(objv[0]), " STMT column", 0); 4866 return TCL_ERROR; 4867 } 4868 4869 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4870 4871 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_column_count(pStmt))); 4872 return TCL_OK; 4873 } 4874 4875 /* 4876 ** Usage: sqlite3_column_type STMT column 4877 ** 4878 ** Return the type of the data in column 'column' of the current row. 4879 */ 4880 static int SQLITE_TCLAPI test_column_type( 4881 void * clientData, 4882 Tcl_Interp *interp, 4883 int objc, 4884 Tcl_Obj *CONST objv[] 4885 ){ 4886 sqlite3_stmt *pStmt; 4887 int col; 4888 int tp; 4889 4890 if( objc!=3 ){ 4891 Tcl_AppendResult(interp, "wrong # args: should be \"", 4892 Tcl_GetString(objv[0]), " STMT column", 0); 4893 return TCL_ERROR; 4894 } 4895 4896 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4897 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 4898 4899 tp = sqlite3_column_type(pStmt, col); 4900 switch( tp ){ 4901 case SQLITE_INTEGER: 4902 Tcl_SetResult(interp, "INTEGER", TCL_STATIC); 4903 break; 4904 case SQLITE_NULL: 4905 Tcl_SetResult(interp, "NULL", TCL_STATIC); 4906 break; 4907 case SQLITE_FLOAT: 4908 Tcl_SetResult(interp, "FLOAT", TCL_STATIC); 4909 break; 4910 case SQLITE_TEXT: 4911 Tcl_SetResult(interp, "TEXT", TCL_STATIC); 4912 break; 4913 case SQLITE_BLOB: 4914 Tcl_SetResult(interp, "BLOB", TCL_STATIC); 4915 break; 4916 default: 4917 assert(0); 4918 } 4919 4920 return TCL_OK; 4921 } 4922 4923 /* 4924 ** Usage: sqlite3_column_int64 STMT column 4925 ** 4926 ** Return the data in column 'column' of the current row cast as an 4927 ** wide (64-bit) integer. 4928 */ 4929 static int SQLITE_TCLAPI test_column_int64( 4930 void * clientData, 4931 Tcl_Interp *interp, 4932 int objc, 4933 Tcl_Obj *CONST objv[] 4934 ){ 4935 sqlite3_stmt *pStmt; 4936 int col; 4937 i64 iVal; 4938 4939 if( objc!=3 ){ 4940 Tcl_AppendResult(interp, "wrong # args: should be \"", 4941 Tcl_GetString(objv[0]), " STMT column", 0); 4942 return TCL_ERROR; 4943 } 4944 4945 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4946 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 4947 4948 iVal = sqlite3_column_int64(pStmt, col); 4949 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(iVal)); 4950 return TCL_OK; 4951 } 4952 4953 /* 4954 ** Usage: sqlite3_column_blob STMT column 4955 */ 4956 static int SQLITE_TCLAPI test_column_blob( 4957 void * clientData, 4958 Tcl_Interp *interp, 4959 int objc, 4960 Tcl_Obj *CONST objv[] 4961 ){ 4962 sqlite3_stmt *pStmt; 4963 int col; 4964 4965 int len; 4966 const void *pBlob; 4967 4968 if( objc!=3 ){ 4969 Tcl_AppendResult(interp, "wrong # args: should be \"", 4970 Tcl_GetString(objv[0]), " STMT column", 0); 4971 return TCL_ERROR; 4972 } 4973 4974 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4975 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 4976 4977 len = sqlite3_column_bytes(pStmt, col); 4978 pBlob = sqlite3_column_blob(pStmt, col); 4979 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pBlob, len)); 4980 return TCL_OK; 4981 } 4982 4983 /* 4984 ** Usage: sqlite3_column_double STMT column 4985 ** 4986 ** Return the data in column 'column' of the current row cast as a double. 4987 */ 4988 static int SQLITE_TCLAPI test_column_double( 4989 void * clientData, 4990 Tcl_Interp *interp, 4991 int objc, 4992 Tcl_Obj *CONST objv[] 4993 ){ 4994 sqlite3_stmt *pStmt; 4995 int col; 4996 double rVal; 4997 4998 if( objc!=3 ){ 4999 Tcl_AppendResult(interp, "wrong # args: should be \"", 5000 Tcl_GetString(objv[0]), " STMT column", 0); 5001 return TCL_ERROR; 5002 } 5003 5004 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 5005 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 5006 5007 rVal = sqlite3_column_double(pStmt, col); 5008 Tcl_SetObjResult(interp, Tcl_NewDoubleObj(rVal)); 5009 return TCL_OK; 5010 } 5011 5012 /* 5013 ** Usage: sqlite3_data_count STMT 5014 ** 5015 ** Return the number of columns returned by the sql statement STMT. 5016 */ 5017 static int SQLITE_TCLAPI test_data_count( 5018 void * clientData, 5019 Tcl_Interp *interp, 5020 int objc, 5021 Tcl_Obj *CONST objv[] 5022 ){ 5023 sqlite3_stmt *pStmt; 5024 5025 if( objc!=2 ){ 5026 Tcl_AppendResult(interp, "wrong # args: should be \"", 5027 Tcl_GetString(objv[0]), " STMT column", 0); 5028 return TCL_ERROR; 5029 } 5030 5031 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 5032 5033 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_data_count(pStmt))); 5034 return TCL_OK; 5035 } 5036 5037 /* 5038 ** Usage: sqlite3_column_text STMT column 5039 ** 5040 ** Usage: sqlite3_column_decltype STMT column 5041 ** 5042 ** Usage: sqlite3_column_name STMT column 5043 */ 5044 static int SQLITE_TCLAPI test_stmt_utf8( 5045 void * clientData, /* Pointer to SQLite API function to be invoke */ 5046 Tcl_Interp *interp, 5047 int objc, 5048 Tcl_Obj *CONST objv[] 5049 ){ 5050 sqlite3_stmt *pStmt; 5051 int col; 5052 const char *(*xFunc)(sqlite3_stmt*, int); 5053 const char *zRet; 5054 5055 xFunc = (const char *(*)(sqlite3_stmt*, int))clientData; 5056 if( objc!=3 ){ 5057 Tcl_AppendResult(interp, "wrong # args: should be \"", 5058 Tcl_GetString(objv[0]), " STMT column", 0); 5059 return TCL_ERROR; 5060 } 5061 5062 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 5063 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 5064 zRet = xFunc(pStmt, col); 5065 if( zRet ){ 5066 Tcl_SetResult(interp, (char *)zRet, 0); 5067 } 5068 return TCL_OK; 5069 } 5070 5071 static int SQLITE_TCLAPI test_global_recover( 5072 void * clientData, 5073 Tcl_Interp *interp, 5074 int objc, 5075 Tcl_Obj *CONST objv[] 5076 ){ 5077 #ifndef SQLITE_OMIT_DEPRECATED 5078 int rc; 5079 if( objc!=1 ){ 5080 Tcl_WrongNumArgs(interp, 1, objv, ""); 5081 return TCL_ERROR; 5082 } 5083 rc = sqlite3_global_recover(); 5084 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 5085 #endif 5086 return TCL_OK; 5087 } 5088 5089 /* 5090 ** Usage: sqlite3_column_text STMT column 5091 ** 5092 ** Usage: sqlite3_column_decltype STMT column 5093 ** 5094 ** Usage: sqlite3_column_name STMT column 5095 */ 5096 static int SQLITE_TCLAPI test_stmt_utf16( 5097 void * clientData, /* Pointer to SQLite API function to be invoked */ 5098 Tcl_Interp *interp, 5099 int objc, 5100 Tcl_Obj *CONST objv[] 5101 ){ 5102 #ifndef SQLITE_OMIT_UTF16 5103 sqlite3_stmt *pStmt; 5104 int col; 5105 Tcl_Obj *pRet; 5106 const void *zName16; 5107 const void *(*xFunc)(sqlite3_stmt*, int); 5108 5109 xFunc = (const void *(*)(sqlite3_stmt*, int))clientData; 5110 if( objc!=3 ){ 5111 Tcl_AppendResult(interp, "wrong # args: should be \"", 5112 Tcl_GetString(objv[0]), " STMT column", 0); 5113 return TCL_ERROR; 5114 } 5115 5116 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 5117 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 5118 5119 zName16 = xFunc(pStmt, col); 5120 if( zName16 ){ 5121 int n; 5122 const char *z = zName16; 5123 for(n=0; z[n] || z[n+1]; n+=2){} 5124 pRet = Tcl_NewByteArrayObj(zName16, n+2); 5125 Tcl_SetObjResult(interp, pRet); 5126 } 5127 #endif /* SQLITE_OMIT_UTF16 */ 5128 5129 return TCL_OK; 5130 } 5131 5132 /* 5133 ** Usage: sqlite3_column_int STMT column 5134 ** 5135 ** Usage: sqlite3_column_bytes STMT column 5136 ** 5137 ** Usage: sqlite3_column_bytes16 STMT column 5138 ** 5139 */ 5140 static int SQLITE_TCLAPI test_stmt_int( 5141 void * clientData, /* Pointer to SQLite API function to be invoked */ 5142 Tcl_Interp *interp, 5143 int objc, 5144 Tcl_Obj *CONST objv[] 5145 ){ 5146 sqlite3_stmt *pStmt; 5147 int col; 5148 int (*xFunc)(sqlite3_stmt*, int); 5149 5150 xFunc = (int (*)(sqlite3_stmt*, int))clientData; 5151 if( objc!=3 ){ 5152 Tcl_AppendResult(interp, "wrong # args: should be \"", 5153 Tcl_GetString(objv[0]), " STMT column", 0); 5154 return TCL_ERROR; 5155 } 5156 5157 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 5158 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 5159 5160 Tcl_SetObjResult(interp, Tcl_NewIntObj(xFunc(pStmt, col))); 5161 return TCL_OK; 5162 } 5163 5164 /* 5165 ** Usage: sqlite_set_magic DB MAGIC-NUMBER 5166 ** 5167 ** Set the db->magic value. This is used to test error recovery logic. 5168 */ 5169 static int SQLITE_TCLAPI sqlite_set_magic( 5170 void * clientData, 5171 Tcl_Interp *interp, 5172 int argc, 5173 char **argv 5174 ){ 5175 sqlite3 *db; 5176 if( argc!=3 ){ 5177 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 5178 " DB MAGIC", 0); 5179 return TCL_ERROR; 5180 } 5181 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 5182 if( strcmp(argv[2], "SQLITE_MAGIC_OPEN")==0 ){ 5183 db->magic = SQLITE_MAGIC_OPEN; 5184 }else if( strcmp(argv[2], "SQLITE_MAGIC_CLOSED")==0 ){ 5185 db->magic = SQLITE_MAGIC_CLOSED; 5186 }else if( strcmp(argv[2], "SQLITE_MAGIC_BUSY")==0 ){ 5187 db->magic = SQLITE_MAGIC_BUSY; 5188 }else if( strcmp(argv[2], "SQLITE_MAGIC_ERROR")==0 ){ 5189 db->magic = SQLITE_MAGIC_ERROR; 5190 }else if( Tcl_GetInt(interp, argv[2], (int*)&db->magic) ){ 5191 return TCL_ERROR; 5192 } 5193 return TCL_OK; 5194 } 5195 5196 /* 5197 ** Usage: sqlite3_interrupt DB 5198 ** 5199 ** Trigger an interrupt on DB 5200 */ 5201 static int SQLITE_TCLAPI test_interrupt( 5202 void * clientData, 5203 Tcl_Interp *interp, 5204 int argc, 5205 char **argv 5206 ){ 5207 sqlite3 *db; 5208 if( argc!=2 ){ 5209 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB", 0); 5210 return TCL_ERROR; 5211 } 5212 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 5213 sqlite3_interrupt(db); 5214 return TCL_OK; 5215 } 5216 5217 /* 5218 ** Usage: sqlite_delete_function DB function-name 5219 ** 5220 ** Delete the user function 'function-name' from database handle DB. It 5221 ** is assumed that the user function was created as UTF8, any number of 5222 ** arguments (the way the TCL interface does it). 5223 */ 5224 static int SQLITE_TCLAPI delete_function( 5225 void * clientData, 5226 Tcl_Interp *interp, 5227 int argc, 5228 char **argv 5229 ){ 5230 int rc; 5231 sqlite3 *db; 5232 if( argc!=3 ){ 5233 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 5234 " DB function-name", 0); 5235 return TCL_ERROR; 5236 } 5237 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 5238 rc = sqlite3_create_function(db, argv[2], -1, SQLITE_UTF8, 0, 0, 0, 0); 5239 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 5240 return TCL_OK; 5241 } 5242 5243 /* 5244 ** Usage: sqlite_delete_collation DB collation-name 5245 ** 5246 ** Delete the collation sequence 'collation-name' from database handle 5247 ** DB. It is assumed that the collation sequence was created as UTF8 (the 5248 ** way the TCL interface does it). 5249 */ 5250 static int SQLITE_TCLAPI delete_collation( 5251 void * clientData, 5252 Tcl_Interp *interp, 5253 int argc, 5254 char **argv 5255 ){ 5256 int rc; 5257 sqlite3 *db; 5258 if( argc!=3 ){ 5259 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 5260 " DB function-name", 0); 5261 return TCL_ERROR; 5262 } 5263 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 5264 rc = sqlite3_create_collation(db, argv[2], SQLITE_UTF8, 0, 0); 5265 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 5266 return TCL_OK; 5267 } 5268 5269 /* 5270 ** Usage: sqlite3_get_autocommit DB 5271 ** 5272 ** Return true if the database DB is currently in auto-commit mode. 5273 ** Return false if not. 5274 */ 5275 static int SQLITE_TCLAPI get_autocommit( 5276 void * clientData, 5277 Tcl_Interp *interp, 5278 int argc, 5279 char **argv 5280 ){ 5281 char zBuf[30]; 5282 sqlite3 *db; 5283 if( argc!=2 ){ 5284 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 5285 " DB", 0); 5286 return TCL_ERROR; 5287 } 5288 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 5289 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", sqlite3_get_autocommit(db)); 5290 Tcl_AppendResult(interp, zBuf, 0); 5291 return TCL_OK; 5292 } 5293 5294 /* 5295 ** Usage: sqlite3_busy_timeout DB MS 5296 ** 5297 ** Set the busy timeout. This is more easily done using the timeout 5298 ** method of the TCL interface. But we need a way to test the case 5299 ** where it returns SQLITE_MISUSE. 5300 */ 5301 static int SQLITE_TCLAPI test_busy_timeout( 5302 void * clientData, 5303 Tcl_Interp *interp, 5304 int argc, 5305 char **argv 5306 ){ 5307 int rc, ms; 5308 sqlite3 *db; 5309 if( argc!=3 ){ 5310 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 5311 " DB", 0); 5312 return TCL_ERROR; 5313 } 5314 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 5315 if( Tcl_GetInt(interp, argv[2], &ms) ) return TCL_ERROR; 5316 rc = sqlite3_busy_timeout(db, ms); 5317 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0); 5318 return TCL_OK; 5319 } 5320 5321 /* 5322 ** Usage: tcl_variable_type VARIABLENAME 5323 ** 5324 ** Return the name of the internal representation for the 5325 ** value of the given variable. 5326 */ 5327 static int SQLITE_TCLAPI tcl_variable_type( 5328 void * clientData, 5329 Tcl_Interp *interp, 5330 int objc, 5331 Tcl_Obj *CONST objv[] 5332 ){ 5333 Tcl_Obj *pVar; 5334 if( objc!=2 ){ 5335 Tcl_WrongNumArgs(interp, 1, objv, "VARIABLE"); 5336 return TCL_ERROR; 5337 } 5338 pVar = Tcl_GetVar2Ex(interp, Tcl_GetString(objv[1]), 0, TCL_LEAVE_ERR_MSG); 5339 if( pVar==0 ) return TCL_ERROR; 5340 if( pVar->typePtr ){ 5341 Tcl_SetObjResult(interp, Tcl_NewStringObj(pVar->typePtr->name, -1)); 5342 } 5343 return TCL_OK; 5344 } 5345 5346 /* 5347 ** Usage: sqlite3_release_memory ?N? 5348 ** 5349 ** Attempt to release memory currently held but not actually required. 5350 ** The integer N is the number of bytes we are trying to release. The 5351 ** return value is the amount of memory actually released. 5352 */ 5353 static int SQLITE_TCLAPI test_release_memory( 5354 void * clientData, 5355 Tcl_Interp *interp, 5356 int objc, 5357 Tcl_Obj *CONST objv[] 5358 ){ 5359 #if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) && !defined(SQLITE_OMIT_DISKIO) 5360 int N; 5361 int amt; 5362 if( objc!=1 && objc!=2 ){ 5363 Tcl_WrongNumArgs(interp, 1, objv, "?N?"); 5364 return TCL_ERROR; 5365 } 5366 if( objc==2 ){ 5367 if( Tcl_GetIntFromObj(interp, objv[1], &N) ) return TCL_ERROR; 5368 }else{ 5369 N = -1; 5370 } 5371 amt = sqlite3_release_memory(N); 5372 Tcl_SetObjResult(interp, Tcl_NewIntObj(amt)); 5373 #endif 5374 return TCL_OK; 5375 } 5376 5377 5378 /* 5379 ** Usage: sqlite3_db_release_memory DB 5380 ** 5381 ** Attempt to release memory currently held by database DB. Return the 5382 ** result code (which in the current implementation is always zero). 5383 */ 5384 static int SQLITE_TCLAPI test_db_release_memory( 5385 void * clientData, 5386 Tcl_Interp *interp, 5387 int objc, 5388 Tcl_Obj *CONST objv[] 5389 ){ 5390 sqlite3 *db; 5391 int rc; 5392 if( objc!=2 ){ 5393 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 5394 return TCL_ERROR; 5395 } 5396 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5397 rc = sqlite3_db_release_memory(db); 5398 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 5399 return TCL_OK; 5400 } 5401 5402 /* 5403 ** Usage: sqlite3_db_cacheflush DB 5404 ** 5405 ** Attempt to flush any dirty pages to disk. 5406 */ 5407 static int SQLITE_TCLAPI test_db_cacheflush( 5408 void * clientData, 5409 Tcl_Interp *interp, 5410 int objc, 5411 Tcl_Obj *CONST objv[] 5412 ){ 5413 sqlite3 *db; 5414 int rc; 5415 if( objc!=2 ){ 5416 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 5417 return TCL_ERROR; 5418 } 5419 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5420 rc = sqlite3_db_cacheflush(db); 5421 if( rc ){ 5422 Tcl_SetResult(interp, (char *)sqlite3ErrStr(rc), TCL_STATIC); 5423 return TCL_ERROR; 5424 } 5425 5426 Tcl_ResetResult(interp); 5427 return TCL_OK; 5428 } 5429 5430 /* 5431 ** Usage: sqlite3_system_errno DB 5432 ** 5433 ** Return the low-level system errno value. 5434 */ 5435 static int SQLITE_TCLAPI test_system_errno( 5436 void * clientData, 5437 Tcl_Interp *interp, 5438 int objc, 5439 Tcl_Obj *CONST objv[] 5440 ){ 5441 sqlite3 *db; 5442 int iErrno; 5443 if( objc!=2 ){ 5444 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 5445 return TCL_ERROR; 5446 } 5447 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5448 iErrno = sqlite3_system_errno(db); 5449 Tcl_SetObjResult(interp, Tcl_NewIntObj(iErrno)); 5450 return TCL_OK; 5451 } 5452 5453 /* 5454 ** Usage: sqlite3_db_filename DB DBNAME 5455 ** 5456 ** Return the name of a file associated with a database. 5457 */ 5458 static int SQLITE_TCLAPI test_db_filename( 5459 void * clientData, 5460 Tcl_Interp *interp, 5461 int objc, 5462 Tcl_Obj *CONST objv[] 5463 ){ 5464 sqlite3 *db; 5465 const char *zDbName; 5466 if( objc!=3 ){ 5467 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME"); 5468 return TCL_ERROR; 5469 } 5470 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5471 zDbName = Tcl_GetString(objv[2]); 5472 Tcl_AppendResult(interp, sqlite3_db_filename(db, zDbName), (void*)0); 5473 return TCL_OK; 5474 } 5475 5476 /* 5477 ** Usage: sqlite3_db_readonly DB DBNAME 5478 ** 5479 ** Return 1 or 0 if DBNAME is readonly or not. Return -1 if DBNAME does 5480 ** not exist. 5481 */ 5482 static int SQLITE_TCLAPI test_db_readonly( 5483 void * clientData, 5484 Tcl_Interp *interp, 5485 int objc, 5486 Tcl_Obj *CONST objv[] 5487 ){ 5488 sqlite3 *db; 5489 const char *zDbName; 5490 if( objc!=3 ){ 5491 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME"); 5492 return TCL_ERROR; 5493 } 5494 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5495 zDbName = Tcl_GetString(objv[2]); 5496 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_db_readonly(db, zDbName))); 5497 return TCL_OK; 5498 } 5499 5500 /* 5501 ** Usage: sqlite3_soft_heap_limit ?N? 5502 ** 5503 ** Query or set the soft heap limit for the current thread. The 5504 ** limit is only changed if the N is present. The previous limit 5505 ** is returned. 5506 */ 5507 static int SQLITE_TCLAPI test_soft_heap_limit( 5508 void * clientData, 5509 Tcl_Interp *interp, 5510 int objc, 5511 Tcl_Obj *CONST objv[] 5512 ){ 5513 sqlite3_int64 amt; 5514 Tcl_WideInt N = -1; 5515 if( objc!=1 && objc!=2 ){ 5516 Tcl_WrongNumArgs(interp, 1, objv, "?N?"); 5517 return TCL_ERROR; 5518 } 5519 if( objc==2 ){ 5520 if( Tcl_GetWideIntFromObj(interp, objv[1], &N) ) return TCL_ERROR; 5521 } 5522 amt = sqlite3_soft_heap_limit64(N); 5523 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(amt)); 5524 return TCL_OK; 5525 } 5526 5527 /* 5528 ** Usage: sqlite3_thread_cleanup 5529 ** 5530 ** Call the sqlite3_thread_cleanup API. 5531 */ 5532 static int SQLITE_TCLAPI test_thread_cleanup( 5533 void * clientData, 5534 Tcl_Interp *interp, 5535 int objc, 5536 Tcl_Obj *CONST objv[] 5537 ){ 5538 #ifndef SQLITE_OMIT_DEPRECATED 5539 sqlite3_thread_cleanup(); 5540 #endif 5541 return TCL_OK; 5542 } 5543 5544 /* 5545 ** Usage: sqlite3_pager_refcounts DB 5546 ** 5547 ** Return a list of numbers which are the PagerRefcount for all 5548 ** pagers on each database connection. 5549 */ 5550 static int SQLITE_TCLAPI test_pager_refcounts( 5551 void * clientData, 5552 Tcl_Interp *interp, 5553 int objc, 5554 Tcl_Obj *CONST objv[] 5555 ){ 5556 sqlite3 *db; 5557 int i; 5558 int v, *a; 5559 Tcl_Obj *pResult; 5560 5561 if( objc!=2 ){ 5562 Tcl_AppendResult(interp, "wrong # args: should be \"", 5563 Tcl_GetStringFromObj(objv[0], 0), " DB", 0); 5564 return TCL_ERROR; 5565 } 5566 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5567 pResult = Tcl_NewObj(); 5568 for(i=0; i<db->nDb; i++){ 5569 if( db->aDb[i].pBt==0 ){ 5570 v = -1; 5571 }else{ 5572 sqlite3_mutex_enter(db->mutex); 5573 a = sqlite3PagerStats(sqlite3BtreePager(db->aDb[i].pBt)); 5574 v = a[0]; 5575 sqlite3_mutex_leave(db->mutex); 5576 } 5577 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(v)); 5578 } 5579 Tcl_SetObjResult(interp, pResult); 5580 return TCL_OK; 5581 } 5582 5583 5584 /* 5585 ** tclcmd: working_64bit_int 5586 ** 5587 ** Some TCL builds (ex: cygwin) do not support 64-bit integers. This 5588 ** leads to a number of test failures. The present command checks the 5589 ** TCL build to see whether or not it supports 64-bit integers. It 5590 ** returns TRUE if it does and FALSE if not. 5591 ** 5592 ** This command is used to warn users that their TCL build is defective 5593 ** and that the errors they are seeing in the test scripts might be 5594 ** a result of their defective TCL rather than problems in SQLite. 5595 */ 5596 static int SQLITE_TCLAPI working_64bit_int( 5597 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5598 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5599 int objc, /* Number of arguments */ 5600 Tcl_Obj *CONST objv[] /* Command arguments */ 5601 ){ 5602 Tcl_Obj *pTestObj; 5603 int working = 0; 5604 5605 pTestObj = Tcl_NewWideIntObj(1000000*(i64)1234567890); 5606 working = strcmp(Tcl_GetString(pTestObj), "1234567890000000")==0; 5607 Tcl_DecrRefCount(pTestObj); 5608 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(working)); 5609 return TCL_OK; 5610 } 5611 5612 5613 /* 5614 ** tclcmd: vfs_unlink_test 5615 ** 5616 ** This TCL command unregisters the primary VFS and then registers 5617 ** it back again. This is used to test the ability to register a 5618 ** VFS when none are previously registered, and the ability to 5619 ** unregister the only available VFS. Ticket #2738 5620 */ 5621 static int SQLITE_TCLAPI vfs_unlink_test( 5622 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5623 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5624 int objc, /* Number of arguments */ 5625 Tcl_Obj *CONST objv[] /* Command arguments */ 5626 ){ 5627 int i; 5628 sqlite3_vfs *pMain; 5629 sqlite3_vfs *apVfs[20]; 5630 sqlite3_vfs one, two; 5631 5632 sqlite3_vfs_unregister(0); /* Unregister of NULL is harmless */ 5633 one.zName = "__one"; 5634 two.zName = "__two"; 5635 5636 /* Calling sqlite3_vfs_register with 2nd argument of 0 does not 5637 ** change the default VFS 5638 */ 5639 pMain = sqlite3_vfs_find(0); 5640 sqlite3_vfs_register(&one, 0); 5641 assert( pMain==0 || pMain==sqlite3_vfs_find(0) ); 5642 sqlite3_vfs_register(&two, 0); 5643 assert( pMain==0 || pMain==sqlite3_vfs_find(0) ); 5644 5645 /* We can find a VFS by its name */ 5646 assert( sqlite3_vfs_find("__one")==&one ); 5647 assert( sqlite3_vfs_find("__two")==&two ); 5648 5649 /* Calling sqlite_vfs_register with non-zero second parameter changes the 5650 ** default VFS, even if the 1st parameter is an existig VFS that is 5651 ** previously registered as the non-default. 5652 */ 5653 sqlite3_vfs_register(&one, 1); 5654 assert( sqlite3_vfs_find("__one")==&one ); 5655 assert( sqlite3_vfs_find("__two")==&two ); 5656 assert( sqlite3_vfs_find(0)==&one ); 5657 sqlite3_vfs_register(&two, 1); 5658 assert( sqlite3_vfs_find("__one")==&one ); 5659 assert( sqlite3_vfs_find("__two")==&two ); 5660 assert( sqlite3_vfs_find(0)==&two ); 5661 if( pMain ){ 5662 sqlite3_vfs_register(pMain, 1); 5663 assert( sqlite3_vfs_find("__one")==&one ); 5664 assert( sqlite3_vfs_find("__two")==&two ); 5665 assert( sqlite3_vfs_find(0)==pMain ); 5666 } 5667 5668 /* Unlink the default VFS. Repeat until there are no more VFSes 5669 ** registered. 5670 */ 5671 for(i=0; i<sizeof(apVfs)/sizeof(apVfs[0]); i++){ 5672 apVfs[i] = sqlite3_vfs_find(0); 5673 if( apVfs[i] ){ 5674 assert( apVfs[i]==sqlite3_vfs_find(apVfs[i]->zName) ); 5675 sqlite3_vfs_unregister(apVfs[i]); 5676 assert( 0==sqlite3_vfs_find(apVfs[i]->zName) ); 5677 } 5678 } 5679 assert( 0==sqlite3_vfs_find(0) ); 5680 5681 /* Register the main VFS as non-default (will be made default, since 5682 ** it'll be the only one in existence). 5683 */ 5684 sqlite3_vfs_register(pMain, 0); 5685 assert( sqlite3_vfs_find(0)==pMain ); 5686 5687 /* Un-register the main VFS again to restore an empty VFS list */ 5688 sqlite3_vfs_unregister(pMain); 5689 assert( 0==sqlite3_vfs_find(0) ); 5690 5691 /* Relink all VFSes in reverse order. */ 5692 for(i=sizeof(apVfs)/sizeof(apVfs[0])-1; i>=0; i--){ 5693 if( apVfs[i] ){ 5694 sqlite3_vfs_register(apVfs[i], 1); 5695 assert( apVfs[i]==sqlite3_vfs_find(0) ); 5696 assert( apVfs[i]==sqlite3_vfs_find(apVfs[i]->zName) ); 5697 } 5698 } 5699 5700 /* Unregister out sample VFSes. */ 5701 sqlite3_vfs_unregister(&one); 5702 sqlite3_vfs_unregister(&two); 5703 5704 /* Unregistering a VFS that is not currently registered is harmless */ 5705 sqlite3_vfs_unregister(&one); 5706 sqlite3_vfs_unregister(&two); 5707 assert( sqlite3_vfs_find("__one")==0 ); 5708 assert( sqlite3_vfs_find("__two")==0 ); 5709 5710 /* We should be left with the original default VFS back as the 5711 ** original */ 5712 assert( sqlite3_vfs_find(0)==pMain ); 5713 5714 return TCL_OK; 5715 } 5716 5717 /* 5718 ** tclcmd: vfs_initfail_test 5719 ** 5720 ** This TCL command attempts to vfs_find and vfs_register when the 5721 ** sqlite3_initialize() interface is failing. All calls should fail. 5722 */ 5723 static int SQLITE_TCLAPI vfs_initfail_test( 5724 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5725 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5726 int objc, /* Number of arguments */ 5727 Tcl_Obj *CONST objv[] /* Command arguments */ 5728 ){ 5729 sqlite3_vfs one; 5730 one.zName = "__one"; 5731 5732 if( sqlite3_vfs_find(0) ) return TCL_ERROR; 5733 sqlite3_vfs_register(&one, 0); 5734 if( sqlite3_vfs_find(0) ) return TCL_ERROR; 5735 sqlite3_vfs_register(&one, 1); 5736 if( sqlite3_vfs_find(0) ) return TCL_ERROR; 5737 return TCL_OK; 5738 } 5739 5740 /* 5741 ** Saved VFSes 5742 */ 5743 static sqlite3_vfs *apVfs[20]; 5744 static int nVfs = 0; 5745 5746 /* 5747 ** tclcmd: vfs_unregister_all 5748 ** 5749 ** Unregister all VFSes. 5750 */ 5751 static int SQLITE_TCLAPI vfs_unregister_all( 5752 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5753 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5754 int objc, /* Number of arguments */ 5755 Tcl_Obj *CONST objv[] /* Command arguments */ 5756 ){ 5757 int i; 5758 for(i=0; i<ArraySize(apVfs); i++){ 5759 apVfs[i] = sqlite3_vfs_find(0); 5760 if( apVfs[i]==0 ) break; 5761 sqlite3_vfs_unregister(apVfs[i]); 5762 } 5763 nVfs = i; 5764 return TCL_OK; 5765 } 5766 /* 5767 ** tclcmd: vfs_reregister_all 5768 ** 5769 ** Restore all VFSes that were removed using vfs_unregister_all. Taking 5770 ** care to put the linked list back together in the same order as it was 5771 ** in before vfs_unregister_all was invoked. 5772 */ 5773 static int SQLITE_TCLAPI vfs_reregister_all( 5774 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5775 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5776 int objc, /* Number of arguments */ 5777 Tcl_Obj *CONST objv[] /* Command arguments */ 5778 ){ 5779 int i; 5780 for(i=nVfs-1; i>=0; i--){ 5781 sqlite3_vfs_register(apVfs[i], 1); 5782 } 5783 return TCL_OK; 5784 } 5785 5786 5787 /* 5788 ** tclcmd: file_control_test DB 5789 ** 5790 ** This TCL command runs the sqlite3_file_control interface and 5791 ** verifies correct operation of the same. 5792 */ 5793 static int SQLITE_TCLAPI file_control_test( 5794 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5795 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5796 int objc, /* Number of arguments */ 5797 Tcl_Obj *CONST objv[] /* Command arguments */ 5798 ){ 5799 int iArg = 0; 5800 sqlite3 *db; 5801 int rc; 5802 5803 if( objc!=2 ){ 5804 Tcl_AppendResult(interp, "wrong # args: should be \"", 5805 Tcl_GetStringFromObj(objv[0], 0), " DB", 0); 5806 return TCL_ERROR; 5807 } 5808 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5809 rc = sqlite3_file_control(db, 0, 0, &iArg); 5810 assert( rc==SQLITE_NOTFOUND ); 5811 rc = sqlite3_file_control(db, "notadatabase", SQLITE_FCNTL_LOCKSTATE, &iArg); 5812 assert( rc==SQLITE_ERROR ); 5813 rc = sqlite3_file_control(db, "main", -1, &iArg); 5814 assert( rc==SQLITE_NOTFOUND ); 5815 rc = sqlite3_file_control(db, "temp", -1, &iArg); 5816 assert( rc==SQLITE_NOTFOUND || rc==SQLITE_ERROR ); 5817 5818 return TCL_OK; 5819 } 5820 5821 5822 /* 5823 ** tclcmd: file_control_lasterrno_test DB 5824 ** 5825 ** This TCL command runs the sqlite3_file_control interface and 5826 ** verifies correct operation of the SQLITE_LAST_ERRNO verb. 5827 */ 5828 static int SQLITE_TCLAPI file_control_lasterrno_test( 5829 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5830 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5831 int objc, /* Number of arguments */ 5832 Tcl_Obj *CONST objv[] /* Command arguments */ 5833 ){ 5834 int iArg = 0; 5835 sqlite3 *db; 5836 int rc; 5837 5838 if( objc!=2 ){ 5839 Tcl_AppendResult(interp, "wrong # args: should be \"", 5840 Tcl_GetStringFromObj(objv[0], 0), " DB", 0); 5841 return TCL_ERROR; 5842 } 5843 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 5844 return TCL_ERROR; 5845 } 5846 rc = sqlite3_file_control(db, NULL, SQLITE_LAST_ERRNO, &iArg); 5847 if( rc ){ 5848 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 5849 return TCL_ERROR; 5850 } 5851 if( iArg!=0 ) { 5852 Tcl_AppendResult(interp, "Unexpected non-zero errno: ", 5853 Tcl_GetStringFromObj(Tcl_NewIntObj(iArg), 0), " ", 0); 5854 return TCL_ERROR; 5855 } 5856 return TCL_OK; 5857 } 5858 5859 /* 5860 ** tclcmd: file_control_data_version DB DBNAME 5861 ** 5862 ** This TCL command runs the sqlite3_file_control with the 5863 ** SQLITE_FCNTL_DATA_VERSION opcode, returning the result. 5864 */ 5865 static int SQLITE_TCLAPI file_control_data_version( 5866 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5867 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5868 int objc, /* Number of arguments */ 5869 Tcl_Obj *CONST objv[] /* Command arguments */ 5870 ){ 5871 unsigned int iVers; /* data version */ 5872 char *zDb; /* Db name ("main", "temp" etc.) */ 5873 sqlite3 *db; /* Database handle */ 5874 int rc; /* file_control() return code */ 5875 char zBuf[100]; 5876 5877 if( objc!=3 && objc!=2 ){ 5878 Tcl_WrongNumArgs(interp, 1, objv, "DB [DBNAME]"); 5879 return TCL_ERROR; 5880 } 5881 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 5882 return TCL_ERROR; 5883 } 5884 zDb = objc==3 ? Tcl_GetString(objv[2]) : NULL; 5885 5886 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_DATA_VERSION, (void *)&iVers); 5887 if( rc ){ 5888 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); 5889 return TCL_ERROR; 5890 }else{ 5891 sqlite3_snprintf(sizeof(zBuf),zBuf,"%u",iVers); 5892 Tcl_SetResult(interp, (char *)zBuf, TCL_VOLATILE); 5893 return TCL_OK; 5894 } 5895 } 5896 5897 /* 5898 ** tclcmd: file_control_chunksize_test DB DBNAME SIZE 5899 ** 5900 ** This TCL command runs the sqlite3_file_control interface and 5901 ** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and 5902 ** SQLITE_SET_LOCKPROXYFILE verbs. 5903 */ 5904 static int SQLITE_TCLAPI file_control_chunksize_test( 5905 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5906 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5907 int objc, /* Number of arguments */ 5908 Tcl_Obj *CONST objv[] /* Command arguments */ 5909 ){ 5910 int nSize; /* New chunk size */ 5911 char *zDb; /* Db name ("main", "temp" etc.) */ 5912 sqlite3 *db; /* Database handle */ 5913 int rc; /* file_control() return code */ 5914 5915 if( objc!=4 ){ 5916 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SIZE"); 5917 return TCL_ERROR; 5918 } 5919 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) 5920 || Tcl_GetIntFromObj(interp, objv[3], &nSize) 5921 ){ 5922 return TCL_ERROR; 5923 } 5924 zDb = Tcl_GetString(objv[2]); 5925 if( zDb[0]=='\0' ) zDb = NULL; 5926 5927 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_CHUNK_SIZE, (void *)&nSize); 5928 if( rc ){ 5929 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); 5930 return TCL_ERROR; 5931 } 5932 return TCL_OK; 5933 } 5934 5935 /* 5936 ** tclcmd: file_control_sizehint_test DB DBNAME SIZE 5937 ** 5938 ** This TCL command runs the sqlite3_file_control interface 5939 ** with SQLITE_FCNTL_SIZE_HINT 5940 */ 5941 static int SQLITE_TCLAPI file_control_sizehint_test( 5942 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5943 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5944 int objc, /* Number of arguments */ 5945 Tcl_Obj *CONST objv[] /* Command arguments */ 5946 ){ 5947 Tcl_WideInt nSize; /* Hinted size */ 5948 char *zDb; /* Db name ("main", "temp" etc.) */ 5949 sqlite3 *db; /* Database handle */ 5950 int rc; /* file_control() return code */ 5951 5952 if( objc!=4 ){ 5953 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SIZE"); 5954 return TCL_ERROR; 5955 } 5956 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) 5957 || Tcl_GetWideIntFromObj(interp, objv[3], &nSize) 5958 ){ 5959 return TCL_ERROR; 5960 } 5961 zDb = Tcl_GetString(objv[2]); 5962 if( zDb[0]=='\0' ) zDb = NULL; 5963 5964 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_SIZE_HINT, (void *)&nSize); 5965 if( rc ){ 5966 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); 5967 return TCL_ERROR; 5968 } 5969 return TCL_OK; 5970 } 5971 5972 /* 5973 ** tclcmd: file_control_lockproxy_test DB PWD 5974 ** 5975 ** This TCL command runs the sqlite3_file_control interface and 5976 ** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and 5977 ** SQLITE_SET_LOCKPROXYFILE verbs. 5978 */ 5979 static int SQLITE_TCLAPI file_control_lockproxy_test( 5980 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5981 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5982 int objc, /* Number of arguments */ 5983 Tcl_Obj *CONST objv[] /* Command arguments */ 5984 ){ 5985 sqlite3 *db; 5986 5987 if( objc!=3 ){ 5988 Tcl_AppendResult(interp, "wrong # args: should be \"", 5989 Tcl_GetStringFromObj(objv[0], 0), " DB PWD", 0); 5990 return TCL_ERROR; 5991 } 5992 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 5993 return TCL_ERROR; 5994 } 5995 5996 #if !defined(SQLITE_ENABLE_LOCKING_STYLE) 5997 # if defined(__APPLE__) 5998 # define SQLITE_ENABLE_LOCKING_STYLE 1 5999 # else 6000 # define SQLITE_ENABLE_LOCKING_STYLE 0 6001 # endif 6002 #endif 6003 #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) 6004 { 6005 char *testPath; 6006 int rc; 6007 int nPwd; 6008 const char *zPwd; 6009 char proxyPath[400]; 6010 6011 zPwd = Tcl_GetStringFromObj(objv[2], &nPwd); 6012 if( sizeof(proxyPath)<nPwd+20 ){ 6013 Tcl_AppendResult(interp, "PWD too big", (void*)0); 6014 return TCL_ERROR; 6015 } 6016 sqlite3_snprintf(sizeof(proxyPath), proxyPath, "%s/test.proxy", zPwd); 6017 rc = sqlite3_file_control(db, NULL, SQLITE_SET_LOCKPROXYFILE, proxyPath); 6018 if( rc ){ 6019 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 6020 return TCL_ERROR; 6021 } 6022 rc = sqlite3_file_control(db, NULL, SQLITE_GET_LOCKPROXYFILE, &testPath); 6023 if( strncmp(proxyPath,testPath,11) ){ 6024 Tcl_AppendResult(interp, "Lock proxy file did not match the " 6025 "previously assigned value", 0); 6026 return TCL_ERROR; 6027 } 6028 if( rc ){ 6029 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 6030 return TCL_ERROR; 6031 } 6032 rc = sqlite3_file_control(db, NULL, SQLITE_SET_LOCKPROXYFILE, proxyPath); 6033 if( rc ){ 6034 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 6035 return TCL_ERROR; 6036 } 6037 } 6038 #endif 6039 return TCL_OK; 6040 } 6041 6042 #if SQLITE_OS_WIN 6043 /* 6044 ** tclcmd: file_control_win32_av_retry DB NRETRY DELAY 6045 ** 6046 ** This TCL command runs the sqlite3_file_control interface with 6047 ** the SQLITE_FCNTL_WIN32_AV_RETRY opcode. 6048 */ 6049 static int SQLITE_TCLAPI file_control_win32_av_retry( 6050 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6051 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6052 int objc, /* Number of arguments */ 6053 Tcl_Obj *CONST objv[] /* Command arguments */ 6054 ){ 6055 sqlite3 *db; 6056 int rc; 6057 int a[2]; 6058 char z[100]; 6059 6060 if( objc!=4 ){ 6061 Tcl_AppendResult(interp, "wrong # args: should be \"", 6062 Tcl_GetStringFromObj(objv[0], 0), " DB NRETRY DELAY", 0); 6063 return TCL_ERROR; 6064 } 6065 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6066 return TCL_ERROR; 6067 } 6068 if( Tcl_GetIntFromObj(interp, objv[2], &a[0]) ) return TCL_ERROR; 6069 if( Tcl_GetIntFromObj(interp, objv[3], &a[1]) ) return TCL_ERROR; 6070 rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_WIN32_AV_RETRY, (void*)a); 6071 sqlite3_snprintf(sizeof(z), z, "%d %d %d", rc, a[0], a[1]); 6072 Tcl_AppendResult(interp, z, (char*)0); 6073 return TCL_OK; 6074 } 6075 6076 /* 6077 ** tclcmd: file_control_win32_get_handle DB 6078 ** 6079 ** This TCL command runs the sqlite3_file_control interface with 6080 ** the SQLITE_FCNTL_WIN32_GET_HANDLE opcode. 6081 */ 6082 static int file_control_win32_get_handle( 6083 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6084 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6085 int objc, /* Number of arguments */ 6086 Tcl_Obj *CONST objv[] /* Command arguments */ 6087 ){ 6088 sqlite3 *db; 6089 int rc; 6090 HANDLE hFile = NULL; 6091 char z[100]; 6092 6093 if( objc!=2 ){ 6094 Tcl_AppendResult(interp, "wrong # args: should be \"", 6095 Tcl_GetStringFromObj(objv[0], 0), " DB", 0); 6096 return TCL_ERROR; 6097 } 6098 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6099 return TCL_ERROR; 6100 } 6101 rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_WIN32_GET_HANDLE, 6102 (void*)&hFile); 6103 sqlite3_snprintf(sizeof(z), z, "%d %p", rc, (void*)hFile); 6104 Tcl_AppendResult(interp, z, (char*)0); 6105 return TCL_OK; 6106 } 6107 6108 /* 6109 ** tclcmd: file_control_win32_set_handle DB HANDLE 6110 ** 6111 ** This TCL command runs the sqlite3_file_control interface with 6112 ** the SQLITE_FCNTL_WIN32_SET_HANDLE opcode. 6113 */ 6114 static int SQLITE_TCLAPI file_control_win32_set_handle( 6115 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6116 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6117 int objc, /* Number of arguments */ 6118 Tcl_Obj *CONST objv[] /* Command arguments */ 6119 ){ 6120 sqlite3 *db; 6121 int rc; 6122 HANDLE hFile = NULL; 6123 char z[100]; 6124 6125 if( objc!=3 ){ 6126 Tcl_AppendResult(interp, "wrong # args: should be \"", 6127 Tcl_GetStringFromObj(objv[0], 0), " DB HANDLE", 0); 6128 return TCL_ERROR; 6129 } 6130 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6131 return TCL_ERROR; 6132 } 6133 if( getWin32Handle(interp, Tcl_GetString(objv[2]), &hFile) ){ 6134 return TCL_ERROR; 6135 } 6136 rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_WIN32_SET_HANDLE, 6137 (void*)&hFile); 6138 sqlite3_snprintf(sizeof(z), z, "%d %p", rc, (void*)hFile); 6139 Tcl_AppendResult(interp, z, (char*)0); 6140 return TCL_OK; 6141 } 6142 #endif 6143 6144 /* 6145 ** tclcmd: file_control_persist_wal DB PERSIST-FLAG 6146 ** 6147 ** This TCL command runs the sqlite3_file_control interface with 6148 ** the SQLITE_FCNTL_PERSIST_WAL opcode. 6149 */ 6150 static int SQLITE_TCLAPI file_control_persist_wal( 6151 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6152 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6153 int objc, /* Number of arguments */ 6154 Tcl_Obj *CONST objv[] /* Command arguments */ 6155 ){ 6156 sqlite3 *db; 6157 int rc; 6158 int bPersist; 6159 char z[100]; 6160 6161 if( objc!=3 ){ 6162 Tcl_AppendResult(interp, "wrong # args: should be \"", 6163 Tcl_GetStringFromObj(objv[0], 0), " DB FLAG", 0); 6164 return TCL_ERROR; 6165 } 6166 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6167 return TCL_ERROR; 6168 } 6169 if( Tcl_GetIntFromObj(interp, objv[2], &bPersist) ) return TCL_ERROR; 6170 rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_PERSIST_WAL, (void*)&bPersist); 6171 sqlite3_snprintf(sizeof(z), z, "%d %d", rc, bPersist); 6172 Tcl_AppendResult(interp, z, (char*)0); 6173 return TCL_OK; 6174 } 6175 6176 /* 6177 ** tclcmd: file_control_powersafe_overwrite DB PSOW-FLAG 6178 ** 6179 ** This TCL command runs the sqlite3_file_control interface with 6180 ** the SQLITE_FCNTL_POWERSAFE_OVERWRITE opcode. 6181 */ 6182 static int SQLITE_TCLAPI file_control_powersafe_overwrite( 6183 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6184 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6185 int objc, /* Number of arguments */ 6186 Tcl_Obj *CONST objv[] /* Command arguments */ 6187 ){ 6188 sqlite3 *db; 6189 int rc; 6190 int b; 6191 char z[100]; 6192 6193 if( objc!=3 ){ 6194 Tcl_AppendResult(interp, "wrong # args: should be \"", 6195 Tcl_GetStringFromObj(objv[0], 0), " DB FLAG", 0); 6196 return TCL_ERROR; 6197 } 6198 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6199 return TCL_ERROR; 6200 } 6201 if( Tcl_GetIntFromObj(interp, objv[2], &b) ) return TCL_ERROR; 6202 rc = sqlite3_file_control(db,NULL,SQLITE_FCNTL_POWERSAFE_OVERWRITE,(void*)&b); 6203 sqlite3_snprintf(sizeof(z), z, "%d %d", rc, b); 6204 Tcl_AppendResult(interp, z, (char*)0); 6205 return TCL_OK; 6206 } 6207 6208 6209 /* 6210 ** tclcmd: file_control_vfsname DB ?AUXDB? 6211 ** 6212 ** Return a string that describes the stack of VFSes. 6213 */ 6214 static int SQLITE_TCLAPI file_control_vfsname( 6215 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6216 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6217 int objc, /* Number of arguments */ 6218 Tcl_Obj *CONST objv[] /* Command arguments */ 6219 ){ 6220 sqlite3 *db; 6221 const char *zDbName = "main"; 6222 char *zVfsName = 0; 6223 6224 if( objc!=2 && objc!=3 ){ 6225 Tcl_AppendResult(interp, "wrong # args: should be \"", 6226 Tcl_GetStringFromObj(objv[0], 0), " DB ?AUXDB?", 0); 6227 return TCL_ERROR; 6228 } 6229 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6230 return TCL_ERROR; 6231 } 6232 if( objc==3 ){ 6233 zDbName = Tcl_GetString(objv[2]); 6234 } 6235 sqlite3_file_control(db, zDbName, SQLITE_FCNTL_VFSNAME,(void*)&zVfsName); 6236 Tcl_AppendResult(interp, zVfsName, (char*)0); 6237 sqlite3_free(zVfsName); 6238 return TCL_OK; 6239 } 6240 6241 /* 6242 ** tclcmd: file_control_tempfilename DB ?AUXDB? 6243 ** 6244 ** Return a string that is a temporary filename 6245 */ 6246 static int SQLITE_TCLAPI file_control_tempfilename( 6247 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6248 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6249 int objc, /* Number of arguments */ 6250 Tcl_Obj *CONST objv[] /* Command arguments */ 6251 ){ 6252 sqlite3 *db; 6253 const char *zDbName = "main"; 6254 char *zTName = 0; 6255 6256 if( objc!=2 && objc!=3 ){ 6257 Tcl_AppendResult(interp, "wrong # args: should be \"", 6258 Tcl_GetStringFromObj(objv[0], 0), " DB ?AUXDB?", 0); 6259 return TCL_ERROR; 6260 } 6261 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6262 return TCL_ERROR; 6263 } 6264 if( objc==3 ){ 6265 zDbName = Tcl_GetString(objv[2]); 6266 } 6267 sqlite3_file_control(db, zDbName, SQLITE_FCNTL_TEMPFILENAME, (void*)&zTName); 6268 Tcl_AppendResult(interp, zTName, (char*)0); 6269 sqlite3_free(zTName); 6270 return TCL_OK; 6271 } 6272 6273 6274 /* 6275 ** tclcmd: sqlite3_vfs_list 6276 ** 6277 ** Return a tcl list containing the names of all registered vfs's. 6278 */ 6279 static int SQLITE_TCLAPI vfs_list( 6280 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6281 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6282 int objc, /* Number of arguments */ 6283 Tcl_Obj *CONST objv[] /* Command arguments */ 6284 ){ 6285 sqlite3_vfs *pVfs; 6286 Tcl_Obj *pRet = Tcl_NewObj(); 6287 if( objc!=1 ){ 6288 Tcl_WrongNumArgs(interp, 1, objv, ""); 6289 return TCL_ERROR; 6290 } 6291 for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){ 6292 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj(pVfs->zName, -1)); 6293 } 6294 Tcl_SetObjResult(interp, pRet); 6295 return TCL_OK; 6296 } 6297 6298 /* 6299 ** tclcmd: sqlite3_limit DB ID VALUE 6300 ** 6301 ** This TCL command runs the sqlite3_limit interface and 6302 ** verifies correct operation of the same. 6303 */ 6304 static int SQLITE_TCLAPI test_limit( 6305 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6306 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6307 int objc, /* Number of arguments */ 6308 Tcl_Obj *CONST objv[] /* Command arguments */ 6309 ){ 6310 sqlite3 *db; 6311 int rc; 6312 static const struct { 6313 char *zName; 6314 int id; 6315 } aId[] = { 6316 { "SQLITE_LIMIT_LENGTH", SQLITE_LIMIT_LENGTH }, 6317 { "SQLITE_LIMIT_SQL_LENGTH", SQLITE_LIMIT_SQL_LENGTH }, 6318 { "SQLITE_LIMIT_COLUMN", SQLITE_LIMIT_COLUMN }, 6319 { "SQLITE_LIMIT_EXPR_DEPTH", SQLITE_LIMIT_EXPR_DEPTH }, 6320 { "SQLITE_LIMIT_COMPOUND_SELECT", SQLITE_LIMIT_COMPOUND_SELECT }, 6321 { "SQLITE_LIMIT_VDBE_OP", SQLITE_LIMIT_VDBE_OP }, 6322 { "SQLITE_LIMIT_FUNCTION_ARG", SQLITE_LIMIT_FUNCTION_ARG }, 6323 { "SQLITE_LIMIT_ATTACHED", SQLITE_LIMIT_ATTACHED }, 6324 { "SQLITE_LIMIT_LIKE_PATTERN_LENGTH", SQLITE_LIMIT_LIKE_PATTERN_LENGTH }, 6325 { "SQLITE_LIMIT_VARIABLE_NUMBER", SQLITE_LIMIT_VARIABLE_NUMBER }, 6326 { "SQLITE_LIMIT_TRIGGER_DEPTH", SQLITE_LIMIT_TRIGGER_DEPTH }, 6327 { "SQLITE_LIMIT_WORKER_THREADS", SQLITE_LIMIT_WORKER_THREADS }, 6328 6329 /* Out of range test cases */ 6330 { "SQLITE_LIMIT_TOOSMALL", -1, }, 6331 { "SQLITE_LIMIT_TOOBIG", SQLITE_LIMIT_WORKER_THREADS+1 }, 6332 }; 6333 int i, id = 0; 6334 int val; 6335 const char *zId; 6336 6337 if( objc!=4 ){ 6338 Tcl_AppendResult(interp, "wrong # args: should be \"", 6339 Tcl_GetStringFromObj(objv[0], 0), " DB ID VALUE", 0); 6340 return TCL_ERROR; 6341 } 6342 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 6343 zId = Tcl_GetString(objv[2]); 6344 for(i=0; i<sizeof(aId)/sizeof(aId[0]); i++){ 6345 if( strcmp(zId, aId[i].zName)==0 ){ 6346 id = aId[i].id; 6347 break; 6348 } 6349 } 6350 if( i>=sizeof(aId)/sizeof(aId[0]) ){ 6351 Tcl_AppendResult(interp, "unknown limit type: ", zId, (char*)0); 6352 return TCL_ERROR; 6353 } 6354 if( Tcl_GetIntFromObj(interp, objv[3], &val) ) return TCL_ERROR; 6355 rc = sqlite3_limit(db, id, val); 6356 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 6357 return TCL_OK; 6358 } 6359 6360 /* 6361 ** tclcmd: save_prng_state 6362 ** 6363 ** Save the state of the pseudo-random number generator. 6364 ** At the same time, verify that sqlite3_test_control works even when 6365 ** called with an out-of-range opcode. 6366 */ 6367 static int SQLITE_TCLAPI save_prng_state( 6368 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6369 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6370 int objc, /* Number of arguments */ 6371 Tcl_Obj *CONST objv[] /* Command arguments */ 6372 ){ 6373 int rc = sqlite3_test_control(9999); 6374 assert( rc==0 ); 6375 rc = sqlite3_test_control(-1); 6376 assert( rc==0 ); 6377 sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SAVE); 6378 return TCL_OK; 6379 } 6380 /* 6381 ** tclcmd: restore_prng_state 6382 */ 6383 static int SQLITE_TCLAPI restore_prng_state( 6384 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6385 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6386 int objc, /* Number of arguments */ 6387 Tcl_Obj *CONST objv[] /* Command arguments */ 6388 ){ 6389 sqlite3_test_control(SQLITE_TESTCTRL_PRNG_RESTORE); 6390 return TCL_OK; 6391 } 6392 /* 6393 ** tclcmd: reset_prng_state 6394 */ 6395 static int SQLITE_TCLAPI reset_prng_state( 6396 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6397 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6398 int objc, /* Number of arguments */ 6399 Tcl_Obj *CONST objv[] /* Command arguments */ 6400 ){ 6401 sqlite3_randomness(0,0); 6402 return TCL_OK; 6403 } 6404 /* 6405 ** tclcmd: prng_seed INT ?DB? 6406 ** 6407 ** Set up the SQLITE_TESTCTRL_PRNG_SEED pragma with parameter INT and DB. 6408 ** INT is an integer. DB is a database connection, or a NULL pointer if 6409 ** omitted. 6410 ** 6411 ** When INT!=0 and DB!=0, set the PRNG seed to the value of the schema 6412 ** cookie for DB, or to INT if the schema cookie happens to be zero. 6413 ** 6414 ** When INT!=0 and DB==0, set the PRNG seed to just INT. 6415 ** 6416 ** If INT==0 and DB==0 then use the default procedure of calling the 6417 ** xRandomness method on the default VFS to get the PRNG seed. 6418 */ 6419 static int SQLITE_TCLAPI prng_seed( 6420 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6421 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6422 int objc, /* Number of arguments */ 6423 Tcl_Obj *CONST objv[] /* Command arguments */ 6424 ){ 6425 int i = 0; 6426 sqlite3 *db = 0; 6427 if( objc!=2 && objc!=3 ){ 6428 Tcl_WrongNumArgs(interp, 1, objv, "SEED ?DB?"); 6429 return TCL_ERROR; 6430 } 6431 if( Tcl_GetIntFromObj(interp,objv[0],&i) ) return TCL_ERROR; 6432 if( objc==3 && getDbPointer(interp, Tcl_GetString(objv[2]), &db) ){ 6433 return TCL_ERROR; 6434 } 6435 sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SEED, i, db); 6436 return TCL_OK; 6437 } 6438 6439 /* 6440 ** tclcmd: database_may_be_corrupt 6441 ** 6442 ** Indicate that database files might be corrupt. In other words, set the normal 6443 ** state of operation. 6444 */ 6445 static int SQLITE_TCLAPI database_may_be_corrupt( 6446 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6447 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6448 int objc, /* Number of arguments */ 6449 Tcl_Obj *CONST objv[] /* Command arguments */ 6450 ){ 6451 sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, 0); 6452 return TCL_OK; 6453 } 6454 /* 6455 ** tclcmd: database_never_corrupt 6456 ** 6457 ** Indicate that database files are always well-formed. This enables 6458 ** extra assert() statements that test conditions that are always true 6459 ** for well-formed databases. 6460 */ 6461 static int SQLITE_TCLAPI database_never_corrupt( 6462 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6463 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6464 int objc, /* Number of arguments */ 6465 Tcl_Obj *CONST objv[] /* Command arguments */ 6466 ){ 6467 sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, 1); 6468 return TCL_OK; 6469 } 6470 6471 /* 6472 ** tclcmd: pcache_stats 6473 */ 6474 static int SQLITE_TCLAPI test_pcache_stats( 6475 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6476 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6477 int objc, /* Number of arguments */ 6478 Tcl_Obj *CONST objv[] /* Command arguments */ 6479 ){ 6480 int nMin; 6481 int nMax; 6482 int nCurrent; 6483 int nRecyclable; 6484 Tcl_Obj *pRet; 6485 6486 sqlite3PcacheStats(&nCurrent, &nMax, &nMin, &nRecyclable); 6487 6488 pRet = Tcl_NewObj(); 6489 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("current", -1)); 6490 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nCurrent)); 6491 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("max", -1)); 6492 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nMax)); 6493 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("min", -1)); 6494 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nMin)); 6495 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("recyclable", -1)); 6496 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nRecyclable)); 6497 6498 Tcl_SetObjResult(interp, pRet); 6499 6500 return TCL_OK; 6501 } 6502 6503 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY 6504 static void test_unlock_notify_cb(void **aArg, int nArg){ 6505 int ii; 6506 for(ii=0; ii<nArg; ii++){ 6507 Tcl_EvalEx((Tcl_Interp *)aArg[ii], "unlock_notify", -1, TCL_EVAL_GLOBAL); 6508 } 6509 } 6510 #endif /* SQLITE_ENABLE_UNLOCK_NOTIFY */ 6511 6512 /* 6513 ** tclcmd: sqlite3_unlock_notify db 6514 */ 6515 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY 6516 static int SQLITE_TCLAPI test_unlock_notify( 6517 ClientData clientData, /* Unused */ 6518 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6519 int objc, /* Number of arguments */ 6520 Tcl_Obj *CONST objv[] /* Command arguments */ 6521 ){ 6522 sqlite3 *db; 6523 int rc; 6524 6525 if( objc!=2 ){ 6526 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 6527 return TCL_ERROR; 6528 } 6529 6530 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6531 return TCL_ERROR; 6532 } 6533 rc = sqlite3_unlock_notify(db, test_unlock_notify_cb, (void *)interp); 6534 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 6535 return TCL_OK; 6536 } 6537 #endif 6538 6539 /* 6540 ** tclcmd: sqlite3_wal_checkpoint db ?NAME? 6541 */ 6542 static int SQLITE_TCLAPI test_wal_checkpoint( 6543 ClientData clientData, /* Unused */ 6544 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6545 int objc, /* Number of arguments */ 6546 Tcl_Obj *CONST objv[] /* Command arguments */ 6547 ){ 6548 char *zDb = 0; 6549 sqlite3 *db; 6550 int rc; 6551 6552 if( objc!=3 && objc!=2 ){ 6553 Tcl_WrongNumArgs(interp, 1, objv, "DB ?NAME?"); 6554 return TCL_ERROR; 6555 } 6556 6557 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6558 return TCL_ERROR; 6559 } 6560 if( objc==3 ){ 6561 zDb = Tcl_GetString(objv[2]); 6562 } 6563 rc = sqlite3_wal_checkpoint(db, zDb); 6564 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 6565 return TCL_OK; 6566 } 6567 6568 /* 6569 ** tclcmd: sqlite3_wal_checkpoint_v2 db MODE ?NAME? 6570 ** 6571 ** This command calls the wal_checkpoint_v2() function with the specified 6572 ** mode argument (passive, full or restart). If present, the database name 6573 ** NAME is passed as the second argument to wal_checkpoint_v2(). If it the 6574 ** NAME argument is not present, a NULL pointer is passed instead. 6575 ** 6576 ** If wal_checkpoint_v2() returns any value other than SQLITE_BUSY or 6577 ** SQLITE_OK, then this command returns TCL_ERROR. The Tcl result is set 6578 ** to the error message obtained from sqlite3_errmsg(). 6579 ** 6580 ** Otherwise, this command returns a list of three integers. The first integer 6581 ** is 1 if SQLITE_BUSY was returned, or 0 otherwise. The following two integers 6582 ** are the values returned via the output parameters by wal_checkpoint_v2() - 6583 ** the number of frames in the log and the number of frames in the log 6584 ** that have been checkpointed. 6585 */ 6586 static int SQLITE_TCLAPI test_wal_checkpoint_v2( 6587 ClientData clientData, /* Unused */ 6588 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6589 int objc, /* Number of arguments */ 6590 Tcl_Obj *CONST objv[] /* Command arguments */ 6591 ){ 6592 char *zDb = 0; 6593 sqlite3 *db; 6594 int rc; 6595 6596 int eMode; 6597 int nLog = -555; 6598 int nCkpt = -555; 6599 Tcl_Obj *pRet; 6600 6601 const char * aMode[] = { "passive", "full", "restart", "truncate", 0 }; 6602 assert( SQLITE_CHECKPOINT_PASSIVE==0 ); 6603 assert( SQLITE_CHECKPOINT_FULL==1 ); 6604 assert( SQLITE_CHECKPOINT_RESTART==2 ); 6605 assert( SQLITE_CHECKPOINT_TRUNCATE==3 ); 6606 6607 if( objc!=3 && objc!=4 ){ 6608 Tcl_WrongNumArgs(interp, 1, objv, "DB MODE ?NAME?"); 6609 return TCL_ERROR; 6610 } 6611 6612 if( objc==4 ){ 6613 zDb = Tcl_GetString(objv[3]); 6614 } 6615 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) || ( 6616 TCL_OK!=Tcl_GetIntFromObj(0, objv[2], &eMode) 6617 && TCL_OK!=Tcl_GetIndexFromObj(interp, objv[2], aMode, "mode", 0, &eMode) 6618 )){ 6619 return TCL_ERROR; 6620 } 6621 6622 rc = sqlite3_wal_checkpoint_v2(db, zDb, eMode, &nLog, &nCkpt); 6623 if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){ 6624 const char *zErrCode = sqlite3ErrName(rc); 6625 Tcl_ResetResult(interp); 6626 Tcl_AppendResult(interp, zErrCode, " - ", (char *)sqlite3_errmsg(db), 0); 6627 return TCL_ERROR; 6628 } 6629 6630 pRet = Tcl_NewObj(); 6631 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(rc==SQLITE_BUSY?1:0)); 6632 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nLog)); 6633 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nCkpt)); 6634 Tcl_SetObjResult(interp, pRet); 6635 6636 return TCL_OK; 6637 } 6638 6639 /* 6640 ** tclcmd: sqlite3_wal_autocheckpoint db VALUE 6641 */ 6642 static int SQLITE_TCLAPI test_wal_autocheckpoint( 6643 ClientData clientData, /* Unused */ 6644 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6645 int objc, /* Number of arguments */ 6646 Tcl_Obj *CONST objv[] /* Command arguments */ 6647 ){ 6648 sqlite3 *db; 6649 int rc; 6650 int iVal; 6651 6652 6653 if( objc!=3 ){ 6654 Tcl_WrongNumArgs(interp, 1, objv, "DB VALUE"); 6655 return TCL_ERROR; 6656 } 6657 6658 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) 6659 || Tcl_GetIntFromObj(0, objv[2], &iVal) 6660 ){ 6661 return TCL_ERROR; 6662 } 6663 6664 rc = sqlite3_wal_autocheckpoint(db, iVal); 6665 Tcl_ResetResult(interp); 6666 if( rc!=SQLITE_OK ){ 6667 const char *zErrCode = sqlite3ErrName(rc); 6668 Tcl_SetObjResult(interp, Tcl_NewStringObj(zErrCode, -1)); 6669 return TCL_ERROR; 6670 } 6671 6672 return TCL_OK; 6673 } 6674 6675 6676 /* 6677 ** tclcmd: test_sqlite3_log ?SCRIPT? 6678 */ 6679 static struct LogCallback { 6680 Tcl_Interp *pInterp; 6681 Tcl_Obj *pObj; 6682 } logcallback = {0, 0}; 6683 static void xLogcallback(void *unused, int err, char *zMsg){ 6684 Tcl_Obj *pNew = Tcl_DuplicateObj(logcallback.pObj); 6685 Tcl_IncrRefCount(pNew); 6686 Tcl_ListObjAppendElement( 6687 0, pNew, Tcl_NewStringObj(sqlite3ErrName(err), -1) 6688 ); 6689 Tcl_ListObjAppendElement(0, pNew, Tcl_NewStringObj(zMsg, -1)); 6690 Tcl_EvalObjEx(logcallback.pInterp, pNew, TCL_EVAL_GLOBAL|TCL_EVAL_DIRECT); 6691 Tcl_DecrRefCount(pNew); 6692 } 6693 static int SQLITE_TCLAPI test_sqlite3_log( 6694 ClientData clientData, 6695 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6696 int objc, /* Number of arguments */ 6697 Tcl_Obj *CONST objv[] /* Command arguments */ 6698 ){ 6699 if( objc>2 ){ 6700 Tcl_WrongNumArgs(interp, 1, objv, "SCRIPT"); 6701 return TCL_ERROR; 6702 } 6703 if( logcallback.pObj ){ 6704 Tcl_DecrRefCount(logcallback.pObj); 6705 logcallback.pObj = 0; 6706 logcallback.pInterp = 0; 6707 sqlite3_config(SQLITE_CONFIG_LOG, (void*)0, (void*)0); 6708 } 6709 if( objc>1 ){ 6710 logcallback.pObj = objv[1]; 6711 Tcl_IncrRefCount(logcallback.pObj); 6712 logcallback.pInterp = interp; 6713 sqlite3_config(SQLITE_CONFIG_LOG, xLogcallback, (void*)0); 6714 } 6715 return TCL_OK; 6716 } 6717 6718 /* 6719 ** tcl_objproc COMMANDNAME ARGS... 6720 ** 6721 ** Run a TCL command using its objProc interface. Throw an error if 6722 ** the command has no objProc interface. 6723 */ 6724 static int SQLITE_TCLAPI runAsObjProc( 6725 void * clientData, 6726 Tcl_Interp *interp, 6727 int objc, 6728 Tcl_Obj *CONST objv[] 6729 ){ 6730 Tcl_CmdInfo cmdInfo; 6731 if( objc<2 ){ 6732 Tcl_WrongNumArgs(interp, 1, objv, "COMMAND ..."); 6733 return TCL_ERROR; 6734 } 6735 if( !Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){ 6736 Tcl_AppendResult(interp, "command not found: ", 6737 Tcl_GetString(objv[1]), (char*)0); 6738 return TCL_ERROR; 6739 } 6740 if( cmdInfo.objProc==0 ){ 6741 Tcl_AppendResult(interp, "command has no objProc: ", 6742 Tcl_GetString(objv[1]), (char*)0); 6743 return TCL_ERROR; 6744 } 6745 return cmdInfo.objProc(cmdInfo.objClientData, interp, objc-1, objv+1); 6746 } 6747 6748 #ifndef SQLITE_OMIT_EXPLAIN 6749 /* 6750 ** WARNING: The following function, printExplainQueryPlan() is an exact 6751 ** copy of example code from eqp.in (eqp.html). If this code is modified, 6752 ** then the documentation copy needs to be modified as well. 6753 */ 6754 /* 6755 ** Argument pStmt is a prepared SQL statement. This function compiles 6756 ** an EXPLAIN QUERY PLAN command to report on the prepared statement, 6757 ** and prints the report to stdout using printf(). 6758 */ 6759 int printExplainQueryPlan(sqlite3_stmt *pStmt){ 6760 const char *zSql; /* Input SQL */ 6761 char *zExplain; /* SQL with EXPLAIN QUERY PLAN prepended */ 6762 sqlite3_stmt *pExplain; /* Compiled EXPLAIN QUERY PLAN command */ 6763 int rc; /* Return code from sqlite3_prepare_v2() */ 6764 6765 zSql = sqlite3_sql(pStmt); 6766 if( zSql==0 ) return SQLITE_ERROR; 6767 6768 zExplain = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zSql); 6769 if( zExplain==0 ) return SQLITE_NOMEM; 6770 6771 rc = sqlite3_prepare_v2(sqlite3_db_handle(pStmt), zExplain, -1, &pExplain, 0); 6772 sqlite3_free(zExplain); 6773 if( rc!=SQLITE_OK ) return rc; 6774 6775 while( SQLITE_ROW==sqlite3_step(pExplain) ){ 6776 int iSelectid = sqlite3_column_int(pExplain, 0); 6777 int iOrder = sqlite3_column_int(pExplain, 1); 6778 int iFrom = sqlite3_column_int(pExplain, 2); 6779 const char *zDetail = (const char *)sqlite3_column_text(pExplain, 3); 6780 6781 printf("%d %d %d %s\n", iSelectid, iOrder, iFrom, zDetail); 6782 } 6783 6784 return sqlite3_finalize(pExplain); 6785 } 6786 6787 static int SQLITE_TCLAPI test_print_eqp( 6788 void * clientData, 6789 Tcl_Interp *interp, 6790 int objc, 6791 Tcl_Obj *CONST objv[] 6792 ){ 6793 int rc; 6794 sqlite3_stmt *pStmt; 6795 6796 if( objc!=2 ){ 6797 Tcl_WrongNumArgs(interp, 1, objv, "STMT"); 6798 return TCL_ERROR; 6799 } 6800 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 6801 rc = printExplainQueryPlan(pStmt); 6802 /* This is needed on Windows so that a test case using this 6803 ** function can open a read pipe and get the output of 6804 ** printExplainQueryPlan() immediately. 6805 */ 6806 fflush(stdout); 6807 Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0); 6808 return TCL_OK; 6809 } 6810 #endif /* SQLITE_OMIT_EXPLAIN */ 6811 6812 /* 6813 ** sqlite3_test_control VERB ARGS... 6814 */ 6815 static int SQLITE_TCLAPI test_test_control( 6816 void * clientData, 6817 Tcl_Interp *interp, 6818 int objc, 6819 Tcl_Obj *CONST objv[] 6820 ){ 6821 struct Verb { 6822 const char *zName; 6823 int i; 6824 } aVerb[] = { 6825 { "SQLITE_TESTCTRL_LOCALTIME_FAULT", SQLITE_TESTCTRL_LOCALTIME_FAULT }, 6826 { "SQLITE_TESTCTRL_SORTER_MMAP", SQLITE_TESTCTRL_SORTER_MMAP }, 6827 { "SQLITE_TESTCTRL_IMPOSTER", SQLITE_TESTCTRL_IMPOSTER }, 6828 { "SQLITE_TESTCTRL_INTERNAL_FUNCTIONS", SQLITE_TESTCTRL_INTERNAL_FUNCTIONS}, 6829 }; 6830 int iVerb; 6831 int iFlag; 6832 int rc; 6833 6834 if( objc<2 ){ 6835 Tcl_WrongNumArgs(interp, 1, objv, "VERB ARGS..."); 6836 return TCL_ERROR; 6837 } 6838 6839 rc = Tcl_GetIndexFromObjStruct( 6840 interp, objv[1], aVerb, sizeof(aVerb[0]), "VERB", 0, &iVerb 6841 ); 6842 if( rc!=TCL_OK ) return rc; 6843 6844 iFlag = aVerb[iVerb].i; 6845 switch( iFlag ){ 6846 case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: 6847 case SQLITE_TESTCTRL_LOCALTIME_FAULT: { 6848 int val; 6849 if( objc!=3 ){ 6850 Tcl_WrongNumArgs(interp, 2, objv, "ONOFF"); 6851 return TCL_ERROR; 6852 } 6853 if( Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR; 6854 sqlite3_test_control(iFlag, val); 6855 break; 6856 } 6857 6858 case SQLITE_TESTCTRL_SORTER_MMAP: { 6859 int val; 6860 sqlite3 *db; 6861 if( objc!=4 ){ 6862 Tcl_WrongNumArgs(interp, 2, objv, "DB LIMIT"); 6863 return TCL_ERROR; 6864 } 6865 if( getDbPointer(interp, Tcl_GetString(objv[2]), &db) ) return TCL_ERROR; 6866 if( Tcl_GetIntFromObj(interp, objv[3], &val) ) return TCL_ERROR; 6867 sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, val); 6868 break; 6869 } 6870 6871 case SQLITE_TESTCTRL_IMPOSTER: { 6872 int onOff, tnum; 6873 const char *zDbName; 6874 sqlite3 *db; 6875 if( objc!=6 ){ 6876 Tcl_WrongNumArgs(interp, 2, objv, "DB dbName onOff tnum"); 6877 return TCL_ERROR; 6878 } 6879 if( getDbPointer(interp, Tcl_GetString(objv[2]), &db) ) return TCL_ERROR; 6880 zDbName = Tcl_GetString(objv[3]); 6881 if( Tcl_GetIntFromObj(interp, objv[4], &onOff) ) return TCL_ERROR; 6882 if( Tcl_GetIntFromObj(interp, objv[5], &tnum) ) return TCL_ERROR; 6883 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, zDbName, onOff, tnum); 6884 break; 6885 } 6886 } 6887 6888 Tcl_ResetResult(interp); 6889 return TCL_OK; 6890 } 6891 6892 #if SQLITE_OS_UNIX 6893 #include <sys/time.h> 6894 #include <sys/resource.h> 6895 6896 static int SQLITE_TCLAPI test_getrusage( 6897 void * clientData, 6898 Tcl_Interp *interp, 6899 int objc, 6900 Tcl_Obj *CONST objv[] 6901 ){ 6902 char buf[1024]; 6903 struct rusage r; 6904 memset(&r, 0, sizeof(r)); 6905 getrusage(RUSAGE_SELF, &r); 6906 6907 sqlite3_snprintf(sizeof(buf), buf, 6908 "ru_utime=%d.%06d ru_stime=%d.%06d ru_minflt=%d ru_majflt=%d", 6909 (int)r.ru_utime.tv_sec, (int)r.ru_utime.tv_usec, 6910 (int)r.ru_stime.tv_sec, (int)r.ru_stime.tv_usec, 6911 (int)r.ru_minflt, (int)r.ru_majflt 6912 ); 6913 Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, -1)); 6914 return TCL_OK; 6915 } 6916 #endif 6917 6918 #if SQLITE_OS_WIN 6919 /* 6920 ** Information passed from the main thread into the windows file locker 6921 ** background thread. 6922 */ 6923 struct win32FileLocker { 6924 char *evName; /* Name of event to signal thread startup */ 6925 HANDLE h; /* Handle of the file to be locked */ 6926 int delay1; /* Delay before locking */ 6927 int delay2; /* Delay before unlocking */ 6928 int ok; /* Finished ok */ 6929 int err; /* True if an error occurs */ 6930 }; 6931 #endif 6932 6933 6934 #if SQLITE_OS_WIN 6935 #include <process.h> 6936 /* 6937 ** The background thread that does file locking. 6938 */ 6939 static void SQLITE_CDECL win32_file_locker(void *pAppData){ 6940 struct win32FileLocker *p = (struct win32FileLocker*)pAppData; 6941 if( p->evName ){ 6942 HANDLE ev = OpenEvent(EVENT_MODIFY_STATE, FALSE, p->evName); 6943 if ( ev ){ 6944 SetEvent(ev); 6945 CloseHandle(ev); 6946 } 6947 } 6948 if( p->delay1 ) Sleep(p->delay1); 6949 if( LockFile(p->h, 0, 0, 100000000, 0) ){ 6950 Sleep(p->delay2); 6951 UnlockFile(p->h, 0, 0, 100000000, 0); 6952 p->ok = 1; 6953 }else{ 6954 p->err = 1; 6955 } 6956 CloseHandle(p->h); 6957 p->h = 0; 6958 p->delay1 = 0; 6959 p->delay2 = 0; 6960 } 6961 #endif 6962 6963 #if SQLITE_OS_WIN 6964 /* 6965 ** lock_win32_file FILENAME DELAY1 DELAY2 6966 ** 6967 ** Get an exclusive manditory lock on file for DELAY2 milliseconds. 6968 ** Wait DELAY1 milliseconds before acquiring the lock. 6969 */ 6970 static int SQLITE_TCLAPI win32_file_lock( 6971 void * clientData, 6972 Tcl_Interp *interp, 6973 int objc, 6974 Tcl_Obj *CONST objv[] 6975 ){ 6976 static struct win32FileLocker x = { "win32_file_lock", 0, 0, 0, 0, 0 }; 6977 const char *zFilename; 6978 char zBuf[200]; 6979 int retry = 0; 6980 HANDLE ev; 6981 DWORD wResult; 6982 6983 if( objc!=4 && objc!=1 ){ 6984 Tcl_WrongNumArgs(interp, 1, objv, "FILENAME DELAY1 DELAY2"); 6985 return TCL_ERROR; 6986 } 6987 if( objc==1 ){ 6988 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d %d %d %d %d", 6989 x.ok, x.err, x.delay1, x.delay2, x.h); 6990 Tcl_AppendResult(interp, zBuf, (char*)0); 6991 return TCL_OK; 6992 } 6993 while( x.h && retry<30 ){ 6994 retry++; 6995 Sleep(100); 6996 } 6997 if( x.h ){ 6998 Tcl_AppendResult(interp, "busy", (char*)0); 6999 return TCL_ERROR; 7000 } 7001 if( Tcl_GetIntFromObj(interp, objv[2], &x.delay1) ) return TCL_ERROR; 7002 if( Tcl_GetIntFromObj(interp, objv[3], &x.delay2) ) return TCL_ERROR; 7003 zFilename = Tcl_GetString(objv[1]); 7004 x.h = CreateFile(zFilename, GENERIC_READ|GENERIC_WRITE, 7005 FILE_SHARE_READ|FILE_SHARE_WRITE, 0, OPEN_ALWAYS, 7006 FILE_ATTRIBUTE_NORMAL, 0); 7007 if( !x.h ){ 7008 Tcl_AppendResult(interp, "cannot open file: ", zFilename, (char*)0); 7009 return TCL_ERROR; 7010 } 7011 ev = CreateEvent(NULL, TRUE, FALSE, x.evName); 7012 if ( !ev ){ 7013 Tcl_AppendResult(interp, "cannot create event: ", x.evName, (char*)0); 7014 return TCL_ERROR; 7015 } 7016 _beginthread(win32_file_locker, 0, (void*)&x); 7017 Sleep(0); 7018 if ( (wResult = WaitForSingleObject(ev, 10000))!=WAIT_OBJECT_0 ){ 7019 sqlite3_snprintf(sizeof(zBuf), zBuf, "0x%x", wResult); 7020 Tcl_AppendResult(interp, "wait failed: ", zBuf, (char*)0); 7021 CloseHandle(ev); 7022 return TCL_ERROR; 7023 } 7024 CloseHandle(ev); 7025 return TCL_OK; 7026 } 7027 7028 /* 7029 ** exists_win32_path PATH 7030 ** 7031 ** Returns non-zero if the specified path exists, whose fully qualified name 7032 ** may exceed 260 characters if it is prefixed with "\\?\". 7033 */ 7034 static int SQLITE_TCLAPI win32_exists_path( 7035 void *clientData, 7036 Tcl_Interp *interp, 7037 int objc, 7038 Tcl_Obj *CONST objv[] 7039 ){ 7040 if( objc!=2 ){ 7041 Tcl_WrongNumArgs(interp, 1, objv, "PATH"); 7042 return TCL_ERROR; 7043 } 7044 Tcl_SetObjResult(interp, Tcl_NewBooleanObj( 7045 GetFileAttributesW( Tcl_GetUnicode(objv[1]))!=INVALID_FILE_ATTRIBUTES )); 7046 return TCL_OK; 7047 } 7048 7049 /* 7050 ** find_win32_file PATTERN 7051 ** 7052 ** Returns a list of entries in a directory that match the specified pattern, 7053 ** whose fully qualified name may exceed 248 characters if it is prefixed with 7054 ** "\\?\". 7055 */ 7056 static int SQLITE_TCLAPI win32_find_file( 7057 void *clientData, 7058 Tcl_Interp *interp, 7059 int objc, 7060 Tcl_Obj *CONST objv[] 7061 ){ 7062 HANDLE hFindFile = INVALID_HANDLE_VALUE; 7063 WIN32_FIND_DATAW findData; 7064 Tcl_Obj *listObj; 7065 DWORD lastErrno; 7066 if( objc!=2 ){ 7067 Tcl_WrongNumArgs(interp, 1, objv, "PATTERN"); 7068 return TCL_ERROR; 7069 } 7070 hFindFile = FindFirstFileW(Tcl_GetUnicode(objv[1]), &findData); 7071 if( hFindFile==INVALID_HANDLE_VALUE ){ 7072 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError())); 7073 return TCL_ERROR; 7074 } 7075 listObj = Tcl_NewObj(); 7076 Tcl_IncrRefCount(listObj); 7077 do { 7078 Tcl_ListObjAppendElement(interp, listObj, Tcl_NewUnicodeObj( 7079 findData.cFileName, -1)); 7080 Tcl_ListObjAppendElement(interp, listObj, Tcl_NewWideIntObj( 7081 findData.dwFileAttributes)); 7082 } while( FindNextFileW(hFindFile, &findData) ); 7083 lastErrno = GetLastError(); 7084 if( lastErrno!=NO_ERROR && lastErrno!=ERROR_NO_MORE_FILES ){ 7085 FindClose(hFindFile); 7086 Tcl_DecrRefCount(listObj); 7087 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError())); 7088 return TCL_ERROR; 7089 } 7090 FindClose(hFindFile); 7091 Tcl_SetObjResult(interp, listObj); 7092 return TCL_OK; 7093 } 7094 7095 /* 7096 ** delete_win32_file FILENAME 7097 ** 7098 ** Deletes the specified file, whose fully qualified name may exceed 260 7099 ** characters if it is prefixed with "\\?\". 7100 */ 7101 static int SQLITE_TCLAPI win32_delete_file( 7102 void *clientData, 7103 Tcl_Interp *interp, 7104 int objc, 7105 Tcl_Obj *CONST objv[] 7106 ){ 7107 if( objc!=2 ){ 7108 Tcl_WrongNumArgs(interp, 1, objv, "FILENAME"); 7109 return TCL_ERROR; 7110 } 7111 if( !DeleteFileW(Tcl_GetUnicode(objv[1])) ){ 7112 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError())); 7113 return TCL_ERROR; 7114 } 7115 Tcl_ResetResult(interp); 7116 return TCL_OK; 7117 } 7118 7119 /* 7120 ** make_win32_dir DIRECTORY 7121 ** 7122 ** Creates the specified directory, whose fully qualified name may exceed 248 7123 ** characters if it is prefixed with "\\?\". 7124 */ 7125 static int SQLITE_TCLAPI win32_mkdir( 7126 void *clientData, 7127 Tcl_Interp *interp, 7128 int objc, 7129 Tcl_Obj *CONST objv[] 7130 ){ 7131 if( objc!=2 ){ 7132 Tcl_WrongNumArgs(interp, 1, objv, "DIRECTORY"); 7133 return TCL_ERROR; 7134 } 7135 if( !CreateDirectoryW(Tcl_GetUnicode(objv[1]), NULL) ){ 7136 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError())); 7137 return TCL_ERROR; 7138 } 7139 Tcl_ResetResult(interp); 7140 return TCL_OK; 7141 } 7142 7143 /* 7144 ** remove_win32_dir DIRECTORY 7145 ** 7146 ** Removes the specified directory, whose fully qualified name may exceed 248 7147 ** characters if it is prefixed with "\\?\". 7148 */ 7149 static int SQLITE_TCLAPI win32_rmdir( 7150 void *clientData, 7151 Tcl_Interp *interp, 7152 int objc, 7153 Tcl_Obj *CONST objv[] 7154 ){ 7155 if( objc!=2 ){ 7156 Tcl_WrongNumArgs(interp, 1, objv, "DIRECTORY"); 7157 return TCL_ERROR; 7158 } 7159 if( !RemoveDirectoryW(Tcl_GetUnicode(objv[1])) ){ 7160 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError())); 7161 return TCL_ERROR; 7162 } 7163 Tcl_ResetResult(interp); 7164 return TCL_OK; 7165 } 7166 #endif 7167 7168 7169 /* 7170 ** optimization_control DB OPT BOOLEAN 7171 ** 7172 ** Enable or disable query optimizations using the sqlite3_test_control() 7173 ** interface. Disable if BOOLEAN is false and enable if BOOLEAN is true. 7174 ** OPT is the name of the optimization to be disabled. 7175 */ 7176 static int SQLITE_TCLAPI optimization_control( 7177 void * clientData, 7178 Tcl_Interp *interp, 7179 int objc, 7180 Tcl_Obj *CONST objv[] 7181 ){ 7182 int i; 7183 sqlite3 *db; 7184 const char *zOpt; 7185 int onoff; 7186 int mask = 0; 7187 static const struct { 7188 const char *zOptName; 7189 int mask; 7190 } aOpt[] = { 7191 { "all", SQLITE_AllOpts }, 7192 { "none", 0 }, 7193 { "query-flattener", SQLITE_QueryFlattener }, 7194 { "groupby-order", SQLITE_GroupByOrder }, 7195 { "factor-constants", SQLITE_FactorOutConst }, 7196 { "distinct-opt", SQLITE_DistinctOpt }, 7197 { "cover-idx-scan", SQLITE_CoverIdxScan }, 7198 { "order-by-idx-join", SQLITE_OrderByIdxJoin }, 7199 { "transitive", SQLITE_Transitive }, 7200 { "omit-noop-join", SQLITE_OmitNoopJoin }, 7201 { "stat4", SQLITE_Stat4 }, 7202 { "skip-scan", SQLITE_SkipScan }, 7203 }; 7204 7205 if( objc!=4 ){ 7206 Tcl_WrongNumArgs(interp, 1, objv, "DB OPT BOOLEAN"); 7207 return TCL_ERROR; 7208 } 7209 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 7210 if( Tcl_GetBooleanFromObj(interp, objv[3], &onoff) ) return TCL_ERROR; 7211 zOpt = Tcl_GetString(objv[2]); 7212 for(i=0; i<sizeof(aOpt)/sizeof(aOpt[0]); i++){ 7213 if( strcmp(zOpt, aOpt[i].zOptName)==0 ){ 7214 mask = aOpt[i].mask; 7215 break; 7216 } 7217 } 7218 if( onoff ) mask = ~mask; 7219 if( i>=sizeof(aOpt)/sizeof(aOpt[0]) ){ 7220 Tcl_AppendResult(interp, "unknown optimization - should be one of:", 7221 (char*)0); 7222 for(i=0; i<sizeof(aOpt)/sizeof(aOpt[0]); i++){ 7223 Tcl_AppendResult(interp, " ", aOpt[i].zOptName, (char*)0); 7224 } 7225 return TCL_ERROR; 7226 } 7227 sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, db, mask); 7228 return TCL_OK; 7229 } 7230 7231 /* 7232 ** load_static_extension DB NAME ... 7233 ** 7234 ** Load one or more statically linked extensions. 7235 */ 7236 static int SQLITE_TCLAPI tclLoadStaticExtensionCmd( 7237 void * clientData, 7238 Tcl_Interp *interp, 7239 int objc, 7240 Tcl_Obj *CONST objv[] 7241 ){ 7242 extern int sqlite3_amatch_init(sqlite3*,char**,const sqlite3_api_routines*); 7243 extern int sqlite3_carray_init(sqlite3*,char**,const sqlite3_api_routines*); 7244 extern int sqlite3_closure_init(sqlite3*,char**,const sqlite3_api_routines*); 7245 extern int sqlite3_csv_init(sqlite3*,char**,const sqlite3_api_routines*); 7246 extern int sqlite3_eval_init(sqlite3*,char**,const sqlite3_api_routines*); 7247 extern int sqlite3_explain_init(sqlite3*,char**,const sqlite3_api_routines*); 7248 extern int sqlite3_fileio_init(sqlite3*,char**,const sqlite3_api_routines*); 7249 extern int sqlite3_fuzzer_init(sqlite3*,char**,const sqlite3_api_routines*); 7250 extern int sqlite3_ieee_init(sqlite3*,char**,const sqlite3_api_routines*); 7251 extern int sqlite3_nextchar_init(sqlite3*,char**,const sqlite3_api_routines*); 7252 extern int sqlite3_percentile_init(sqlite3*,char**,const sqlite3_api_routines*); 7253 #ifndef SQLITE_OMIT_VIRTUALTABLE 7254 extern int sqlite3_prefixes_init(sqlite3*,char**,const sqlite3_api_routines*); 7255 #endif 7256 extern int sqlite3_regexp_init(sqlite3*,char**,const sqlite3_api_routines*); 7257 extern int sqlite3_remember_init(sqlite3*,char**,const sqlite3_api_routines*); 7258 extern int sqlite3_series_init(sqlite3*,char**,const sqlite3_api_routines*); 7259 extern int sqlite3_spellfix_init(sqlite3*,char**,const sqlite3_api_routines*); 7260 extern int sqlite3_totype_init(sqlite3*,char**,const sqlite3_api_routines*); 7261 extern int sqlite3_wholenumber_init(sqlite3*,char**,const sqlite3_api_routines*); 7262 extern int sqlite3_unionvtab_init(sqlite3*,char**,const sqlite3_api_routines*); 7263 #ifdef SQLITE_HAVE_ZLIB 7264 extern int sqlite3_zipfile_init(sqlite3*,char**,const sqlite3_api_routines*); 7265 #endif 7266 static const struct { 7267 const char *zExtName; 7268 int (*pInit)(sqlite3*,char**,const sqlite3_api_routines*); 7269 } aExtension[] = { 7270 { "amatch", sqlite3_amatch_init }, 7271 { "carray", sqlite3_carray_init }, 7272 { "closure", sqlite3_closure_init }, 7273 { "csv", sqlite3_csv_init }, 7274 { "eval", sqlite3_eval_init }, 7275 { "explain", sqlite3_explain_init }, 7276 { "fileio", sqlite3_fileio_init }, 7277 { "fuzzer", sqlite3_fuzzer_init }, 7278 { "ieee754", sqlite3_ieee_init }, 7279 { "nextchar", sqlite3_nextchar_init }, 7280 { "percentile", sqlite3_percentile_init }, 7281 #ifndef SQLITE_OMIT_VIRTUALTABLE 7282 { "prefixes", sqlite3_prefixes_init }, 7283 #endif 7284 { "regexp", sqlite3_regexp_init }, 7285 { "remember", sqlite3_remember_init }, 7286 { "series", sqlite3_series_init }, 7287 { "spellfix", sqlite3_spellfix_init }, 7288 { "totype", sqlite3_totype_init }, 7289 { "unionvtab", sqlite3_unionvtab_init }, 7290 { "wholenumber", sqlite3_wholenumber_init }, 7291 #ifdef SQLITE_HAVE_ZLIB 7292 { "zipfile", sqlite3_zipfile_init }, 7293 #endif 7294 }; 7295 sqlite3 *db; 7296 const char *zName; 7297 int i, j, rc; 7298 char *zErrMsg = 0; 7299 if( objc<3 ){ 7300 Tcl_WrongNumArgs(interp, 1, objv, "DB NAME ..."); 7301 return TCL_ERROR; 7302 } 7303 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 7304 for(j=2; j<objc; j++){ 7305 zName = Tcl_GetString(objv[j]); 7306 for(i=0; i<ArraySize(aExtension); i++){ 7307 if( strcmp(zName, aExtension[i].zExtName)==0 ) break; 7308 } 7309 if( i>=ArraySize(aExtension) ){ 7310 Tcl_AppendResult(interp, "no such extension: ", zName, (char*)0); 7311 return TCL_ERROR; 7312 } 7313 if( aExtension[i].pInit ){ 7314 rc = aExtension[i].pInit(db, &zErrMsg, 0); 7315 }else{ 7316 rc = SQLITE_OK; 7317 } 7318 if( rc!=SQLITE_OK || zErrMsg ){ 7319 Tcl_AppendResult(interp, "initialization of ", zName, " failed: ", zErrMsg, 7320 (char*)0); 7321 sqlite3_free(zErrMsg); 7322 return TCL_ERROR; 7323 } 7324 } 7325 return TCL_OK; 7326 } 7327 7328 /* 7329 ** sorter_test_fakeheap BOOL 7330 ** 7331 */ 7332 static int SQLITE_TCLAPI sorter_test_fakeheap( 7333 void * clientData, 7334 Tcl_Interp *interp, 7335 int objc, 7336 Tcl_Obj *CONST objv[] 7337 ){ 7338 int bArg; 7339 if( objc!=2 ){ 7340 Tcl_WrongNumArgs(interp, 1, objv, "BOOL"); 7341 return TCL_ERROR; 7342 } 7343 7344 if( Tcl_GetBooleanFromObj(interp, objv[1], &bArg) ){ 7345 return TCL_ERROR; 7346 } 7347 7348 if( bArg ){ 7349 if( sqlite3GlobalConfig.pHeap==0 ){ 7350 sqlite3GlobalConfig.pHeap = SQLITE_INT_TO_PTR(-1); 7351 } 7352 }else{ 7353 if( sqlite3GlobalConfig.pHeap==SQLITE_INT_TO_PTR(-1) ){ 7354 sqlite3GlobalConfig.pHeap = 0; 7355 } 7356 } 7357 7358 Tcl_ResetResult(interp); 7359 return TCL_OK; 7360 } 7361 7362 /* 7363 ** sorter_test_sort4_helper DB SQL1 NSTEP SQL2 7364 ** 7365 ** Compile SQL statement $SQL1 and step it $NSTEP times. For each row, 7366 ** check that the leftmost and rightmost columns returned are both integers, 7367 ** and that both contain the same value. 7368 ** 7369 ** Then execute statement $SQL2. Check that the statement returns the same 7370 ** set of integers in the same order as in the previous step (using $SQL1). 7371 */ 7372 static int SQLITE_TCLAPI sorter_test_sort4_helper( 7373 void * clientData, 7374 Tcl_Interp *interp, 7375 int objc, 7376 Tcl_Obj *CONST objv[] 7377 ){ 7378 const char *zSql1; 7379 const char *zSql2; 7380 int nStep; 7381 int iStep; 7382 unsigned int iCksum1 = 0; 7383 unsigned int iCksum2 = 0; 7384 int rc; 7385 int iB; 7386 sqlite3 *db; 7387 sqlite3_stmt *pStmt; 7388 7389 if( objc!=5 ){ 7390 Tcl_WrongNumArgs(interp, 1, objv, "DB SQL1 NSTEP SQL2"); 7391 return TCL_ERROR; 7392 } 7393 7394 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 7395 zSql1 = Tcl_GetString(objv[2]); 7396 if( Tcl_GetIntFromObj(interp, objv[3], &nStep) ) return TCL_ERROR; 7397 zSql2 = Tcl_GetString(objv[4]); 7398 7399 rc = sqlite3_prepare_v2(db, zSql1, -1, &pStmt, 0); 7400 if( rc!=SQLITE_OK ) goto sql_error; 7401 7402 iB = sqlite3_column_count(pStmt)-1; 7403 for(iStep=0; iStep<nStep && SQLITE_ROW==sqlite3_step(pStmt); iStep++){ 7404 int a = sqlite3_column_int(pStmt, 0); 7405 if( a!=sqlite3_column_int(pStmt, iB) ){ 7406 Tcl_AppendResult(interp, "data error: (a!=b)", 0); 7407 return TCL_ERROR; 7408 } 7409 7410 iCksum1 += (iCksum1 << 3) + (unsigned int)a; 7411 } 7412 rc = sqlite3_finalize(pStmt); 7413 if( rc!=SQLITE_OK ) goto sql_error; 7414 7415 rc = sqlite3_prepare_v2(db, zSql2, -1, &pStmt, 0); 7416 if( rc!=SQLITE_OK ) goto sql_error; 7417 for(iStep=0; SQLITE_ROW==sqlite3_step(pStmt); iStep++){ 7418 int a = sqlite3_column_int(pStmt, 0); 7419 iCksum2 += (iCksum2 << 3) + (unsigned int)a; 7420 } 7421 rc = sqlite3_finalize(pStmt); 7422 if( rc!=SQLITE_OK ) goto sql_error; 7423 7424 if( iCksum1!=iCksum2 ){ 7425 Tcl_AppendResult(interp, "checksum mismatch", 0); 7426 return TCL_ERROR; 7427 } 7428 7429 return TCL_OK; 7430 sql_error: 7431 Tcl_AppendResult(interp, "sql error: ", sqlite3_errmsg(db), 0); 7432 return TCL_ERROR; 7433 } 7434 7435 7436 #ifdef SQLITE_USER_AUTHENTICATION 7437 #include "sqlite3userauth.h" 7438 /* 7439 ** tclcmd: sqlite3_user_authenticate DB USERNAME PASSWORD 7440 */ 7441 static int SQLITE_TCLAPI test_user_authenticate( 7442 ClientData clientData, /* Unused */ 7443 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 7444 int objc, /* Number of arguments */ 7445 Tcl_Obj *CONST objv[] /* Command arguments */ 7446 ){ 7447 char *zUser = 0; 7448 char *zPasswd = 0; 7449 int nPasswd = 0; 7450 sqlite3 *db; 7451 int rc; 7452 7453 if( objc!=4 ){ 7454 Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME PASSWORD"); 7455 return TCL_ERROR; 7456 } 7457 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 7458 return TCL_ERROR; 7459 } 7460 zUser = Tcl_GetString(objv[2]); 7461 zPasswd = Tcl_GetStringFromObj(objv[3], &nPasswd); 7462 rc = sqlite3_user_authenticate(db, zUser, zPasswd, nPasswd); 7463 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 7464 return TCL_OK; 7465 } 7466 #endif /* SQLITE_USER_AUTHENTICATION */ 7467 7468 #ifdef SQLITE_USER_AUTHENTICATION 7469 /* 7470 ** tclcmd: sqlite3_user_add DB USERNAME PASSWORD ISADMIN 7471 */ 7472 static int SQLITE_TCLAPI test_user_add( 7473 ClientData clientData, /* Unused */ 7474 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 7475 int objc, /* Number of arguments */ 7476 Tcl_Obj *CONST objv[] /* Command arguments */ 7477 ){ 7478 char *zUser = 0; 7479 char *zPasswd = 0; 7480 int nPasswd = 0; 7481 int isAdmin = 0; 7482 sqlite3 *db; 7483 int rc; 7484 7485 if( objc!=5 ){ 7486 Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME PASSWORD ISADMIN"); 7487 return TCL_ERROR; 7488 } 7489 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 7490 return TCL_ERROR; 7491 } 7492 zUser = Tcl_GetString(objv[2]); 7493 zPasswd = Tcl_GetStringFromObj(objv[3], &nPasswd); 7494 Tcl_GetBooleanFromObj(interp, objv[4], &isAdmin); 7495 rc = sqlite3_user_add(db, zUser, zPasswd, nPasswd, isAdmin); 7496 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 7497 return TCL_OK; 7498 } 7499 #endif /* SQLITE_USER_AUTHENTICATION */ 7500 7501 #ifdef SQLITE_USER_AUTHENTICATION 7502 /* 7503 ** tclcmd: sqlite3_user_change DB USERNAME PASSWORD ISADMIN 7504 */ 7505 static int SQLITE_TCLAPI test_user_change( 7506 ClientData clientData, /* Unused */ 7507 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 7508 int objc, /* Number of arguments */ 7509 Tcl_Obj *CONST objv[] /* Command arguments */ 7510 ){ 7511 char *zUser = 0; 7512 char *zPasswd = 0; 7513 int nPasswd = 0; 7514 int isAdmin = 0; 7515 sqlite3 *db; 7516 int rc; 7517 7518 if( objc!=5 ){ 7519 Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME PASSWORD ISADMIN"); 7520 return TCL_ERROR; 7521 } 7522 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 7523 return TCL_ERROR; 7524 } 7525 zUser = Tcl_GetString(objv[2]); 7526 zPasswd = Tcl_GetStringFromObj(objv[3], &nPasswd); 7527 Tcl_GetBooleanFromObj(interp, objv[4], &isAdmin); 7528 rc = sqlite3_user_change(db, zUser, zPasswd, nPasswd, isAdmin); 7529 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 7530 return TCL_OK; 7531 } 7532 #endif /* SQLITE_USER_AUTHENTICATION */ 7533 7534 #ifdef SQLITE_USER_AUTHENTICATION 7535 /* 7536 ** tclcmd: sqlite3_user_delete DB USERNAME 7537 */ 7538 static int SQLITE_TCLAPI test_user_delete( 7539 ClientData clientData, /* Unused */ 7540 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 7541 int objc, /* Number of arguments */ 7542 Tcl_Obj *CONST objv[] /* Command arguments */ 7543 ){ 7544 char *zUser = 0; 7545 sqlite3 *db; 7546 int rc; 7547 7548 if( objc!=3 ){ 7549 Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME"); 7550 return TCL_ERROR; 7551 } 7552 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 7553 return TCL_ERROR; 7554 } 7555 zUser = Tcl_GetString(objv[2]); 7556 rc = sqlite3_user_delete(db, zUser); 7557 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 7558 return TCL_OK; 7559 } 7560 #endif /* SQLITE_USER_AUTHENTICATION */ 7561 7562 /* 7563 ** tclcmd: bad_behavior TYPE 7564 ** 7565 ** Do some things that should trigger a valgrind or -fsanitize=undefined 7566 ** warning. This is used to verify that errors and warnings output by those 7567 ** tools are detected by the test scripts. 7568 ** 7569 ** TYPE BEHAVIOR 7570 ** 1 Overflow a signed integer 7571 ** 2 Jump based on an uninitialized variable 7572 ** 3 Read after free 7573 ** 4 Panic 7574 */ 7575 static int SQLITE_TCLAPI test_bad_behavior( 7576 ClientData clientData, /* Pointer to an integer containing zero */ 7577 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 7578 int objc, /* Number of arguments */ 7579 Tcl_Obj *CONST objv[] /* Command arguments */ 7580 ){ 7581 int iType; 7582 int xyz; 7583 int i = *(int*)clientData; 7584 int j; 7585 int w[10]; 7586 int *a; 7587 if( objc!=2 ){ 7588 Tcl_WrongNumArgs(interp, 1, objv, "TYPE"); 7589 return TCL_ERROR; 7590 } 7591 if( Tcl_GetIntFromObj(interp, objv[1], &iType) ) return TCL_ERROR; 7592 switch( iType ){ 7593 case 1: { 7594 xyz = 0x7fffff00 - i; 7595 xyz += 0x100; 7596 Tcl_SetObjResult(interp, Tcl_NewIntObj(xyz)); 7597 break; 7598 } 7599 case 2: { 7600 w[1] = 5; 7601 if( w[i]>0 ) w[1]++; 7602 Tcl_SetObjResult(interp, Tcl_NewIntObj(w[1])); 7603 break; 7604 } 7605 case 3: { 7606 a = malloc( sizeof(int)*10 ); 7607 for(j=0; j<10; j++) a[j] = j; 7608 free(a); 7609 Tcl_SetObjResult(interp, Tcl_NewIntObj(a[i])); 7610 break; 7611 } 7612 case 4: { 7613 Tcl_Panic("Deliberate panic"); 7614 break; 7615 } 7616 } 7617 return TCL_OK; 7618 } 7619 7620 /* 7621 ** tclcmd: register_dbstat_vtab DB 7622 ** 7623 ** Cause the dbstat virtual table to be available on the connection DB 7624 */ 7625 static int SQLITE_TCLAPI test_register_dbstat_vtab( 7626 void *clientData, 7627 Tcl_Interp *interp, 7628 int objc, 7629 Tcl_Obj *CONST objv[] 7630 ){ 7631 #ifdef SQLITE_OMIT_VIRTUALTABLE 7632 Tcl_AppendResult(interp, "dbstat not available because of " 7633 "SQLITE_OMIT_VIRTUALTABLE", (void*)0); 7634 return TCL_ERROR; 7635 #else 7636 struct SqliteDb { sqlite3 *db; }; 7637 char *zDb; 7638 Tcl_CmdInfo cmdInfo; 7639 7640 if( objc!=2 ){ 7641 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 7642 return TCL_ERROR; 7643 } 7644 7645 zDb = Tcl_GetString(objv[1]); 7646 if( Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){ 7647 sqlite3* db = ((struct SqliteDb*)cmdInfo.objClientData)->db; 7648 sqlite3DbstatRegister(db); 7649 } 7650 return TCL_OK; 7651 #endif /* SQLITE_OMIT_VIRTUALTABLE */ 7652 } 7653 7654 /* 7655 ** tclcmd: sqlite3_db_config DB SETTING VALUE 7656 ** 7657 ** Invoke sqlite3_db_config() for one of the setting values. 7658 */ 7659 static int SQLITE_TCLAPI test_sqlite3_db_config( 7660 void *clientData, 7661 Tcl_Interp *interp, 7662 int objc, 7663 Tcl_Obj *CONST objv[] 7664 ){ 7665 static const struct { 7666 const char *zName; 7667 int eVal; 7668 } aSetting[] = { 7669 { "FKEY", SQLITE_DBCONFIG_ENABLE_FKEY }, 7670 { "TRIGGER", SQLITE_DBCONFIG_ENABLE_TRIGGER }, 7671 { "FTS3_TOKENIZER", SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER }, 7672 { "LOAD_EXTENSION", SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION }, 7673 { "NO_CKPT_ON_CLOSE", SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE }, 7674 { "QPSG", SQLITE_DBCONFIG_ENABLE_QPSG }, 7675 { "TRIGGER_EQP", SQLITE_DBCONFIG_TRIGGER_EQP }, 7676 { "RESET_DB", SQLITE_DBCONFIG_RESET_DATABASE }, 7677 { "DEFENSIVE", SQLITE_DBCONFIG_DEFENSIVE }, 7678 { "WRITABLE_SCHEMA", SQLITE_DBCONFIG_WRITABLE_SCHEMA }, 7679 { "LEGACY_ALTER_TABLE", SQLITE_DBCONFIG_LEGACY_ALTER_TABLE }, 7680 { "DQS_DML", SQLITE_DBCONFIG_DQS_DML }, 7681 { "DQS_DDL", SQLITE_DBCONFIG_DQS_DDL }, 7682 }; 7683 int i; 7684 int v; 7685 const char *zSetting; 7686 sqlite3 *db; 7687 7688 if( objc!=4 ){ 7689 Tcl_WrongNumArgs(interp, 1, objv, "DB SETTING VALUE"); 7690 return TCL_ERROR; 7691 } 7692 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 7693 zSetting = Tcl_GetString(objv[2]); 7694 if( sqlite3_strglob("SQLITE_*", zSetting)==0 ) zSetting += 7; 7695 if( sqlite3_strglob("DBCONFIG_*", zSetting)==0 ) zSetting += 9; 7696 if( sqlite3_strglob("ENABLE_*", zSetting)==0 ) zSetting += 7; 7697 for(i=0; i<ArraySize(aSetting); i++){ 7698 if( strcmp(zSetting, aSetting[i].zName)==0 ) break; 7699 } 7700 if( i>=ArraySize(aSetting) ){ 7701 Tcl_SetObjResult(interp, 7702 Tcl_NewStringObj("unknown sqlite3_db_config setting", -1)); 7703 return TCL_ERROR; 7704 } 7705 if( Tcl_GetIntFromObj(interp, objv[3], &v) ) return TCL_ERROR; 7706 sqlite3_db_config(db, aSetting[i].eVal, v, &v); 7707 Tcl_SetObjResult(interp, Tcl_NewIntObj(v)); 7708 return TCL_OK; 7709 } 7710 7711 /* 7712 ** Change the name of the main database schema from "main" to "icecube". 7713 */ 7714 static int SQLITE_TCLAPI test_dbconfig_maindbname_icecube( 7715 void * clientData, 7716 Tcl_Interp *interp, 7717 int objc, 7718 Tcl_Obj *CONST objv[] 7719 ){ 7720 int rc; 7721 sqlite3 *db; 7722 extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**); 7723 if( objc!=2 ){ 7724 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 7725 return TCL_ERROR; 7726 }else{ 7727 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 7728 rc = sqlite3_db_config(db, SQLITE_DBCONFIG_MAINDBNAME, "icecube"); 7729 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 7730 return TCL_OK; 7731 } 7732 } 7733 7734 /* 7735 ** Usage: sqlite3_mmap_warm DB DBNAME 7736 */ 7737 static int SQLITE_TCLAPI test_mmap_warm( 7738 void * clientData, 7739 Tcl_Interp *interp, 7740 int objc, 7741 Tcl_Obj *CONST objv[] 7742 ){ 7743 extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**); 7744 extern int sqlite3_mmap_warm(sqlite3 *db, const char *); 7745 7746 if( objc!=2 && objc!=3 ){ 7747 Tcl_WrongNumArgs(interp, 1, objv, "DB ?DBNAME?"); 7748 return TCL_ERROR; 7749 }else{ 7750 int rc; 7751 sqlite3 *db; 7752 const char *zDb = 0; 7753 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 7754 if( objc==3 ){ 7755 zDb = Tcl_GetString(objv[2]); 7756 } 7757 rc = sqlite3_mmap_warm(db, zDb); 7758 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); 7759 return TCL_OK; 7760 } 7761 } 7762 7763 /* 7764 ** Usage: decode_hexdb TEXT 7765 ** 7766 ** Example: db deserialize [decode_hexdb $output_of_dbtotxt] 7767 ** 7768 ** This routine returns a byte-array for an SQLite database file that 7769 ** is constructed from a text input which is the output of the "dbtotxt" 7770 ** utility. 7771 */ 7772 static int SQLITE_TCLAPI test_decode_hexdb( 7773 void * clientData, 7774 Tcl_Interp *interp, 7775 int objc, 7776 Tcl_Obj *CONST objv[] 7777 ){ 7778 const char *zIn = 0; 7779 unsigned char *a = 0; 7780 int n = 0; 7781 int lineno = 0; 7782 int i, iNext; 7783 int iOffset = 0; 7784 int j, k; 7785 int rc; 7786 unsigned int x[16]; 7787 if( objc!=2 ){ 7788 Tcl_WrongNumArgs(interp, 1, objv, "HEXDB"); 7789 return TCL_ERROR; 7790 } 7791 zIn = Tcl_GetString(objv[1]); 7792 for(i=0; zIn[i]; i=iNext){ 7793 lineno++; 7794 for(iNext=i; zIn[iNext] && zIn[iNext]!='\n'; iNext++){} 7795 if( zIn[iNext]=='\n' ) iNext++; 7796 while( zIn[i]==' ' || zIn[i]=='\t' ){ i++; } 7797 if( a==0 ){ 7798 int pgsz; 7799 rc = sscanf(zIn+i, "| size %d pagesize %d", &n, &pgsz); 7800 if( rc!=2 ) continue; 7801 if( pgsz<512 || pgsz>65536 || (pgsz&(pgsz-1))!=0 ){ 7802 Tcl_AppendResult(interp, "bad 'pagesize' field", (void*)0); 7803 return TCL_ERROR; 7804 } 7805 n = (n+pgsz-1)&~(pgsz-1); /* Round n up to the next multiple of pgsz */ 7806 if( n<512 ){ 7807 Tcl_AppendResult(interp, "bad 'size' field", (void*)0); 7808 return TCL_ERROR; 7809 } 7810 a = malloc( n ); 7811 if( a==0 ){ 7812 Tcl_AppendResult(interp, "out of memory", (void*)0); 7813 return TCL_ERROR; 7814 } 7815 memset(a, 0, n); 7816 continue; 7817 } 7818 rc = sscanf(zIn+i, "| page %d offset %d", &j, &k); 7819 if( rc==2 ){ 7820 iOffset = k; 7821 continue; 7822 } 7823 rc = sscanf(zIn+i,"| %d: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x", 7824 &j, &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7], 7825 &x[8], &x[9], &x[10], &x[11], &x[12], &x[13], &x[14], &x[15]); 7826 if( rc==17 ){ 7827 k = iOffset+j; 7828 if( k+16<=n ){ 7829 int ii; 7830 for(ii=0; ii<16; ii++) a[k+ii] = x[ii]&0xff; 7831 } 7832 continue; 7833 } 7834 } 7835 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(a, n)); 7836 free(a); 7837 return TCL_OK; 7838 } 7839 7840 7841 /* 7842 ** Register commands with the TCL interpreter. 7843 */ 7844 int Sqlitetest1_Init(Tcl_Interp *interp){ 7845 extern int sqlite3_search_count; 7846 extern int sqlite3_found_count; 7847 extern int sqlite3_interrupt_count; 7848 extern int sqlite3_open_file_count; 7849 extern int sqlite3_sort_count; 7850 extern int sqlite3_current_time; 7851 #if SQLITE_OS_UNIX && defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE 7852 extern int sqlite3_hostid_num; 7853 #endif 7854 extern int sqlite3_max_blobsize; 7855 extern int SQLITE_TCLAPI sqlite3BtreeSharedCacheReport(void*, 7856 Tcl_Interp*,int,Tcl_Obj*CONST*); 7857 static int iZero = 0; 7858 static struct { 7859 char *zName; 7860 Tcl_CmdProc *xProc; 7861 } aCmd[] = { 7862 { "db_enter", (Tcl_CmdProc*)db_enter }, 7863 { "db_leave", (Tcl_CmdProc*)db_leave }, 7864 { "sqlite3_mprintf_int", (Tcl_CmdProc*)sqlite3_mprintf_int }, 7865 { "sqlite3_mprintf_int64", (Tcl_CmdProc*)sqlite3_mprintf_int64 }, 7866 { "sqlite3_mprintf_long", (Tcl_CmdProc*)sqlite3_mprintf_long }, 7867 { "sqlite3_mprintf_str", (Tcl_CmdProc*)sqlite3_mprintf_str }, 7868 { "sqlite3_snprintf_str", (Tcl_CmdProc*)sqlite3_snprintf_str }, 7869 { "sqlite3_mprintf_stronly", (Tcl_CmdProc*)sqlite3_mprintf_stronly}, 7870 { "sqlite3_mprintf_double", (Tcl_CmdProc*)sqlite3_mprintf_double }, 7871 { "sqlite3_mprintf_scaled", (Tcl_CmdProc*)sqlite3_mprintf_scaled }, 7872 { "sqlite3_mprintf_hexdouble", (Tcl_CmdProc*)sqlite3_mprintf_hexdouble}, 7873 { "sqlite3_mprintf_z_test", (Tcl_CmdProc*)test_mprintf_z }, 7874 { "sqlite3_mprintf_n_test", (Tcl_CmdProc*)test_mprintf_n }, 7875 { "sqlite3_snprintf_int", (Tcl_CmdProc*)test_snprintf_int }, 7876 { "sqlite3_last_insert_rowid", (Tcl_CmdProc*)test_last_rowid }, 7877 { "sqlite3_exec_printf", (Tcl_CmdProc*)test_exec_printf }, 7878 { "sqlite3_exec_hex", (Tcl_CmdProc*)test_exec_hex }, 7879 { "sqlite3_exec", (Tcl_CmdProc*)test_exec }, 7880 { "sqlite3_exec_nr", (Tcl_CmdProc*)test_exec_nr }, 7881 #ifndef SQLITE_OMIT_GET_TABLE 7882 { "sqlite3_get_table_printf", (Tcl_CmdProc*)test_get_table_printf }, 7883 #endif 7884 { "sqlite3_close", (Tcl_CmdProc*)sqlite_test_close }, 7885 { "sqlite3_close_v2", (Tcl_CmdProc*)sqlite_test_close_v2 }, 7886 { "sqlite3_create_function", (Tcl_CmdProc*)test_create_function }, 7887 { "sqlite3_create_aggregate", (Tcl_CmdProc*)test_create_aggregate }, 7888 { "sqlite3_drop_modules", (Tcl_CmdProc*)test_drop_modules }, 7889 { "sqlite_register_test_function", (Tcl_CmdProc*)test_register_func }, 7890 { "sqlite_abort", (Tcl_CmdProc*)sqlite_abort }, 7891 { "sqlite_bind", (Tcl_CmdProc*)test_bind }, 7892 { "breakpoint", (Tcl_CmdProc*)test_breakpoint }, 7893 { "sqlite3_key", (Tcl_CmdProc*)test_key }, 7894 { "sqlite3_rekey", (Tcl_CmdProc*)test_rekey }, 7895 { "sqlite_set_magic", (Tcl_CmdProc*)sqlite_set_magic }, 7896 { "sqlite3_interrupt", (Tcl_CmdProc*)test_interrupt }, 7897 { "sqlite_delete_function", (Tcl_CmdProc*)delete_function }, 7898 { "sqlite_delete_collation", (Tcl_CmdProc*)delete_collation }, 7899 { "sqlite3_get_autocommit", (Tcl_CmdProc*)get_autocommit }, 7900 { "sqlite3_busy_timeout", (Tcl_CmdProc*)test_busy_timeout }, 7901 { "printf", (Tcl_CmdProc*)test_printf }, 7902 { "sqlite3IoTrace", (Tcl_CmdProc*)test_io_trace }, 7903 { "clang_sanitize_address", (Tcl_CmdProc*)clang_sanitize_address }, 7904 }; 7905 static struct { 7906 char *zName; 7907 Tcl_ObjCmdProc *xProc; 7908 void *clientData; 7909 } aObjCmd[] = { 7910 { "sqlite3_db_config", test_sqlite3_db_config, 0 }, 7911 { "bad_behavior", test_bad_behavior, (void*)&iZero }, 7912 { "register_dbstat_vtab", test_register_dbstat_vtab }, 7913 { "sqlite3_connection_pointer", get_sqlite_pointer, 0 }, 7914 { "intarray_addr", test_intarray_addr, 0 }, 7915 { "int64array_addr", test_int64array_addr, 0 }, 7916 { "doublearray_addr", test_doublearray_addr, 0 }, 7917 { "textarray_addr", test_textarray_addr, 0 }, 7918 { "sqlite3_bind_int", test_bind_int, 0 }, 7919 { "sqlite3_bind_zeroblob", test_bind_zeroblob, 0 }, 7920 { "sqlite3_bind_zeroblob64", test_bind_zeroblob64, 0 }, 7921 { "sqlite3_bind_int64", test_bind_int64, 0 }, 7922 { "sqlite3_bind_double", test_bind_double, 0 }, 7923 { "sqlite3_bind_null", test_bind_null ,0 }, 7924 { "sqlite3_bind_text", test_bind_text ,0 }, 7925 { "sqlite3_bind_text16", test_bind_text16 ,0 }, 7926 { "sqlite3_bind_blob", test_bind_blob ,0 }, 7927 { "sqlite3_bind_parameter_count", test_bind_parameter_count, 0}, 7928 { "sqlite3_bind_parameter_name", test_bind_parameter_name, 0}, 7929 { "sqlite3_bind_parameter_index", test_bind_parameter_index, 0}, 7930 { "sqlite3_clear_bindings", test_clear_bindings, 0}, 7931 { "sqlite3_sleep", test_sleep, 0}, 7932 { "sqlite3_errcode", test_errcode ,0 }, 7933 { "sqlite3_extended_errcode", test_ex_errcode ,0 }, 7934 { "sqlite3_errmsg", test_errmsg ,0 }, 7935 { "sqlite3_errmsg16", test_errmsg16 ,0 }, 7936 { "sqlite3_open", test_open ,0 }, 7937 { "sqlite3_open16", test_open16 ,0 }, 7938 { "sqlite3_open_v2", test_open_v2 ,0 }, 7939 { "sqlite3_complete16", test_complete16 ,0 }, 7940 { "sqlite3_normalize", test_normalize ,0 }, 7941 7942 { "sqlite3_prepare", test_prepare ,0 }, 7943 { "sqlite3_prepare16", test_prepare16 ,0 }, 7944 { "sqlite3_prepare_v2", test_prepare_v2 ,0 }, 7945 { "sqlite3_prepare_v3", test_prepare_v3 ,0 }, 7946 { "sqlite3_prepare_tkt3134", test_prepare_tkt3134, 0}, 7947 { "sqlite3_prepare16_v2", test_prepare16_v2 ,0 }, 7948 { "sqlite3_finalize", test_finalize ,0 }, 7949 { "sqlite3_stmt_status", test_stmt_status ,0 }, 7950 { "sqlite3_reset", test_reset ,0 }, 7951 { "sqlite3_expired", test_expired ,0 }, 7952 { "sqlite3_transfer_bindings", test_transfer_bind ,0 }, 7953 { "sqlite3_changes", test_changes ,0 }, 7954 { "sqlite3_step", test_step ,0 }, 7955 { "sqlite3_sql", test_sql ,0 }, 7956 { "sqlite3_expanded_sql", test_ex_sql ,0 }, 7957 #ifdef SQLITE_ENABLE_NORMALIZE 7958 { "sqlite3_normalized_sql", test_norm_sql ,0 }, 7959 #endif 7960 { "sqlite3_next_stmt", test_next_stmt ,0 }, 7961 { "sqlite3_stmt_readonly", test_stmt_readonly ,0 }, 7962 { "sqlite3_stmt_isexplain", test_stmt_isexplain,0 }, 7963 { "sqlite3_stmt_busy", test_stmt_busy ,0 }, 7964 { "uses_stmt_journal", uses_stmt_journal ,0 }, 7965 7966 { "sqlite3_release_memory", test_release_memory, 0}, 7967 { "sqlite3_db_release_memory", test_db_release_memory, 0}, 7968 { "sqlite3_db_cacheflush", test_db_cacheflush, 0}, 7969 { "sqlite3_system_errno", test_system_errno, 0}, 7970 { "sqlite3_db_filename", test_db_filename, 0}, 7971 { "sqlite3_db_readonly", test_db_readonly, 0}, 7972 { "sqlite3_soft_heap_limit", test_soft_heap_limit, 0}, 7973 { "sqlite3_thread_cleanup", test_thread_cleanup, 0}, 7974 { "sqlite3_pager_refcounts", test_pager_refcounts, 0}, 7975 7976 { "sqlite3_load_extension", test_load_extension, 0}, 7977 { "sqlite3_enable_load_extension", test_enable_load, 0}, 7978 { "sqlite3_extended_result_codes", test_extended_result_codes, 0}, 7979 { "sqlite3_limit", test_limit, 0}, 7980 { "dbconfig_maindbname_icecube", test_dbconfig_maindbname_icecube }, 7981 7982 { "save_prng_state", save_prng_state, 0 }, 7983 { "restore_prng_state", restore_prng_state, 0 }, 7984 { "reset_prng_state", reset_prng_state, 0 }, 7985 { "prng_seed", prng_seed, 0 }, 7986 { "database_never_corrupt", database_never_corrupt, 0}, 7987 { "database_may_be_corrupt", database_may_be_corrupt, 0}, 7988 { "optimization_control", optimization_control,0}, 7989 #if SQLITE_OS_WIN 7990 { "lock_win32_file", win32_file_lock, 0 }, 7991 { "exists_win32_path", win32_exists_path, 0 }, 7992 { "find_win32_file", win32_find_file, 0 }, 7993 { "delete_win32_file", win32_delete_file, 0 }, 7994 { "make_win32_dir", win32_mkdir, 0 }, 7995 { "remove_win32_dir", win32_rmdir, 0 }, 7996 #endif 7997 { "tcl_objproc", runAsObjProc, 0 }, 7998 7999 /* sqlite3_column_*() API */ 8000 { "sqlite3_column_count", test_column_count ,0 }, 8001 { "sqlite3_data_count", test_data_count ,0 }, 8002 { "sqlite3_column_type", test_column_type ,0 }, 8003 { "sqlite3_column_blob", test_column_blob ,0 }, 8004 { "sqlite3_column_double", test_column_double ,0 }, 8005 { "sqlite3_column_int64", test_column_int64 ,0 }, 8006 { "sqlite3_column_text", test_stmt_utf8, (void*)sqlite3_column_text }, 8007 { "sqlite3_column_name", test_stmt_utf8, (void*)sqlite3_column_name }, 8008 { "sqlite3_column_int", test_stmt_int, (void*)sqlite3_column_int }, 8009 { "sqlite3_column_bytes", test_stmt_int, (void*)sqlite3_column_bytes}, 8010 #ifndef SQLITE_OMIT_DECLTYPE 8011 { "sqlite3_column_decltype",test_stmt_utf8,(void*)sqlite3_column_decltype}, 8012 #endif 8013 #ifdef SQLITE_ENABLE_COLUMN_METADATA 8014 { "sqlite3_column_database_name",test_stmt_utf8,(void*)sqlite3_column_database_name}, 8015 { "sqlite3_column_table_name",test_stmt_utf8,(void*)sqlite3_column_table_name}, 8016 { "sqlite3_column_origin_name",test_stmt_utf8,(void*)sqlite3_column_origin_name}, 8017 #endif 8018 8019 #ifndef SQLITE_OMIT_UTF16 8020 { "sqlite3_column_bytes16", test_stmt_int, (void*)sqlite3_column_bytes16 }, 8021 { "sqlite3_column_text16", test_stmt_utf16, (void*)sqlite3_column_text16}, 8022 { "sqlite3_column_name16", test_stmt_utf16, (void*)sqlite3_column_name16}, 8023 { "add_alignment_test_collations", add_alignment_test_collations, 0 }, 8024 #ifndef SQLITE_OMIT_DECLTYPE 8025 { "sqlite3_column_decltype16",test_stmt_utf16,(void*)sqlite3_column_decltype16}, 8026 #endif 8027 #ifdef SQLITE_ENABLE_COLUMN_METADATA 8028 {"sqlite3_column_database_name16", 8029 test_stmt_utf16, (void*)sqlite3_column_database_name16}, 8030 {"sqlite3_column_table_name16", test_stmt_utf16, (void*)sqlite3_column_table_name16}, 8031 {"sqlite3_column_origin_name16", test_stmt_utf16, (void*)sqlite3_column_origin_name16}, 8032 #endif 8033 #endif 8034 { "sqlite3_create_collation_v2", test_create_collation_v2, 0 }, 8035 { "sqlite3_global_recover", test_global_recover, 0 }, 8036 { "working_64bit_int", working_64bit_int, 0 }, 8037 { "vfs_unlink_test", vfs_unlink_test, 0 }, 8038 { "vfs_initfail_test", vfs_initfail_test, 0 }, 8039 { "vfs_unregister_all", vfs_unregister_all, 0 }, 8040 { "vfs_reregister_all", vfs_reregister_all, 0 }, 8041 { "file_control_test", file_control_test, 0 }, 8042 { "file_control_lasterrno_test", file_control_lasterrno_test, 0 }, 8043 { "file_control_lockproxy_test", file_control_lockproxy_test, 0 }, 8044 { "file_control_chunksize_test", file_control_chunksize_test, 0 }, 8045 { "file_control_sizehint_test", file_control_sizehint_test, 0 }, 8046 { "file_control_data_version", file_control_data_version, 0 }, 8047 #if SQLITE_OS_WIN 8048 { "file_control_win32_av_retry", file_control_win32_av_retry, 0 }, 8049 { "file_control_win32_get_handle", file_control_win32_get_handle, 0 }, 8050 { "file_control_win32_set_handle", file_control_win32_set_handle, 0 }, 8051 #endif 8052 { "file_control_persist_wal", file_control_persist_wal, 0 }, 8053 { "file_control_powersafe_overwrite",file_control_powersafe_overwrite,0}, 8054 { "file_control_vfsname", file_control_vfsname, 0 }, 8055 { "file_control_tempfilename", file_control_tempfilename, 0 }, 8056 { "sqlite3_vfs_list", vfs_list, 0 }, 8057 { "sqlite3_create_function_v2", test_create_function_v2, 0 }, 8058 8059 /* Functions from os.h */ 8060 #ifndef SQLITE_OMIT_UTF16 8061 { "add_test_collate", test_collate, 0 }, 8062 { "add_test_collate_needed", test_collate_needed, 0 }, 8063 { "add_test_function", test_function, 0 }, 8064 { "add_test_utf16bin_collate", test_utf16bin_collate, 0 }, 8065 #endif 8066 { "sqlite3_test_errstr", test_errstr, 0 }, 8067 { "tcl_variable_type", tcl_variable_type, 0 }, 8068 #ifndef SQLITE_OMIT_SHARED_CACHE 8069 { "sqlite3_enable_shared_cache", test_enable_shared, 0 }, 8070 { "sqlite3_shared_cache_report", sqlite3BtreeSharedCacheReport, 0}, 8071 #endif 8072 { "sqlite3_libversion_number", test_libversion_number, 0 }, 8073 { "sqlite3_table_column_metadata", test_table_column_metadata, 0 }, 8074 #ifndef SQLITE_OMIT_INCRBLOB 8075 { "sqlite3_blob_reopen", test_blob_reopen, 0 }, 8076 #endif 8077 { "pcache_stats", test_pcache_stats, 0 }, 8078 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY 8079 { "sqlite3_unlock_notify", test_unlock_notify, 0 }, 8080 #endif 8081 { "sqlite3_wal_checkpoint", test_wal_checkpoint, 0 }, 8082 { "sqlite3_wal_checkpoint_v2",test_wal_checkpoint_v2, 0 }, 8083 { "sqlite3_wal_autocheckpoint",test_wal_autocheckpoint, 0 }, 8084 { "test_sqlite3_log", test_sqlite3_log, 0 }, 8085 #ifndef SQLITE_OMIT_EXPLAIN 8086 { "print_explain_query_plan", test_print_eqp, 0 }, 8087 #endif 8088 { "sqlite3_test_control", test_test_control }, 8089 #if SQLITE_OS_UNIX 8090 { "getrusage", test_getrusage }, 8091 #endif 8092 { "load_static_extension", tclLoadStaticExtensionCmd }, 8093 { "sorter_test_fakeheap", sorter_test_fakeheap }, 8094 { "sorter_test_sort4_helper", sorter_test_sort4_helper }, 8095 #ifdef SQLITE_USER_AUTHENTICATION 8096 { "sqlite3_user_authenticate", test_user_authenticate, 0 }, 8097 { "sqlite3_user_add", test_user_add, 0 }, 8098 { "sqlite3_user_change", test_user_change, 0 }, 8099 { "sqlite3_user_delete", test_user_delete, 0 }, 8100 #endif 8101 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS 8102 { "sqlite3_stmt_scanstatus", test_stmt_scanstatus, 0 }, 8103 { "sqlite3_stmt_scanstatus_reset", test_stmt_scanstatus_reset, 0 }, 8104 #endif 8105 #ifdef SQLITE_ENABLE_SQLLOG 8106 { "sqlite3_config_sqllog", test_config_sqllog, 0 }, 8107 #endif 8108 { "vfs_current_time_int64", vfsCurrentTimeInt64, 0 }, 8109 #ifdef SQLITE_ENABLE_SNAPSHOT 8110 { "sqlite3_snapshot_get", test_snapshot_get, 0 }, 8111 { "sqlite3_snapshot_open", test_snapshot_open, 0 }, 8112 { "sqlite3_snapshot_free", test_snapshot_free, 0 }, 8113 { "sqlite3_snapshot_cmp", test_snapshot_cmp, 0 }, 8114 { "sqlite3_snapshot_recover", test_snapshot_recover, 0 }, 8115 { "sqlite3_snapshot_get_blob", test_snapshot_get_blob, 0 }, 8116 { "sqlite3_snapshot_open_blob", test_snapshot_open_blob, 0 }, 8117 { "sqlite3_snapshot_cmp_blob", test_snapshot_cmp_blob, 0 }, 8118 #endif 8119 { "sqlite3_delete_database", test_delete_database, 0 }, 8120 { "atomic_batch_write", test_atomic_batch_write, 0 }, 8121 { "sqlite3_mmap_warm", test_mmap_warm, 0 }, 8122 { "sqlite3_config_sorterref", test_config_sorterref, 0 }, 8123 { "decode_hexdb", test_decode_hexdb, 0 }, 8124 }; 8125 static int bitmask_size = sizeof(Bitmask)*8; 8126 static int longdouble_size = sizeof(LONGDOUBLE_TYPE); 8127 int i; 8128 extern int sqlite3_sync_count, sqlite3_fullsync_count; 8129 extern int sqlite3_opentemp_count; 8130 extern int sqlite3_like_count; 8131 extern int sqlite3_xferopt_count; 8132 extern int sqlite3_pager_readdb_count; 8133 extern int sqlite3_pager_writedb_count; 8134 extern int sqlite3_pager_writej_count; 8135 #if SQLITE_OS_WIN 8136 extern LONG volatile sqlite3_os_type; 8137 #endif 8138 #ifdef SQLITE_DEBUG 8139 extern int sqlite3WhereTrace; 8140 extern int sqlite3OSTrace; 8141 extern int sqlite3WalTrace; 8142 #endif 8143 #ifdef SQLITE_TEST 8144 #ifdef SQLITE_ENABLE_FTS3 8145 extern int sqlite3_fts3_enable_parentheses; 8146 #endif 8147 #endif 8148 #if defined(SQLITE_ENABLE_SELECTTRACE) 8149 extern int sqlite3SelectTrace; 8150 #endif 8151 8152 for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){ 8153 Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0); 8154 } 8155 for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ 8156 Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 8157 aObjCmd[i].xProc, aObjCmd[i].clientData, 0); 8158 } 8159 Tcl_LinkVar(interp, "sqlite_search_count", 8160 (char*)&sqlite3_search_count, TCL_LINK_INT); 8161 Tcl_LinkVar(interp, "sqlite_found_count", 8162 (char*)&sqlite3_found_count, TCL_LINK_INT); 8163 Tcl_LinkVar(interp, "sqlite_sort_count", 8164 (char*)&sqlite3_sort_count, TCL_LINK_INT); 8165 Tcl_LinkVar(interp, "sqlite3_max_blobsize", 8166 (char*)&sqlite3_max_blobsize, TCL_LINK_INT); 8167 Tcl_LinkVar(interp, "sqlite_like_count", 8168 (char*)&sqlite3_like_count, TCL_LINK_INT); 8169 Tcl_LinkVar(interp, "sqlite_interrupt_count", 8170 (char*)&sqlite3_interrupt_count, TCL_LINK_INT); 8171 Tcl_LinkVar(interp, "sqlite_open_file_count", 8172 (char*)&sqlite3_open_file_count, TCL_LINK_INT); 8173 Tcl_LinkVar(interp, "sqlite_current_time", 8174 (char*)&sqlite3_current_time, TCL_LINK_INT); 8175 #if SQLITE_OS_UNIX && defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE 8176 Tcl_LinkVar(interp, "sqlite_hostid_num", 8177 (char*)&sqlite3_hostid_num, TCL_LINK_INT); 8178 #endif 8179 Tcl_LinkVar(interp, "sqlite3_xferopt_count", 8180 (char*)&sqlite3_xferopt_count, TCL_LINK_INT); 8181 Tcl_LinkVar(interp, "sqlite3_pager_readdb_count", 8182 (char*)&sqlite3_pager_readdb_count, TCL_LINK_INT); 8183 Tcl_LinkVar(interp, "sqlite3_pager_writedb_count", 8184 (char*)&sqlite3_pager_writedb_count, TCL_LINK_INT); 8185 Tcl_LinkVar(interp, "sqlite3_pager_writej_count", 8186 (char*)&sqlite3_pager_writej_count, TCL_LINK_INT); 8187 #ifndef SQLITE_OMIT_UTF16 8188 Tcl_LinkVar(interp, "unaligned_string_counter", 8189 (char*)&unaligned_string_counter, TCL_LINK_INT); 8190 #endif 8191 #ifndef SQLITE_OMIT_UTF16 8192 Tcl_LinkVar(interp, "sqlite_last_needed_collation", 8193 (char*)&pzNeededCollation, TCL_LINK_STRING|TCL_LINK_READ_ONLY); 8194 #endif 8195 #if SQLITE_OS_WIN 8196 Tcl_LinkVar(interp, "sqlite_os_type", 8197 (char*)&sqlite3_os_type, TCL_LINK_LONG); 8198 #endif 8199 #ifdef SQLITE_TEST 8200 { 8201 static const char *query_plan = "*** OBSOLETE VARIABLE ***"; 8202 Tcl_LinkVar(interp, "sqlite_query_plan", 8203 (char*)&query_plan, TCL_LINK_STRING|TCL_LINK_READ_ONLY); 8204 } 8205 #endif 8206 #ifdef SQLITE_DEBUG 8207 Tcl_LinkVar(interp, "sqlite_where_trace", 8208 (char*)&sqlite3WhereTrace, TCL_LINK_INT); 8209 Tcl_LinkVar(interp, "sqlite_os_trace", 8210 (char*)&sqlite3OSTrace, TCL_LINK_INT); 8211 #ifndef SQLITE_OMIT_WAL 8212 Tcl_LinkVar(interp, "sqlite_wal_trace", 8213 (char*)&sqlite3WalTrace, TCL_LINK_INT); 8214 #endif 8215 #endif 8216 #ifndef SQLITE_OMIT_DISKIO 8217 Tcl_LinkVar(interp, "sqlite_opentemp_count", 8218 (char*)&sqlite3_opentemp_count, TCL_LINK_INT); 8219 #endif 8220 Tcl_LinkVar(interp, "sqlite_static_bind_value", 8221 (char*)&sqlite_static_bind_value, TCL_LINK_STRING); 8222 Tcl_LinkVar(interp, "sqlite_static_bind_nbyte", 8223 (char*)&sqlite_static_bind_nbyte, TCL_LINK_INT); 8224 Tcl_LinkVar(interp, "sqlite_temp_directory", 8225 (char*)&sqlite3_temp_directory, TCL_LINK_STRING); 8226 Tcl_LinkVar(interp, "sqlite_data_directory", 8227 (char*)&sqlite3_data_directory, TCL_LINK_STRING); 8228 Tcl_LinkVar(interp, "bitmask_size", 8229 (char*)&bitmask_size, TCL_LINK_INT|TCL_LINK_READ_ONLY); 8230 Tcl_LinkVar(interp, "longdouble_size", 8231 (char*)&longdouble_size, TCL_LINK_INT|TCL_LINK_READ_ONLY); 8232 Tcl_LinkVar(interp, "sqlite_sync_count", 8233 (char*)&sqlite3_sync_count, TCL_LINK_INT); 8234 Tcl_LinkVar(interp, "sqlite_fullsync_count", 8235 (char*)&sqlite3_fullsync_count, TCL_LINK_INT); 8236 #if defined(SQLITE_ENABLE_SELECTTRACE) 8237 Tcl_LinkVar(interp, "sqlite3SelectTrace", 8238 (char*)&sqlite3SelectTrace, TCL_LINK_INT); 8239 #endif 8240 #if defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_TEST) 8241 Tcl_LinkVar(interp, "sqlite_fts3_enable_parentheses", 8242 (char*)&sqlite3_fts3_enable_parentheses, TCL_LINK_INT); 8243 #endif 8244 return TCL_OK; 8245 } 8246