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 } 2397 return TCL_OK; 2398 } 2399 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2400 2401 #ifdef SQLITE_ENABLE_SNAPSHOT 2402 /* 2403 ** Usage: sqlite3_snapshot_free SNAPSHOT 2404 */ 2405 static int SQLITE_TCLAPI test_snapshot_free( 2406 void * clientData, 2407 Tcl_Interp *interp, 2408 int objc, 2409 Tcl_Obj *CONST objv[] 2410 ){ 2411 sqlite3_snapshot *pSnapshot; 2412 if( objc!=2 ){ 2413 Tcl_WrongNumArgs(interp, 1, objv, "SNAPSHOT"); 2414 return TCL_ERROR; 2415 } 2416 pSnapshot = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[1])); 2417 sqlite3_snapshot_free(pSnapshot); 2418 return TCL_OK; 2419 } 2420 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2421 2422 #ifdef SQLITE_ENABLE_SNAPSHOT 2423 /* 2424 ** Usage: sqlite3_snapshot_cmp SNAPSHOT1 SNAPSHOT2 2425 */ 2426 static int SQLITE_TCLAPI test_snapshot_cmp( 2427 void * clientData, 2428 Tcl_Interp *interp, 2429 int objc, 2430 Tcl_Obj *CONST objv[] 2431 ){ 2432 int res; 2433 sqlite3_snapshot *p1; 2434 sqlite3_snapshot *p2; 2435 if( objc!=3 ){ 2436 Tcl_WrongNumArgs(interp, 1, objv, "SNAPSHOT1 SNAPSHOT2"); 2437 return TCL_ERROR; 2438 } 2439 p1 = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[1])); 2440 p2 = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[2])); 2441 res = sqlite3_snapshot_cmp(p1, p2); 2442 Tcl_SetObjResult(interp, Tcl_NewIntObj(res)); 2443 return TCL_OK; 2444 } 2445 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2446 2447 #ifdef SQLITE_ENABLE_SNAPSHOT 2448 /* 2449 ** Usage: sqlite3_snapshot_get_blob DB DBNAME 2450 */ 2451 static int SQLITE_TCLAPI test_snapshot_get_blob( 2452 void * clientData, 2453 Tcl_Interp *interp, 2454 int objc, 2455 Tcl_Obj *CONST objv[] 2456 ){ 2457 int rc; 2458 sqlite3 *db; 2459 char *zName; 2460 sqlite3_snapshot *pSnapshot = 0; 2461 2462 if( objc!=3 ){ 2463 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME"); 2464 return TCL_ERROR; 2465 } 2466 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 2467 zName = Tcl_GetString(objv[2]); 2468 2469 rc = sqlite3_snapshot_get(db, zName, &pSnapshot); 2470 if( rc!=SQLITE_OK ){ 2471 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); 2472 return TCL_ERROR; 2473 }else{ 2474 Tcl_SetObjResult(interp, 2475 Tcl_NewByteArrayObj((unsigned char*)pSnapshot, sizeof(sqlite3_snapshot)) 2476 ); 2477 sqlite3_snapshot_free(pSnapshot); 2478 } 2479 return TCL_OK; 2480 } 2481 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2482 2483 #ifdef SQLITE_ENABLE_SNAPSHOT 2484 /* 2485 ** Usage: sqlite3_snapshot_open_blob DB DBNAME SNAPSHOT 2486 */ 2487 static int SQLITE_TCLAPI test_snapshot_open_blob( 2488 void * clientData, 2489 Tcl_Interp *interp, 2490 int objc, 2491 Tcl_Obj *CONST objv[] 2492 ){ 2493 int rc; 2494 sqlite3 *db; 2495 char *zName; 2496 unsigned char *pBlob; 2497 int nBlob; 2498 2499 if( objc!=4 ){ 2500 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SNAPSHOT"); 2501 return TCL_ERROR; 2502 } 2503 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 2504 zName = Tcl_GetString(objv[2]); 2505 pBlob = Tcl_GetByteArrayFromObj(objv[3], &nBlob); 2506 if( nBlob!=sizeof(sqlite3_snapshot) ){ 2507 Tcl_AppendResult(interp, "bad SNAPSHOT", 0); 2508 return TCL_ERROR; 2509 } 2510 rc = sqlite3_snapshot_open(db, zName, (sqlite3_snapshot*)pBlob); 2511 if( rc!=SQLITE_OK ){ 2512 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); 2513 return TCL_ERROR; 2514 } 2515 return TCL_OK; 2516 } 2517 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2518 2519 #ifdef SQLITE_ENABLE_SNAPSHOT 2520 /* 2521 ** Usage: sqlite3_snapshot_cmp_blob SNAPSHOT1 SNAPSHOT2 2522 */ 2523 static int SQLITE_TCLAPI test_snapshot_cmp_blob( 2524 void * clientData, 2525 Tcl_Interp *interp, 2526 int objc, 2527 Tcl_Obj *CONST objv[] 2528 ){ 2529 int res; 2530 unsigned char *p1; 2531 unsigned char *p2; 2532 int n1; 2533 int n2; 2534 2535 if( objc!=3 ){ 2536 Tcl_WrongNumArgs(interp, 1, objv, "SNAPSHOT1 SNAPSHOT2"); 2537 return TCL_ERROR; 2538 } 2539 2540 p1 = Tcl_GetByteArrayFromObj(objv[1], &n1); 2541 p2 = Tcl_GetByteArrayFromObj(objv[2], &n2); 2542 2543 if( n1!=sizeof(sqlite3_snapshot) || n1!=n2 ){ 2544 Tcl_AppendResult(interp, "bad SNAPSHOT", 0); 2545 return TCL_ERROR; 2546 } 2547 2548 res = sqlite3_snapshot_cmp((sqlite3_snapshot*)p1, (sqlite3_snapshot*)p2); 2549 Tcl_SetObjResult(interp, Tcl_NewIntObj(res)); 2550 return TCL_OK; 2551 } 2552 #endif /* SQLITE_ENABLE_SNAPSHOT */ 2553 2554 /* 2555 ** Usage: sqlite3_delete_database FILENAME 2556 */ 2557 int sqlite3_delete_database(const char*); /* in test_delete.c */ 2558 static int SQLITE_TCLAPI test_delete_database( 2559 void * clientData, 2560 Tcl_Interp *interp, 2561 int objc, 2562 Tcl_Obj *CONST objv[] 2563 ){ 2564 int rc; 2565 const char *zFile; 2566 if( objc!=2 ){ 2567 Tcl_WrongNumArgs(interp, 1, objv, "FILE"); 2568 return TCL_ERROR; 2569 } 2570 zFile = (const char*)Tcl_GetString(objv[1]); 2571 rc = sqlite3_delete_database(zFile); 2572 2573 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); 2574 return TCL_OK; 2575 } 2576 2577 /* 2578 ** Usage: atomic_batch_write PATH 2579 */ 2580 static int SQLITE_TCLAPI test_atomic_batch_write( 2581 void * clientData, 2582 Tcl_Interp *interp, 2583 int objc, 2584 Tcl_Obj *CONST objv[] 2585 ){ 2586 char *zFile = 0; /* Path to file to test */ 2587 sqlite3 *db = 0; /* Database handle */ 2588 sqlite3_file *pFd = 0; /* SQLite fd open on zFile */ 2589 int bRes = 0; /* Integer result of this command */ 2590 int dc = 0; /* Device-characteristics mask */ 2591 int rc; /* sqlite3_open() return code */ 2592 2593 if( objc!=2 ){ 2594 Tcl_WrongNumArgs(interp, 1, objv, "PATH"); 2595 return TCL_ERROR; 2596 } 2597 zFile = Tcl_GetString(objv[1]); 2598 2599 rc = sqlite3_open(zFile, &db); 2600 if( rc!=SQLITE_OK ){ 2601 Tcl_AppendResult(interp, sqlite3_errmsg(db), 0); 2602 sqlite3_close(db); 2603 return TCL_ERROR; 2604 } 2605 2606 rc = sqlite3_file_control(db, "main", SQLITE_FCNTL_FILE_POINTER, (void*)&pFd); 2607 dc = pFd->pMethods->xDeviceCharacteristics(pFd); 2608 if( dc & SQLITE_IOCAP_BATCH_ATOMIC ){ 2609 bRes = 1; 2610 } 2611 2612 Tcl_SetObjResult(interp, Tcl_NewIntObj(bRes)); 2613 sqlite3_close(db); 2614 return TCL_OK; 2615 } 2616 2617 /* 2618 ** Usage: sqlite3_next_stmt DB STMT 2619 ** 2620 ** Return the next statment in sequence after STMT. 2621 */ 2622 static int SQLITE_TCLAPI test_next_stmt( 2623 void * clientData, 2624 Tcl_Interp *interp, 2625 int objc, 2626 Tcl_Obj *CONST objv[] 2627 ){ 2628 sqlite3_stmt *pStmt; 2629 sqlite3 *db = 0; 2630 char zBuf[50]; 2631 2632 if( objc!=3 ){ 2633 Tcl_AppendResult(interp, "wrong # args: should be \"", 2634 Tcl_GetStringFromObj(objv[0], 0), " DB STMT", 0); 2635 return TCL_ERROR; 2636 } 2637 2638 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 2639 if( getStmtPointer(interp, Tcl_GetString(objv[2]), &pStmt) ) return TCL_ERROR; 2640 pStmt = sqlite3_next_stmt(db, pStmt); 2641 if( pStmt ){ 2642 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 2643 Tcl_AppendResult(interp, zBuf, 0); 2644 } 2645 return TCL_OK; 2646 } 2647 2648 /* 2649 ** Usage: sqlite3_stmt_readonly STMT 2650 ** 2651 ** Return true if STMT is a NULL pointer or a pointer to a statement 2652 ** that is guaranteed to leave the database unmodified. 2653 */ 2654 static int SQLITE_TCLAPI test_stmt_readonly( 2655 void * clientData, 2656 Tcl_Interp *interp, 2657 int objc, 2658 Tcl_Obj *CONST objv[] 2659 ){ 2660 sqlite3_stmt *pStmt; 2661 int rc; 2662 2663 if( objc!=2 ){ 2664 Tcl_AppendResult(interp, "wrong # args: should be \"", 2665 Tcl_GetStringFromObj(objv[0], 0), " STMT", 0); 2666 return TCL_ERROR; 2667 } 2668 2669 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2670 rc = sqlite3_stmt_readonly(pStmt); 2671 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(rc)); 2672 return TCL_OK; 2673 } 2674 2675 /* 2676 ** Usage: sqlite3_stmt_busy STMT 2677 ** 2678 ** Return true if STMT is a non-NULL pointer to a statement 2679 ** that has been stepped but not to completion. 2680 */ 2681 static int SQLITE_TCLAPI test_stmt_busy( 2682 void * clientData, 2683 Tcl_Interp *interp, 2684 int objc, 2685 Tcl_Obj *CONST objv[] 2686 ){ 2687 sqlite3_stmt *pStmt; 2688 int rc; 2689 2690 if( objc!=2 ){ 2691 Tcl_AppendResult(interp, "wrong # args: should be \"", 2692 Tcl_GetStringFromObj(objv[0], 0), " STMT", 0); 2693 return TCL_ERROR; 2694 } 2695 2696 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2697 rc = sqlite3_stmt_busy(pStmt); 2698 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(rc)); 2699 return TCL_OK; 2700 } 2701 2702 /* 2703 ** Usage: uses_stmt_journal STMT 2704 ** 2705 ** Return true if STMT uses a statement journal. 2706 */ 2707 static int SQLITE_TCLAPI uses_stmt_journal( 2708 void * clientData, 2709 Tcl_Interp *interp, 2710 int objc, 2711 Tcl_Obj *CONST objv[] 2712 ){ 2713 sqlite3_stmt *pStmt; 2714 2715 if( objc!=2 ){ 2716 Tcl_AppendResult(interp, "wrong # args: should be \"", 2717 Tcl_GetStringFromObj(objv[0], 0), " STMT", 0); 2718 return TCL_ERROR; 2719 } 2720 2721 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2722 sqlite3_stmt_readonly(pStmt); 2723 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(((Vdbe *)pStmt)->usesStmtJournal)); 2724 return TCL_OK; 2725 } 2726 2727 2728 /* 2729 ** Usage: sqlite3_reset STMT 2730 ** 2731 ** Reset a statement handle. 2732 */ 2733 static int SQLITE_TCLAPI test_reset( 2734 void * clientData, 2735 Tcl_Interp *interp, 2736 int objc, 2737 Tcl_Obj *CONST objv[] 2738 ){ 2739 sqlite3_stmt *pStmt; 2740 int rc; 2741 2742 if( objc!=2 ){ 2743 Tcl_AppendResult(interp, "wrong # args: should be \"", 2744 Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0); 2745 return TCL_ERROR; 2746 } 2747 2748 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2749 2750 rc = sqlite3_reset(pStmt); 2751 if( pStmt && sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ){ 2752 return TCL_ERROR; 2753 } 2754 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 2755 /* 2756 if( rc ){ 2757 return TCL_ERROR; 2758 } 2759 */ 2760 return TCL_OK; 2761 } 2762 2763 /* 2764 ** Usage: sqlite3_expired STMT 2765 ** 2766 ** Return TRUE if a recompilation of the statement is recommended. 2767 */ 2768 static int SQLITE_TCLAPI test_expired( 2769 void * clientData, 2770 Tcl_Interp *interp, 2771 int objc, 2772 Tcl_Obj *CONST objv[] 2773 ){ 2774 #ifndef SQLITE_OMIT_DEPRECATED 2775 sqlite3_stmt *pStmt; 2776 if( objc!=2 ){ 2777 Tcl_AppendResult(interp, "wrong # args: should be \"", 2778 Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0); 2779 return TCL_ERROR; 2780 } 2781 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 2782 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(sqlite3_expired(pStmt))); 2783 #endif 2784 return TCL_OK; 2785 } 2786 2787 /* 2788 ** Usage: sqlite3_transfer_bindings FROMSTMT TOSTMT 2789 ** 2790 ** Transfer all bindings from FROMSTMT over to TOSTMT 2791 */ 2792 static int SQLITE_TCLAPI test_transfer_bind( 2793 void * clientData, 2794 Tcl_Interp *interp, 2795 int objc, 2796 Tcl_Obj *CONST objv[] 2797 ){ 2798 #ifndef SQLITE_OMIT_DEPRECATED 2799 sqlite3_stmt *pStmt1, *pStmt2; 2800 if( objc!=3 ){ 2801 Tcl_AppendResult(interp, "wrong # args: should be \"", 2802 Tcl_GetStringFromObj(objv[0], 0), " FROM-STMT TO-STMT", 0); 2803 return TCL_ERROR; 2804 } 2805 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt1)) return TCL_ERROR; 2806 if( getStmtPointer(interp, Tcl_GetString(objv[2]), &pStmt2)) return TCL_ERROR; 2807 Tcl_SetObjResult(interp, 2808 Tcl_NewIntObj(sqlite3_transfer_bindings(pStmt1,pStmt2))); 2809 #endif 2810 return TCL_OK; 2811 } 2812 2813 /* 2814 ** Usage: sqlite3_changes DB 2815 ** 2816 ** Return the number of changes made to the database by the last SQL 2817 ** execution. 2818 */ 2819 static int SQLITE_TCLAPI test_changes( 2820 void * clientData, 2821 Tcl_Interp *interp, 2822 int objc, 2823 Tcl_Obj *CONST objv[] 2824 ){ 2825 sqlite3 *db; 2826 if( objc!=2 ){ 2827 Tcl_AppendResult(interp, "wrong # args: should be \"", 2828 Tcl_GetString(objv[0]), " DB", 0); 2829 return TCL_ERROR; 2830 } 2831 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 2832 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_changes(db))); 2833 return TCL_OK; 2834 } 2835 2836 /* 2837 ** This is the "static_bind_value" that variables are bound to when 2838 ** the FLAG option of sqlite3_bind is "static" 2839 */ 2840 static char *sqlite_static_bind_value = 0; 2841 static int sqlite_static_bind_nbyte = 0; 2842 2843 /* 2844 ** Usage: sqlite3_bind VM IDX VALUE FLAGS 2845 ** 2846 ** Sets the value of the IDX-th occurrence of "?" in the original SQL 2847 ** string. VALUE is the new value. If FLAGS=="null" then VALUE is 2848 ** ignored and the value is set to NULL. If FLAGS=="static" then 2849 ** the value is set to the value of a static variable named 2850 ** "sqlite_static_bind_value". If FLAGS=="normal" then a copy 2851 ** of the VALUE is made. If FLAGS=="blob10" then a VALUE is ignored 2852 ** an a 10-byte blob "abc\000xyz\000pq" is inserted. 2853 */ 2854 static int SQLITE_TCLAPI test_bind( 2855 void *NotUsed, 2856 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 2857 int argc, /* Number of arguments */ 2858 char **argv /* Text of each argument */ 2859 ){ 2860 sqlite3_stmt *pStmt; 2861 int rc; 2862 int idx; 2863 if( argc!=5 ){ 2864 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 2865 " VM IDX VALUE (null|static|normal)\"", 0); 2866 return TCL_ERROR; 2867 } 2868 if( getStmtPointer(interp, argv[1], &pStmt) ) return TCL_ERROR; 2869 if( Tcl_GetInt(interp, argv[2], &idx) ) return TCL_ERROR; 2870 if( strcmp(argv[4],"null")==0 ){ 2871 rc = sqlite3_bind_null(pStmt, idx); 2872 }else if( strcmp(argv[4],"static")==0 ){ 2873 rc = sqlite3_bind_text(pStmt, idx, sqlite_static_bind_value, -1, 0); 2874 }else if( strcmp(argv[4],"static-nbytes")==0 ){ 2875 rc = sqlite3_bind_text(pStmt, idx, sqlite_static_bind_value, 2876 sqlite_static_bind_nbyte, 0); 2877 }else if( strcmp(argv[4],"normal")==0 ){ 2878 rc = sqlite3_bind_text(pStmt, idx, argv[3], -1, SQLITE_TRANSIENT); 2879 }else if( strcmp(argv[4],"blob10")==0 ){ 2880 rc = sqlite3_bind_text(pStmt, idx, "abc\000xyz\000pq", 10, SQLITE_STATIC); 2881 }else{ 2882 Tcl_AppendResult(interp, "4th argument should be " 2883 "\"null\" or \"static\" or \"normal\"", 0); 2884 return TCL_ERROR; 2885 } 2886 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 2887 if( rc ){ 2888 char zBuf[50]; 2889 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc); 2890 Tcl_AppendResult(interp, zBuf, sqlite3ErrStr(rc), 0); 2891 return TCL_ERROR; 2892 } 2893 return TCL_OK; 2894 } 2895 2896 #ifndef SQLITE_OMIT_UTF16 2897 /* 2898 ** Usage: add_test_collate <db ptr> <utf8> <utf16le> <utf16be> 2899 ** 2900 ** This function is used to test that SQLite selects the correct collation 2901 ** sequence callback when multiple versions (for different text encodings) 2902 ** are available. 2903 ** 2904 ** Calling this routine registers the collation sequence "test_collate" 2905 ** with database handle <db>. The second argument must be a list of three 2906 ** boolean values. If the first is true, then a version of test_collate is 2907 ** registered for UTF-8, if the second is true, a version is registered for 2908 ** UTF-16le, if the third is true, a UTF-16be version is available. 2909 ** Previous versions of test_collate are deleted. 2910 ** 2911 ** The collation sequence test_collate is implemented by calling the 2912 ** following TCL script: 2913 ** 2914 ** "test_collate <enc> <lhs> <rhs>" 2915 ** 2916 ** The <lhs> and <rhs> are the two values being compared, encoded in UTF-8. 2917 ** The <enc> parameter is the encoding of the collation function that 2918 ** SQLite selected to call. The TCL test script implements the 2919 ** "test_collate" proc. 2920 ** 2921 ** Note that this will only work with one interpreter at a time, as the 2922 ** interp pointer to use when evaluating the TCL script is stored in 2923 ** pTestCollateInterp. 2924 */ 2925 static Tcl_Interp* pTestCollateInterp; 2926 static int test_collate_func( 2927 void *pCtx, 2928 int nA, const void *zA, 2929 int nB, const void *zB 2930 ){ 2931 Tcl_Interp *i = pTestCollateInterp; 2932 int encin = SQLITE_PTR_TO_INT(pCtx); 2933 int res; 2934 int n; 2935 2936 sqlite3_value *pVal; 2937 Tcl_Obj *pX; 2938 2939 pX = Tcl_NewStringObj("test_collate", -1); 2940 Tcl_IncrRefCount(pX); 2941 2942 switch( encin ){ 2943 case SQLITE_UTF8: 2944 Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-8",-1)); 2945 break; 2946 case SQLITE_UTF16LE: 2947 Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-16LE",-1)); 2948 break; 2949 case SQLITE_UTF16BE: 2950 Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-16BE",-1)); 2951 break; 2952 default: 2953 assert(0); 2954 } 2955 2956 sqlite3BeginBenignMalloc(); 2957 pVal = sqlite3ValueNew(0); 2958 if( pVal ){ 2959 sqlite3ValueSetStr(pVal, nA, zA, encin, SQLITE_STATIC); 2960 n = sqlite3_value_bytes(pVal); 2961 Tcl_ListObjAppendElement(i,pX, 2962 Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n)); 2963 sqlite3ValueSetStr(pVal, nB, zB, encin, SQLITE_STATIC); 2964 n = sqlite3_value_bytes(pVal); 2965 Tcl_ListObjAppendElement(i,pX, 2966 Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n)); 2967 sqlite3ValueFree(pVal); 2968 } 2969 sqlite3EndBenignMalloc(); 2970 2971 Tcl_EvalObjEx(i, pX, 0); 2972 Tcl_DecrRefCount(pX); 2973 Tcl_GetIntFromObj(i, Tcl_GetObjResult(i), &res); 2974 return res; 2975 } 2976 static int SQLITE_TCLAPI test_collate( 2977 void * clientData, 2978 Tcl_Interp *interp, 2979 int objc, 2980 Tcl_Obj *CONST objv[] 2981 ){ 2982 sqlite3 *db; 2983 int val; 2984 sqlite3_value *pVal; 2985 int rc; 2986 2987 if( objc!=5 ) goto bad_args; 2988 pTestCollateInterp = interp; 2989 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 2990 2991 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR; 2992 rc = sqlite3_create_collation(db, "test_collate", SQLITE_UTF8, 2993 (void *)SQLITE_UTF8, val?test_collate_func:0); 2994 if( rc==SQLITE_OK ){ 2995 const void *zUtf16; 2996 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &val) ) return TCL_ERROR; 2997 rc = sqlite3_create_collation(db, "test_collate", SQLITE_UTF16LE, 2998 (void *)SQLITE_UTF16LE, val?test_collate_func:0); 2999 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[4], &val) ) return TCL_ERROR; 3000 3001 #if 0 3002 if( sqlite3_iMallocFail>0 ){ 3003 sqlite3_iMallocFail++; 3004 } 3005 #endif 3006 sqlite3_mutex_enter(db->mutex); 3007 pVal = sqlite3ValueNew(db); 3008 sqlite3ValueSetStr(pVal, -1, "test_collate", SQLITE_UTF8, SQLITE_STATIC); 3009 zUtf16 = sqlite3ValueText(pVal, SQLITE_UTF16NATIVE); 3010 if( db->mallocFailed ){ 3011 rc = SQLITE_NOMEM; 3012 }else{ 3013 rc = sqlite3_create_collation16(db, zUtf16, SQLITE_UTF16BE, 3014 (void *)SQLITE_UTF16BE, val?test_collate_func:0); 3015 } 3016 sqlite3ValueFree(pVal); 3017 sqlite3_mutex_leave(db->mutex); 3018 } 3019 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 3020 3021 if( rc!=SQLITE_OK ){ 3022 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0); 3023 return TCL_ERROR; 3024 } 3025 return TCL_OK; 3026 3027 bad_args: 3028 Tcl_AppendResult(interp, "wrong # args: should be \"", 3029 Tcl_GetStringFromObj(objv[0], 0), " <DB> <utf8> <utf16le> <utf16be>", 0); 3030 return TCL_ERROR; 3031 } 3032 3033 /* 3034 ** Usage: add_test_utf16bin_collate <db ptr> 3035 ** 3036 ** Add a utf-16 collation sequence named "utf16bin" to the database 3037 ** handle. This collation sequence compares arguments in the same way as the 3038 ** built-in collation "binary". 3039 */ 3040 static int test_utf16bin_collate_func( 3041 void *pCtx, 3042 int nA, const void *zA, 3043 int nB, const void *zB 3044 ){ 3045 int nCmp = (nA>nB ? nB : nA); 3046 int res = memcmp(zA, zB, nCmp); 3047 if( res==0 ) res = nA - nB; 3048 return res; 3049 } 3050 static int SQLITE_TCLAPI test_utf16bin_collate( 3051 void * clientData, 3052 Tcl_Interp *interp, 3053 int objc, 3054 Tcl_Obj *CONST objv[] 3055 ){ 3056 sqlite3 *db; 3057 int rc; 3058 3059 if( objc!=2 ) goto bad_args; 3060 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 3061 3062 rc = sqlite3_create_collation(db, "utf16bin", SQLITE_UTF16, 0, 3063 test_utf16bin_collate_func 3064 ); 3065 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 3066 return TCL_OK; 3067 3068 bad_args: 3069 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 3070 return TCL_ERROR; 3071 } 3072 3073 /* 3074 ** When the collation needed callback is invoked, record the name of 3075 ** the requested collating function here. The recorded name is linked 3076 ** to a TCL variable and used to make sure that the requested collation 3077 ** name is correct. 3078 */ 3079 static char zNeededCollation[200]; 3080 static char *pzNeededCollation = zNeededCollation; 3081 3082 3083 /* 3084 ** Called when a collating sequence is needed. Registered using 3085 ** sqlite3_collation_needed16(). 3086 */ 3087 static void test_collate_needed_cb( 3088 void *pCtx, 3089 sqlite3 *db, 3090 int eTextRep, 3091 const void *pName 3092 ){ 3093 int enc = ENC(db); 3094 int i; 3095 char *z; 3096 for(z = (char*)pName, i=0; *z || z[1]; z++){ 3097 if( *z ) zNeededCollation[i++] = *z; 3098 } 3099 zNeededCollation[i] = 0; 3100 sqlite3_create_collation( 3101 db, "test_collate", ENC(db), SQLITE_INT_TO_PTR(enc), test_collate_func); 3102 } 3103 3104 /* 3105 ** Usage: add_test_collate_needed DB 3106 */ 3107 static int SQLITE_TCLAPI test_collate_needed( 3108 void * clientData, 3109 Tcl_Interp *interp, 3110 int objc, 3111 Tcl_Obj *CONST objv[] 3112 ){ 3113 sqlite3 *db; 3114 int rc; 3115 3116 if( objc!=2 ) goto bad_args; 3117 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 3118 rc = sqlite3_collation_needed16(db, 0, test_collate_needed_cb); 3119 zNeededCollation[0] = 0; 3120 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 3121 return TCL_OK; 3122 3123 bad_args: 3124 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 3125 return TCL_ERROR; 3126 } 3127 3128 /* 3129 ** tclcmd: add_alignment_test_collations DB 3130 ** 3131 ** Add two new collating sequences to the database DB 3132 ** 3133 ** utf16_aligned 3134 ** utf16_unaligned 3135 ** 3136 ** Both collating sequences use the same sort order as BINARY. 3137 ** The only difference is that the utf16_aligned collating 3138 ** sequence is declared with the SQLITE_UTF16_ALIGNED flag. 3139 ** Both collating functions increment the unaligned utf16 counter 3140 ** whenever they see a string that begins on an odd byte boundary. 3141 */ 3142 static int unaligned_string_counter = 0; 3143 static int alignmentCollFunc( 3144 void *NotUsed, 3145 int nKey1, const void *pKey1, 3146 int nKey2, const void *pKey2 3147 ){ 3148 int rc, n; 3149 n = nKey1<nKey2 ? nKey1 : nKey2; 3150 if( nKey1>0 && 1==(1&(SQLITE_PTR_TO_INT(pKey1))) ) unaligned_string_counter++; 3151 if( nKey2>0 && 1==(1&(SQLITE_PTR_TO_INT(pKey2))) ) unaligned_string_counter++; 3152 rc = memcmp(pKey1, pKey2, n); 3153 if( rc==0 ){ 3154 rc = nKey1 - nKey2; 3155 } 3156 return rc; 3157 } 3158 static int SQLITE_TCLAPI add_alignment_test_collations( 3159 void * clientData, 3160 Tcl_Interp *interp, 3161 int objc, 3162 Tcl_Obj *CONST objv[] 3163 ){ 3164 sqlite3 *db; 3165 if( objc>=2 ){ 3166 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 3167 sqlite3_create_collation(db, "utf16_unaligned", SQLITE_UTF16, 3168 0, alignmentCollFunc); 3169 sqlite3_create_collation(db, "utf16_aligned", SQLITE_UTF16_ALIGNED, 3170 0, alignmentCollFunc); 3171 } 3172 return SQLITE_OK; 3173 } 3174 #endif /* !defined(SQLITE_OMIT_UTF16) */ 3175 3176 /* 3177 ** Usage: add_test_function <db ptr> <utf8> <utf16le> <utf16be> 3178 ** 3179 ** This function is used to test that SQLite selects the correct user 3180 ** function callback when multiple versions (for different text encodings) 3181 ** are available. 3182 ** 3183 ** Calling this routine registers up to three versions of the user function 3184 ** "test_function" with database handle <db>. If the second argument is 3185 ** true, then a version of test_function is registered for UTF-8, if the 3186 ** third is true, a version is registered for UTF-16le, if the fourth is 3187 ** true, a UTF-16be version is available. Previous versions of 3188 ** test_function are deleted. 3189 ** 3190 ** The user function is implemented by calling the following TCL script: 3191 ** 3192 ** "test_function <enc> <arg>" 3193 ** 3194 ** Where <enc> is one of UTF-8, UTF-16LE or UTF16BE, and <arg> is the 3195 ** single argument passed to the SQL function. The value returned by 3196 ** the TCL script is used as the return value of the SQL function. It 3197 ** is passed to SQLite using UTF-16BE for a UTF-8 test_function(), UTF-8 3198 ** for a UTF-16LE test_function(), and UTF-16LE for an implementation that 3199 ** prefers UTF-16BE. 3200 */ 3201 #ifndef SQLITE_OMIT_UTF16 3202 static void test_function_utf8( 3203 sqlite3_context *pCtx, 3204 int nArg, 3205 sqlite3_value **argv 3206 ){ 3207 Tcl_Interp *interp; 3208 Tcl_Obj *pX; 3209 sqlite3_value *pVal; 3210 interp = (Tcl_Interp *)sqlite3_user_data(pCtx); 3211 pX = Tcl_NewStringObj("test_function", -1); 3212 Tcl_IncrRefCount(pX); 3213 Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-8", -1)); 3214 Tcl_ListObjAppendElement(interp, pX, 3215 Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1)); 3216 Tcl_EvalObjEx(interp, pX, 0); 3217 Tcl_DecrRefCount(pX); 3218 sqlite3_result_text(pCtx, Tcl_GetStringResult(interp), -1, SQLITE_TRANSIENT); 3219 pVal = sqlite3ValueNew(0); 3220 sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp), 3221 SQLITE_UTF8, SQLITE_STATIC); 3222 sqlite3_result_text16be(pCtx, sqlite3_value_text16be(pVal), 3223 -1, SQLITE_TRANSIENT); 3224 sqlite3ValueFree(pVal); 3225 } 3226 static void test_function_utf16le( 3227 sqlite3_context *pCtx, 3228 int nArg, 3229 sqlite3_value **argv 3230 ){ 3231 Tcl_Interp *interp; 3232 Tcl_Obj *pX; 3233 sqlite3_value *pVal; 3234 interp = (Tcl_Interp *)sqlite3_user_data(pCtx); 3235 pX = Tcl_NewStringObj("test_function", -1); 3236 Tcl_IncrRefCount(pX); 3237 Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-16LE", -1)); 3238 Tcl_ListObjAppendElement(interp, pX, 3239 Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1)); 3240 Tcl_EvalObjEx(interp, pX, 0); 3241 Tcl_DecrRefCount(pX); 3242 pVal = sqlite3ValueNew(0); 3243 sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp), 3244 SQLITE_UTF8, SQLITE_STATIC); 3245 sqlite3_result_text(pCtx,(char*)sqlite3_value_text(pVal),-1,SQLITE_TRANSIENT); 3246 sqlite3ValueFree(pVal); 3247 } 3248 static void test_function_utf16be( 3249 sqlite3_context *pCtx, 3250 int nArg, 3251 sqlite3_value **argv 3252 ){ 3253 Tcl_Interp *interp; 3254 Tcl_Obj *pX; 3255 sqlite3_value *pVal; 3256 interp = (Tcl_Interp *)sqlite3_user_data(pCtx); 3257 pX = Tcl_NewStringObj("test_function", -1); 3258 Tcl_IncrRefCount(pX); 3259 Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-16BE", -1)); 3260 Tcl_ListObjAppendElement(interp, pX, 3261 Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1)); 3262 Tcl_EvalObjEx(interp, pX, 0); 3263 Tcl_DecrRefCount(pX); 3264 pVal = sqlite3ValueNew(0); 3265 sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp), 3266 SQLITE_UTF8, SQLITE_STATIC); 3267 sqlite3_result_text16(pCtx, sqlite3_value_text16le(pVal), 3268 -1, SQLITE_TRANSIENT); 3269 sqlite3_result_text16be(pCtx, sqlite3_value_text16le(pVal), 3270 -1, SQLITE_TRANSIENT); 3271 sqlite3_result_text16le(pCtx, sqlite3_value_text16le(pVal), 3272 -1, SQLITE_TRANSIENT); 3273 sqlite3ValueFree(pVal); 3274 } 3275 #endif /* SQLITE_OMIT_UTF16 */ 3276 static int SQLITE_TCLAPI test_function( 3277 void * clientData, 3278 Tcl_Interp *interp, 3279 int objc, 3280 Tcl_Obj *CONST objv[] 3281 ){ 3282 #ifndef SQLITE_OMIT_UTF16 3283 sqlite3 *db; 3284 int val; 3285 3286 if( objc!=5 ) goto bad_args; 3287 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 3288 3289 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR; 3290 if( val ){ 3291 sqlite3_create_function(db, "test_function", 1, SQLITE_UTF8, 3292 interp, test_function_utf8, 0, 0); 3293 } 3294 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &val) ) return TCL_ERROR; 3295 if( val ){ 3296 sqlite3_create_function(db, "test_function", 1, SQLITE_UTF16LE, 3297 interp, test_function_utf16le, 0, 0); 3298 } 3299 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[4], &val) ) return TCL_ERROR; 3300 if( val ){ 3301 sqlite3_create_function(db, "test_function", 1, SQLITE_UTF16BE, 3302 interp, test_function_utf16be, 0, 0); 3303 } 3304 3305 return TCL_OK; 3306 bad_args: 3307 Tcl_AppendResult(interp, "wrong # args: should be \"", 3308 Tcl_GetStringFromObj(objv[0], 0), " <DB> <utf8> <utf16le> <utf16be>", 0); 3309 #endif /* SQLITE_OMIT_UTF16 */ 3310 return TCL_ERROR; 3311 } 3312 3313 /* 3314 ** Usage: sqlite3_test_errstr <err code> 3315 ** 3316 ** Test that the english language string equivalents for sqlite error codes 3317 ** are sane. The parameter is an integer representing an sqlite error code. 3318 ** The result is a list of two elements, the string representation of the 3319 ** error code and the english language explanation. 3320 */ 3321 static int SQLITE_TCLAPI test_errstr( 3322 void * clientData, 3323 Tcl_Interp *interp, 3324 int objc, 3325 Tcl_Obj *CONST objv[] 3326 ){ 3327 char *zCode; 3328 int i; 3329 if( objc!=1 ){ 3330 Tcl_WrongNumArgs(interp, 1, objv, "<error code>"); 3331 } 3332 3333 zCode = Tcl_GetString(objv[1]); 3334 for(i=0; i<200; i++){ 3335 if( 0==strcmp(t1ErrorName(i), zCode) ) break; 3336 } 3337 Tcl_SetResult(interp, (char *)sqlite3ErrStr(i), 0); 3338 return TCL_OK; 3339 } 3340 3341 /* 3342 ** Usage: breakpoint 3343 ** 3344 ** This routine exists for one purpose - to provide a place to put a 3345 ** breakpoint with GDB that can be triggered using TCL code. The use 3346 ** for this is when a particular test fails on (say) the 1485th iteration. 3347 ** In the TCL test script, we can add code like this: 3348 ** 3349 ** if {$i==1485} breakpoint 3350 ** 3351 ** Then run testfixture in the debugger and wait for the breakpoint to 3352 ** fire. Then additional breakpoints can be set to trace down the bug. 3353 */ 3354 static int SQLITE_TCLAPI test_breakpoint( 3355 void *NotUsed, 3356 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 3357 int argc, /* Number of arguments */ 3358 char **argv /* Text of each argument */ 3359 ){ 3360 return TCL_OK; /* Do nothing */ 3361 } 3362 3363 /* 3364 ** Usage: sqlite3_bind_zeroblob STMT IDX N 3365 ** 3366 ** Test the sqlite3_bind_zeroblob interface. STMT is a prepared statement. 3367 ** IDX is the index of a wildcard in the prepared statement. This command 3368 ** binds a N-byte zero-filled BLOB to the wildcard. 3369 */ 3370 static int SQLITE_TCLAPI test_bind_zeroblob( 3371 void * clientData, 3372 Tcl_Interp *interp, 3373 int objc, 3374 Tcl_Obj *CONST objv[] 3375 ){ 3376 sqlite3_stmt *pStmt; 3377 int idx; 3378 int n; 3379 int rc; 3380 3381 if( objc!=4 ){ 3382 Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX N"); 3383 return TCL_ERROR; 3384 } 3385 3386 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3387 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3388 if( Tcl_GetIntFromObj(interp, objv[3], &n) ) return TCL_ERROR; 3389 3390 rc = sqlite3_bind_zeroblob(pStmt, idx, n); 3391 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3392 if( rc!=SQLITE_OK ){ 3393 return TCL_ERROR; 3394 } 3395 3396 return TCL_OK; 3397 } 3398 3399 /* 3400 ** Usage: sqlite3_bind_zeroblob64 STMT IDX N 3401 ** 3402 ** Test the sqlite3_bind_zeroblob64 interface. STMT is a prepared statement. 3403 ** IDX is the index of a wildcard in the prepared statement. This command 3404 ** binds a N-byte zero-filled BLOB to the wildcard. 3405 */ 3406 static int SQLITE_TCLAPI test_bind_zeroblob64( 3407 void * clientData, 3408 Tcl_Interp *interp, 3409 int objc, 3410 Tcl_Obj *CONST objv[] 3411 ){ 3412 sqlite3_stmt *pStmt; 3413 int idx; 3414 Tcl_WideInt n; 3415 int rc; 3416 3417 if( objc!=4 ){ 3418 Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX N"); 3419 return TCL_ERROR; 3420 } 3421 3422 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3423 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3424 if( Tcl_GetWideIntFromObj(interp, objv[3], &n) ) return TCL_ERROR; 3425 3426 rc = sqlite3_bind_zeroblob64(pStmt, idx, n); 3427 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3428 if( rc!=SQLITE_OK ){ 3429 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0); 3430 return TCL_ERROR; 3431 } 3432 3433 return TCL_OK; 3434 } 3435 3436 /* 3437 ** Usage: sqlite3_bind_int STMT N VALUE 3438 ** 3439 ** Test the sqlite3_bind_int interface. STMT is a prepared statement. 3440 ** N is the index of a wildcard in the prepared statement. This command 3441 ** binds a 32-bit integer VALUE to that wildcard. 3442 */ 3443 static int SQLITE_TCLAPI test_bind_int( 3444 void * clientData, 3445 Tcl_Interp *interp, 3446 int objc, 3447 Tcl_Obj *CONST objv[] 3448 ){ 3449 sqlite3_stmt *pStmt; 3450 int idx; 3451 int value; 3452 int rc; 3453 3454 if( objc!=4 ){ 3455 Tcl_AppendResult(interp, "wrong # args: should be \"", 3456 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0); 3457 return TCL_ERROR; 3458 } 3459 3460 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3461 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3462 if( Tcl_GetIntFromObj(interp, objv[3], &value) ) return TCL_ERROR; 3463 3464 rc = sqlite3_bind_int(pStmt, idx, value); 3465 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3466 if( rc!=SQLITE_OK ){ 3467 return TCL_ERROR; 3468 } 3469 3470 return TCL_OK; 3471 } 3472 3473 3474 /* 3475 ** Usage: intarray_addr INT ... 3476 ** 3477 ** Return the address of a C-language array of 32-bit integers. 3478 ** 3479 ** Space to hold the array is obtained from malloc(). Call this procedure once 3480 ** with no arguments in order to release memory. Each call to this procedure 3481 ** overwrites the previous array. 3482 */ 3483 static int SQLITE_TCLAPI test_intarray_addr( 3484 void * clientData, 3485 Tcl_Interp *interp, 3486 int objc, 3487 Tcl_Obj *CONST objv[] 3488 ){ 3489 int i; 3490 static int *p = 0; 3491 3492 sqlite3_free(p); 3493 p = 0; 3494 if( objc>1 ){ 3495 p = sqlite3_malloc( sizeof(p[0])*(objc-1) ); 3496 if( p==0 ) return TCL_ERROR; 3497 for(i=0; i<objc-1; i++){ 3498 if( Tcl_GetIntFromObj(interp, objv[1+i], &p[i]) ){ 3499 sqlite3_free(p); 3500 p = 0; 3501 return TCL_ERROR; 3502 } 3503 } 3504 } 3505 Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p)); 3506 return TCL_OK; 3507 } 3508 /* 3509 ** Usage: intarray_addr INT ... 3510 ** 3511 ** Return the address of a C-language array of 32-bit integers. 3512 ** 3513 ** Space to hold the array is obtained from malloc(). Call this procedure once 3514 ** with no arguments in order to release memory. Each call to this procedure 3515 ** overwrites the previous array. 3516 */ 3517 static int SQLITE_TCLAPI test_int64array_addr( 3518 void * clientData, 3519 Tcl_Interp *interp, 3520 int objc, 3521 Tcl_Obj *CONST objv[] 3522 ){ 3523 int i; 3524 static sqlite3_int64 *p = 0; 3525 3526 sqlite3_free(p); 3527 p = 0; 3528 if( objc>1 ){ 3529 p = sqlite3_malloc( sizeof(p[0])*(objc-1) ); 3530 if( p==0 ) return TCL_ERROR; 3531 for(i=0; i<objc-1; i++){ 3532 Tcl_WideInt v; 3533 if( Tcl_GetWideIntFromObj(interp, objv[1+i], &v) ){ 3534 sqlite3_free(p); 3535 p = 0; 3536 return TCL_ERROR; 3537 } 3538 p[i] = v; 3539 } 3540 } 3541 Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p)); 3542 return TCL_OK; 3543 } 3544 /* 3545 ** Usage: doublearray_addr INT ... 3546 ** 3547 ** Return the address of a C-language array of doubles. 3548 ** 3549 ** Space to hold the array is obtained from malloc(). Call this procedure once 3550 ** with no arguments in order to release memory. Each call to this procedure 3551 ** overwrites the previous array. 3552 */ 3553 static int SQLITE_TCLAPI test_doublearray_addr( 3554 void * clientData, 3555 Tcl_Interp *interp, 3556 int objc, 3557 Tcl_Obj *CONST objv[] 3558 ){ 3559 int i; 3560 static double *p = 0; 3561 3562 sqlite3_free(p); 3563 p = 0; 3564 if( objc>1 ){ 3565 p = sqlite3_malloc( sizeof(p[0])*(objc-1) ); 3566 if( p==0 ) return TCL_ERROR; 3567 for(i=0; i<objc-1; i++){ 3568 if( Tcl_GetDoubleFromObj(interp, objv[1+i], &p[i]) ){ 3569 sqlite3_free(p); 3570 p = 0; 3571 return TCL_ERROR; 3572 } 3573 } 3574 } 3575 Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p)); 3576 return TCL_OK; 3577 } 3578 /* 3579 ** Usage: textarray_addr TEXT ... 3580 ** 3581 ** Return the address of a C-language array of strings. 3582 ** 3583 ** Space to hold the array is obtained from malloc(). Call this procedure once 3584 ** with no arguments in order to release memory. Each call to this procedure 3585 ** overwrites the previous array. 3586 */ 3587 static int SQLITE_TCLAPI test_textarray_addr( 3588 void * clientData, 3589 Tcl_Interp *interp, 3590 int objc, 3591 Tcl_Obj *CONST objv[] 3592 ){ 3593 int i; 3594 static int n = 0; 3595 static char **p = 0; 3596 3597 for(i=0; i<n; i++) sqlite3_free(p[i]); 3598 sqlite3_free(p); 3599 p = 0; 3600 if( objc>1 ){ 3601 p = sqlite3_malloc( sizeof(p[0])*(objc-1) ); 3602 if( p==0 ) return TCL_ERROR; 3603 for(i=0; i<objc-1; i++){ 3604 p[i] = sqlite3_mprintf("%s", Tcl_GetString(objv[1+i])); 3605 } 3606 } 3607 n = objc-1; 3608 Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p)); 3609 return TCL_OK; 3610 } 3611 3612 3613 /* 3614 ** Usage: sqlite3_bind_int64 STMT N VALUE 3615 ** 3616 ** Test the sqlite3_bind_int64 interface. STMT is a prepared statement. 3617 ** N is the index of a wildcard in the prepared statement. This command 3618 ** binds a 64-bit integer VALUE to that wildcard. 3619 */ 3620 static int SQLITE_TCLAPI test_bind_int64( 3621 void * clientData, 3622 Tcl_Interp *interp, 3623 int objc, 3624 Tcl_Obj *CONST objv[] 3625 ){ 3626 sqlite3_stmt *pStmt; 3627 int idx; 3628 Tcl_WideInt value; 3629 int rc; 3630 3631 if( objc!=4 ){ 3632 Tcl_AppendResult(interp, "wrong # args: should be \"", 3633 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0); 3634 return TCL_ERROR; 3635 } 3636 3637 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3638 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3639 if( Tcl_GetWideIntFromObj(interp, objv[3], &value) ) return TCL_ERROR; 3640 3641 rc = sqlite3_bind_int64(pStmt, idx, value); 3642 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3643 if( rc!=SQLITE_OK ){ 3644 return TCL_ERROR; 3645 } 3646 3647 return TCL_OK; 3648 } 3649 3650 3651 /* 3652 ** Usage: sqlite3_bind_double STMT N VALUE 3653 ** 3654 ** Test the sqlite3_bind_double interface. STMT is a prepared statement. 3655 ** N is the index of a wildcard in the prepared statement. This command 3656 ** binds a 64-bit integer VALUE to that wildcard. 3657 */ 3658 static int SQLITE_TCLAPI test_bind_double( 3659 void * clientData, 3660 Tcl_Interp *interp, 3661 int objc, 3662 Tcl_Obj *CONST objv[] 3663 ){ 3664 sqlite3_stmt *pStmt; 3665 int idx; 3666 double value = 0; 3667 int rc; 3668 const char *zVal; 3669 int i; 3670 static const struct { 3671 const char *zName; /* Name of the special floating point value */ 3672 unsigned int iUpper; /* Upper 32 bits */ 3673 unsigned int iLower; /* Lower 32 bits */ 3674 } aSpecialFp[] = { 3675 { "NaN", 0x7fffffff, 0xffffffff }, 3676 { "SNaN", 0x7ff7ffff, 0xffffffff }, 3677 { "-NaN", 0xffffffff, 0xffffffff }, 3678 { "-SNaN", 0xfff7ffff, 0xffffffff }, 3679 { "+Inf", 0x7ff00000, 0x00000000 }, 3680 { "-Inf", 0xfff00000, 0x00000000 }, 3681 { "Epsilon", 0x00000000, 0x00000001 }, 3682 { "-Epsilon", 0x80000000, 0x00000001 }, 3683 { "NaN0", 0x7ff80000, 0x00000000 }, 3684 { "-NaN0", 0xfff80000, 0x00000000 }, 3685 }; 3686 3687 if( objc!=4 ){ 3688 Tcl_AppendResult(interp, "wrong # args: should be \"", 3689 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0); 3690 return TCL_ERROR; 3691 } 3692 3693 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3694 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3695 3696 /* Intercept the string "NaN" and generate a NaN value for it. 3697 ** All other strings are passed through to Tcl_GetDoubleFromObj(). 3698 ** Tcl_GetDoubleFromObj() should understand "NaN" but some versions 3699 ** contain a bug. 3700 */ 3701 zVal = Tcl_GetString(objv[3]); 3702 for(i=0; i<sizeof(aSpecialFp)/sizeof(aSpecialFp[0]); i++){ 3703 if( strcmp(aSpecialFp[i].zName, zVal)==0 ){ 3704 sqlite3_uint64 x; 3705 x = aSpecialFp[i].iUpper; 3706 x <<= 32; 3707 x |= aSpecialFp[i].iLower; 3708 assert( sizeof(value)==8 ); 3709 assert( sizeof(x)==8 ); 3710 memcpy(&value, &x, 8); 3711 break; 3712 } 3713 } 3714 if( i>=sizeof(aSpecialFp)/sizeof(aSpecialFp[0]) && 3715 Tcl_GetDoubleFromObj(interp, objv[3], &value) ){ 3716 return TCL_ERROR; 3717 } 3718 rc = sqlite3_bind_double(pStmt, idx, value); 3719 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3720 if( rc!=SQLITE_OK ){ 3721 return TCL_ERROR; 3722 } 3723 3724 return TCL_OK; 3725 } 3726 3727 /* 3728 ** Usage: sqlite3_bind_null STMT N 3729 ** 3730 ** Test the sqlite3_bind_null interface. STMT is a prepared statement. 3731 ** N is the index of a wildcard in the prepared statement. This command 3732 ** binds a NULL to the wildcard. 3733 */ 3734 static int SQLITE_TCLAPI test_bind_null( 3735 void * clientData, 3736 Tcl_Interp *interp, 3737 int objc, 3738 Tcl_Obj *CONST objv[] 3739 ){ 3740 sqlite3_stmt *pStmt; 3741 int idx; 3742 int rc; 3743 3744 if( objc!=3 ){ 3745 Tcl_AppendResult(interp, "wrong # args: should be \"", 3746 Tcl_GetStringFromObj(objv[0], 0), " STMT N", 0); 3747 return TCL_ERROR; 3748 } 3749 3750 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3751 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3752 3753 rc = sqlite3_bind_null(pStmt, idx); 3754 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3755 if( rc!=SQLITE_OK ){ 3756 return TCL_ERROR; 3757 } 3758 3759 return TCL_OK; 3760 } 3761 3762 /* 3763 ** Usage: sqlite3_bind_text STMT N STRING BYTES 3764 ** 3765 ** Test the sqlite3_bind_text interface. STMT is a prepared statement. 3766 ** N is the index of a wildcard in the prepared statement. This command 3767 ** binds a UTF-8 string STRING to the wildcard. The string is BYTES bytes 3768 ** long. 3769 */ 3770 static int SQLITE_TCLAPI test_bind_text( 3771 void * clientData, 3772 Tcl_Interp *interp, 3773 int objc, 3774 Tcl_Obj *CONST objv[] 3775 ){ 3776 sqlite3_stmt *pStmt; 3777 int idx; 3778 int bytes; 3779 char *value; 3780 int rc; 3781 3782 if( objc!=5 ){ 3783 Tcl_AppendResult(interp, "wrong # args: should be \"", 3784 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE BYTES", 0); 3785 return TCL_ERROR; 3786 } 3787 3788 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3789 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3790 value = (char*)Tcl_GetByteArrayFromObj(objv[3], &bytes); 3791 if( Tcl_GetIntFromObj(interp, objv[4], &bytes) ) return TCL_ERROR; 3792 3793 rc = sqlite3_bind_text(pStmt, idx, value, bytes, SQLITE_TRANSIENT); 3794 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3795 if( rc!=SQLITE_OK ){ 3796 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0); 3797 return TCL_ERROR; 3798 } 3799 3800 return TCL_OK; 3801 } 3802 3803 /* 3804 ** Usage: sqlite3_bind_text16 ?-static? STMT N STRING BYTES 3805 ** 3806 ** Test the sqlite3_bind_text16 interface. STMT is a prepared statement. 3807 ** N is the index of a wildcard in the prepared statement. This command 3808 ** binds a UTF-16 string STRING to the wildcard. The string is BYTES bytes 3809 ** long. 3810 */ 3811 static int SQLITE_TCLAPI test_bind_text16( 3812 void * clientData, 3813 Tcl_Interp *interp, 3814 int objc, 3815 Tcl_Obj *CONST objv[] 3816 ){ 3817 #ifndef SQLITE_OMIT_UTF16 3818 sqlite3_stmt *pStmt; 3819 int idx; 3820 int bytes; 3821 char *value; 3822 int rc; 3823 3824 void (*xDel)(void*) = (objc==6?SQLITE_STATIC:SQLITE_TRANSIENT); 3825 Tcl_Obj *oStmt = objv[objc-4]; 3826 Tcl_Obj *oN = objv[objc-3]; 3827 Tcl_Obj *oString = objv[objc-2]; 3828 Tcl_Obj *oBytes = objv[objc-1]; 3829 3830 if( objc!=5 && objc!=6){ 3831 Tcl_AppendResult(interp, "wrong # args: should be \"", 3832 Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE BYTES", 0); 3833 return TCL_ERROR; 3834 } 3835 3836 if( getStmtPointer(interp, Tcl_GetString(oStmt), &pStmt) ) return TCL_ERROR; 3837 if( Tcl_GetIntFromObj(interp, oN, &idx) ) return TCL_ERROR; 3838 value = (char*)Tcl_GetByteArrayFromObj(oString, 0); 3839 if( Tcl_GetIntFromObj(interp, oBytes, &bytes) ) return TCL_ERROR; 3840 3841 rc = sqlite3_bind_text16(pStmt, idx, (void *)value, bytes, xDel); 3842 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3843 if( rc!=SQLITE_OK ){ 3844 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0); 3845 return TCL_ERROR; 3846 } 3847 3848 #endif /* SQLITE_OMIT_UTF16 */ 3849 return TCL_OK; 3850 } 3851 3852 /* 3853 ** Usage: sqlite3_bind_blob ?-static? STMT N DATA BYTES 3854 ** 3855 ** Test the sqlite3_bind_blob interface. STMT is a prepared statement. 3856 ** N is the index of a wildcard in the prepared statement. This command 3857 ** binds a BLOB to the wildcard. The BLOB is BYTES bytes in size. 3858 */ 3859 static int SQLITE_TCLAPI test_bind_blob( 3860 void * clientData, 3861 Tcl_Interp *interp, 3862 int objc, 3863 Tcl_Obj *CONST objv[] 3864 ){ 3865 sqlite3_stmt *pStmt; 3866 int len, idx; 3867 int bytes; 3868 char *value; 3869 int rc; 3870 sqlite3_destructor_type xDestructor = SQLITE_TRANSIENT; 3871 3872 if( objc!=5 && objc!=6 ){ 3873 Tcl_AppendResult(interp, "wrong # args: should be \"", 3874 Tcl_GetStringFromObj(objv[0], 0), " STMT N DATA BYTES", 0); 3875 return TCL_ERROR; 3876 } 3877 3878 if( objc==6 ){ 3879 xDestructor = SQLITE_STATIC; 3880 objv++; 3881 } 3882 3883 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3884 if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; 3885 3886 value = (char*)Tcl_GetByteArrayFromObj(objv[3], &len); 3887 if( Tcl_GetIntFromObj(interp, objv[4], &bytes) ) return TCL_ERROR; 3888 3889 if( bytes>len ){ 3890 char zBuf[200]; 3891 sqlite3_snprintf(sizeof(zBuf), zBuf, 3892 "cannot use %d blob bytes, have %d", bytes, len); 3893 Tcl_AppendResult(interp, zBuf, -1); 3894 return TCL_ERROR; 3895 } 3896 3897 rc = sqlite3_bind_blob(pStmt, idx, value, bytes, xDestructor); 3898 if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR; 3899 if( rc!=SQLITE_OK ){ 3900 return TCL_ERROR; 3901 } 3902 3903 return TCL_OK; 3904 } 3905 3906 /* 3907 ** Usage: sqlite3_bind_parameter_count STMT 3908 ** 3909 ** Return the number of wildcards in the given statement. 3910 */ 3911 static int SQLITE_TCLAPI test_bind_parameter_count( 3912 void * clientData, 3913 Tcl_Interp *interp, 3914 int objc, 3915 Tcl_Obj *CONST objv[] 3916 ){ 3917 sqlite3_stmt *pStmt; 3918 3919 if( objc!=2 ){ 3920 Tcl_WrongNumArgs(interp, 1, objv, "STMT"); 3921 return TCL_ERROR; 3922 } 3923 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3924 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_bind_parameter_count(pStmt))); 3925 return TCL_OK; 3926 } 3927 3928 /* 3929 ** Usage: sqlite3_bind_parameter_name STMT N 3930 ** 3931 ** Return the name of the Nth wildcard. The first wildcard is 1. 3932 ** An empty string is returned if N is out of range or if the wildcard 3933 ** is nameless. 3934 */ 3935 static int SQLITE_TCLAPI test_bind_parameter_name( 3936 void * clientData, 3937 Tcl_Interp *interp, 3938 int objc, 3939 Tcl_Obj *CONST objv[] 3940 ){ 3941 sqlite3_stmt *pStmt; 3942 int i; 3943 3944 if( objc!=3 ){ 3945 Tcl_WrongNumArgs(interp, 1, objv, "STMT N"); 3946 return TCL_ERROR; 3947 } 3948 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3949 if( Tcl_GetIntFromObj(interp, objv[2], &i) ) return TCL_ERROR; 3950 Tcl_SetObjResult(interp, 3951 Tcl_NewStringObj(sqlite3_bind_parameter_name(pStmt,i),-1) 3952 ); 3953 return TCL_OK; 3954 } 3955 3956 /* 3957 ** Usage: sqlite3_bind_parameter_index STMT NAME 3958 ** 3959 ** Return the index of the wildcard called NAME. Return 0 if there is 3960 ** no such wildcard. 3961 */ 3962 static int SQLITE_TCLAPI test_bind_parameter_index( 3963 void * clientData, 3964 Tcl_Interp *interp, 3965 int objc, 3966 Tcl_Obj *CONST objv[] 3967 ){ 3968 sqlite3_stmt *pStmt; 3969 3970 if( objc!=3 ){ 3971 Tcl_WrongNumArgs(interp, 1, objv, "STMT NAME"); 3972 return TCL_ERROR; 3973 } 3974 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 3975 Tcl_SetObjResult(interp, 3976 Tcl_NewIntObj( 3977 sqlite3_bind_parameter_index(pStmt,Tcl_GetString(objv[2])) 3978 ) 3979 ); 3980 return TCL_OK; 3981 } 3982 3983 /* 3984 ** Usage: sqlite3_clear_bindings STMT 3985 ** 3986 */ 3987 static int SQLITE_TCLAPI test_clear_bindings( 3988 void * clientData, 3989 Tcl_Interp *interp, 3990 int objc, 3991 Tcl_Obj *CONST objv[] 3992 ){ 3993 sqlite3_stmt *pStmt; 3994 3995 if( objc!=2 ){ 3996 Tcl_WrongNumArgs(interp, 1, objv, "STMT"); 3997 return TCL_ERROR; 3998 } 3999 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4000 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_clear_bindings(pStmt))); 4001 return TCL_OK; 4002 } 4003 4004 /* 4005 ** Usage: sqlite3_sleep MILLISECONDS 4006 */ 4007 static int SQLITE_TCLAPI test_sleep( 4008 void * clientData, 4009 Tcl_Interp *interp, 4010 int objc, 4011 Tcl_Obj *CONST objv[] 4012 ){ 4013 int ms; 4014 4015 if( objc!=2 ){ 4016 Tcl_WrongNumArgs(interp, 1, objv, "MILLISECONDS"); 4017 return TCL_ERROR; 4018 } 4019 if( Tcl_GetIntFromObj(interp, objv[1], &ms) ){ 4020 return TCL_ERROR; 4021 } 4022 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_sleep(ms))); 4023 return TCL_OK; 4024 } 4025 4026 /* 4027 ** Usage: sqlite3_extended_errcode DB 4028 ** 4029 ** Return the string representation of the most recent sqlite3_* API 4030 ** error code. e.g. "SQLITE_ERROR". 4031 */ 4032 static int SQLITE_TCLAPI test_ex_errcode( 4033 void * clientData, 4034 Tcl_Interp *interp, 4035 int objc, 4036 Tcl_Obj *CONST objv[] 4037 ){ 4038 sqlite3 *db; 4039 int rc; 4040 4041 if( objc!=2 ){ 4042 Tcl_AppendResult(interp, "wrong # args: should be \"", 4043 Tcl_GetString(objv[0]), " DB", 0); 4044 return TCL_ERROR; 4045 } 4046 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4047 rc = sqlite3_extended_errcode(db); 4048 Tcl_AppendResult(interp, (char *)t1ErrorName(rc), 0); 4049 return TCL_OK; 4050 } 4051 4052 4053 /* 4054 ** Usage: sqlite3_errcode DB 4055 ** 4056 ** Return the string representation of the most recent sqlite3_* API 4057 ** error code. e.g. "SQLITE_ERROR". 4058 */ 4059 static int SQLITE_TCLAPI test_errcode( 4060 void * clientData, 4061 Tcl_Interp *interp, 4062 int objc, 4063 Tcl_Obj *CONST objv[] 4064 ){ 4065 sqlite3 *db; 4066 int rc; 4067 4068 if( objc!=2 ){ 4069 Tcl_AppendResult(interp, "wrong # args: should be \"", 4070 Tcl_GetString(objv[0]), " DB", 0); 4071 return TCL_ERROR; 4072 } 4073 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4074 rc = sqlite3_errcode(db); 4075 Tcl_AppendResult(interp, (char *)t1ErrorName(rc), 0); 4076 return TCL_OK; 4077 } 4078 4079 /* 4080 ** Usage: sqlite3_errmsg DB 4081 ** 4082 ** Returns the UTF-8 representation of the error message string for the 4083 ** most recent sqlite3_* API call. 4084 */ 4085 static int SQLITE_TCLAPI test_errmsg( 4086 void * clientData, 4087 Tcl_Interp *interp, 4088 int objc, 4089 Tcl_Obj *CONST objv[] 4090 ){ 4091 sqlite3 *db; 4092 const char *zErr; 4093 4094 if( objc!=2 ){ 4095 Tcl_AppendResult(interp, "wrong # args: should be \"", 4096 Tcl_GetString(objv[0]), " DB", 0); 4097 return TCL_ERROR; 4098 } 4099 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4100 4101 zErr = sqlite3_errmsg(db); 4102 Tcl_SetObjResult(interp, Tcl_NewStringObj(zErr, -1)); 4103 return TCL_OK; 4104 } 4105 4106 /* 4107 ** Usage: test_errmsg16 DB 4108 ** 4109 ** Returns the UTF-16 representation of the error message string for the 4110 ** most recent sqlite3_* API call. This is a byte array object at the TCL 4111 ** level, and it includes the 0x00 0x00 terminator bytes at the end of the 4112 ** UTF-16 string. 4113 */ 4114 static int SQLITE_TCLAPI test_errmsg16( 4115 void * clientData, 4116 Tcl_Interp *interp, 4117 int objc, 4118 Tcl_Obj *CONST objv[] 4119 ){ 4120 #ifndef SQLITE_OMIT_UTF16 4121 sqlite3 *db; 4122 const void *zErr; 4123 const char *z; 4124 int bytes = 0; 4125 4126 if( objc!=2 ){ 4127 Tcl_AppendResult(interp, "wrong # args: should be \"", 4128 Tcl_GetString(objv[0]), " DB", 0); 4129 return TCL_ERROR; 4130 } 4131 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4132 4133 zErr = sqlite3_errmsg16(db); 4134 if( zErr ){ 4135 z = zErr; 4136 for(bytes=0; z[bytes] || z[bytes+1]; bytes+=2){} 4137 } 4138 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(zErr, bytes)); 4139 #endif /* SQLITE_OMIT_UTF16 */ 4140 return TCL_OK; 4141 } 4142 4143 /* 4144 ** Usage: sqlite3_prepare DB sql bytes ?tailvar? 4145 ** 4146 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using 4147 ** database handle <DB>. The parameter <tailval> is the name of a global 4148 ** variable that is set to the unused portion of <sql> (if any). A 4149 ** STMT handle is returned. 4150 */ 4151 static int SQLITE_TCLAPI test_prepare( 4152 void * clientData, 4153 Tcl_Interp *interp, 4154 int objc, 4155 Tcl_Obj *CONST objv[] 4156 ){ 4157 sqlite3 *db; 4158 const char *zSql; 4159 int bytes; 4160 const char *zTail = 0; 4161 sqlite3_stmt *pStmt = 0; 4162 char zBuf[50]; 4163 int rc; 4164 4165 if( objc!=5 && objc!=4 ){ 4166 Tcl_AppendResult(interp, "wrong # args: should be \"", 4167 Tcl_GetString(objv[0]), " DB sql bytes ?tailvar?", 0); 4168 return TCL_ERROR; 4169 } 4170 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4171 zSql = Tcl_GetString(objv[2]); 4172 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR; 4173 4174 rc = sqlite3_prepare(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0); 4175 Tcl_ResetResult(interp); 4176 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 4177 if( zTail && objc>=5 ){ 4178 if( bytes>=0 ){ 4179 bytes = bytes - (int)(zTail-zSql); 4180 } 4181 if( (int)strlen(zTail)<bytes ){ 4182 bytes = (int)strlen(zTail); 4183 } 4184 Tcl_ObjSetVar2(interp, objv[4], 0, Tcl_NewStringObj(zTail, bytes), 0); 4185 } 4186 if( rc!=SQLITE_OK ){ 4187 assert( pStmt==0 ); 4188 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc); 4189 Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0); 4190 return TCL_ERROR; 4191 } 4192 4193 if( pStmt ){ 4194 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 4195 Tcl_AppendResult(interp, zBuf, 0); 4196 } 4197 return TCL_OK; 4198 } 4199 4200 /* 4201 ** Usage: sqlite3_prepare_v2 DB sql bytes ?tailvar? 4202 ** 4203 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using 4204 ** database handle <DB>. The parameter <tailval> is the name of a global 4205 ** variable that is set to the unused portion of <sql> (if any). A 4206 ** STMT handle is returned. 4207 */ 4208 static int SQLITE_TCLAPI test_prepare_v2( 4209 void * clientData, 4210 Tcl_Interp *interp, 4211 int objc, 4212 Tcl_Obj *CONST objv[] 4213 ){ 4214 sqlite3 *db; 4215 const char *zSql; 4216 char *zCopy = 0; /* malloc() copy of zSql */ 4217 int bytes; 4218 const char *zTail = 0; 4219 sqlite3_stmt *pStmt = 0; 4220 char zBuf[50]; 4221 int rc; 4222 4223 if( objc!=5 && objc!=4 ){ 4224 Tcl_AppendResult(interp, "wrong # args: should be \"", 4225 Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0); 4226 return TCL_ERROR; 4227 } 4228 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4229 zSql = Tcl_GetString(objv[2]); 4230 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR; 4231 4232 /* Instead of using zSql directly, make a copy into a buffer obtained 4233 ** directly from malloc(). The idea is to make it easier for valgrind 4234 ** to spot buffer overreads. */ 4235 if( bytes>=0 ){ 4236 zCopy = malloc(bytes); 4237 memcpy(zCopy, zSql, bytes); 4238 }else{ 4239 int n = (int)strlen(zSql) + 1; 4240 zCopy = malloc(n); 4241 memcpy(zCopy, zSql, n); 4242 } 4243 rc = sqlite3_prepare_v2(db, zCopy, bytes, &pStmt, objc>=5 ? &zTail : 0); 4244 free(zCopy); 4245 zTail = &zSql[(zTail - zCopy)]; 4246 4247 assert(rc==SQLITE_OK || pStmt==0); 4248 Tcl_ResetResult(interp); 4249 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 4250 if( rc==SQLITE_OK && zTail && objc>=5 ){ 4251 if( bytes>=0 ){ 4252 bytes = bytes - (int)(zTail-zSql); 4253 } 4254 Tcl_ObjSetVar2(interp, objv[4], 0, Tcl_NewStringObj(zTail, bytes), 0); 4255 } 4256 if( rc!=SQLITE_OK ){ 4257 assert( pStmt==0 ); 4258 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc); 4259 Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0); 4260 return TCL_ERROR; 4261 } 4262 4263 if( pStmt ){ 4264 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 4265 Tcl_AppendResult(interp, zBuf, 0); 4266 } 4267 return TCL_OK; 4268 } 4269 4270 /* 4271 ** Usage: sqlite3_prepare_tkt3134 DB 4272 ** 4273 ** Generate a prepared statement for a zero-byte string as a test 4274 ** for ticket #3134. The string should be preceded by a zero byte. 4275 */ 4276 static int SQLITE_TCLAPI test_prepare_tkt3134( 4277 void * clientData, 4278 Tcl_Interp *interp, 4279 int objc, 4280 Tcl_Obj *CONST objv[] 4281 ){ 4282 sqlite3 *db; 4283 static const char zSql[] = "\000SELECT 1"; 4284 sqlite3_stmt *pStmt = 0; 4285 char zBuf[50]; 4286 int rc; 4287 4288 if( objc!=2 ){ 4289 Tcl_AppendResult(interp, "wrong # args: should be \"", 4290 Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0); 4291 return TCL_ERROR; 4292 } 4293 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4294 rc = sqlite3_prepare_v2(db, &zSql[1], 0, &pStmt, 0); 4295 assert(rc==SQLITE_OK || pStmt==0); 4296 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 4297 if( rc!=SQLITE_OK ){ 4298 assert( pStmt==0 ); 4299 sqlite3_snprintf(sizeof(zBuf), zBuf, "(%d) ", rc); 4300 Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0); 4301 return TCL_ERROR; 4302 } 4303 4304 if( pStmt ){ 4305 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 4306 Tcl_AppendResult(interp, zBuf, 0); 4307 } 4308 return TCL_OK; 4309 } 4310 4311 /* 4312 ** Usage: sqlite3_prepare16 DB sql bytes tailvar 4313 ** 4314 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using 4315 ** database handle <DB>. The parameter <tailval> is the name of a global 4316 ** variable that is set to the unused portion of <sql> (if any). A 4317 ** STMT handle is returned. 4318 */ 4319 static int SQLITE_TCLAPI test_prepare16( 4320 void * clientData, 4321 Tcl_Interp *interp, 4322 int objc, 4323 Tcl_Obj *CONST objv[] 4324 ){ 4325 #ifndef SQLITE_OMIT_UTF16 4326 sqlite3 *db; 4327 const void *zSql; 4328 const void *zTail = 0; 4329 Tcl_Obj *pTail = 0; 4330 sqlite3_stmt *pStmt = 0; 4331 char zBuf[50]; 4332 int rc; 4333 int bytes; /* The integer specified as arg 3 */ 4334 int objlen; /* The byte-array length of arg 2 */ 4335 4336 if( objc!=5 && objc!=4 ){ 4337 Tcl_AppendResult(interp, "wrong # args: should be \"", 4338 Tcl_GetString(objv[0]), " DB sql bytes ?tailvar?", 0); 4339 return TCL_ERROR; 4340 } 4341 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4342 zSql = Tcl_GetByteArrayFromObj(objv[2], &objlen); 4343 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR; 4344 4345 rc = sqlite3_prepare16(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0); 4346 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 4347 if( rc ){ 4348 return TCL_ERROR; 4349 } 4350 4351 if( objc>=5 ){ 4352 if( zTail ){ 4353 objlen = objlen - (int)((u8 *)zTail-(u8 *)zSql); 4354 }else{ 4355 objlen = 0; 4356 } 4357 pTail = Tcl_NewByteArrayObj((u8 *)zTail, objlen); 4358 Tcl_IncrRefCount(pTail); 4359 Tcl_ObjSetVar2(interp, objv[4], 0, pTail, 0); 4360 Tcl_DecrRefCount(pTail); 4361 } 4362 4363 if( pStmt ){ 4364 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 4365 } 4366 Tcl_AppendResult(interp, zBuf, 0); 4367 #endif /* SQLITE_OMIT_UTF16 */ 4368 return TCL_OK; 4369 } 4370 4371 /* 4372 ** Usage: sqlite3_prepare16_v2 DB sql bytes ?tailvar? 4373 ** 4374 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using 4375 ** database handle <DB>. The parameter <tailval> is the name of a global 4376 ** variable that is set to the unused portion of <sql> (if any). A 4377 ** STMT handle is returned. 4378 */ 4379 static int SQLITE_TCLAPI test_prepare16_v2( 4380 void * clientData, 4381 Tcl_Interp *interp, 4382 int objc, 4383 Tcl_Obj *CONST objv[] 4384 ){ 4385 #ifndef SQLITE_OMIT_UTF16 4386 sqlite3 *db; 4387 const void *zSql; 4388 const void *zTail = 0; 4389 Tcl_Obj *pTail = 0; 4390 sqlite3_stmt *pStmt = 0; 4391 char zBuf[50]; 4392 int rc; 4393 int bytes; /* The integer specified as arg 3 */ 4394 int objlen; /* The byte-array length of arg 2 */ 4395 4396 if( objc!=5 && objc!=4 ){ 4397 Tcl_AppendResult(interp, "wrong # args: should be \"", 4398 Tcl_GetString(objv[0]), " DB sql bytes ?tailvar?", 0); 4399 return TCL_ERROR; 4400 } 4401 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 4402 zSql = Tcl_GetByteArrayFromObj(objv[2], &objlen); 4403 if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR; 4404 4405 rc = sqlite3_prepare16_v2(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0); 4406 if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR; 4407 if( rc ){ 4408 return TCL_ERROR; 4409 } 4410 4411 if( objc>=5 ){ 4412 if( zTail ){ 4413 objlen = objlen - (int)((u8 *)zTail-(u8 *)zSql); 4414 }else{ 4415 objlen = 0; 4416 } 4417 pTail = Tcl_NewByteArrayObj((u8 *)zTail, objlen); 4418 Tcl_IncrRefCount(pTail); 4419 Tcl_ObjSetVar2(interp, objv[4], 0, pTail, 0); 4420 Tcl_DecrRefCount(pTail); 4421 } 4422 4423 if( pStmt ){ 4424 if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR; 4425 } 4426 Tcl_AppendResult(interp, zBuf, 0); 4427 #endif /* SQLITE_OMIT_UTF16 */ 4428 return TCL_OK; 4429 } 4430 4431 /* 4432 ** Usage: sqlite3_open filename ?options-list? 4433 */ 4434 static int SQLITE_TCLAPI test_open( 4435 void * clientData, 4436 Tcl_Interp *interp, 4437 int objc, 4438 Tcl_Obj *CONST objv[] 4439 ){ 4440 const char *zFilename; 4441 sqlite3 *db; 4442 char zBuf[100]; 4443 4444 if( objc!=3 && objc!=2 && objc!=1 ){ 4445 Tcl_AppendResult(interp, "wrong # args: should be \"", 4446 Tcl_GetString(objv[0]), " filename options-list", 0); 4447 return TCL_ERROR; 4448 } 4449 4450 zFilename = objc>1 ? Tcl_GetString(objv[1]) : 0; 4451 sqlite3_open(zFilename, &db); 4452 4453 if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR; 4454 Tcl_AppendResult(interp, zBuf, 0); 4455 return TCL_OK; 4456 } 4457 4458 /* 4459 ** Usage: sqlite3_open_v2 FILENAME FLAGS VFS 4460 */ 4461 static int SQLITE_TCLAPI test_open_v2( 4462 void * clientData, 4463 Tcl_Interp *interp, 4464 int objc, 4465 Tcl_Obj *CONST objv[] 4466 ){ 4467 const char *zFilename; 4468 const char *zVfs; 4469 int flags = 0; 4470 sqlite3 *db; 4471 int rc; 4472 char zBuf[100]; 4473 4474 int nFlag; 4475 Tcl_Obj **apFlag; 4476 int i; 4477 4478 if( objc!=4 ){ 4479 Tcl_WrongNumArgs(interp, 1, objv, "FILENAME FLAGS VFS"); 4480 return TCL_ERROR; 4481 } 4482 zFilename = Tcl_GetString(objv[1]); 4483 zVfs = Tcl_GetString(objv[3]); 4484 if( zVfs[0]==0x00 ) zVfs = 0; 4485 4486 rc = Tcl_ListObjGetElements(interp, objv[2], &nFlag, &apFlag); 4487 if( rc!=TCL_OK ) return rc; 4488 for(i=0; i<nFlag; i++){ 4489 int iFlag; 4490 struct OpenFlag { 4491 const char *zFlag; 4492 int flag; 4493 } aFlag[] = { 4494 { "SQLITE_OPEN_READONLY", SQLITE_OPEN_READONLY }, 4495 { "SQLITE_OPEN_READWRITE", SQLITE_OPEN_READWRITE }, 4496 { "SQLITE_OPEN_CREATE", SQLITE_OPEN_CREATE }, 4497 { "SQLITE_OPEN_DELETEONCLOSE", SQLITE_OPEN_DELETEONCLOSE }, 4498 { "SQLITE_OPEN_EXCLUSIVE", SQLITE_OPEN_EXCLUSIVE }, 4499 { "SQLITE_OPEN_AUTOPROXY", SQLITE_OPEN_AUTOPROXY }, 4500 { "SQLITE_OPEN_MAIN_DB", SQLITE_OPEN_MAIN_DB }, 4501 { "SQLITE_OPEN_TEMP_DB", SQLITE_OPEN_TEMP_DB }, 4502 { "SQLITE_OPEN_TRANSIENT_DB", SQLITE_OPEN_TRANSIENT_DB }, 4503 { "SQLITE_OPEN_MAIN_JOURNAL", SQLITE_OPEN_MAIN_JOURNAL }, 4504 { "SQLITE_OPEN_TEMP_JOURNAL", SQLITE_OPEN_TEMP_JOURNAL }, 4505 { "SQLITE_OPEN_SUBJOURNAL", SQLITE_OPEN_SUBJOURNAL }, 4506 { "SQLITE_OPEN_MASTER_JOURNAL", SQLITE_OPEN_MASTER_JOURNAL }, 4507 { "SQLITE_OPEN_NOMUTEX", SQLITE_OPEN_NOMUTEX }, 4508 { "SQLITE_OPEN_FULLMUTEX", SQLITE_OPEN_FULLMUTEX }, 4509 { "SQLITE_OPEN_SHAREDCACHE", SQLITE_OPEN_SHAREDCACHE }, 4510 { "SQLITE_OPEN_PRIVATECACHE", SQLITE_OPEN_PRIVATECACHE }, 4511 { "SQLITE_OPEN_WAL", SQLITE_OPEN_WAL }, 4512 { "SQLITE_OPEN_URI", SQLITE_OPEN_URI }, 4513 { 0, 0 } 4514 }; 4515 rc = Tcl_GetIndexFromObjStruct(interp, apFlag[i], aFlag, sizeof(aFlag[0]), 4516 "flag", 0, &iFlag 4517 ); 4518 if( rc!=TCL_OK ) return rc; 4519 flags |= aFlag[iFlag].flag; 4520 } 4521 4522 rc = sqlite3_open_v2(zFilename, &db, flags, zVfs); 4523 if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR; 4524 Tcl_AppendResult(interp, zBuf, 0); 4525 return TCL_OK; 4526 } 4527 4528 /* 4529 ** Usage: sqlite3_open16 filename options 4530 */ 4531 static int SQLITE_TCLAPI test_open16( 4532 void * clientData, 4533 Tcl_Interp *interp, 4534 int objc, 4535 Tcl_Obj *CONST objv[] 4536 ){ 4537 #ifndef SQLITE_OMIT_UTF16 4538 const void *zFilename; 4539 sqlite3 *db; 4540 char zBuf[100]; 4541 4542 if( objc!=3 ){ 4543 Tcl_AppendResult(interp, "wrong # args: should be \"", 4544 Tcl_GetString(objv[0]), " filename options-list", 0); 4545 return TCL_ERROR; 4546 } 4547 4548 zFilename = Tcl_GetByteArrayFromObj(objv[1], 0); 4549 sqlite3_open16(zFilename, &db); 4550 4551 if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR; 4552 Tcl_AppendResult(interp, zBuf, 0); 4553 #endif /* SQLITE_OMIT_UTF16 */ 4554 return TCL_OK; 4555 } 4556 4557 /* 4558 ** Usage: sqlite3_complete16 <UTF-16 string> 4559 ** 4560 ** Return 1 if the supplied argument is a complete SQL statement, or zero 4561 ** otherwise. 4562 */ 4563 static int SQLITE_TCLAPI test_complete16( 4564 void * clientData, 4565 Tcl_Interp *interp, 4566 int objc, 4567 Tcl_Obj *CONST objv[] 4568 ){ 4569 #if !defined(SQLITE_OMIT_COMPLETE) && !defined(SQLITE_OMIT_UTF16) 4570 char *zBuf; 4571 4572 if( objc!=2 ){ 4573 Tcl_WrongNumArgs(interp, 1, objv, "<utf-16 sql>"); 4574 return TCL_ERROR; 4575 } 4576 4577 zBuf = (char*)Tcl_GetByteArrayFromObj(objv[1], 0); 4578 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_complete16(zBuf))); 4579 #endif /* SQLITE_OMIT_COMPLETE && SQLITE_OMIT_UTF16 */ 4580 return TCL_OK; 4581 } 4582 4583 /* 4584 ** Usage: sqlite3_normalize SQL 4585 ** 4586 ** Return the normalized value for an SQL statement. 4587 */ 4588 static int SQLITE_TCLAPI test_normalize( 4589 void * clientData, 4590 Tcl_Interp *interp, 4591 int objc, 4592 Tcl_Obj *CONST objv[] 4593 ){ 4594 char *zSql; 4595 char *zNorm; 4596 extern char *sqlite3_normalize(const char*); 4597 4598 if( objc!=2 ){ 4599 Tcl_WrongNumArgs(interp, 1, objv, "SQL"); 4600 return TCL_ERROR; 4601 } 4602 4603 zSql = (char*)Tcl_GetString(objv[1]); 4604 zNorm = sqlite3_normalize(zSql); 4605 if( zNorm ){ 4606 Tcl_SetObjResult(interp, Tcl_NewStringObj(zNorm, -1)); 4607 sqlite3_free(zNorm); 4608 } 4609 return TCL_OK; 4610 } 4611 4612 /* 4613 ** Usage: sqlite3_step STMT 4614 ** 4615 ** Advance the statement to the next row. 4616 */ 4617 static int SQLITE_TCLAPI test_step( 4618 void * clientData, 4619 Tcl_Interp *interp, 4620 int objc, 4621 Tcl_Obj *CONST objv[] 4622 ){ 4623 sqlite3_stmt *pStmt; 4624 int rc; 4625 4626 if( objc!=2 ){ 4627 Tcl_AppendResult(interp, "wrong # args: should be \"", 4628 Tcl_GetString(objv[0]), " STMT", 0); 4629 return TCL_ERROR; 4630 } 4631 4632 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4633 rc = sqlite3_step(pStmt); 4634 4635 /* if( rc!=SQLITE_DONE && rc!=SQLITE_ROW ) return TCL_ERROR; */ 4636 Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0); 4637 return TCL_OK; 4638 } 4639 4640 static int SQLITE_TCLAPI test_sql( 4641 void * clientData, 4642 Tcl_Interp *interp, 4643 int objc, 4644 Tcl_Obj *CONST objv[] 4645 ){ 4646 sqlite3_stmt *pStmt; 4647 4648 if( objc!=2 ){ 4649 Tcl_WrongNumArgs(interp, 1, objv, "STMT"); 4650 return TCL_ERROR; 4651 } 4652 4653 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4654 Tcl_SetResult(interp, (char *)sqlite3_sql(pStmt), TCL_VOLATILE); 4655 return TCL_OK; 4656 } 4657 static int SQLITE_TCLAPI test_ex_sql( 4658 void * clientData, 4659 Tcl_Interp *interp, 4660 int objc, 4661 Tcl_Obj *CONST objv[] 4662 ){ 4663 sqlite3_stmt *pStmt; 4664 char *z; 4665 4666 if( objc!=2 ){ 4667 Tcl_WrongNumArgs(interp, 1, objv, "STMT"); 4668 return TCL_ERROR; 4669 } 4670 4671 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4672 z = sqlite3_expanded_sql(pStmt); 4673 Tcl_SetResult(interp, z, TCL_VOLATILE); 4674 sqlite3_free(z); 4675 return TCL_OK; 4676 } 4677 4678 /* 4679 ** Usage: sqlite3_column_count STMT 4680 ** 4681 ** Return the number of columns returned by the sql statement STMT. 4682 */ 4683 static int SQLITE_TCLAPI test_column_count( 4684 void * clientData, 4685 Tcl_Interp *interp, 4686 int objc, 4687 Tcl_Obj *CONST objv[] 4688 ){ 4689 sqlite3_stmt *pStmt; 4690 4691 if( objc!=2 ){ 4692 Tcl_AppendResult(interp, "wrong # args: should be \"", 4693 Tcl_GetString(objv[0]), " STMT column", 0); 4694 return TCL_ERROR; 4695 } 4696 4697 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4698 4699 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_column_count(pStmt))); 4700 return TCL_OK; 4701 } 4702 4703 /* 4704 ** Usage: sqlite3_column_type STMT column 4705 ** 4706 ** Return the type of the data in column 'column' of the current row. 4707 */ 4708 static int SQLITE_TCLAPI test_column_type( 4709 void * clientData, 4710 Tcl_Interp *interp, 4711 int objc, 4712 Tcl_Obj *CONST objv[] 4713 ){ 4714 sqlite3_stmt *pStmt; 4715 int col; 4716 int tp; 4717 4718 if( objc!=3 ){ 4719 Tcl_AppendResult(interp, "wrong # args: should be \"", 4720 Tcl_GetString(objv[0]), " STMT column", 0); 4721 return TCL_ERROR; 4722 } 4723 4724 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4725 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 4726 4727 tp = sqlite3_column_type(pStmt, col); 4728 switch( tp ){ 4729 case SQLITE_INTEGER: 4730 Tcl_SetResult(interp, "INTEGER", TCL_STATIC); 4731 break; 4732 case SQLITE_NULL: 4733 Tcl_SetResult(interp, "NULL", TCL_STATIC); 4734 break; 4735 case SQLITE_FLOAT: 4736 Tcl_SetResult(interp, "FLOAT", TCL_STATIC); 4737 break; 4738 case SQLITE_TEXT: 4739 Tcl_SetResult(interp, "TEXT", TCL_STATIC); 4740 break; 4741 case SQLITE_BLOB: 4742 Tcl_SetResult(interp, "BLOB", TCL_STATIC); 4743 break; 4744 default: 4745 assert(0); 4746 } 4747 4748 return TCL_OK; 4749 } 4750 4751 /* 4752 ** Usage: sqlite3_column_int64 STMT column 4753 ** 4754 ** Return the data in column 'column' of the current row cast as an 4755 ** wide (64-bit) integer. 4756 */ 4757 static int SQLITE_TCLAPI test_column_int64( 4758 void * clientData, 4759 Tcl_Interp *interp, 4760 int objc, 4761 Tcl_Obj *CONST objv[] 4762 ){ 4763 sqlite3_stmt *pStmt; 4764 int col; 4765 i64 iVal; 4766 4767 if( objc!=3 ){ 4768 Tcl_AppendResult(interp, "wrong # args: should be \"", 4769 Tcl_GetString(objv[0]), " STMT column", 0); 4770 return TCL_ERROR; 4771 } 4772 4773 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4774 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 4775 4776 iVal = sqlite3_column_int64(pStmt, col); 4777 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(iVal)); 4778 return TCL_OK; 4779 } 4780 4781 /* 4782 ** Usage: sqlite3_column_blob STMT column 4783 */ 4784 static int SQLITE_TCLAPI test_column_blob( 4785 void * clientData, 4786 Tcl_Interp *interp, 4787 int objc, 4788 Tcl_Obj *CONST objv[] 4789 ){ 4790 sqlite3_stmt *pStmt; 4791 int col; 4792 4793 int len; 4794 const void *pBlob; 4795 4796 if( objc!=3 ){ 4797 Tcl_AppendResult(interp, "wrong # args: should be \"", 4798 Tcl_GetString(objv[0]), " STMT column", 0); 4799 return TCL_ERROR; 4800 } 4801 4802 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4803 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 4804 4805 len = sqlite3_column_bytes(pStmt, col); 4806 pBlob = sqlite3_column_blob(pStmt, col); 4807 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pBlob, len)); 4808 return TCL_OK; 4809 } 4810 4811 /* 4812 ** Usage: sqlite3_column_double STMT column 4813 ** 4814 ** Return the data in column 'column' of the current row cast as a double. 4815 */ 4816 static int SQLITE_TCLAPI test_column_double( 4817 void * clientData, 4818 Tcl_Interp *interp, 4819 int objc, 4820 Tcl_Obj *CONST objv[] 4821 ){ 4822 sqlite3_stmt *pStmt; 4823 int col; 4824 double rVal; 4825 4826 if( objc!=3 ){ 4827 Tcl_AppendResult(interp, "wrong # args: should be \"", 4828 Tcl_GetString(objv[0]), " STMT column", 0); 4829 return TCL_ERROR; 4830 } 4831 4832 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4833 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 4834 4835 rVal = sqlite3_column_double(pStmt, col); 4836 Tcl_SetObjResult(interp, Tcl_NewDoubleObj(rVal)); 4837 return TCL_OK; 4838 } 4839 4840 /* 4841 ** Usage: sqlite3_data_count STMT 4842 ** 4843 ** Return the number of columns returned by the sql statement STMT. 4844 */ 4845 static int SQLITE_TCLAPI test_data_count( 4846 void * clientData, 4847 Tcl_Interp *interp, 4848 int objc, 4849 Tcl_Obj *CONST objv[] 4850 ){ 4851 sqlite3_stmt *pStmt; 4852 4853 if( objc!=2 ){ 4854 Tcl_AppendResult(interp, "wrong # args: should be \"", 4855 Tcl_GetString(objv[0]), " STMT column", 0); 4856 return TCL_ERROR; 4857 } 4858 4859 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4860 4861 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_data_count(pStmt))); 4862 return TCL_OK; 4863 } 4864 4865 /* 4866 ** Usage: sqlite3_column_text STMT column 4867 ** 4868 ** Usage: sqlite3_column_decltype STMT column 4869 ** 4870 ** Usage: sqlite3_column_name STMT column 4871 */ 4872 static int SQLITE_TCLAPI test_stmt_utf8( 4873 void * clientData, /* Pointer to SQLite API function to be invoke */ 4874 Tcl_Interp *interp, 4875 int objc, 4876 Tcl_Obj *CONST objv[] 4877 ){ 4878 sqlite3_stmt *pStmt; 4879 int col; 4880 const char *(*xFunc)(sqlite3_stmt*, int); 4881 const char *zRet; 4882 4883 xFunc = (const char *(*)(sqlite3_stmt*, int))clientData; 4884 if( objc!=3 ){ 4885 Tcl_AppendResult(interp, "wrong # args: should be \"", 4886 Tcl_GetString(objv[0]), " STMT column", 0); 4887 return TCL_ERROR; 4888 } 4889 4890 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4891 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 4892 zRet = xFunc(pStmt, col); 4893 if( zRet ){ 4894 Tcl_SetResult(interp, (char *)zRet, 0); 4895 } 4896 return TCL_OK; 4897 } 4898 4899 static int SQLITE_TCLAPI test_global_recover( 4900 void * clientData, 4901 Tcl_Interp *interp, 4902 int objc, 4903 Tcl_Obj *CONST objv[] 4904 ){ 4905 #ifndef SQLITE_OMIT_DEPRECATED 4906 int rc; 4907 if( objc!=1 ){ 4908 Tcl_WrongNumArgs(interp, 1, objv, ""); 4909 return TCL_ERROR; 4910 } 4911 rc = sqlite3_global_recover(); 4912 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 4913 #endif 4914 return TCL_OK; 4915 } 4916 4917 /* 4918 ** Usage: sqlite3_column_text STMT column 4919 ** 4920 ** Usage: sqlite3_column_decltype STMT column 4921 ** 4922 ** Usage: sqlite3_column_name STMT column 4923 */ 4924 static int SQLITE_TCLAPI test_stmt_utf16( 4925 void * clientData, /* Pointer to SQLite API function to be invoked */ 4926 Tcl_Interp *interp, 4927 int objc, 4928 Tcl_Obj *CONST objv[] 4929 ){ 4930 #ifndef SQLITE_OMIT_UTF16 4931 sqlite3_stmt *pStmt; 4932 int col; 4933 Tcl_Obj *pRet; 4934 const void *zName16; 4935 const void *(*xFunc)(sqlite3_stmt*, int); 4936 4937 xFunc = (const void *(*)(sqlite3_stmt*, int))clientData; 4938 if( objc!=3 ){ 4939 Tcl_AppendResult(interp, "wrong # args: should be \"", 4940 Tcl_GetString(objv[0]), " STMT column", 0); 4941 return TCL_ERROR; 4942 } 4943 4944 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4945 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 4946 4947 zName16 = xFunc(pStmt, col); 4948 if( zName16 ){ 4949 int n; 4950 const char *z = zName16; 4951 for(n=0; z[n] || z[n+1]; n+=2){} 4952 pRet = Tcl_NewByteArrayObj(zName16, n+2); 4953 Tcl_SetObjResult(interp, pRet); 4954 } 4955 #endif /* SQLITE_OMIT_UTF16 */ 4956 4957 return TCL_OK; 4958 } 4959 4960 /* 4961 ** Usage: sqlite3_column_int STMT column 4962 ** 4963 ** Usage: sqlite3_column_bytes STMT column 4964 ** 4965 ** Usage: sqlite3_column_bytes16 STMT column 4966 ** 4967 */ 4968 static int SQLITE_TCLAPI test_stmt_int( 4969 void * clientData, /* Pointer to SQLite API function to be invoked */ 4970 Tcl_Interp *interp, 4971 int objc, 4972 Tcl_Obj *CONST objv[] 4973 ){ 4974 sqlite3_stmt *pStmt; 4975 int col; 4976 int (*xFunc)(sqlite3_stmt*, int); 4977 4978 xFunc = (int (*)(sqlite3_stmt*, int))clientData; 4979 if( objc!=3 ){ 4980 Tcl_AppendResult(interp, "wrong # args: should be \"", 4981 Tcl_GetString(objv[0]), " STMT column", 0); 4982 return TCL_ERROR; 4983 } 4984 4985 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 4986 if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; 4987 4988 Tcl_SetObjResult(interp, Tcl_NewIntObj(xFunc(pStmt, col))); 4989 return TCL_OK; 4990 } 4991 4992 /* 4993 ** Usage: sqlite_set_magic DB MAGIC-NUMBER 4994 ** 4995 ** Set the db->magic value. This is used to test error recovery logic. 4996 */ 4997 static int SQLITE_TCLAPI sqlite_set_magic( 4998 void * clientData, 4999 Tcl_Interp *interp, 5000 int argc, 5001 char **argv 5002 ){ 5003 sqlite3 *db; 5004 if( argc!=3 ){ 5005 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 5006 " DB MAGIC", 0); 5007 return TCL_ERROR; 5008 } 5009 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 5010 if( strcmp(argv[2], "SQLITE_MAGIC_OPEN")==0 ){ 5011 db->magic = SQLITE_MAGIC_OPEN; 5012 }else if( strcmp(argv[2], "SQLITE_MAGIC_CLOSED")==0 ){ 5013 db->magic = SQLITE_MAGIC_CLOSED; 5014 }else if( strcmp(argv[2], "SQLITE_MAGIC_BUSY")==0 ){ 5015 db->magic = SQLITE_MAGIC_BUSY; 5016 }else if( strcmp(argv[2], "SQLITE_MAGIC_ERROR")==0 ){ 5017 db->magic = SQLITE_MAGIC_ERROR; 5018 }else if( Tcl_GetInt(interp, argv[2], (int*)&db->magic) ){ 5019 return TCL_ERROR; 5020 } 5021 return TCL_OK; 5022 } 5023 5024 /* 5025 ** Usage: sqlite3_interrupt DB 5026 ** 5027 ** Trigger an interrupt on DB 5028 */ 5029 static int SQLITE_TCLAPI test_interrupt( 5030 void * clientData, 5031 Tcl_Interp *interp, 5032 int argc, 5033 char **argv 5034 ){ 5035 sqlite3 *db; 5036 if( argc!=2 ){ 5037 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB", 0); 5038 return TCL_ERROR; 5039 } 5040 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 5041 sqlite3_interrupt(db); 5042 return TCL_OK; 5043 } 5044 5045 /* 5046 ** Usage: sqlite_delete_function DB function-name 5047 ** 5048 ** Delete the user function 'function-name' from database handle DB. It 5049 ** is assumed that the user function was created as UTF8, any number of 5050 ** arguments (the way the TCL interface does it). 5051 */ 5052 static int SQLITE_TCLAPI delete_function( 5053 void * clientData, 5054 Tcl_Interp *interp, 5055 int argc, 5056 char **argv 5057 ){ 5058 int rc; 5059 sqlite3 *db; 5060 if( argc!=3 ){ 5061 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 5062 " DB function-name", 0); 5063 return TCL_ERROR; 5064 } 5065 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 5066 rc = sqlite3_create_function(db, argv[2], -1, SQLITE_UTF8, 0, 0, 0, 0); 5067 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 5068 return TCL_OK; 5069 } 5070 5071 /* 5072 ** Usage: sqlite_delete_collation DB collation-name 5073 ** 5074 ** Delete the collation sequence 'collation-name' from database handle 5075 ** DB. It is assumed that the collation sequence was created as UTF8 (the 5076 ** way the TCL interface does it). 5077 */ 5078 static int SQLITE_TCLAPI delete_collation( 5079 void * clientData, 5080 Tcl_Interp *interp, 5081 int argc, 5082 char **argv 5083 ){ 5084 int rc; 5085 sqlite3 *db; 5086 if( argc!=3 ){ 5087 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 5088 " DB function-name", 0); 5089 return TCL_ERROR; 5090 } 5091 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 5092 rc = sqlite3_create_collation(db, argv[2], SQLITE_UTF8, 0, 0); 5093 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 5094 return TCL_OK; 5095 } 5096 5097 /* 5098 ** Usage: sqlite3_get_autocommit DB 5099 ** 5100 ** Return true if the database DB is currently in auto-commit mode. 5101 ** Return false if not. 5102 */ 5103 static int SQLITE_TCLAPI get_autocommit( 5104 void * clientData, 5105 Tcl_Interp *interp, 5106 int argc, 5107 char **argv 5108 ){ 5109 char zBuf[30]; 5110 sqlite3 *db; 5111 if( argc!=2 ){ 5112 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 5113 " DB", 0); 5114 return TCL_ERROR; 5115 } 5116 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 5117 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", sqlite3_get_autocommit(db)); 5118 Tcl_AppendResult(interp, zBuf, 0); 5119 return TCL_OK; 5120 } 5121 5122 /* 5123 ** Usage: sqlite3_busy_timeout DB MS 5124 ** 5125 ** Set the busy timeout. This is more easily done using the timeout 5126 ** method of the TCL interface. But we need a way to test the case 5127 ** where it returns SQLITE_MISUSE. 5128 */ 5129 static int SQLITE_TCLAPI test_busy_timeout( 5130 void * clientData, 5131 Tcl_Interp *interp, 5132 int argc, 5133 char **argv 5134 ){ 5135 int rc, ms; 5136 sqlite3 *db; 5137 if( argc!=3 ){ 5138 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 5139 " DB", 0); 5140 return TCL_ERROR; 5141 } 5142 if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; 5143 if( Tcl_GetInt(interp, argv[2], &ms) ) return TCL_ERROR; 5144 rc = sqlite3_busy_timeout(db, ms); 5145 Tcl_AppendResult(interp, sqlite3ErrName(rc), 0); 5146 return TCL_OK; 5147 } 5148 5149 /* 5150 ** Usage: tcl_variable_type VARIABLENAME 5151 ** 5152 ** Return the name of the internal representation for the 5153 ** value of the given variable. 5154 */ 5155 static int SQLITE_TCLAPI tcl_variable_type( 5156 void * clientData, 5157 Tcl_Interp *interp, 5158 int objc, 5159 Tcl_Obj *CONST objv[] 5160 ){ 5161 Tcl_Obj *pVar; 5162 if( objc!=2 ){ 5163 Tcl_WrongNumArgs(interp, 1, objv, "VARIABLE"); 5164 return TCL_ERROR; 5165 } 5166 pVar = Tcl_GetVar2Ex(interp, Tcl_GetString(objv[1]), 0, TCL_LEAVE_ERR_MSG); 5167 if( pVar==0 ) return TCL_ERROR; 5168 if( pVar->typePtr ){ 5169 Tcl_SetObjResult(interp, Tcl_NewStringObj(pVar->typePtr->name, -1)); 5170 } 5171 return TCL_OK; 5172 } 5173 5174 /* 5175 ** Usage: sqlite3_release_memory ?N? 5176 ** 5177 ** Attempt to release memory currently held but not actually required. 5178 ** The integer N is the number of bytes we are trying to release. The 5179 ** return value is the amount of memory actually released. 5180 */ 5181 static int SQLITE_TCLAPI test_release_memory( 5182 void * clientData, 5183 Tcl_Interp *interp, 5184 int objc, 5185 Tcl_Obj *CONST objv[] 5186 ){ 5187 #if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) && !defined(SQLITE_OMIT_DISKIO) 5188 int N; 5189 int amt; 5190 if( objc!=1 && objc!=2 ){ 5191 Tcl_WrongNumArgs(interp, 1, objv, "?N?"); 5192 return TCL_ERROR; 5193 } 5194 if( objc==2 ){ 5195 if( Tcl_GetIntFromObj(interp, objv[1], &N) ) return TCL_ERROR; 5196 }else{ 5197 N = -1; 5198 } 5199 amt = sqlite3_release_memory(N); 5200 Tcl_SetObjResult(interp, Tcl_NewIntObj(amt)); 5201 #endif 5202 return TCL_OK; 5203 } 5204 5205 5206 /* 5207 ** Usage: sqlite3_db_release_memory DB 5208 ** 5209 ** Attempt to release memory currently held by database DB. Return the 5210 ** result code (which in the current implementation is always zero). 5211 */ 5212 static int SQLITE_TCLAPI test_db_release_memory( 5213 void * clientData, 5214 Tcl_Interp *interp, 5215 int objc, 5216 Tcl_Obj *CONST objv[] 5217 ){ 5218 sqlite3 *db; 5219 int rc; 5220 if( objc!=2 ){ 5221 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 5222 return TCL_ERROR; 5223 } 5224 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5225 rc = sqlite3_db_release_memory(db); 5226 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 5227 return TCL_OK; 5228 } 5229 5230 /* 5231 ** Usage: sqlite3_db_cacheflush DB 5232 ** 5233 ** Attempt to flush any dirty pages to disk. 5234 */ 5235 static int SQLITE_TCLAPI test_db_cacheflush( 5236 void * clientData, 5237 Tcl_Interp *interp, 5238 int objc, 5239 Tcl_Obj *CONST objv[] 5240 ){ 5241 sqlite3 *db; 5242 int rc; 5243 if( objc!=2 ){ 5244 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 5245 return TCL_ERROR; 5246 } 5247 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5248 rc = sqlite3_db_cacheflush(db); 5249 if( rc ){ 5250 Tcl_SetResult(interp, (char *)sqlite3ErrStr(rc), TCL_STATIC); 5251 return TCL_ERROR; 5252 } 5253 5254 Tcl_ResetResult(interp); 5255 return TCL_OK; 5256 } 5257 5258 /* 5259 ** Usage: sqlite3_system_errno DB 5260 ** 5261 ** Return the low-level system errno value. 5262 */ 5263 static int SQLITE_TCLAPI test_system_errno( 5264 void * clientData, 5265 Tcl_Interp *interp, 5266 int objc, 5267 Tcl_Obj *CONST objv[] 5268 ){ 5269 sqlite3 *db; 5270 int iErrno; 5271 if( objc!=2 ){ 5272 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 5273 return TCL_ERROR; 5274 } 5275 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5276 iErrno = sqlite3_system_errno(db); 5277 Tcl_SetObjResult(interp, Tcl_NewIntObj(iErrno)); 5278 return TCL_OK; 5279 } 5280 5281 /* 5282 ** Usage: sqlite3_db_filename DB DBNAME 5283 ** 5284 ** Return the name of a file associated with a database. 5285 */ 5286 static int SQLITE_TCLAPI test_db_filename( 5287 void * clientData, 5288 Tcl_Interp *interp, 5289 int objc, 5290 Tcl_Obj *CONST objv[] 5291 ){ 5292 sqlite3 *db; 5293 const char *zDbName; 5294 if( objc!=3 ){ 5295 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME"); 5296 return TCL_ERROR; 5297 } 5298 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5299 zDbName = Tcl_GetString(objv[2]); 5300 Tcl_AppendResult(interp, sqlite3_db_filename(db, zDbName), (void*)0); 5301 return TCL_OK; 5302 } 5303 5304 /* 5305 ** Usage: sqlite3_db_readonly DB DBNAME 5306 ** 5307 ** Return 1 or 0 if DBNAME is readonly or not. Return -1 if DBNAME does 5308 ** not exist. 5309 */ 5310 static int SQLITE_TCLAPI test_db_readonly( 5311 void * clientData, 5312 Tcl_Interp *interp, 5313 int objc, 5314 Tcl_Obj *CONST objv[] 5315 ){ 5316 sqlite3 *db; 5317 const char *zDbName; 5318 if( objc!=3 ){ 5319 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME"); 5320 return TCL_ERROR; 5321 } 5322 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5323 zDbName = Tcl_GetString(objv[2]); 5324 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_db_readonly(db, zDbName))); 5325 return TCL_OK; 5326 } 5327 5328 /* 5329 ** Usage: sqlite3_soft_heap_limit ?N? 5330 ** 5331 ** Query or set the soft heap limit for the current thread. The 5332 ** limit is only changed if the N is present. The previous limit 5333 ** is returned. 5334 */ 5335 static int SQLITE_TCLAPI test_soft_heap_limit( 5336 void * clientData, 5337 Tcl_Interp *interp, 5338 int objc, 5339 Tcl_Obj *CONST objv[] 5340 ){ 5341 sqlite3_int64 amt; 5342 Tcl_WideInt N = -1; 5343 if( objc!=1 && objc!=2 ){ 5344 Tcl_WrongNumArgs(interp, 1, objv, "?N?"); 5345 return TCL_ERROR; 5346 } 5347 if( objc==2 ){ 5348 if( Tcl_GetWideIntFromObj(interp, objv[1], &N) ) return TCL_ERROR; 5349 } 5350 amt = sqlite3_soft_heap_limit64(N); 5351 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(amt)); 5352 return TCL_OK; 5353 } 5354 5355 /* 5356 ** Usage: sqlite3_thread_cleanup 5357 ** 5358 ** Call the sqlite3_thread_cleanup API. 5359 */ 5360 static int SQLITE_TCLAPI test_thread_cleanup( 5361 void * clientData, 5362 Tcl_Interp *interp, 5363 int objc, 5364 Tcl_Obj *CONST objv[] 5365 ){ 5366 #ifndef SQLITE_OMIT_DEPRECATED 5367 sqlite3_thread_cleanup(); 5368 #endif 5369 return TCL_OK; 5370 } 5371 5372 /* 5373 ** Usage: sqlite3_pager_refcounts DB 5374 ** 5375 ** Return a list of numbers which are the PagerRefcount for all 5376 ** pagers on each database connection. 5377 */ 5378 static int SQLITE_TCLAPI test_pager_refcounts( 5379 void * clientData, 5380 Tcl_Interp *interp, 5381 int objc, 5382 Tcl_Obj *CONST objv[] 5383 ){ 5384 sqlite3 *db; 5385 int i; 5386 int v, *a; 5387 Tcl_Obj *pResult; 5388 5389 if( objc!=2 ){ 5390 Tcl_AppendResult(interp, "wrong # args: should be \"", 5391 Tcl_GetStringFromObj(objv[0], 0), " DB", 0); 5392 return TCL_ERROR; 5393 } 5394 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5395 pResult = Tcl_NewObj(); 5396 for(i=0; i<db->nDb; i++){ 5397 if( db->aDb[i].pBt==0 ){ 5398 v = -1; 5399 }else{ 5400 sqlite3_mutex_enter(db->mutex); 5401 a = sqlite3PagerStats(sqlite3BtreePager(db->aDb[i].pBt)); 5402 v = a[0]; 5403 sqlite3_mutex_leave(db->mutex); 5404 } 5405 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(v)); 5406 } 5407 Tcl_SetObjResult(interp, pResult); 5408 return TCL_OK; 5409 } 5410 5411 5412 /* 5413 ** tclcmd: working_64bit_int 5414 ** 5415 ** Some TCL builds (ex: cygwin) do not support 64-bit integers. This 5416 ** leads to a number of test failures. The present command checks the 5417 ** TCL build to see whether or not it supports 64-bit integers. It 5418 ** returns TRUE if it does and FALSE if not. 5419 ** 5420 ** This command is used to warn users that their TCL build is defective 5421 ** and that the errors they are seeing in the test scripts might be 5422 ** a result of their defective TCL rather than problems in SQLite. 5423 */ 5424 static int SQLITE_TCLAPI working_64bit_int( 5425 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5426 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5427 int objc, /* Number of arguments */ 5428 Tcl_Obj *CONST objv[] /* Command arguments */ 5429 ){ 5430 Tcl_Obj *pTestObj; 5431 int working = 0; 5432 5433 pTestObj = Tcl_NewWideIntObj(1000000*(i64)1234567890); 5434 working = strcmp(Tcl_GetString(pTestObj), "1234567890000000")==0; 5435 Tcl_DecrRefCount(pTestObj); 5436 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(working)); 5437 return TCL_OK; 5438 } 5439 5440 5441 /* 5442 ** tclcmd: vfs_unlink_test 5443 ** 5444 ** This TCL command unregisters the primary VFS and then registers 5445 ** it back again. This is used to test the ability to register a 5446 ** VFS when none are previously registered, and the ability to 5447 ** unregister the only available VFS. Ticket #2738 5448 */ 5449 static int SQLITE_TCLAPI vfs_unlink_test( 5450 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5451 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5452 int objc, /* Number of arguments */ 5453 Tcl_Obj *CONST objv[] /* Command arguments */ 5454 ){ 5455 int i; 5456 sqlite3_vfs *pMain; 5457 sqlite3_vfs *apVfs[20]; 5458 sqlite3_vfs one, two; 5459 5460 sqlite3_vfs_unregister(0); /* Unregister of NULL is harmless */ 5461 one.zName = "__one"; 5462 two.zName = "__two"; 5463 5464 /* Calling sqlite3_vfs_register with 2nd argument of 0 does not 5465 ** change the default VFS 5466 */ 5467 pMain = sqlite3_vfs_find(0); 5468 sqlite3_vfs_register(&one, 0); 5469 assert( pMain==0 || pMain==sqlite3_vfs_find(0) ); 5470 sqlite3_vfs_register(&two, 0); 5471 assert( pMain==0 || pMain==sqlite3_vfs_find(0) ); 5472 5473 /* We can find a VFS by its name */ 5474 assert( sqlite3_vfs_find("__one")==&one ); 5475 assert( sqlite3_vfs_find("__two")==&two ); 5476 5477 /* Calling sqlite_vfs_register with non-zero second parameter changes the 5478 ** default VFS, even if the 1st parameter is an existig VFS that is 5479 ** previously registered as the non-default. 5480 */ 5481 sqlite3_vfs_register(&one, 1); 5482 assert( sqlite3_vfs_find("__one")==&one ); 5483 assert( sqlite3_vfs_find("__two")==&two ); 5484 assert( sqlite3_vfs_find(0)==&one ); 5485 sqlite3_vfs_register(&two, 1); 5486 assert( sqlite3_vfs_find("__one")==&one ); 5487 assert( sqlite3_vfs_find("__two")==&two ); 5488 assert( sqlite3_vfs_find(0)==&two ); 5489 if( pMain ){ 5490 sqlite3_vfs_register(pMain, 1); 5491 assert( sqlite3_vfs_find("__one")==&one ); 5492 assert( sqlite3_vfs_find("__two")==&two ); 5493 assert( sqlite3_vfs_find(0)==pMain ); 5494 } 5495 5496 /* Unlink the default VFS. Repeat until there are no more VFSes 5497 ** registered. 5498 */ 5499 for(i=0; i<sizeof(apVfs)/sizeof(apVfs[0]); i++){ 5500 apVfs[i] = sqlite3_vfs_find(0); 5501 if( apVfs[i] ){ 5502 assert( apVfs[i]==sqlite3_vfs_find(apVfs[i]->zName) ); 5503 sqlite3_vfs_unregister(apVfs[i]); 5504 assert( 0==sqlite3_vfs_find(apVfs[i]->zName) ); 5505 } 5506 } 5507 assert( 0==sqlite3_vfs_find(0) ); 5508 5509 /* Register the main VFS as non-default (will be made default, since 5510 ** it'll be the only one in existence). 5511 */ 5512 sqlite3_vfs_register(pMain, 0); 5513 assert( sqlite3_vfs_find(0)==pMain ); 5514 5515 /* Un-register the main VFS again to restore an empty VFS list */ 5516 sqlite3_vfs_unregister(pMain); 5517 assert( 0==sqlite3_vfs_find(0) ); 5518 5519 /* Relink all VFSes in reverse order. */ 5520 for(i=sizeof(apVfs)/sizeof(apVfs[0])-1; i>=0; i--){ 5521 if( apVfs[i] ){ 5522 sqlite3_vfs_register(apVfs[i], 1); 5523 assert( apVfs[i]==sqlite3_vfs_find(0) ); 5524 assert( apVfs[i]==sqlite3_vfs_find(apVfs[i]->zName) ); 5525 } 5526 } 5527 5528 /* Unregister out sample VFSes. */ 5529 sqlite3_vfs_unregister(&one); 5530 sqlite3_vfs_unregister(&two); 5531 5532 /* Unregistering a VFS that is not currently registered is harmless */ 5533 sqlite3_vfs_unregister(&one); 5534 sqlite3_vfs_unregister(&two); 5535 assert( sqlite3_vfs_find("__one")==0 ); 5536 assert( sqlite3_vfs_find("__two")==0 ); 5537 5538 /* We should be left with the original default VFS back as the 5539 ** original */ 5540 assert( sqlite3_vfs_find(0)==pMain ); 5541 5542 return TCL_OK; 5543 } 5544 5545 /* 5546 ** tclcmd: vfs_initfail_test 5547 ** 5548 ** This TCL command attempts to vfs_find and vfs_register when the 5549 ** sqlite3_initialize() interface is failing. All calls should fail. 5550 */ 5551 static int SQLITE_TCLAPI vfs_initfail_test( 5552 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5553 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5554 int objc, /* Number of arguments */ 5555 Tcl_Obj *CONST objv[] /* Command arguments */ 5556 ){ 5557 sqlite3_vfs one; 5558 one.zName = "__one"; 5559 5560 if( sqlite3_vfs_find(0) ) return TCL_ERROR; 5561 sqlite3_vfs_register(&one, 0); 5562 if( sqlite3_vfs_find(0) ) return TCL_ERROR; 5563 sqlite3_vfs_register(&one, 1); 5564 if( sqlite3_vfs_find(0) ) return TCL_ERROR; 5565 return TCL_OK; 5566 } 5567 5568 /* 5569 ** Saved VFSes 5570 */ 5571 static sqlite3_vfs *apVfs[20]; 5572 static int nVfs = 0; 5573 5574 /* 5575 ** tclcmd: vfs_unregister_all 5576 ** 5577 ** Unregister all VFSes. 5578 */ 5579 static int SQLITE_TCLAPI vfs_unregister_all( 5580 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5581 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5582 int objc, /* Number of arguments */ 5583 Tcl_Obj *CONST objv[] /* Command arguments */ 5584 ){ 5585 int i; 5586 for(i=0; i<ArraySize(apVfs); i++){ 5587 apVfs[i] = sqlite3_vfs_find(0); 5588 if( apVfs[i]==0 ) break; 5589 sqlite3_vfs_unregister(apVfs[i]); 5590 } 5591 nVfs = i; 5592 return TCL_OK; 5593 } 5594 /* 5595 ** tclcmd: vfs_reregister_all 5596 ** 5597 ** Restore all VFSes that were removed using vfs_unregister_all. Taking 5598 ** care to put the linked list back together in the same order as it was 5599 ** in before vfs_unregister_all was invoked. 5600 */ 5601 static int SQLITE_TCLAPI vfs_reregister_all( 5602 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5603 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5604 int objc, /* Number of arguments */ 5605 Tcl_Obj *CONST objv[] /* Command arguments */ 5606 ){ 5607 int i; 5608 for(i=nVfs-1; i>=0; i--){ 5609 sqlite3_vfs_register(apVfs[i], 1); 5610 } 5611 return TCL_OK; 5612 } 5613 5614 5615 /* 5616 ** tclcmd: file_control_test DB 5617 ** 5618 ** This TCL command runs the sqlite3_file_control interface and 5619 ** verifies correct operation of the same. 5620 */ 5621 static int SQLITE_TCLAPI file_control_test( 5622 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5623 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5624 int objc, /* Number of arguments */ 5625 Tcl_Obj *CONST objv[] /* Command arguments */ 5626 ){ 5627 int iArg = 0; 5628 sqlite3 *db; 5629 int rc; 5630 5631 if( objc!=2 ){ 5632 Tcl_AppendResult(interp, "wrong # args: should be \"", 5633 Tcl_GetStringFromObj(objv[0], 0), " DB", 0); 5634 return TCL_ERROR; 5635 } 5636 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 5637 rc = sqlite3_file_control(db, 0, 0, &iArg); 5638 assert( rc==SQLITE_NOTFOUND ); 5639 rc = sqlite3_file_control(db, "notadatabase", SQLITE_FCNTL_LOCKSTATE, &iArg); 5640 assert( rc==SQLITE_ERROR ); 5641 rc = sqlite3_file_control(db, "main", -1, &iArg); 5642 assert( rc==SQLITE_NOTFOUND ); 5643 rc = sqlite3_file_control(db, "temp", -1, &iArg); 5644 assert( rc==SQLITE_NOTFOUND || rc==SQLITE_ERROR ); 5645 5646 return TCL_OK; 5647 } 5648 5649 5650 /* 5651 ** tclcmd: file_control_lasterrno_test DB 5652 ** 5653 ** This TCL command runs the sqlite3_file_control interface and 5654 ** verifies correct operation of the SQLITE_LAST_ERRNO verb. 5655 */ 5656 static int SQLITE_TCLAPI file_control_lasterrno_test( 5657 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5658 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5659 int objc, /* Number of arguments */ 5660 Tcl_Obj *CONST objv[] /* Command arguments */ 5661 ){ 5662 int iArg = 0; 5663 sqlite3 *db; 5664 int rc; 5665 5666 if( objc!=2 ){ 5667 Tcl_AppendResult(interp, "wrong # args: should be \"", 5668 Tcl_GetStringFromObj(objv[0], 0), " DB", 0); 5669 return TCL_ERROR; 5670 } 5671 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 5672 return TCL_ERROR; 5673 } 5674 rc = sqlite3_file_control(db, NULL, SQLITE_LAST_ERRNO, &iArg); 5675 if( rc ){ 5676 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 5677 return TCL_ERROR; 5678 } 5679 if( iArg!=0 ) { 5680 Tcl_AppendResult(interp, "Unexpected non-zero errno: ", 5681 Tcl_GetStringFromObj(Tcl_NewIntObj(iArg), 0), " ", 0); 5682 return TCL_ERROR; 5683 } 5684 return TCL_OK; 5685 } 5686 5687 /* 5688 ** tclcmd: file_control_chunksize_test DB DBNAME SIZE 5689 ** 5690 ** This TCL command runs the sqlite3_file_control interface and 5691 ** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and 5692 ** SQLITE_SET_LOCKPROXYFILE verbs. 5693 */ 5694 static int SQLITE_TCLAPI file_control_chunksize_test( 5695 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5696 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5697 int objc, /* Number of arguments */ 5698 Tcl_Obj *CONST objv[] /* Command arguments */ 5699 ){ 5700 int nSize; /* New chunk size */ 5701 char *zDb; /* Db name ("main", "temp" etc.) */ 5702 sqlite3 *db; /* Database handle */ 5703 int rc; /* file_control() return code */ 5704 5705 if( objc!=4 ){ 5706 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SIZE"); 5707 return TCL_ERROR; 5708 } 5709 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) 5710 || Tcl_GetIntFromObj(interp, objv[3], &nSize) 5711 ){ 5712 return TCL_ERROR; 5713 } 5714 zDb = Tcl_GetString(objv[2]); 5715 if( zDb[0]=='\0' ) zDb = NULL; 5716 5717 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_CHUNK_SIZE, (void *)&nSize); 5718 if( rc ){ 5719 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); 5720 return TCL_ERROR; 5721 } 5722 return TCL_OK; 5723 } 5724 5725 /* 5726 ** tclcmd: file_control_sizehint_test DB DBNAME SIZE 5727 ** 5728 ** This TCL command runs the sqlite3_file_control interface 5729 ** with SQLITE_FCNTL_SIZE_HINT 5730 */ 5731 static int SQLITE_TCLAPI file_control_sizehint_test( 5732 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5733 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5734 int objc, /* Number of arguments */ 5735 Tcl_Obj *CONST objv[] /* Command arguments */ 5736 ){ 5737 Tcl_WideInt nSize; /* Hinted size */ 5738 char *zDb; /* Db name ("main", "temp" etc.) */ 5739 sqlite3 *db; /* Database handle */ 5740 int rc; /* file_control() return code */ 5741 5742 if( objc!=4 ){ 5743 Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SIZE"); 5744 return TCL_ERROR; 5745 } 5746 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) 5747 || Tcl_GetWideIntFromObj(interp, objv[3], &nSize) 5748 ){ 5749 return TCL_ERROR; 5750 } 5751 zDb = Tcl_GetString(objv[2]); 5752 if( zDb[0]=='\0' ) zDb = NULL; 5753 5754 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_SIZE_HINT, (void *)&nSize); 5755 if( rc ){ 5756 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); 5757 return TCL_ERROR; 5758 } 5759 return TCL_OK; 5760 } 5761 5762 /* 5763 ** tclcmd: file_control_lockproxy_test DB PWD 5764 ** 5765 ** This TCL command runs the sqlite3_file_control interface and 5766 ** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and 5767 ** SQLITE_SET_LOCKPROXYFILE verbs. 5768 */ 5769 static int SQLITE_TCLAPI file_control_lockproxy_test( 5770 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5771 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5772 int objc, /* Number of arguments */ 5773 Tcl_Obj *CONST objv[] /* Command arguments */ 5774 ){ 5775 sqlite3 *db; 5776 5777 if( objc!=3 ){ 5778 Tcl_AppendResult(interp, "wrong # args: should be \"", 5779 Tcl_GetStringFromObj(objv[0], 0), " DB PWD", 0); 5780 return TCL_ERROR; 5781 } 5782 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 5783 return TCL_ERROR; 5784 } 5785 5786 #if !defined(SQLITE_ENABLE_LOCKING_STYLE) 5787 # if defined(__APPLE__) 5788 # define SQLITE_ENABLE_LOCKING_STYLE 1 5789 # else 5790 # define SQLITE_ENABLE_LOCKING_STYLE 0 5791 # endif 5792 #endif 5793 #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) 5794 { 5795 char *testPath; 5796 int rc; 5797 int nPwd; 5798 const char *zPwd; 5799 char proxyPath[400]; 5800 5801 zPwd = Tcl_GetStringFromObj(objv[2], &nPwd); 5802 if( sizeof(proxyPath)<nPwd+20 ){ 5803 Tcl_AppendResult(interp, "PWD too big", (void*)0); 5804 return TCL_ERROR; 5805 } 5806 sqlite3_snprintf(sizeof(proxyPath), proxyPath, "%s/test.proxy", zPwd); 5807 rc = sqlite3_file_control(db, NULL, SQLITE_SET_LOCKPROXYFILE, proxyPath); 5808 if( rc ){ 5809 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 5810 return TCL_ERROR; 5811 } 5812 rc = sqlite3_file_control(db, NULL, SQLITE_GET_LOCKPROXYFILE, &testPath); 5813 if( strncmp(proxyPath,testPath,11) ){ 5814 Tcl_AppendResult(interp, "Lock proxy file did not match the " 5815 "previously assigned value", 0); 5816 return TCL_ERROR; 5817 } 5818 if( rc ){ 5819 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 5820 return TCL_ERROR; 5821 } 5822 rc = sqlite3_file_control(db, NULL, SQLITE_SET_LOCKPROXYFILE, proxyPath); 5823 if( rc ){ 5824 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 5825 return TCL_ERROR; 5826 } 5827 } 5828 #endif 5829 return TCL_OK; 5830 } 5831 5832 #if SQLITE_OS_WIN 5833 /* 5834 ** tclcmd: file_control_win32_av_retry DB NRETRY DELAY 5835 ** 5836 ** This TCL command runs the sqlite3_file_control interface with 5837 ** the SQLITE_FCNTL_WIN32_AV_RETRY opcode. 5838 */ 5839 static int SQLITE_TCLAPI file_control_win32_av_retry( 5840 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5841 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5842 int objc, /* Number of arguments */ 5843 Tcl_Obj *CONST objv[] /* Command arguments */ 5844 ){ 5845 sqlite3 *db; 5846 int rc; 5847 int a[2]; 5848 char z[100]; 5849 5850 if( objc!=4 ){ 5851 Tcl_AppendResult(interp, "wrong # args: should be \"", 5852 Tcl_GetStringFromObj(objv[0], 0), " DB NRETRY DELAY", 0); 5853 return TCL_ERROR; 5854 } 5855 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 5856 return TCL_ERROR; 5857 } 5858 if( Tcl_GetIntFromObj(interp, objv[2], &a[0]) ) return TCL_ERROR; 5859 if( Tcl_GetIntFromObj(interp, objv[3], &a[1]) ) return TCL_ERROR; 5860 rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_WIN32_AV_RETRY, (void*)a); 5861 sqlite3_snprintf(sizeof(z), z, "%d %d %d", rc, a[0], a[1]); 5862 Tcl_AppendResult(interp, z, (char*)0); 5863 return TCL_OK; 5864 } 5865 5866 /* 5867 ** tclcmd: file_control_win32_get_handle DB 5868 ** 5869 ** This TCL command runs the sqlite3_file_control interface with 5870 ** the SQLITE_FCNTL_WIN32_GET_HANDLE opcode. 5871 */ 5872 static int file_control_win32_get_handle( 5873 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5874 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5875 int objc, /* Number of arguments */ 5876 Tcl_Obj *CONST objv[] /* Command arguments */ 5877 ){ 5878 sqlite3 *db; 5879 int rc; 5880 HANDLE hFile = NULL; 5881 char z[100]; 5882 5883 if( objc!=2 ){ 5884 Tcl_AppendResult(interp, "wrong # args: should be \"", 5885 Tcl_GetStringFromObj(objv[0], 0), " DB", 0); 5886 return TCL_ERROR; 5887 } 5888 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 5889 return TCL_ERROR; 5890 } 5891 rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_WIN32_GET_HANDLE, 5892 (void*)&hFile); 5893 sqlite3_snprintf(sizeof(z), z, "%d %p", rc, (void*)hFile); 5894 Tcl_AppendResult(interp, z, (char*)0); 5895 return TCL_OK; 5896 } 5897 5898 /* 5899 ** tclcmd: file_control_win32_set_handle DB HANDLE 5900 ** 5901 ** This TCL command runs the sqlite3_file_control interface with 5902 ** the SQLITE_FCNTL_WIN32_SET_HANDLE opcode. 5903 */ 5904 static int SQLITE_TCLAPI file_control_win32_set_handle( 5905 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5906 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5907 int objc, /* Number of arguments */ 5908 Tcl_Obj *CONST objv[] /* Command arguments */ 5909 ){ 5910 sqlite3 *db; 5911 int rc; 5912 HANDLE hFile = NULL; 5913 char z[100]; 5914 5915 if( objc!=3 ){ 5916 Tcl_AppendResult(interp, "wrong # args: should be \"", 5917 Tcl_GetStringFromObj(objv[0], 0), " DB HANDLE", 0); 5918 return TCL_ERROR; 5919 } 5920 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 5921 return TCL_ERROR; 5922 } 5923 if( getWin32Handle(interp, Tcl_GetString(objv[2]), &hFile) ){ 5924 return TCL_ERROR; 5925 } 5926 rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_WIN32_SET_HANDLE, 5927 (void*)&hFile); 5928 sqlite3_snprintf(sizeof(z), z, "%d %p", rc, (void*)hFile); 5929 Tcl_AppendResult(interp, z, (char*)0); 5930 return TCL_OK; 5931 } 5932 #endif 5933 5934 /* 5935 ** tclcmd: file_control_persist_wal DB PERSIST-FLAG 5936 ** 5937 ** This TCL command runs the sqlite3_file_control interface with 5938 ** the SQLITE_FCNTL_PERSIST_WAL opcode. 5939 */ 5940 static int SQLITE_TCLAPI file_control_persist_wal( 5941 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5942 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5943 int objc, /* Number of arguments */ 5944 Tcl_Obj *CONST objv[] /* Command arguments */ 5945 ){ 5946 sqlite3 *db; 5947 int rc; 5948 int bPersist; 5949 char z[100]; 5950 5951 if( objc!=3 ){ 5952 Tcl_AppendResult(interp, "wrong # args: should be \"", 5953 Tcl_GetStringFromObj(objv[0], 0), " DB FLAG", 0); 5954 return TCL_ERROR; 5955 } 5956 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 5957 return TCL_ERROR; 5958 } 5959 if( Tcl_GetIntFromObj(interp, objv[2], &bPersist) ) return TCL_ERROR; 5960 rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_PERSIST_WAL, (void*)&bPersist); 5961 sqlite3_snprintf(sizeof(z), z, "%d %d", rc, bPersist); 5962 Tcl_AppendResult(interp, z, (char*)0); 5963 return TCL_OK; 5964 } 5965 5966 /* 5967 ** tclcmd: file_control_powersafe_overwrite DB PSOW-FLAG 5968 ** 5969 ** This TCL command runs the sqlite3_file_control interface with 5970 ** the SQLITE_FCNTL_POWERSAFE_OVERWRITE opcode. 5971 */ 5972 static int SQLITE_TCLAPI file_control_powersafe_overwrite( 5973 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 5974 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 5975 int objc, /* Number of arguments */ 5976 Tcl_Obj *CONST objv[] /* Command arguments */ 5977 ){ 5978 sqlite3 *db; 5979 int rc; 5980 int b; 5981 char z[100]; 5982 5983 if( objc!=3 ){ 5984 Tcl_AppendResult(interp, "wrong # args: should be \"", 5985 Tcl_GetStringFromObj(objv[0], 0), " DB FLAG", 0); 5986 return TCL_ERROR; 5987 } 5988 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 5989 return TCL_ERROR; 5990 } 5991 if( Tcl_GetIntFromObj(interp, objv[2], &b) ) return TCL_ERROR; 5992 rc = sqlite3_file_control(db,NULL,SQLITE_FCNTL_POWERSAFE_OVERWRITE,(void*)&b); 5993 sqlite3_snprintf(sizeof(z), z, "%d %d", rc, b); 5994 Tcl_AppendResult(interp, z, (char*)0); 5995 return TCL_OK; 5996 } 5997 5998 5999 /* 6000 ** tclcmd: file_control_vfsname DB ?AUXDB? 6001 ** 6002 ** Return a string that describes the stack of VFSes. 6003 */ 6004 static int SQLITE_TCLAPI file_control_vfsname( 6005 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6006 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6007 int objc, /* Number of arguments */ 6008 Tcl_Obj *CONST objv[] /* Command arguments */ 6009 ){ 6010 sqlite3 *db; 6011 const char *zDbName = "main"; 6012 char *zVfsName = 0; 6013 6014 if( objc!=2 && objc!=3 ){ 6015 Tcl_AppendResult(interp, "wrong # args: should be \"", 6016 Tcl_GetStringFromObj(objv[0], 0), " DB ?AUXDB?", 0); 6017 return TCL_ERROR; 6018 } 6019 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6020 return TCL_ERROR; 6021 } 6022 if( objc==3 ){ 6023 zDbName = Tcl_GetString(objv[2]); 6024 } 6025 sqlite3_file_control(db, zDbName, SQLITE_FCNTL_VFSNAME,(void*)&zVfsName); 6026 Tcl_AppendResult(interp, zVfsName, (char*)0); 6027 sqlite3_free(zVfsName); 6028 return TCL_OK; 6029 } 6030 6031 /* 6032 ** tclcmd: file_control_tempfilename DB ?AUXDB? 6033 ** 6034 ** Return a string that is a temporary filename 6035 */ 6036 static int SQLITE_TCLAPI file_control_tempfilename( 6037 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6038 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6039 int objc, /* Number of arguments */ 6040 Tcl_Obj *CONST objv[] /* Command arguments */ 6041 ){ 6042 sqlite3 *db; 6043 const char *zDbName = "main"; 6044 char *zTName = 0; 6045 6046 if( objc!=2 && objc!=3 ){ 6047 Tcl_AppendResult(interp, "wrong # args: should be \"", 6048 Tcl_GetStringFromObj(objv[0], 0), " DB ?AUXDB?", 0); 6049 return TCL_ERROR; 6050 } 6051 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6052 return TCL_ERROR; 6053 } 6054 if( objc==3 ){ 6055 zDbName = Tcl_GetString(objv[2]); 6056 } 6057 sqlite3_file_control(db, zDbName, SQLITE_FCNTL_TEMPFILENAME, (void*)&zTName); 6058 Tcl_AppendResult(interp, zTName, (char*)0); 6059 sqlite3_free(zTName); 6060 return TCL_OK; 6061 } 6062 6063 6064 /* 6065 ** tclcmd: sqlite3_vfs_list 6066 ** 6067 ** Return a tcl list containing the names of all registered vfs's. 6068 */ 6069 static int SQLITE_TCLAPI vfs_list( 6070 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6071 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6072 int objc, /* Number of arguments */ 6073 Tcl_Obj *CONST objv[] /* Command arguments */ 6074 ){ 6075 sqlite3_vfs *pVfs; 6076 Tcl_Obj *pRet = Tcl_NewObj(); 6077 if( objc!=1 ){ 6078 Tcl_WrongNumArgs(interp, 1, objv, ""); 6079 return TCL_ERROR; 6080 } 6081 for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){ 6082 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj(pVfs->zName, -1)); 6083 } 6084 Tcl_SetObjResult(interp, pRet); 6085 return TCL_OK; 6086 } 6087 6088 /* 6089 ** tclcmd: sqlite3_limit DB ID VALUE 6090 ** 6091 ** This TCL command runs the sqlite3_limit interface and 6092 ** verifies correct operation of the same. 6093 */ 6094 static int SQLITE_TCLAPI test_limit( 6095 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6096 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6097 int objc, /* Number of arguments */ 6098 Tcl_Obj *CONST objv[] /* Command arguments */ 6099 ){ 6100 sqlite3 *db; 6101 int rc; 6102 static const struct { 6103 char *zName; 6104 int id; 6105 } aId[] = { 6106 { "SQLITE_LIMIT_LENGTH", SQLITE_LIMIT_LENGTH }, 6107 { "SQLITE_LIMIT_SQL_LENGTH", SQLITE_LIMIT_SQL_LENGTH }, 6108 { "SQLITE_LIMIT_COLUMN", SQLITE_LIMIT_COLUMN }, 6109 { "SQLITE_LIMIT_EXPR_DEPTH", SQLITE_LIMIT_EXPR_DEPTH }, 6110 { "SQLITE_LIMIT_COMPOUND_SELECT", SQLITE_LIMIT_COMPOUND_SELECT }, 6111 { "SQLITE_LIMIT_VDBE_OP", SQLITE_LIMIT_VDBE_OP }, 6112 { "SQLITE_LIMIT_FUNCTION_ARG", SQLITE_LIMIT_FUNCTION_ARG }, 6113 { "SQLITE_LIMIT_ATTACHED", SQLITE_LIMIT_ATTACHED }, 6114 { "SQLITE_LIMIT_LIKE_PATTERN_LENGTH", SQLITE_LIMIT_LIKE_PATTERN_LENGTH }, 6115 { "SQLITE_LIMIT_VARIABLE_NUMBER", SQLITE_LIMIT_VARIABLE_NUMBER }, 6116 { "SQLITE_LIMIT_TRIGGER_DEPTH", SQLITE_LIMIT_TRIGGER_DEPTH }, 6117 { "SQLITE_LIMIT_WORKER_THREADS", SQLITE_LIMIT_WORKER_THREADS }, 6118 6119 /* Out of range test cases */ 6120 { "SQLITE_LIMIT_TOOSMALL", -1, }, 6121 { "SQLITE_LIMIT_TOOBIG", SQLITE_LIMIT_WORKER_THREADS+1 }, 6122 }; 6123 int i, id = 0; 6124 int val; 6125 const char *zId; 6126 6127 if( objc!=4 ){ 6128 Tcl_AppendResult(interp, "wrong # args: should be \"", 6129 Tcl_GetStringFromObj(objv[0], 0), " DB ID VALUE", 0); 6130 return TCL_ERROR; 6131 } 6132 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 6133 zId = Tcl_GetString(objv[2]); 6134 for(i=0; i<sizeof(aId)/sizeof(aId[0]); i++){ 6135 if( strcmp(zId, aId[i].zName)==0 ){ 6136 id = aId[i].id; 6137 break; 6138 } 6139 } 6140 if( i>=sizeof(aId)/sizeof(aId[0]) ){ 6141 Tcl_AppendResult(interp, "unknown limit type: ", zId, (char*)0); 6142 return TCL_ERROR; 6143 } 6144 if( Tcl_GetIntFromObj(interp, objv[3], &val) ) return TCL_ERROR; 6145 rc = sqlite3_limit(db, id, val); 6146 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 6147 return TCL_OK; 6148 } 6149 6150 /* 6151 ** tclcmd: save_prng_state 6152 ** 6153 ** Save the state of the pseudo-random number generator. 6154 ** At the same time, verify that sqlite3_test_control works even when 6155 ** called with an out-of-range opcode. 6156 */ 6157 static int SQLITE_TCLAPI save_prng_state( 6158 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6159 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6160 int objc, /* Number of arguments */ 6161 Tcl_Obj *CONST objv[] /* Command arguments */ 6162 ){ 6163 int rc = sqlite3_test_control(9999); 6164 assert( rc==0 ); 6165 rc = sqlite3_test_control(-1); 6166 assert( rc==0 ); 6167 sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SAVE); 6168 return TCL_OK; 6169 } 6170 /* 6171 ** tclcmd: restore_prng_state 6172 */ 6173 static int SQLITE_TCLAPI restore_prng_state( 6174 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6175 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6176 int objc, /* Number of arguments */ 6177 Tcl_Obj *CONST objv[] /* Command arguments */ 6178 ){ 6179 sqlite3_test_control(SQLITE_TESTCTRL_PRNG_RESTORE); 6180 return TCL_OK; 6181 } 6182 /* 6183 ** tclcmd: reset_prng_state 6184 */ 6185 static int SQLITE_TCLAPI reset_prng_state( 6186 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6187 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6188 int objc, /* Number of arguments */ 6189 Tcl_Obj *CONST objv[] /* Command arguments */ 6190 ){ 6191 sqlite3_test_control(SQLITE_TESTCTRL_PRNG_RESET); 6192 return TCL_OK; 6193 } 6194 6195 /* 6196 ** tclcmd: database_may_be_corrupt 6197 ** 6198 ** Indicate that database files might be corrupt. In other words, set the normal 6199 ** state of operation. 6200 */ 6201 static int SQLITE_TCLAPI database_may_be_corrupt( 6202 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6203 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6204 int objc, /* Number of arguments */ 6205 Tcl_Obj *CONST objv[] /* Command arguments */ 6206 ){ 6207 sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, 0); 6208 return TCL_OK; 6209 } 6210 /* 6211 ** tclcmd: database_never_corrupt 6212 ** 6213 ** Indicate that database files are always well-formed. This enables extra assert() 6214 ** statements that test conditions that are always true for well-formed databases. 6215 */ 6216 static int SQLITE_TCLAPI database_never_corrupt( 6217 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6218 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6219 int objc, /* Number of arguments */ 6220 Tcl_Obj *CONST objv[] /* Command arguments */ 6221 ){ 6222 sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, 1); 6223 return TCL_OK; 6224 } 6225 6226 /* 6227 ** tclcmd: pcache_stats 6228 */ 6229 static int SQLITE_TCLAPI test_pcache_stats( 6230 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 6231 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6232 int objc, /* Number of arguments */ 6233 Tcl_Obj *CONST objv[] /* Command arguments */ 6234 ){ 6235 int nMin; 6236 int nMax; 6237 int nCurrent; 6238 int nRecyclable; 6239 Tcl_Obj *pRet; 6240 6241 sqlite3PcacheStats(&nCurrent, &nMax, &nMin, &nRecyclable); 6242 6243 pRet = Tcl_NewObj(); 6244 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("current", -1)); 6245 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nCurrent)); 6246 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("max", -1)); 6247 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nMax)); 6248 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("min", -1)); 6249 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nMin)); 6250 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("recyclable", -1)); 6251 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nRecyclable)); 6252 6253 Tcl_SetObjResult(interp, pRet); 6254 6255 return TCL_OK; 6256 } 6257 6258 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY 6259 static void test_unlock_notify_cb(void **aArg, int nArg){ 6260 int ii; 6261 for(ii=0; ii<nArg; ii++){ 6262 Tcl_EvalEx((Tcl_Interp *)aArg[ii], "unlock_notify", -1, TCL_EVAL_GLOBAL); 6263 } 6264 } 6265 #endif /* SQLITE_ENABLE_UNLOCK_NOTIFY */ 6266 6267 /* 6268 ** tclcmd: sqlite3_unlock_notify db 6269 */ 6270 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY 6271 static int SQLITE_TCLAPI test_unlock_notify( 6272 ClientData clientData, /* Unused */ 6273 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6274 int objc, /* Number of arguments */ 6275 Tcl_Obj *CONST objv[] /* Command arguments */ 6276 ){ 6277 sqlite3 *db; 6278 int rc; 6279 6280 if( objc!=2 ){ 6281 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 6282 return TCL_ERROR; 6283 } 6284 6285 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6286 return TCL_ERROR; 6287 } 6288 rc = sqlite3_unlock_notify(db, test_unlock_notify_cb, (void *)interp); 6289 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 6290 return TCL_OK; 6291 } 6292 #endif 6293 6294 /* 6295 ** tclcmd: sqlite3_wal_checkpoint db ?NAME? 6296 */ 6297 static int SQLITE_TCLAPI test_wal_checkpoint( 6298 ClientData clientData, /* Unused */ 6299 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6300 int objc, /* Number of arguments */ 6301 Tcl_Obj *CONST objv[] /* Command arguments */ 6302 ){ 6303 char *zDb = 0; 6304 sqlite3 *db; 6305 int rc; 6306 6307 if( objc!=3 && objc!=2 ){ 6308 Tcl_WrongNumArgs(interp, 1, objv, "DB ?NAME?"); 6309 return TCL_ERROR; 6310 } 6311 6312 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 6313 return TCL_ERROR; 6314 } 6315 if( objc==3 ){ 6316 zDb = Tcl_GetString(objv[2]); 6317 } 6318 rc = sqlite3_wal_checkpoint(db, zDb); 6319 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 6320 return TCL_OK; 6321 } 6322 6323 /* 6324 ** tclcmd: sqlite3_wal_checkpoint_v2 db MODE ?NAME? 6325 ** 6326 ** This command calls the wal_checkpoint_v2() function with the specified 6327 ** mode argument (passive, full or restart). If present, the database name 6328 ** NAME is passed as the second argument to wal_checkpoint_v2(). If it the 6329 ** NAME argument is not present, a NULL pointer is passed instead. 6330 ** 6331 ** If wal_checkpoint_v2() returns any value other than SQLITE_BUSY or 6332 ** SQLITE_OK, then this command returns TCL_ERROR. The Tcl result is set 6333 ** to the error message obtained from sqlite3_errmsg(). 6334 ** 6335 ** Otherwise, this command returns a list of three integers. The first integer 6336 ** is 1 if SQLITE_BUSY was returned, or 0 otherwise. The following two integers 6337 ** are the values returned via the output parameters by wal_checkpoint_v2() - 6338 ** the number of frames in the log and the number of frames in the log 6339 ** that have been checkpointed. 6340 */ 6341 static int SQLITE_TCLAPI test_wal_checkpoint_v2( 6342 ClientData clientData, /* Unused */ 6343 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6344 int objc, /* Number of arguments */ 6345 Tcl_Obj *CONST objv[] /* Command arguments */ 6346 ){ 6347 char *zDb = 0; 6348 sqlite3 *db; 6349 int rc; 6350 6351 int eMode; 6352 int nLog = -555; 6353 int nCkpt = -555; 6354 Tcl_Obj *pRet; 6355 6356 const char * aMode[] = { "passive", "full", "restart", "truncate", 0 }; 6357 assert( SQLITE_CHECKPOINT_PASSIVE==0 ); 6358 assert( SQLITE_CHECKPOINT_FULL==1 ); 6359 assert( SQLITE_CHECKPOINT_RESTART==2 ); 6360 assert( SQLITE_CHECKPOINT_TRUNCATE==3 ); 6361 6362 if( objc!=3 && objc!=4 ){ 6363 Tcl_WrongNumArgs(interp, 1, objv, "DB MODE ?NAME?"); 6364 return TCL_ERROR; 6365 } 6366 6367 if( objc==4 ){ 6368 zDb = Tcl_GetString(objv[3]); 6369 } 6370 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) || ( 6371 TCL_OK!=Tcl_GetIntFromObj(0, objv[2], &eMode) 6372 && TCL_OK!=Tcl_GetIndexFromObj(interp, objv[2], aMode, "mode", 0, &eMode) 6373 )){ 6374 return TCL_ERROR; 6375 } 6376 6377 rc = sqlite3_wal_checkpoint_v2(db, zDb, eMode, &nLog, &nCkpt); 6378 if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){ 6379 const char *zErrCode = sqlite3ErrName(rc); 6380 Tcl_ResetResult(interp); 6381 Tcl_AppendResult(interp, zErrCode, " - ", (char *)sqlite3_errmsg(db), 0); 6382 return TCL_ERROR; 6383 } 6384 6385 pRet = Tcl_NewObj(); 6386 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(rc==SQLITE_BUSY?1:0)); 6387 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nLog)); 6388 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nCkpt)); 6389 Tcl_SetObjResult(interp, pRet); 6390 6391 return TCL_OK; 6392 } 6393 6394 /* 6395 ** tclcmd: sqlite3_wal_autocheckpoint db VALUE 6396 */ 6397 static int SQLITE_TCLAPI test_wal_autocheckpoint( 6398 ClientData clientData, /* Unused */ 6399 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6400 int objc, /* Number of arguments */ 6401 Tcl_Obj *CONST objv[] /* Command arguments */ 6402 ){ 6403 sqlite3 *db; 6404 int rc; 6405 int iVal; 6406 6407 6408 if( objc!=3 ){ 6409 Tcl_WrongNumArgs(interp, 1, objv, "DB VALUE"); 6410 return TCL_ERROR; 6411 } 6412 6413 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) 6414 || Tcl_GetIntFromObj(0, objv[2], &iVal) 6415 ){ 6416 return TCL_ERROR; 6417 } 6418 6419 rc = sqlite3_wal_autocheckpoint(db, iVal); 6420 Tcl_ResetResult(interp); 6421 if( rc!=SQLITE_OK ){ 6422 const char *zErrCode = sqlite3ErrName(rc); 6423 Tcl_SetObjResult(interp, Tcl_NewStringObj(zErrCode, -1)); 6424 return TCL_ERROR; 6425 } 6426 6427 return TCL_OK; 6428 } 6429 6430 6431 /* 6432 ** tclcmd: test_sqlite3_log ?SCRIPT? 6433 */ 6434 static struct LogCallback { 6435 Tcl_Interp *pInterp; 6436 Tcl_Obj *pObj; 6437 } logcallback = {0, 0}; 6438 static void xLogcallback(void *unused, int err, char *zMsg){ 6439 Tcl_Obj *pNew = Tcl_DuplicateObj(logcallback.pObj); 6440 Tcl_IncrRefCount(pNew); 6441 Tcl_ListObjAppendElement( 6442 0, pNew, Tcl_NewStringObj(sqlite3ErrName(err), -1) 6443 ); 6444 Tcl_ListObjAppendElement(0, pNew, Tcl_NewStringObj(zMsg, -1)); 6445 Tcl_EvalObjEx(logcallback.pInterp, pNew, TCL_EVAL_GLOBAL|TCL_EVAL_DIRECT); 6446 Tcl_DecrRefCount(pNew); 6447 } 6448 static int SQLITE_TCLAPI test_sqlite3_log( 6449 ClientData clientData, 6450 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 6451 int objc, /* Number of arguments */ 6452 Tcl_Obj *CONST objv[] /* Command arguments */ 6453 ){ 6454 if( objc>2 ){ 6455 Tcl_WrongNumArgs(interp, 1, objv, "SCRIPT"); 6456 return TCL_ERROR; 6457 } 6458 if( logcallback.pObj ){ 6459 Tcl_DecrRefCount(logcallback.pObj); 6460 logcallback.pObj = 0; 6461 logcallback.pInterp = 0; 6462 sqlite3_config(SQLITE_CONFIG_LOG, (void*)0, (void*)0); 6463 } 6464 if( objc>1 ){ 6465 logcallback.pObj = objv[1]; 6466 Tcl_IncrRefCount(logcallback.pObj); 6467 logcallback.pInterp = interp; 6468 sqlite3_config(SQLITE_CONFIG_LOG, xLogcallback, (void*)0); 6469 } 6470 return TCL_OK; 6471 } 6472 6473 /* 6474 ** tcl_objproc COMMANDNAME ARGS... 6475 ** 6476 ** Run a TCL command using its objProc interface. Throw an error if 6477 ** the command has no objProc interface. 6478 */ 6479 static int SQLITE_TCLAPI runAsObjProc( 6480 void * clientData, 6481 Tcl_Interp *interp, 6482 int objc, 6483 Tcl_Obj *CONST objv[] 6484 ){ 6485 Tcl_CmdInfo cmdInfo; 6486 if( objc<2 ){ 6487 Tcl_WrongNumArgs(interp, 1, objv, "COMMAND ..."); 6488 return TCL_ERROR; 6489 } 6490 if( !Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){ 6491 Tcl_AppendResult(interp, "command not found: ", 6492 Tcl_GetString(objv[1]), (char*)0); 6493 return TCL_ERROR; 6494 } 6495 if( cmdInfo.objProc==0 ){ 6496 Tcl_AppendResult(interp, "command has no objProc: ", 6497 Tcl_GetString(objv[1]), (char*)0); 6498 return TCL_ERROR; 6499 } 6500 return cmdInfo.objProc(cmdInfo.objClientData, interp, objc-1, objv+1); 6501 } 6502 6503 #ifndef SQLITE_OMIT_EXPLAIN 6504 /* 6505 ** WARNING: The following function, printExplainQueryPlan() is an exact 6506 ** copy of example code from eqp.in (eqp.html). If this code is modified, 6507 ** then the documentation copy needs to be modified as well. 6508 */ 6509 /* 6510 ** Argument pStmt is a prepared SQL statement. This function compiles 6511 ** an EXPLAIN QUERY PLAN command to report on the prepared statement, 6512 ** and prints the report to stdout using printf(). 6513 */ 6514 int printExplainQueryPlan(sqlite3_stmt *pStmt){ 6515 const char *zSql; /* Input SQL */ 6516 char *zExplain; /* SQL with EXPLAIN QUERY PLAN prepended */ 6517 sqlite3_stmt *pExplain; /* Compiled EXPLAIN QUERY PLAN command */ 6518 int rc; /* Return code from sqlite3_prepare_v2() */ 6519 6520 zSql = sqlite3_sql(pStmt); 6521 if( zSql==0 ) return SQLITE_ERROR; 6522 6523 zExplain = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zSql); 6524 if( zExplain==0 ) return SQLITE_NOMEM; 6525 6526 rc = sqlite3_prepare_v2(sqlite3_db_handle(pStmt), zExplain, -1, &pExplain, 0); 6527 sqlite3_free(zExplain); 6528 if( rc!=SQLITE_OK ) return rc; 6529 6530 while( SQLITE_ROW==sqlite3_step(pExplain) ){ 6531 int iSelectid = sqlite3_column_int(pExplain, 0); 6532 int iOrder = sqlite3_column_int(pExplain, 1); 6533 int iFrom = sqlite3_column_int(pExplain, 2); 6534 const char *zDetail = (const char *)sqlite3_column_text(pExplain, 3); 6535 6536 printf("%d %d %d %s\n", iSelectid, iOrder, iFrom, zDetail); 6537 } 6538 6539 return sqlite3_finalize(pExplain); 6540 } 6541 6542 static int SQLITE_TCLAPI test_print_eqp( 6543 void * clientData, 6544 Tcl_Interp *interp, 6545 int objc, 6546 Tcl_Obj *CONST objv[] 6547 ){ 6548 int rc; 6549 sqlite3_stmt *pStmt; 6550 6551 if( objc!=2 ){ 6552 Tcl_WrongNumArgs(interp, 1, objv, "STMT"); 6553 return TCL_ERROR; 6554 } 6555 if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; 6556 rc = printExplainQueryPlan(pStmt); 6557 /* This is needed on Windows so that a test case using this 6558 ** function can open a read pipe and get the output of 6559 ** printExplainQueryPlan() immediately. 6560 */ 6561 fflush(stdout); 6562 Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0); 6563 return TCL_OK; 6564 } 6565 #endif /* SQLITE_OMIT_EXPLAIN */ 6566 6567 /* 6568 ** sqlite3_test_control VERB ARGS... 6569 */ 6570 static int SQLITE_TCLAPI test_test_control( 6571 void * clientData, 6572 Tcl_Interp *interp, 6573 int objc, 6574 Tcl_Obj *CONST objv[] 6575 ){ 6576 struct Verb { 6577 const char *zName; 6578 int i; 6579 } aVerb[] = { 6580 { "SQLITE_TESTCTRL_LOCALTIME_FAULT", SQLITE_TESTCTRL_LOCALTIME_FAULT }, 6581 { "SQLITE_TESTCTRL_SORTER_MMAP", SQLITE_TESTCTRL_SORTER_MMAP }, 6582 { "SQLITE_TESTCTRL_IMPOSTER", SQLITE_TESTCTRL_IMPOSTER }, 6583 }; 6584 int iVerb; 6585 int iFlag; 6586 int rc; 6587 6588 if( objc<2 ){ 6589 Tcl_WrongNumArgs(interp, 1, objv, "VERB ARGS..."); 6590 return TCL_ERROR; 6591 } 6592 6593 rc = Tcl_GetIndexFromObjStruct( 6594 interp, objv[1], aVerb, sizeof(aVerb[0]), "VERB", 0, &iVerb 6595 ); 6596 if( rc!=TCL_OK ) return rc; 6597 6598 iFlag = aVerb[iVerb].i; 6599 switch( iFlag ){ 6600 case SQLITE_TESTCTRL_LOCALTIME_FAULT: { 6601 int val; 6602 if( objc!=3 ){ 6603 Tcl_WrongNumArgs(interp, 2, objv, "ONOFF"); 6604 return TCL_ERROR; 6605 } 6606 if( Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR; 6607 sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, val); 6608 break; 6609 } 6610 6611 case SQLITE_TESTCTRL_SORTER_MMAP: { 6612 int val; 6613 sqlite3 *db; 6614 if( objc!=4 ){ 6615 Tcl_WrongNumArgs(interp, 2, objv, "DB LIMIT"); 6616 return TCL_ERROR; 6617 } 6618 if( getDbPointer(interp, Tcl_GetString(objv[2]), &db) ) return TCL_ERROR; 6619 if( Tcl_GetIntFromObj(interp, objv[3], &val) ) return TCL_ERROR; 6620 sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, val); 6621 break; 6622 } 6623 6624 case SQLITE_TESTCTRL_IMPOSTER: { 6625 int onOff, tnum; 6626 const char *zDbName; 6627 sqlite3 *db; 6628 if( objc!=6 ){ 6629 Tcl_WrongNumArgs(interp, 2, objv, "DB dbName onOff tnum"); 6630 return TCL_ERROR; 6631 } 6632 if( getDbPointer(interp, Tcl_GetString(objv[2]), &db) ) return TCL_ERROR; 6633 zDbName = Tcl_GetString(objv[3]); 6634 if( Tcl_GetIntFromObj(interp, objv[4], &onOff) ) return TCL_ERROR; 6635 if( Tcl_GetIntFromObj(interp, objv[5], &tnum) ) return TCL_ERROR; 6636 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, zDbName, onOff, tnum); 6637 break; 6638 } 6639 } 6640 6641 Tcl_ResetResult(interp); 6642 return TCL_OK; 6643 } 6644 6645 #if SQLITE_OS_UNIX 6646 #include <sys/time.h> 6647 #include <sys/resource.h> 6648 6649 static int SQLITE_TCLAPI test_getrusage( 6650 void * clientData, 6651 Tcl_Interp *interp, 6652 int objc, 6653 Tcl_Obj *CONST objv[] 6654 ){ 6655 char buf[1024]; 6656 struct rusage r; 6657 memset(&r, 0, sizeof(r)); 6658 getrusage(RUSAGE_SELF, &r); 6659 6660 sqlite3_snprintf(sizeof(buf), buf, 6661 "ru_utime=%d.%06d ru_stime=%d.%06d ru_minflt=%d ru_majflt=%d", 6662 (int)r.ru_utime.tv_sec, (int)r.ru_utime.tv_usec, 6663 (int)r.ru_stime.tv_sec, (int)r.ru_stime.tv_usec, 6664 (int)r.ru_minflt, (int)r.ru_majflt 6665 ); 6666 Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, -1)); 6667 return TCL_OK; 6668 } 6669 #endif 6670 6671 #if SQLITE_OS_WIN 6672 /* 6673 ** Information passed from the main thread into the windows file locker 6674 ** background thread. 6675 */ 6676 struct win32FileLocker { 6677 char *evName; /* Name of event to signal thread startup */ 6678 HANDLE h; /* Handle of the file to be locked */ 6679 int delay1; /* Delay before locking */ 6680 int delay2; /* Delay before unlocking */ 6681 int ok; /* Finished ok */ 6682 int err; /* True if an error occurs */ 6683 }; 6684 #endif 6685 6686 6687 #if SQLITE_OS_WIN 6688 #include <process.h> 6689 /* 6690 ** The background thread that does file locking. 6691 */ 6692 static void SQLITE_CDECL win32_file_locker(void *pAppData){ 6693 struct win32FileLocker *p = (struct win32FileLocker*)pAppData; 6694 if( p->evName ){ 6695 HANDLE ev = OpenEvent(EVENT_MODIFY_STATE, FALSE, p->evName); 6696 if ( ev ){ 6697 SetEvent(ev); 6698 CloseHandle(ev); 6699 } 6700 } 6701 if( p->delay1 ) Sleep(p->delay1); 6702 if( LockFile(p->h, 0, 0, 100000000, 0) ){ 6703 Sleep(p->delay2); 6704 UnlockFile(p->h, 0, 0, 100000000, 0); 6705 p->ok = 1; 6706 }else{ 6707 p->err = 1; 6708 } 6709 CloseHandle(p->h); 6710 p->h = 0; 6711 p->delay1 = 0; 6712 p->delay2 = 0; 6713 } 6714 #endif 6715 6716 #if SQLITE_OS_WIN 6717 /* 6718 ** lock_win32_file FILENAME DELAY1 DELAY2 6719 ** 6720 ** Get an exclusive manditory lock on file for DELAY2 milliseconds. 6721 ** Wait DELAY1 milliseconds before acquiring the lock. 6722 */ 6723 static int SQLITE_TCLAPI win32_file_lock( 6724 void * clientData, 6725 Tcl_Interp *interp, 6726 int objc, 6727 Tcl_Obj *CONST objv[] 6728 ){ 6729 static struct win32FileLocker x = { "win32_file_lock", 0, 0, 0, 0, 0 }; 6730 const char *zFilename; 6731 char zBuf[200]; 6732 int retry = 0; 6733 HANDLE ev; 6734 DWORD wResult; 6735 6736 if( objc!=4 && objc!=1 ){ 6737 Tcl_WrongNumArgs(interp, 1, objv, "FILENAME DELAY1 DELAY2"); 6738 return TCL_ERROR; 6739 } 6740 if( objc==1 ){ 6741 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d %d %d %d %d", 6742 x.ok, x.err, x.delay1, x.delay2, x.h); 6743 Tcl_AppendResult(interp, zBuf, (char*)0); 6744 return TCL_OK; 6745 } 6746 while( x.h && retry<30 ){ 6747 retry++; 6748 Sleep(100); 6749 } 6750 if( x.h ){ 6751 Tcl_AppendResult(interp, "busy", (char*)0); 6752 return TCL_ERROR; 6753 } 6754 if( Tcl_GetIntFromObj(interp, objv[2], &x.delay1) ) return TCL_ERROR; 6755 if( Tcl_GetIntFromObj(interp, objv[3], &x.delay2) ) return TCL_ERROR; 6756 zFilename = Tcl_GetString(objv[1]); 6757 x.h = CreateFile(zFilename, GENERIC_READ|GENERIC_WRITE, 6758 FILE_SHARE_READ|FILE_SHARE_WRITE, 0, OPEN_ALWAYS, 6759 FILE_ATTRIBUTE_NORMAL, 0); 6760 if( !x.h ){ 6761 Tcl_AppendResult(interp, "cannot open file: ", zFilename, (char*)0); 6762 return TCL_ERROR; 6763 } 6764 ev = CreateEvent(NULL, TRUE, FALSE, x.evName); 6765 if ( !ev ){ 6766 Tcl_AppendResult(interp, "cannot create event: ", x.evName, (char*)0); 6767 return TCL_ERROR; 6768 } 6769 _beginthread(win32_file_locker, 0, (void*)&x); 6770 Sleep(0); 6771 if ( (wResult = WaitForSingleObject(ev, 10000))!=WAIT_OBJECT_0 ){ 6772 sqlite3_snprintf(sizeof(zBuf), zBuf, "0x%x", wResult); 6773 Tcl_AppendResult(interp, "wait failed: ", zBuf, (char*)0); 6774 CloseHandle(ev); 6775 return TCL_ERROR; 6776 } 6777 CloseHandle(ev); 6778 return TCL_OK; 6779 } 6780 6781 /* 6782 ** exists_win32_path PATH 6783 ** 6784 ** Returns non-zero if the specified path exists, whose fully qualified name 6785 ** may exceed 260 characters if it is prefixed with "\\?\". 6786 */ 6787 static int SQLITE_TCLAPI win32_exists_path( 6788 void *clientData, 6789 Tcl_Interp *interp, 6790 int objc, 6791 Tcl_Obj *CONST objv[] 6792 ){ 6793 if( objc!=2 ){ 6794 Tcl_WrongNumArgs(interp, 1, objv, "PATH"); 6795 return TCL_ERROR; 6796 } 6797 Tcl_SetObjResult(interp, Tcl_NewBooleanObj( 6798 GetFileAttributesW( Tcl_GetUnicode(objv[1]))!=INVALID_FILE_ATTRIBUTES )); 6799 return TCL_OK; 6800 } 6801 6802 /* 6803 ** find_win32_file PATTERN 6804 ** 6805 ** Returns a list of entries in a directory that match the specified pattern, 6806 ** whose fully qualified name may exceed 248 characters if it is prefixed with 6807 ** "\\?\". 6808 */ 6809 static int SQLITE_TCLAPI win32_find_file( 6810 void *clientData, 6811 Tcl_Interp *interp, 6812 int objc, 6813 Tcl_Obj *CONST objv[] 6814 ){ 6815 HANDLE hFindFile = INVALID_HANDLE_VALUE; 6816 WIN32_FIND_DATAW findData; 6817 Tcl_Obj *listObj; 6818 DWORD lastErrno; 6819 if( objc!=2 ){ 6820 Tcl_WrongNumArgs(interp, 1, objv, "PATTERN"); 6821 return TCL_ERROR; 6822 } 6823 hFindFile = FindFirstFileW(Tcl_GetUnicode(objv[1]), &findData); 6824 if( hFindFile==INVALID_HANDLE_VALUE ){ 6825 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError())); 6826 return TCL_ERROR; 6827 } 6828 listObj = Tcl_NewObj(); 6829 Tcl_IncrRefCount(listObj); 6830 do { 6831 Tcl_ListObjAppendElement(interp, listObj, Tcl_NewUnicodeObj( 6832 findData.cFileName, -1)); 6833 Tcl_ListObjAppendElement(interp, listObj, Tcl_NewWideIntObj( 6834 findData.dwFileAttributes)); 6835 } while( FindNextFileW(hFindFile, &findData) ); 6836 lastErrno = GetLastError(); 6837 if( lastErrno!=NO_ERROR && lastErrno!=ERROR_NO_MORE_FILES ){ 6838 FindClose(hFindFile); 6839 Tcl_DecrRefCount(listObj); 6840 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError())); 6841 return TCL_ERROR; 6842 } 6843 FindClose(hFindFile); 6844 Tcl_SetObjResult(interp, listObj); 6845 return TCL_OK; 6846 } 6847 6848 /* 6849 ** delete_win32_file FILENAME 6850 ** 6851 ** Deletes the specified file, whose fully qualified name may exceed 260 6852 ** characters if it is prefixed with "\\?\". 6853 */ 6854 static int SQLITE_TCLAPI win32_delete_file( 6855 void *clientData, 6856 Tcl_Interp *interp, 6857 int objc, 6858 Tcl_Obj *CONST objv[] 6859 ){ 6860 if( objc!=2 ){ 6861 Tcl_WrongNumArgs(interp, 1, objv, "FILENAME"); 6862 return TCL_ERROR; 6863 } 6864 if( !DeleteFileW(Tcl_GetUnicode(objv[1])) ){ 6865 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError())); 6866 return TCL_ERROR; 6867 } 6868 Tcl_ResetResult(interp); 6869 return TCL_OK; 6870 } 6871 6872 /* 6873 ** make_win32_dir DIRECTORY 6874 ** 6875 ** Creates the specified directory, whose fully qualified name may exceed 248 6876 ** characters if it is prefixed with "\\?\". 6877 */ 6878 static int SQLITE_TCLAPI win32_mkdir( 6879 void *clientData, 6880 Tcl_Interp *interp, 6881 int objc, 6882 Tcl_Obj *CONST objv[] 6883 ){ 6884 if( objc!=2 ){ 6885 Tcl_WrongNumArgs(interp, 1, objv, "DIRECTORY"); 6886 return TCL_ERROR; 6887 } 6888 if( !CreateDirectoryW(Tcl_GetUnicode(objv[1]), NULL) ){ 6889 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError())); 6890 return TCL_ERROR; 6891 } 6892 Tcl_ResetResult(interp); 6893 return TCL_OK; 6894 } 6895 6896 /* 6897 ** remove_win32_dir DIRECTORY 6898 ** 6899 ** Removes the specified directory, whose fully qualified name may exceed 248 6900 ** characters if it is prefixed with "\\?\". 6901 */ 6902 static int SQLITE_TCLAPI win32_rmdir( 6903 void *clientData, 6904 Tcl_Interp *interp, 6905 int objc, 6906 Tcl_Obj *CONST objv[] 6907 ){ 6908 if( objc!=2 ){ 6909 Tcl_WrongNumArgs(interp, 1, objv, "DIRECTORY"); 6910 return TCL_ERROR; 6911 } 6912 if( !RemoveDirectoryW(Tcl_GetUnicode(objv[1])) ){ 6913 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError())); 6914 return TCL_ERROR; 6915 } 6916 Tcl_ResetResult(interp); 6917 return TCL_OK; 6918 } 6919 #endif 6920 6921 6922 /* 6923 ** optimization_control DB OPT BOOLEAN 6924 ** 6925 ** Enable or disable query optimizations using the sqlite3_test_control() 6926 ** interface. Disable if BOOLEAN is false and enable if BOOLEAN is true. 6927 ** OPT is the name of the optimization to be disabled. 6928 */ 6929 static int SQLITE_TCLAPI optimization_control( 6930 void * clientData, 6931 Tcl_Interp *interp, 6932 int objc, 6933 Tcl_Obj *CONST objv[] 6934 ){ 6935 int i; 6936 sqlite3 *db; 6937 const char *zOpt; 6938 int onoff; 6939 int mask = 0; 6940 static const struct { 6941 const char *zOptName; 6942 int mask; 6943 } aOpt[] = { 6944 { "all", SQLITE_AllOpts }, 6945 { "none", 0 }, 6946 { "query-flattener", SQLITE_QueryFlattener }, 6947 { "column-cache", SQLITE_ColumnCache }, 6948 { "groupby-order", SQLITE_GroupByOrder }, 6949 { "factor-constants", SQLITE_FactorOutConst }, 6950 { "distinct-opt", SQLITE_DistinctOpt }, 6951 { "cover-idx-scan", SQLITE_CoverIdxScan }, 6952 { "order-by-idx-join", SQLITE_OrderByIdxJoin }, 6953 { "transitive", SQLITE_Transitive }, 6954 { "omit-noop-join", SQLITE_OmitNoopJoin }, 6955 { "stat3", SQLITE_Stat34 }, 6956 { "stat4", SQLITE_Stat34 }, 6957 }; 6958 6959 if( objc!=4 ){ 6960 Tcl_WrongNumArgs(interp, 1, objv, "DB OPT BOOLEAN"); 6961 return TCL_ERROR; 6962 } 6963 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 6964 if( Tcl_GetBooleanFromObj(interp, objv[3], &onoff) ) return TCL_ERROR; 6965 zOpt = Tcl_GetString(objv[2]); 6966 for(i=0; i<sizeof(aOpt)/sizeof(aOpt[0]); i++){ 6967 if( strcmp(zOpt, aOpt[i].zOptName)==0 ){ 6968 mask = aOpt[i].mask; 6969 break; 6970 } 6971 } 6972 if( onoff ) mask = ~mask; 6973 if( i>=sizeof(aOpt)/sizeof(aOpt[0]) ){ 6974 Tcl_AppendResult(interp, "unknown optimization - should be one of:", 6975 (char*)0); 6976 for(i=0; i<sizeof(aOpt)/sizeof(aOpt[0]); i++){ 6977 Tcl_AppendResult(interp, " ", aOpt[i].zOptName, (char*)0); 6978 } 6979 return TCL_ERROR; 6980 } 6981 sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, db, mask); 6982 return TCL_OK; 6983 } 6984 6985 /* 6986 ** load_static_extension DB NAME ... 6987 ** 6988 ** Load one or more statically linked extensions. 6989 */ 6990 static int SQLITE_TCLAPI tclLoadStaticExtensionCmd( 6991 void * clientData, 6992 Tcl_Interp *interp, 6993 int objc, 6994 Tcl_Obj *CONST objv[] 6995 ){ 6996 extern int sqlite3_amatch_init(sqlite3*,char**,const sqlite3_api_routines*); 6997 extern int sqlite3_carray_init(sqlite3*,char**,const sqlite3_api_routines*); 6998 extern int sqlite3_closure_init(sqlite3*,char**,const sqlite3_api_routines*); 6999 extern int sqlite3_csv_init(sqlite3*,char**,const sqlite3_api_routines*); 7000 extern int sqlite3_eval_init(sqlite3*,char**,const sqlite3_api_routines*); 7001 extern int sqlite3_fileio_init(sqlite3*,char**,const sqlite3_api_routines*); 7002 extern int sqlite3_fuzzer_init(sqlite3*,char**,const sqlite3_api_routines*); 7003 extern int sqlite3_ieee_init(sqlite3*,char**,const sqlite3_api_routines*); 7004 extern int sqlite3_nextchar_init(sqlite3*,char**,const sqlite3_api_routines*); 7005 extern int sqlite3_percentile_init(sqlite3*,char**,const sqlite3_api_routines*); 7006 extern int sqlite3_regexp_init(sqlite3*,char**,const sqlite3_api_routines*); 7007 extern int sqlite3_remember_init(sqlite3*,char**,const sqlite3_api_routines*); 7008 extern int sqlite3_series_init(sqlite3*,char**,const sqlite3_api_routines*); 7009 extern int sqlite3_spellfix_init(sqlite3*,char**,const sqlite3_api_routines*); 7010 extern int sqlite3_totype_init(sqlite3*,char**,const sqlite3_api_routines*); 7011 extern int sqlite3_wholenumber_init(sqlite3*,char**,const sqlite3_api_routines*); 7012 extern int sqlite3_unionvtab_init(sqlite3*,char**,const sqlite3_api_routines*); 7013 #ifdef SQLITE_HAVE_ZLIB 7014 extern int sqlite3_zipfile_init(sqlite3*,char**,const sqlite3_api_routines*); 7015 #endif 7016 static const struct { 7017 const char *zExtName; 7018 int (*pInit)(sqlite3*,char**,const sqlite3_api_routines*); 7019 } aExtension[] = { 7020 { "amatch", sqlite3_amatch_init }, 7021 { "carray", sqlite3_carray_init }, 7022 { "closure", sqlite3_closure_init }, 7023 { "csv", sqlite3_csv_init }, 7024 { "eval", sqlite3_eval_init }, 7025 { "fileio", sqlite3_fileio_init }, 7026 { "fuzzer", sqlite3_fuzzer_init }, 7027 { "ieee754", sqlite3_ieee_init }, 7028 { "nextchar", sqlite3_nextchar_init }, 7029 { "percentile", sqlite3_percentile_init }, 7030 { "regexp", sqlite3_regexp_init }, 7031 { "remember", sqlite3_remember_init }, 7032 { "series", sqlite3_series_init }, 7033 { "spellfix", sqlite3_spellfix_init }, 7034 { "totype", sqlite3_totype_init }, 7035 { "unionvtab", sqlite3_unionvtab_init }, 7036 { "wholenumber", sqlite3_wholenumber_init }, 7037 #ifdef SQLITE_HAVE_ZLIB 7038 { "zipfile", sqlite3_zipfile_init }, 7039 #endif 7040 }; 7041 sqlite3 *db; 7042 const char *zName; 7043 int i, j, rc; 7044 char *zErrMsg = 0; 7045 if( objc<3 ){ 7046 Tcl_WrongNumArgs(interp, 1, objv, "DB NAME ..."); 7047 return TCL_ERROR; 7048 } 7049 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 7050 for(j=2; j<objc; j++){ 7051 zName = Tcl_GetString(objv[j]); 7052 for(i=0; i<ArraySize(aExtension); i++){ 7053 if( strcmp(zName, aExtension[i].zExtName)==0 ) break; 7054 } 7055 if( i>=ArraySize(aExtension) ){ 7056 Tcl_AppendResult(interp, "no such extension: ", zName, (char*)0); 7057 return TCL_ERROR; 7058 } 7059 if( aExtension[i].pInit ){ 7060 rc = aExtension[i].pInit(db, &zErrMsg, 0); 7061 }else{ 7062 rc = SQLITE_OK; 7063 } 7064 if( rc!=SQLITE_OK || zErrMsg ){ 7065 Tcl_AppendResult(interp, "initialization of ", zName, " failed: ", zErrMsg, 7066 (char*)0); 7067 sqlite3_free(zErrMsg); 7068 return TCL_ERROR; 7069 } 7070 } 7071 return TCL_OK; 7072 } 7073 7074 /* 7075 ** sorter_test_fakeheap BOOL 7076 ** 7077 */ 7078 static int SQLITE_TCLAPI sorter_test_fakeheap( 7079 void * clientData, 7080 Tcl_Interp *interp, 7081 int objc, 7082 Tcl_Obj *CONST objv[] 7083 ){ 7084 int bArg; 7085 if( objc!=2 ){ 7086 Tcl_WrongNumArgs(interp, 1, objv, "BOOL"); 7087 return TCL_ERROR; 7088 } 7089 7090 if( Tcl_GetBooleanFromObj(interp, objv[1], &bArg) ){ 7091 return TCL_ERROR; 7092 } 7093 7094 if( bArg ){ 7095 if( sqlite3GlobalConfig.pHeap==0 ){ 7096 sqlite3GlobalConfig.pHeap = SQLITE_INT_TO_PTR(-1); 7097 } 7098 }else{ 7099 if( sqlite3GlobalConfig.pHeap==SQLITE_INT_TO_PTR(-1) ){ 7100 sqlite3GlobalConfig.pHeap = 0; 7101 } 7102 } 7103 7104 Tcl_ResetResult(interp); 7105 return TCL_OK; 7106 } 7107 7108 /* 7109 ** sorter_test_sort4_helper DB SQL1 NSTEP SQL2 7110 ** 7111 ** Compile SQL statement $SQL1 and step it $NSTEP times. For each row, 7112 ** check that the leftmost and rightmost columns returned are both integers, 7113 ** and that both contain the same value. 7114 ** 7115 ** Then execute statement $SQL2. Check that the statement returns the same 7116 ** set of integers in the same order as in the previous step (using $SQL1). 7117 */ 7118 static int SQLITE_TCLAPI sorter_test_sort4_helper( 7119 void * clientData, 7120 Tcl_Interp *interp, 7121 int objc, 7122 Tcl_Obj *CONST objv[] 7123 ){ 7124 const char *zSql1; 7125 const char *zSql2; 7126 int nStep; 7127 int iStep; 7128 unsigned int iCksum1 = 0; 7129 unsigned int iCksum2 = 0; 7130 int rc; 7131 int iB; 7132 sqlite3 *db; 7133 sqlite3_stmt *pStmt; 7134 7135 if( objc!=5 ){ 7136 Tcl_WrongNumArgs(interp, 1, objv, "DB SQL1 NSTEP SQL2"); 7137 return TCL_ERROR; 7138 } 7139 7140 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 7141 zSql1 = Tcl_GetString(objv[2]); 7142 if( Tcl_GetIntFromObj(interp, objv[3], &nStep) ) return TCL_ERROR; 7143 zSql2 = Tcl_GetString(objv[4]); 7144 7145 rc = sqlite3_prepare_v2(db, zSql1, -1, &pStmt, 0); 7146 if( rc!=SQLITE_OK ) goto sql_error; 7147 7148 iB = sqlite3_column_count(pStmt)-1; 7149 for(iStep=0; iStep<nStep && SQLITE_ROW==sqlite3_step(pStmt); iStep++){ 7150 int a = sqlite3_column_int(pStmt, 0); 7151 if( a!=sqlite3_column_int(pStmt, iB) ){ 7152 Tcl_AppendResult(interp, "data error: (a!=b)", 0); 7153 return TCL_ERROR; 7154 } 7155 7156 iCksum1 += (iCksum1 << 3) + (unsigned int)a; 7157 } 7158 rc = sqlite3_finalize(pStmt); 7159 if( rc!=SQLITE_OK ) goto sql_error; 7160 7161 rc = sqlite3_prepare_v2(db, zSql2, -1, &pStmt, 0); 7162 if( rc!=SQLITE_OK ) goto sql_error; 7163 for(iStep=0; SQLITE_ROW==sqlite3_step(pStmt); iStep++){ 7164 int a = sqlite3_column_int(pStmt, 0); 7165 iCksum2 += (iCksum2 << 3) + (unsigned int)a; 7166 } 7167 rc = sqlite3_finalize(pStmt); 7168 if( rc!=SQLITE_OK ) goto sql_error; 7169 7170 if( iCksum1!=iCksum2 ){ 7171 Tcl_AppendResult(interp, "checksum mismatch", 0); 7172 return TCL_ERROR; 7173 } 7174 7175 return TCL_OK; 7176 sql_error: 7177 Tcl_AppendResult(interp, "sql error: ", sqlite3_errmsg(db), 0); 7178 return TCL_ERROR; 7179 } 7180 7181 7182 #ifdef SQLITE_USER_AUTHENTICATION 7183 #include "sqlite3userauth.h" 7184 /* 7185 ** tclcmd: sqlite3_user_authenticate DB USERNAME PASSWORD 7186 */ 7187 static int SQLITE_TCLAPI test_user_authenticate( 7188 ClientData clientData, /* Unused */ 7189 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 7190 int objc, /* Number of arguments */ 7191 Tcl_Obj *CONST objv[] /* Command arguments */ 7192 ){ 7193 char *zUser = 0; 7194 char *zPasswd = 0; 7195 int nPasswd = 0; 7196 sqlite3 *db; 7197 int rc; 7198 7199 if( objc!=4 ){ 7200 Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME PASSWORD"); 7201 return TCL_ERROR; 7202 } 7203 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 7204 return TCL_ERROR; 7205 } 7206 zUser = Tcl_GetString(objv[2]); 7207 zPasswd = Tcl_GetStringFromObj(objv[3], &nPasswd); 7208 rc = sqlite3_user_authenticate(db, zUser, zPasswd, nPasswd); 7209 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 7210 return TCL_OK; 7211 } 7212 #endif /* SQLITE_USER_AUTHENTICATION */ 7213 7214 #ifdef SQLITE_USER_AUTHENTICATION 7215 /* 7216 ** tclcmd: sqlite3_user_add DB USERNAME PASSWORD ISADMIN 7217 */ 7218 static int SQLITE_TCLAPI test_user_add( 7219 ClientData clientData, /* Unused */ 7220 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 7221 int objc, /* Number of arguments */ 7222 Tcl_Obj *CONST objv[] /* Command arguments */ 7223 ){ 7224 char *zUser = 0; 7225 char *zPasswd = 0; 7226 int nPasswd = 0; 7227 int isAdmin = 0; 7228 sqlite3 *db; 7229 int rc; 7230 7231 if( objc!=5 ){ 7232 Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME PASSWORD ISADMIN"); 7233 return TCL_ERROR; 7234 } 7235 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 7236 return TCL_ERROR; 7237 } 7238 zUser = Tcl_GetString(objv[2]); 7239 zPasswd = Tcl_GetStringFromObj(objv[3], &nPasswd); 7240 Tcl_GetBooleanFromObj(interp, objv[4], &isAdmin); 7241 rc = sqlite3_user_add(db, zUser, zPasswd, nPasswd, isAdmin); 7242 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 7243 return TCL_OK; 7244 } 7245 #endif /* SQLITE_USER_AUTHENTICATION */ 7246 7247 #ifdef SQLITE_USER_AUTHENTICATION 7248 /* 7249 ** tclcmd: sqlite3_user_change DB USERNAME PASSWORD ISADMIN 7250 */ 7251 static int SQLITE_TCLAPI test_user_change( 7252 ClientData clientData, /* Unused */ 7253 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 7254 int objc, /* Number of arguments */ 7255 Tcl_Obj *CONST objv[] /* Command arguments */ 7256 ){ 7257 char *zUser = 0; 7258 char *zPasswd = 0; 7259 int nPasswd = 0; 7260 int isAdmin = 0; 7261 sqlite3 *db; 7262 int rc; 7263 7264 if( objc!=5 ){ 7265 Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME PASSWORD ISADMIN"); 7266 return TCL_ERROR; 7267 } 7268 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 7269 return TCL_ERROR; 7270 } 7271 zUser = Tcl_GetString(objv[2]); 7272 zPasswd = Tcl_GetStringFromObj(objv[3], &nPasswd); 7273 Tcl_GetBooleanFromObj(interp, objv[4], &isAdmin); 7274 rc = sqlite3_user_change(db, zUser, zPasswd, nPasswd, isAdmin); 7275 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 7276 return TCL_OK; 7277 } 7278 #endif /* SQLITE_USER_AUTHENTICATION */ 7279 7280 #ifdef SQLITE_USER_AUTHENTICATION 7281 /* 7282 ** tclcmd: sqlite3_user_delete DB USERNAME 7283 */ 7284 static int SQLITE_TCLAPI test_user_delete( 7285 ClientData clientData, /* Unused */ 7286 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 7287 int objc, /* Number of arguments */ 7288 Tcl_Obj *CONST objv[] /* Command arguments */ 7289 ){ 7290 char *zUser = 0; 7291 sqlite3 *db; 7292 int rc; 7293 7294 if( objc!=3 ){ 7295 Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME"); 7296 return TCL_ERROR; 7297 } 7298 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){ 7299 return TCL_ERROR; 7300 } 7301 zUser = Tcl_GetString(objv[2]); 7302 rc = sqlite3_user_delete(db, zUser); 7303 Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); 7304 return TCL_OK; 7305 } 7306 #endif /* SQLITE_USER_AUTHENTICATION */ 7307 7308 /* 7309 ** tclcmd: bad_behavior TYPE 7310 ** 7311 ** Do some things that should trigger a valgrind or -fsanitize=undefined 7312 ** warning. This is used to verify that errors and warnings output by those 7313 ** tools are detected by the test scripts. 7314 ** 7315 ** TYPE BEHAVIOR 7316 ** 1 Overflow a signed integer 7317 ** 2 Jump based on an uninitialized variable 7318 ** 3 Read after free 7319 ** 4 Panic 7320 */ 7321 static int SQLITE_TCLAPI test_bad_behavior( 7322 ClientData clientData, /* Pointer to an integer containing zero */ 7323 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 7324 int objc, /* Number of arguments */ 7325 Tcl_Obj *CONST objv[] /* Command arguments */ 7326 ){ 7327 int iType; 7328 int xyz; 7329 int i = *(int*)clientData; 7330 int j; 7331 int w[10]; 7332 int *a; 7333 if( objc!=2 ){ 7334 Tcl_WrongNumArgs(interp, 1, objv, "TYPE"); 7335 return TCL_ERROR; 7336 } 7337 if( Tcl_GetIntFromObj(interp, objv[1], &iType) ) return TCL_ERROR; 7338 switch( iType ){ 7339 case 1: { 7340 xyz = 0x7fffff00 - i; 7341 xyz += 0x100; 7342 Tcl_SetObjResult(interp, Tcl_NewIntObj(xyz)); 7343 break; 7344 } 7345 case 2: { 7346 w[1] = 5; 7347 if( w[i]>0 ) w[1]++; 7348 Tcl_SetObjResult(interp, Tcl_NewIntObj(w[1])); 7349 break; 7350 } 7351 case 3: { 7352 a = malloc( sizeof(int)*10 ); 7353 for(j=0; j<10; j++) a[j] = j; 7354 free(a); 7355 Tcl_SetObjResult(interp, Tcl_NewIntObj(a[i])); 7356 break; 7357 } 7358 case 4: { 7359 Tcl_Panic("Deliberate panic"); 7360 break; 7361 } 7362 } 7363 return TCL_OK; 7364 } 7365 7366 /* 7367 ** tclcmd: register_dbstat_vtab DB 7368 ** 7369 ** Cause the dbstat virtual table to be available on the connection DB 7370 */ 7371 static int SQLITE_TCLAPI test_register_dbstat_vtab( 7372 void *clientData, 7373 Tcl_Interp *interp, 7374 int objc, 7375 Tcl_Obj *CONST objv[] 7376 ){ 7377 #ifdef SQLITE_OMIT_VIRTUALTABLE 7378 Tcl_AppendResult(interp, "dbstat not available because of " 7379 "SQLITE_OMIT_VIRTUALTABLE", (void*)0); 7380 return TCL_ERROR; 7381 #else 7382 struct SqliteDb { sqlite3 *db; }; 7383 char *zDb; 7384 Tcl_CmdInfo cmdInfo; 7385 7386 if( objc!=2 ){ 7387 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 7388 return TCL_ERROR; 7389 } 7390 7391 zDb = Tcl_GetString(objv[1]); 7392 if( Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){ 7393 sqlite3* db = ((struct SqliteDb*)cmdInfo.objClientData)->db; 7394 sqlite3DbstatRegister(db); 7395 } 7396 return TCL_OK; 7397 #endif /* SQLITE_OMIT_VIRTUALTABLE */ 7398 } 7399 7400 /* 7401 ** tclcmd: sqlite3_db_config DB SETTING VALUE 7402 ** 7403 ** Invoke sqlite3_db_config() for one of the setting values. 7404 */ 7405 static int SQLITE_TCLAPI test_sqlite3_db_config( 7406 void *clientData, 7407 Tcl_Interp *interp, 7408 int objc, 7409 Tcl_Obj *CONST objv[] 7410 ){ 7411 static const struct { 7412 const char *zName; 7413 int eVal; 7414 } aSetting[] = { 7415 { "FKEY", SQLITE_DBCONFIG_ENABLE_FKEY }, 7416 { "TRIGGER", SQLITE_DBCONFIG_ENABLE_TRIGGER }, 7417 { "FTS3_TOKENIZER", SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER }, 7418 { "LOAD_EXTENSION", SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION }, 7419 { "NO_CKPT_ON_CLOSE",SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE }, 7420 { "QPSG", SQLITE_DBCONFIG_ENABLE_QPSG }, 7421 }; 7422 int i; 7423 int v; 7424 const char *zSetting; 7425 sqlite3 *db; 7426 7427 if( objc!=4 ){ 7428 Tcl_WrongNumArgs(interp, 1, objv, "DB SETTING VALUE"); 7429 return TCL_ERROR; 7430 } 7431 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 7432 zSetting = Tcl_GetString(objv[2]); 7433 if( sqlite3_strglob("SQLITE_*", zSetting)==0 ) zSetting += 7; 7434 if( sqlite3_strglob("DBCONFIG_*", zSetting)==0 ) zSetting += 9; 7435 if( sqlite3_strglob("ENABLE_*", zSetting)==0 ) zSetting += 7; 7436 for(i=0; i<ArraySize(aSetting); i++){ 7437 if( strcmp(zSetting, aSetting[i].zName)==0 ) break; 7438 } 7439 if( i>=ArraySize(aSetting) ){ 7440 Tcl_SetObjResult(interp, 7441 Tcl_NewStringObj("unknown sqlite3_db_config setting", -1)); 7442 return TCL_ERROR; 7443 } 7444 if( Tcl_GetIntFromObj(interp, objv[3], &v) ) return TCL_ERROR; 7445 sqlite3_db_config(db, aSetting[i].eVal, v, &v); 7446 Tcl_SetObjResult(interp, Tcl_NewIntObj(v)); 7447 return TCL_OK; 7448 } 7449 7450 /* 7451 ** Change the name of the main database schema from "main" to "icecube". 7452 */ 7453 static int SQLITE_TCLAPI test_dbconfig_maindbname_icecube( 7454 void * clientData, 7455 Tcl_Interp *interp, 7456 int objc, 7457 Tcl_Obj *CONST objv[] 7458 ){ 7459 int rc; 7460 sqlite3 *db; 7461 extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**); 7462 if( objc!=2 ){ 7463 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 7464 return TCL_ERROR; 7465 }else{ 7466 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 7467 rc = sqlite3_db_config(db, SQLITE_DBCONFIG_MAINDBNAME, "icecube"); 7468 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 7469 return TCL_OK; 7470 } 7471 } 7472 7473 /* 7474 ** Usage: sqlite3_mmap_warm DB DBNAME 7475 */ 7476 static int SQLITE_TCLAPI test_mmap_warm( 7477 void * clientData, 7478 Tcl_Interp *interp, 7479 int objc, 7480 Tcl_Obj *CONST objv[] 7481 ){ 7482 extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**); 7483 extern int sqlite3_mmap_warm(sqlite3 *db, const char *); 7484 7485 if( objc!=2 && objc!=3 ){ 7486 Tcl_WrongNumArgs(interp, 1, objv, "DB ?DBNAME?"); 7487 return TCL_ERROR; 7488 }else{ 7489 int rc; 7490 sqlite3 *db; 7491 const char *zDb = 0; 7492 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 7493 if( objc==3 ){ 7494 zDb = Tcl_GetString(objv[2]); 7495 } 7496 rc = sqlite3_mmap_warm(db, zDb); 7497 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); 7498 return TCL_OK; 7499 } 7500 } 7501 7502 /* 7503 ** Register commands with the TCL interpreter. 7504 */ 7505 int Sqlitetest1_Init(Tcl_Interp *interp){ 7506 extern int sqlite3_search_count; 7507 extern int sqlite3_found_count; 7508 extern int sqlite3_interrupt_count; 7509 extern int sqlite3_open_file_count; 7510 extern int sqlite3_sort_count; 7511 extern int sqlite3_current_time; 7512 #if SQLITE_OS_UNIX && defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE 7513 extern int sqlite3_hostid_num; 7514 #endif 7515 extern int sqlite3_max_blobsize; 7516 extern int SQLITE_TCLAPI sqlite3BtreeSharedCacheReport(void*, 7517 Tcl_Interp*,int,Tcl_Obj*CONST*); 7518 static int iZero = 0; 7519 static struct { 7520 char *zName; 7521 Tcl_CmdProc *xProc; 7522 } aCmd[] = { 7523 { "db_enter", (Tcl_CmdProc*)db_enter }, 7524 { "db_leave", (Tcl_CmdProc*)db_leave }, 7525 { "sqlite3_mprintf_int", (Tcl_CmdProc*)sqlite3_mprintf_int }, 7526 { "sqlite3_mprintf_int64", (Tcl_CmdProc*)sqlite3_mprintf_int64 }, 7527 { "sqlite3_mprintf_long", (Tcl_CmdProc*)sqlite3_mprintf_long }, 7528 { "sqlite3_mprintf_str", (Tcl_CmdProc*)sqlite3_mprintf_str }, 7529 { "sqlite3_snprintf_str", (Tcl_CmdProc*)sqlite3_snprintf_str }, 7530 { "sqlite3_mprintf_stronly", (Tcl_CmdProc*)sqlite3_mprintf_stronly}, 7531 { "sqlite3_mprintf_double", (Tcl_CmdProc*)sqlite3_mprintf_double }, 7532 { "sqlite3_mprintf_scaled", (Tcl_CmdProc*)sqlite3_mprintf_scaled }, 7533 { "sqlite3_mprintf_hexdouble", (Tcl_CmdProc*)sqlite3_mprintf_hexdouble}, 7534 { "sqlite3_mprintf_z_test", (Tcl_CmdProc*)test_mprintf_z }, 7535 { "sqlite3_mprintf_n_test", (Tcl_CmdProc*)test_mprintf_n }, 7536 { "sqlite3_snprintf_int", (Tcl_CmdProc*)test_snprintf_int }, 7537 { "sqlite3_last_insert_rowid", (Tcl_CmdProc*)test_last_rowid }, 7538 { "sqlite3_exec_printf", (Tcl_CmdProc*)test_exec_printf }, 7539 { "sqlite3_exec_hex", (Tcl_CmdProc*)test_exec_hex }, 7540 { "sqlite3_exec", (Tcl_CmdProc*)test_exec }, 7541 { "sqlite3_exec_nr", (Tcl_CmdProc*)test_exec_nr }, 7542 #ifndef SQLITE_OMIT_GET_TABLE 7543 { "sqlite3_get_table_printf", (Tcl_CmdProc*)test_get_table_printf }, 7544 #endif 7545 { "sqlite3_close", (Tcl_CmdProc*)sqlite_test_close }, 7546 { "sqlite3_close_v2", (Tcl_CmdProc*)sqlite_test_close_v2 }, 7547 { "sqlite3_create_function", (Tcl_CmdProc*)test_create_function }, 7548 { "sqlite3_create_aggregate", (Tcl_CmdProc*)test_create_aggregate }, 7549 { "sqlite_register_test_function", (Tcl_CmdProc*)test_register_func }, 7550 { "sqlite_abort", (Tcl_CmdProc*)sqlite_abort }, 7551 { "sqlite_bind", (Tcl_CmdProc*)test_bind }, 7552 { "breakpoint", (Tcl_CmdProc*)test_breakpoint }, 7553 { "sqlite3_key", (Tcl_CmdProc*)test_key }, 7554 { "sqlite3_rekey", (Tcl_CmdProc*)test_rekey }, 7555 { "sqlite_set_magic", (Tcl_CmdProc*)sqlite_set_magic }, 7556 { "sqlite3_interrupt", (Tcl_CmdProc*)test_interrupt }, 7557 { "sqlite_delete_function", (Tcl_CmdProc*)delete_function }, 7558 { "sqlite_delete_collation", (Tcl_CmdProc*)delete_collation }, 7559 { "sqlite3_get_autocommit", (Tcl_CmdProc*)get_autocommit }, 7560 { "sqlite3_busy_timeout", (Tcl_CmdProc*)test_busy_timeout }, 7561 { "printf", (Tcl_CmdProc*)test_printf }, 7562 { "sqlite3IoTrace", (Tcl_CmdProc*)test_io_trace }, 7563 { "clang_sanitize_address", (Tcl_CmdProc*)clang_sanitize_address }, 7564 }; 7565 static struct { 7566 char *zName; 7567 Tcl_ObjCmdProc *xProc; 7568 void *clientData; 7569 } aObjCmd[] = { 7570 { "sqlite3_db_config", test_sqlite3_db_config, 0 }, 7571 { "bad_behavior", test_bad_behavior, (void*)&iZero }, 7572 { "register_dbstat_vtab", test_register_dbstat_vtab }, 7573 { "sqlite3_connection_pointer", get_sqlite_pointer, 0 }, 7574 { "intarray_addr", test_intarray_addr, 0 }, 7575 { "int64array_addr", test_int64array_addr, 0 }, 7576 { "doublearray_addr", test_doublearray_addr, 0 }, 7577 { "textarray_addr", test_textarray_addr, 0 }, 7578 { "sqlite3_bind_int", test_bind_int, 0 }, 7579 { "sqlite3_bind_zeroblob", test_bind_zeroblob, 0 }, 7580 { "sqlite3_bind_zeroblob64", test_bind_zeroblob64, 0 }, 7581 { "sqlite3_bind_int64", test_bind_int64, 0 }, 7582 { "sqlite3_bind_double", test_bind_double, 0 }, 7583 { "sqlite3_bind_null", test_bind_null ,0 }, 7584 { "sqlite3_bind_text", test_bind_text ,0 }, 7585 { "sqlite3_bind_text16", test_bind_text16 ,0 }, 7586 { "sqlite3_bind_blob", test_bind_blob ,0 }, 7587 { "sqlite3_bind_parameter_count", test_bind_parameter_count, 0}, 7588 { "sqlite3_bind_parameter_name", test_bind_parameter_name, 0}, 7589 { "sqlite3_bind_parameter_index", test_bind_parameter_index, 0}, 7590 { "sqlite3_clear_bindings", test_clear_bindings, 0}, 7591 { "sqlite3_sleep", test_sleep, 0}, 7592 { "sqlite3_errcode", test_errcode ,0 }, 7593 { "sqlite3_extended_errcode", test_ex_errcode ,0 }, 7594 { "sqlite3_errmsg", test_errmsg ,0 }, 7595 { "sqlite3_errmsg16", test_errmsg16 ,0 }, 7596 { "sqlite3_open", test_open ,0 }, 7597 { "sqlite3_open16", test_open16 ,0 }, 7598 { "sqlite3_open_v2", test_open_v2 ,0 }, 7599 { "sqlite3_complete16", test_complete16 ,0 }, 7600 { "sqlite3_normalize", test_normalize ,0 }, 7601 7602 { "sqlite3_prepare", test_prepare ,0 }, 7603 { "sqlite3_prepare16", test_prepare16 ,0 }, 7604 { "sqlite3_prepare_v2", test_prepare_v2 ,0 }, 7605 { "sqlite3_prepare_tkt3134", test_prepare_tkt3134, 0}, 7606 { "sqlite3_prepare16_v2", test_prepare16_v2 ,0 }, 7607 { "sqlite3_finalize", test_finalize ,0 }, 7608 { "sqlite3_stmt_status", test_stmt_status ,0 }, 7609 { "sqlite3_reset", test_reset ,0 }, 7610 { "sqlite3_expired", test_expired ,0 }, 7611 { "sqlite3_transfer_bindings", test_transfer_bind ,0 }, 7612 { "sqlite3_changes", test_changes ,0 }, 7613 { "sqlite3_step", test_step ,0 }, 7614 { "sqlite3_sql", test_sql ,0 }, 7615 { "sqlite3_expanded_sql", test_ex_sql ,0 }, 7616 { "sqlite3_next_stmt", test_next_stmt ,0 }, 7617 { "sqlite3_stmt_readonly", test_stmt_readonly ,0 }, 7618 { "sqlite3_stmt_busy", test_stmt_busy ,0 }, 7619 { "uses_stmt_journal", uses_stmt_journal ,0 }, 7620 7621 { "sqlite3_release_memory", test_release_memory, 0}, 7622 { "sqlite3_db_release_memory", test_db_release_memory, 0}, 7623 { "sqlite3_db_cacheflush", test_db_cacheflush, 0}, 7624 { "sqlite3_system_errno", test_system_errno, 0}, 7625 { "sqlite3_db_filename", test_db_filename, 0}, 7626 { "sqlite3_db_readonly", test_db_readonly, 0}, 7627 { "sqlite3_soft_heap_limit", test_soft_heap_limit, 0}, 7628 { "sqlite3_thread_cleanup", test_thread_cleanup, 0}, 7629 { "sqlite3_pager_refcounts", test_pager_refcounts, 0}, 7630 7631 { "sqlite3_load_extension", test_load_extension, 0}, 7632 { "sqlite3_enable_load_extension", test_enable_load, 0}, 7633 { "sqlite3_extended_result_codes", test_extended_result_codes, 0}, 7634 { "sqlite3_limit", test_limit, 0}, 7635 { "dbconfig_maindbname_icecube", test_dbconfig_maindbname_icecube }, 7636 7637 { "save_prng_state", save_prng_state, 0 }, 7638 { "restore_prng_state", restore_prng_state, 0 }, 7639 { "reset_prng_state", reset_prng_state, 0 }, 7640 { "database_never_corrupt", database_never_corrupt, 0}, 7641 { "database_may_be_corrupt", database_may_be_corrupt, 0}, 7642 { "optimization_control", optimization_control,0}, 7643 #if SQLITE_OS_WIN 7644 { "lock_win32_file", win32_file_lock, 0 }, 7645 { "exists_win32_path", win32_exists_path, 0 }, 7646 { "find_win32_file", win32_find_file, 0 }, 7647 { "delete_win32_file", win32_delete_file, 0 }, 7648 { "make_win32_dir", win32_mkdir, 0 }, 7649 { "remove_win32_dir", win32_rmdir, 0 }, 7650 #endif 7651 { "tcl_objproc", runAsObjProc, 0 }, 7652 7653 /* sqlite3_column_*() API */ 7654 { "sqlite3_column_count", test_column_count ,0 }, 7655 { "sqlite3_data_count", test_data_count ,0 }, 7656 { "sqlite3_column_type", test_column_type ,0 }, 7657 { "sqlite3_column_blob", test_column_blob ,0 }, 7658 { "sqlite3_column_double", test_column_double ,0 }, 7659 { "sqlite3_column_int64", test_column_int64 ,0 }, 7660 { "sqlite3_column_text", test_stmt_utf8, (void*)sqlite3_column_text }, 7661 { "sqlite3_column_name", test_stmt_utf8, (void*)sqlite3_column_name }, 7662 { "sqlite3_column_int", test_stmt_int, (void*)sqlite3_column_int }, 7663 { "sqlite3_column_bytes", test_stmt_int, (void*)sqlite3_column_bytes}, 7664 #ifndef SQLITE_OMIT_DECLTYPE 7665 { "sqlite3_column_decltype",test_stmt_utf8,(void*)sqlite3_column_decltype}, 7666 #endif 7667 #ifdef SQLITE_ENABLE_COLUMN_METADATA 7668 { "sqlite3_column_database_name",test_stmt_utf8,(void*)sqlite3_column_database_name}, 7669 { "sqlite3_column_table_name",test_stmt_utf8,(void*)sqlite3_column_table_name}, 7670 { "sqlite3_column_origin_name",test_stmt_utf8,(void*)sqlite3_column_origin_name}, 7671 #endif 7672 7673 #ifndef SQLITE_OMIT_UTF16 7674 { "sqlite3_column_bytes16", test_stmt_int, (void*)sqlite3_column_bytes16 }, 7675 { "sqlite3_column_text16", test_stmt_utf16, (void*)sqlite3_column_text16}, 7676 { "sqlite3_column_name16", test_stmt_utf16, (void*)sqlite3_column_name16}, 7677 { "add_alignment_test_collations", add_alignment_test_collations, 0 }, 7678 #ifndef SQLITE_OMIT_DECLTYPE 7679 { "sqlite3_column_decltype16",test_stmt_utf16,(void*)sqlite3_column_decltype16}, 7680 #endif 7681 #ifdef SQLITE_ENABLE_COLUMN_METADATA 7682 {"sqlite3_column_database_name16", 7683 test_stmt_utf16, (void*)sqlite3_column_database_name16}, 7684 {"sqlite3_column_table_name16", test_stmt_utf16, (void*)sqlite3_column_table_name16}, 7685 {"sqlite3_column_origin_name16", test_stmt_utf16, (void*)sqlite3_column_origin_name16}, 7686 #endif 7687 #endif 7688 { "sqlite3_create_collation_v2", test_create_collation_v2, 0 }, 7689 { "sqlite3_global_recover", test_global_recover, 0 }, 7690 { "working_64bit_int", working_64bit_int, 0 }, 7691 { "vfs_unlink_test", vfs_unlink_test, 0 }, 7692 { "vfs_initfail_test", vfs_initfail_test, 0 }, 7693 { "vfs_unregister_all", vfs_unregister_all, 0 }, 7694 { "vfs_reregister_all", vfs_reregister_all, 0 }, 7695 { "file_control_test", file_control_test, 0 }, 7696 { "file_control_lasterrno_test", file_control_lasterrno_test, 0 }, 7697 { "file_control_lockproxy_test", file_control_lockproxy_test, 0 }, 7698 { "file_control_chunksize_test", file_control_chunksize_test, 0 }, 7699 { "file_control_sizehint_test", file_control_sizehint_test, 0 }, 7700 #if SQLITE_OS_WIN 7701 { "file_control_win32_av_retry", file_control_win32_av_retry, 0 }, 7702 { "file_control_win32_get_handle", file_control_win32_get_handle, 0 }, 7703 { "file_control_win32_set_handle", file_control_win32_set_handle, 0 }, 7704 #endif 7705 { "file_control_persist_wal", file_control_persist_wal, 0 }, 7706 { "file_control_powersafe_overwrite",file_control_powersafe_overwrite,0}, 7707 { "file_control_vfsname", file_control_vfsname, 0 }, 7708 { "file_control_tempfilename", file_control_tempfilename, 0 }, 7709 { "sqlite3_vfs_list", vfs_list, 0 }, 7710 { "sqlite3_create_function_v2", test_create_function_v2, 0 }, 7711 7712 /* Functions from os.h */ 7713 #ifndef SQLITE_OMIT_UTF16 7714 { "add_test_collate", test_collate, 0 }, 7715 { "add_test_collate_needed", test_collate_needed, 0 }, 7716 { "add_test_function", test_function, 0 }, 7717 { "add_test_utf16bin_collate", test_utf16bin_collate, 0 }, 7718 #endif 7719 { "sqlite3_test_errstr", test_errstr, 0 }, 7720 { "tcl_variable_type", tcl_variable_type, 0 }, 7721 #ifndef SQLITE_OMIT_SHARED_CACHE 7722 { "sqlite3_enable_shared_cache", test_enable_shared, 0 }, 7723 { "sqlite3_shared_cache_report", sqlite3BtreeSharedCacheReport, 0}, 7724 #endif 7725 { "sqlite3_libversion_number", test_libversion_number, 0 }, 7726 { "sqlite3_table_column_metadata", test_table_column_metadata, 0 }, 7727 #ifndef SQLITE_OMIT_INCRBLOB 7728 { "sqlite3_blob_reopen", test_blob_reopen, 0 }, 7729 #endif 7730 { "pcache_stats", test_pcache_stats, 0 }, 7731 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY 7732 { "sqlite3_unlock_notify", test_unlock_notify, 0 }, 7733 #endif 7734 { "sqlite3_wal_checkpoint", test_wal_checkpoint, 0 }, 7735 { "sqlite3_wal_checkpoint_v2",test_wal_checkpoint_v2, 0 }, 7736 { "sqlite3_wal_autocheckpoint",test_wal_autocheckpoint, 0 }, 7737 { "test_sqlite3_log", test_sqlite3_log, 0 }, 7738 #ifndef SQLITE_OMIT_EXPLAIN 7739 { "print_explain_query_plan", test_print_eqp, 0 }, 7740 #endif 7741 { "sqlite3_test_control", test_test_control }, 7742 #if SQLITE_OS_UNIX 7743 { "getrusage", test_getrusage }, 7744 #endif 7745 { "load_static_extension", tclLoadStaticExtensionCmd }, 7746 { "sorter_test_fakeheap", sorter_test_fakeheap }, 7747 { "sorter_test_sort4_helper", sorter_test_sort4_helper }, 7748 #ifdef SQLITE_USER_AUTHENTICATION 7749 { "sqlite3_user_authenticate", test_user_authenticate, 0 }, 7750 { "sqlite3_user_add", test_user_add, 0 }, 7751 { "sqlite3_user_change", test_user_change, 0 }, 7752 { "sqlite3_user_delete", test_user_delete, 0 }, 7753 #endif 7754 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS 7755 { "sqlite3_stmt_scanstatus", test_stmt_scanstatus, 0 }, 7756 { "sqlite3_stmt_scanstatus_reset", test_stmt_scanstatus_reset, 0 }, 7757 #endif 7758 #ifdef SQLITE_ENABLE_SQLLOG 7759 { "sqlite3_config_sqllog", test_config_sqllog, 0 }, 7760 #endif 7761 { "vfs_current_time_int64", vfsCurrentTimeInt64, 0 }, 7762 #ifdef SQLITE_ENABLE_SNAPSHOT 7763 { "sqlite3_snapshot_get", test_snapshot_get, 0 }, 7764 { "sqlite3_snapshot_open", test_snapshot_open, 0 }, 7765 { "sqlite3_snapshot_free", test_snapshot_free, 0 }, 7766 { "sqlite3_snapshot_cmp", test_snapshot_cmp, 0 }, 7767 { "sqlite3_snapshot_recover", test_snapshot_recover, 0 }, 7768 { "sqlite3_snapshot_get_blob", test_snapshot_get_blob, 0 }, 7769 { "sqlite3_snapshot_open_blob", test_snapshot_open_blob, 0 }, 7770 { "sqlite3_snapshot_cmp_blob", test_snapshot_cmp_blob, 0 }, 7771 #endif 7772 { "sqlite3_delete_database", test_delete_database, 0 }, 7773 { "atomic_batch_write", test_atomic_batch_write, 0 }, 7774 { "sqlite3_mmap_warm", test_mmap_warm, 0 }, 7775 { "sqlite3_config_sorterref", test_config_sorterref, 0 }, 7776 }; 7777 static int bitmask_size = sizeof(Bitmask)*8; 7778 static int longdouble_size = sizeof(LONGDOUBLE_TYPE); 7779 int i; 7780 extern int sqlite3_sync_count, sqlite3_fullsync_count; 7781 extern int sqlite3_opentemp_count; 7782 extern int sqlite3_like_count; 7783 extern int sqlite3_xferopt_count; 7784 extern int sqlite3_pager_readdb_count; 7785 extern int sqlite3_pager_writedb_count; 7786 extern int sqlite3_pager_writej_count; 7787 #if SQLITE_OS_WIN 7788 extern LONG volatile sqlite3_os_type; 7789 #endif 7790 #ifdef SQLITE_DEBUG 7791 extern int sqlite3WhereTrace; 7792 extern int sqlite3OSTrace; 7793 extern int sqlite3WalTrace; 7794 #endif 7795 #ifdef SQLITE_TEST 7796 #ifdef SQLITE_ENABLE_FTS3 7797 extern int sqlite3_fts3_enable_parentheses; 7798 #endif 7799 #endif 7800 7801 for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){ 7802 Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0); 7803 } 7804 for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ 7805 Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 7806 aObjCmd[i].xProc, aObjCmd[i].clientData, 0); 7807 } 7808 Tcl_LinkVar(interp, "sqlite_search_count", 7809 (char*)&sqlite3_search_count, TCL_LINK_INT); 7810 Tcl_LinkVar(interp, "sqlite_found_count", 7811 (char*)&sqlite3_found_count, TCL_LINK_INT); 7812 Tcl_LinkVar(interp, "sqlite_sort_count", 7813 (char*)&sqlite3_sort_count, TCL_LINK_INT); 7814 Tcl_LinkVar(interp, "sqlite3_max_blobsize", 7815 (char*)&sqlite3_max_blobsize, TCL_LINK_INT); 7816 Tcl_LinkVar(interp, "sqlite_like_count", 7817 (char*)&sqlite3_like_count, TCL_LINK_INT); 7818 Tcl_LinkVar(interp, "sqlite_interrupt_count", 7819 (char*)&sqlite3_interrupt_count, TCL_LINK_INT); 7820 Tcl_LinkVar(interp, "sqlite_open_file_count", 7821 (char*)&sqlite3_open_file_count, TCL_LINK_INT); 7822 Tcl_LinkVar(interp, "sqlite_current_time", 7823 (char*)&sqlite3_current_time, TCL_LINK_INT); 7824 #if SQLITE_OS_UNIX && defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE 7825 Tcl_LinkVar(interp, "sqlite_hostid_num", 7826 (char*)&sqlite3_hostid_num, TCL_LINK_INT); 7827 #endif 7828 Tcl_LinkVar(interp, "sqlite3_xferopt_count", 7829 (char*)&sqlite3_xferopt_count, TCL_LINK_INT); 7830 Tcl_LinkVar(interp, "sqlite3_pager_readdb_count", 7831 (char*)&sqlite3_pager_readdb_count, TCL_LINK_INT); 7832 Tcl_LinkVar(interp, "sqlite3_pager_writedb_count", 7833 (char*)&sqlite3_pager_writedb_count, TCL_LINK_INT); 7834 Tcl_LinkVar(interp, "sqlite3_pager_writej_count", 7835 (char*)&sqlite3_pager_writej_count, TCL_LINK_INT); 7836 #ifndef SQLITE_OMIT_UTF16 7837 Tcl_LinkVar(interp, "unaligned_string_counter", 7838 (char*)&unaligned_string_counter, TCL_LINK_INT); 7839 #endif 7840 #ifndef SQLITE_OMIT_UTF16 7841 Tcl_LinkVar(interp, "sqlite_last_needed_collation", 7842 (char*)&pzNeededCollation, TCL_LINK_STRING|TCL_LINK_READ_ONLY); 7843 #endif 7844 #if SQLITE_OS_WIN 7845 Tcl_LinkVar(interp, "sqlite_os_type", 7846 (char*)&sqlite3_os_type, TCL_LINK_LONG); 7847 #endif 7848 #ifdef SQLITE_TEST 7849 { 7850 static const char *query_plan = "*** OBSOLETE VARIABLE ***"; 7851 Tcl_LinkVar(interp, "sqlite_query_plan", 7852 (char*)&query_plan, TCL_LINK_STRING|TCL_LINK_READ_ONLY); 7853 } 7854 #endif 7855 #ifdef SQLITE_DEBUG 7856 Tcl_LinkVar(interp, "sqlite_where_trace", 7857 (char*)&sqlite3WhereTrace, TCL_LINK_INT); 7858 Tcl_LinkVar(interp, "sqlite_os_trace", 7859 (char*)&sqlite3OSTrace, TCL_LINK_INT); 7860 #ifndef SQLITE_OMIT_WAL 7861 Tcl_LinkVar(interp, "sqlite_wal_trace", 7862 (char*)&sqlite3WalTrace, TCL_LINK_INT); 7863 #endif 7864 #endif 7865 #ifndef SQLITE_OMIT_DISKIO 7866 Tcl_LinkVar(interp, "sqlite_opentemp_count", 7867 (char*)&sqlite3_opentemp_count, TCL_LINK_INT); 7868 #endif 7869 Tcl_LinkVar(interp, "sqlite_static_bind_value", 7870 (char*)&sqlite_static_bind_value, TCL_LINK_STRING); 7871 Tcl_LinkVar(interp, "sqlite_static_bind_nbyte", 7872 (char*)&sqlite_static_bind_nbyte, TCL_LINK_INT); 7873 Tcl_LinkVar(interp, "sqlite_temp_directory", 7874 (char*)&sqlite3_temp_directory, TCL_LINK_STRING); 7875 Tcl_LinkVar(interp, "sqlite_data_directory", 7876 (char*)&sqlite3_data_directory, TCL_LINK_STRING); 7877 Tcl_LinkVar(interp, "bitmask_size", 7878 (char*)&bitmask_size, TCL_LINK_INT|TCL_LINK_READ_ONLY); 7879 Tcl_LinkVar(interp, "longdouble_size", 7880 (char*)&longdouble_size, TCL_LINK_INT|TCL_LINK_READ_ONLY); 7881 Tcl_LinkVar(interp, "sqlite_sync_count", 7882 (char*)&sqlite3_sync_count, TCL_LINK_INT); 7883 Tcl_LinkVar(interp, "sqlite_fullsync_count", 7884 (char*)&sqlite3_fullsync_count, TCL_LINK_INT); 7885 #if defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_TEST) 7886 Tcl_LinkVar(interp, "sqlite_fts3_enable_parentheses", 7887 (char*)&sqlite3_fts3_enable_parentheses, TCL_LINK_INT); 7888 #endif 7889 return TCL_OK; 7890 } 7891