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