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