Annotation of embedaddon/sqlite3/src/test1.c, revision 1.1
1.1 ! misho 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: #include "vdbeInt.h"
! 18: #include "tcl.h"
! 19: #include <stdlib.h>
! 20: #include <string.h>
! 21:
! 22: /*
! 23: ** This is a copy of the first part of the SqliteDb structure in
! 24: ** tclsqlite.c. We need it here so that the get_sqlite_pointer routine
! 25: ** can extract the sqlite3* pointer from an existing Tcl SQLite
! 26: ** connection.
! 27: */
! 28: struct SqliteDb {
! 29: sqlite3 *db;
! 30: };
! 31:
! 32: /*
! 33: ** Convert text generated by the "%p" conversion format back into
! 34: ** a pointer.
! 35: */
! 36: static int testHexToInt(int h){
! 37: if( h>='0' && h<='9' ){
! 38: return h - '0';
! 39: }else if( h>='a' && h<='f' ){
! 40: return h - 'a' + 10;
! 41: }else{
! 42: assert( h>='A' && h<='F' );
! 43: return h - 'A' + 10;
! 44: }
! 45: }
! 46: void *sqlite3TestTextToPtr(const char *z){
! 47: void *p;
! 48: u64 v;
! 49: u32 v2;
! 50: if( z[0]=='0' && z[1]=='x' ){
! 51: z += 2;
! 52: }
! 53: v = 0;
! 54: while( *z ){
! 55: v = (v<<4) + testHexToInt(*z);
! 56: z++;
! 57: }
! 58: if( sizeof(p)==sizeof(v) ){
! 59: memcpy(&p, &v, sizeof(p));
! 60: }else{
! 61: assert( sizeof(p)==sizeof(v2) );
! 62: v2 = (u32)v;
! 63: memcpy(&p, &v2, sizeof(p));
! 64: }
! 65: return p;
! 66: }
! 67:
! 68:
! 69: /*
! 70: ** A TCL command that returns the address of the sqlite* pointer
! 71: ** for an sqlite connection instance. Bad things happen if the
! 72: ** input is not an sqlite connection.
! 73: */
! 74: static int get_sqlite_pointer(
! 75: void * clientData,
! 76: Tcl_Interp *interp,
! 77: int objc,
! 78: Tcl_Obj *CONST objv[]
! 79: ){
! 80: struct SqliteDb *p;
! 81: Tcl_CmdInfo cmdInfo;
! 82: char zBuf[100];
! 83: if( objc!=2 ){
! 84: Tcl_WrongNumArgs(interp, 1, objv, "SQLITE-CONNECTION");
! 85: return TCL_ERROR;
! 86: }
! 87: if( !Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){
! 88: Tcl_AppendResult(interp, "command not found: ",
! 89: Tcl_GetString(objv[1]), (char*)0);
! 90: return TCL_ERROR;
! 91: }
! 92: p = (struct SqliteDb*)cmdInfo.objClientData;
! 93: sprintf(zBuf, "%p", p->db);
! 94: if( strncmp(zBuf,"0x",2) ){
! 95: sprintf(zBuf, "0x%p", p->db);
! 96: }
! 97: Tcl_AppendResult(interp, zBuf, 0);
! 98: return TCL_OK;
! 99: }
! 100:
! 101: /*
! 102: ** Decode a pointer to an sqlite3 object.
! 103: */
! 104: int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb){
! 105: struct SqliteDb *p;
! 106: Tcl_CmdInfo cmdInfo;
! 107: if( Tcl_GetCommandInfo(interp, zA, &cmdInfo) ){
! 108: p = (struct SqliteDb*)cmdInfo.objClientData;
! 109: *ppDb = p->db;
! 110: }else{
! 111: *ppDb = (sqlite3*)sqlite3TestTextToPtr(zA);
! 112: }
! 113: return TCL_OK;
! 114: }
! 115:
! 116:
! 117: const char *sqlite3TestErrorName(int rc){
! 118: const char *zName = 0;
! 119: switch( rc ){
! 120: case SQLITE_OK: zName = "SQLITE_OK"; break;
! 121: case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
! 122: case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break;
! 123: case SQLITE_PERM: zName = "SQLITE_PERM"; break;
! 124: case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
! 125: case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
! 126: case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
! 127: case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
! 128: case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
! 129: case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
! 130: case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
! 131: case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
! 132: case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
! 133: case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break;
! 134: case SQLITE_FULL: zName = "SQLITE_FULL"; break;
! 135: case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
! 136: case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
! 137: case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
! 138: case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;
! 139: case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break;
! 140: case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
! 141: case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
! 142: case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
! 143: case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
! 144: case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;
! 145: case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;
! 146: case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;
! 147: case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break;
! 148: case SQLITE_ROW: zName = "SQLITE_ROW"; break;
! 149: case SQLITE_DONE: zName = "SQLITE_DONE"; break;
! 150: case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break;
! 151: case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break;
! 152: case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break;
! 153: case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break;
! 154: case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break;
! 155: case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break;
! 156: case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break;
! 157: case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break;
! 158: case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break;
! 159: case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break;
! 160: case SQLITE_IOERR_BLOCKED: zName = "SQLITE_IOERR_BLOCKED"; break;
! 161: case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break;
! 162: case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break;
! 163: case SQLITE_IOERR_CHECKRESERVEDLOCK:
! 164: zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
! 165: case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break;
! 166: case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break;
! 167: case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
! 168: case SQLITE_READONLY_CANTLOCK: zName = "SQLITE_READONLY_CANTLOCK"; break;
! 169: default: zName = "SQLITE_Unknown"; break;
! 170: }
! 171: return zName;
! 172: }
! 173: #define t1ErrorName sqlite3TestErrorName
! 174:
! 175: /*
! 176: ** Convert an sqlite3_stmt* into an sqlite3*. This depends on the
! 177: ** fact that the sqlite3* is the first field in the Vdbe structure.
! 178: */
! 179: #define StmtToDb(X) sqlite3_db_handle(X)
! 180:
! 181: /*
! 182: ** Check a return value to make sure it agrees with the results
! 183: ** from sqlite3_errcode.
! 184: */
! 185: int sqlite3TestErrCode(Tcl_Interp *interp, sqlite3 *db, int rc){
! 186: if( sqlite3_threadsafe()==0 && rc!=SQLITE_MISUSE && rc!=SQLITE_OK
! 187: && sqlite3_errcode(db)!=rc ){
! 188: char zBuf[200];
! 189: int r2 = sqlite3_errcode(db);
! 190: sprintf(zBuf, "error code %s (%d) does not match sqlite3_errcode %s (%d)",
! 191: t1ErrorName(rc), rc, t1ErrorName(r2), r2);
! 192: Tcl_ResetResult(interp);
! 193: Tcl_AppendResult(interp, zBuf, 0);
! 194: return 1;
! 195: }
! 196: return 0;
! 197: }
! 198:
! 199: /*
! 200: ** Decode a pointer to an sqlite3_stmt object.
! 201: */
! 202: static int getStmtPointer(
! 203: Tcl_Interp *interp,
! 204: const char *zArg,
! 205: sqlite3_stmt **ppStmt
! 206: ){
! 207: *ppStmt = (sqlite3_stmt*)sqlite3TestTextToPtr(zArg);
! 208: return TCL_OK;
! 209: }
! 210:
! 211: /*
! 212: ** Generate a text representation of a pointer that can be understood
! 213: ** by the getDbPointer and getVmPointer routines above.
! 214: **
! 215: ** The problem is, on some machines (Solaris) if you do a printf with
! 216: ** "%p" you cannot turn around and do a scanf with the same "%p" and
! 217: ** get your pointer back. You have to prepend a "0x" before it will
! 218: ** work. Or at least that is what is reported to me (drh). But this
! 219: ** behavior varies from machine to machine. The solution used her is
! 220: ** to test the string right after it is generated to see if it can be
! 221: ** understood by scanf, and if not, try prepending an "0x" to see if
! 222: ** that helps. If nothing works, a fatal error is generated.
! 223: */
! 224: int sqlite3TestMakePointerStr(Tcl_Interp *interp, char *zPtr, void *p){
! 225: sqlite3_snprintf(100, zPtr, "%p", p);
! 226: return TCL_OK;
! 227: }
! 228:
! 229: /*
! 230: ** The callback routine for sqlite3_exec_printf().
! 231: */
! 232: static int exec_printf_cb(void *pArg, int argc, char **argv, char **name){
! 233: Tcl_DString *str = (Tcl_DString*)pArg;
! 234: int i;
! 235:
! 236: if( Tcl_DStringLength(str)==0 ){
! 237: for(i=0; i<argc; i++){
! 238: Tcl_DStringAppendElement(str, name[i] ? name[i] : "NULL");
! 239: }
! 240: }
! 241: for(i=0; i<argc; i++){
! 242: Tcl_DStringAppendElement(str, argv[i] ? argv[i] : "NULL");
! 243: }
! 244: return 0;
! 245: }
! 246:
! 247: /*
! 248: ** The I/O tracing callback.
! 249: */
! 250: #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
! 251: static FILE *iotrace_file = 0;
! 252: static void io_trace_callback(const char *zFormat, ...){
! 253: va_list ap;
! 254: va_start(ap, zFormat);
! 255: vfprintf(iotrace_file, zFormat, ap);
! 256: va_end(ap);
! 257: fflush(iotrace_file);
! 258: }
! 259: #endif
! 260:
! 261: /*
! 262: ** Usage: io_trace FILENAME
! 263: **
! 264: ** Turn I/O tracing on or off. If FILENAME is not an empty string,
! 265: ** I/O tracing begins going into FILENAME. If FILENAME is an empty
! 266: ** string, I/O tracing is turned off.
! 267: */
! 268: static int test_io_trace(
! 269: void *NotUsed,
! 270: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 271: int argc, /* Number of arguments */
! 272: char **argv /* Text of each argument */
! 273: ){
! 274: #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
! 275: if( argc!=2 ){
! 276: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 277: " FILENAME\"", 0);
! 278: return TCL_ERROR;
! 279: }
! 280: if( iotrace_file ){
! 281: if( iotrace_file!=stdout && iotrace_file!=stderr ){
! 282: fclose(iotrace_file);
! 283: }
! 284: iotrace_file = 0;
! 285: sqlite3IoTrace = 0;
! 286: }
! 287: if( argv[1][0] ){
! 288: if( strcmp(argv[1],"stdout")==0 ){
! 289: iotrace_file = stdout;
! 290: }else if( strcmp(argv[1],"stderr")==0 ){
! 291: iotrace_file = stderr;
! 292: }else{
! 293: iotrace_file = fopen(argv[1], "w");
! 294: }
! 295: sqlite3IoTrace = io_trace_callback;
! 296: }
! 297: #endif
! 298: return TCL_OK;
! 299: }
! 300:
! 301:
! 302: /*
! 303: ** Usage: sqlite3_exec_printf DB FORMAT STRING
! 304: **
! 305: ** Invoke the sqlite3_exec_printf() interface using the open database
! 306: ** DB. The SQL is the string FORMAT. The format string should contain
! 307: ** one %s or %q. STRING is the value inserted into %s or %q.
! 308: */
! 309: static int test_exec_printf(
! 310: void *NotUsed,
! 311: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 312: int argc, /* Number of arguments */
! 313: char **argv /* Text of each argument */
! 314: ){
! 315: sqlite3 *db;
! 316: Tcl_DString str;
! 317: int rc;
! 318: char *zErr = 0;
! 319: char *zSql;
! 320: char zBuf[30];
! 321: if( argc!=4 ){
! 322: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 323: " DB FORMAT STRING", 0);
! 324: return TCL_ERROR;
! 325: }
! 326: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 327: Tcl_DStringInit(&str);
! 328: zSql = sqlite3_mprintf(argv[2], argv[3]);
! 329: rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);
! 330: sqlite3_free(zSql);
! 331: sprintf(zBuf, "%d", rc);
! 332: Tcl_AppendElement(interp, zBuf);
! 333: Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);
! 334: Tcl_DStringFree(&str);
! 335: if( zErr ) sqlite3_free(zErr);
! 336: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 337: return TCL_OK;
! 338: }
! 339:
! 340: /*
! 341: ** Usage: sqlite3_exec_hex DB HEX
! 342: **
! 343: ** Invoke the sqlite3_exec() on a string that is obtained by translating
! 344: ** HEX into ASCII. Most characters are translated as is. %HH becomes
! 345: ** a hex character.
! 346: */
! 347: static int test_exec_hex(
! 348: void *NotUsed,
! 349: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 350: int argc, /* Number of arguments */
! 351: char **argv /* Text of each argument */
! 352: ){
! 353: sqlite3 *db;
! 354: Tcl_DString str;
! 355: int rc, i, j;
! 356: char *zErr = 0;
! 357: char *zHex;
! 358: char zSql[500];
! 359: char zBuf[30];
! 360: if( argc!=3 ){
! 361: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 362: " DB HEX", 0);
! 363: return TCL_ERROR;
! 364: }
! 365: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 366: zHex = argv[2];
! 367: for(i=j=0; i<sizeof(zSql) && zHex[j]; i++, j++){
! 368: if( zHex[j]=='%' && zHex[j+2] && zHex[j+2] ){
! 369: zSql[i] = (testHexToInt(zHex[j+1])<<4) + testHexToInt(zHex[j+2]);
! 370: j += 2;
! 371: }else{
! 372: zSql[i] = zHex[j];
! 373: }
! 374: }
! 375: zSql[i] = 0;
! 376: Tcl_DStringInit(&str);
! 377: rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);
! 378: sprintf(zBuf, "%d", rc);
! 379: Tcl_AppendElement(interp, zBuf);
! 380: Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);
! 381: Tcl_DStringFree(&str);
! 382: if( zErr ) sqlite3_free(zErr);
! 383: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 384: return TCL_OK;
! 385: }
! 386:
! 387: /*
! 388: ** Usage: db_enter DB
! 389: ** db_leave DB
! 390: **
! 391: ** Enter or leave the mutex on a database connection.
! 392: */
! 393: static int db_enter(
! 394: void *NotUsed,
! 395: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 396: int argc, /* Number of arguments */
! 397: char **argv /* Text of each argument */
! 398: ){
! 399: sqlite3 *db;
! 400: if( argc!=2 ){
! 401: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 402: " DB", 0);
! 403: return TCL_ERROR;
! 404: }
! 405: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 406: sqlite3_mutex_enter(db->mutex);
! 407: return TCL_OK;
! 408: }
! 409: static int db_leave(
! 410: void *NotUsed,
! 411: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 412: int argc, /* Number of arguments */
! 413: char **argv /* Text of each argument */
! 414: ){
! 415: sqlite3 *db;
! 416: if( argc!=2 ){
! 417: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 418: " DB", 0);
! 419: return TCL_ERROR;
! 420: }
! 421: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 422: sqlite3_mutex_leave(db->mutex);
! 423: return TCL_OK;
! 424: }
! 425:
! 426: /*
! 427: ** Usage: sqlite3_exec DB SQL
! 428: **
! 429: ** Invoke the sqlite3_exec interface using the open database DB
! 430: */
! 431: static int test_exec(
! 432: void *NotUsed,
! 433: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 434: int argc, /* Number of arguments */
! 435: char **argv /* Text of each argument */
! 436: ){
! 437: sqlite3 *db;
! 438: Tcl_DString str;
! 439: int rc;
! 440: char *zErr = 0;
! 441: char *zSql;
! 442: int i, j;
! 443: char zBuf[30];
! 444: if( argc!=3 ){
! 445: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 446: " DB SQL", 0);
! 447: return TCL_ERROR;
! 448: }
! 449: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 450: Tcl_DStringInit(&str);
! 451: zSql = sqlite3_mprintf("%s", argv[2]);
! 452: for(i=j=0; zSql[i];){
! 453: if( zSql[i]=='%' ){
! 454: zSql[j++] = (testHexToInt(zSql[i+1])<<4) + testHexToInt(zSql[i+2]);
! 455: i += 3;
! 456: }else{
! 457: zSql[j++] = zSql[i++];
! 458: }
! 459: }
! 460: zSql[j] = 0;
! 461: rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);
! 462: sqlite3_free(zSql);
! 463: sprintf(zBuf, "%d", rc);
! 464: Tcl_AppendElement(interp, zBuf);
! 465: Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);
! 466: Tcl_DStringFree(&str);
! 467: if( zErr ) sqlite3_free(zErr);
! 468: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 469: return TCL_OK;
! 470: }
! 471:
! 472: /*
! 473: ** Usage: sqlite3_exec_nr DB SQL
! 474: **
! 475: ** Invoke the sqlite3_exec interface using the open database DB. Discard
! 476: ** all results
! 477: */
! 478: static int test_exec_nr(
! 479: void *NotUsed,
! 480: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 481: int argc, /* Number of arguments */
! 482: char **argv /* Text of each argument */
! 483: ){
! 484: sqlite3 *db;
! 485: int rc;
! 486: char *zErr = 0;
! 487: if( argc!=3 ){
! 488: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 489: " DB SQL", 0);
! 490: return TCL_ERROR;
! 491: }
! 492: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 493: rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);
! 494: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 495: return TCL_OK;
! 496: }
! 497:
! 498: /*
! 499: ** Usage: sqlite3_mprintf_z_test SEPARATOR ARG0 ARG1 ...
! 500: **
! 501: ** Test the %z format of sqlite_mprintf(). Use multiple mprintf() calls to
! 502: ** concatenate arg0 through argn using separator as the separator.
! 503: ** Return the result.
! 504: */
! 505: static int test_mprintf_z(
! 506: void *NotUsed,
! 507: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 508: int argc, /* Number of arguments */
! 509: char **argv /* Text of each argument */
! 510: ){
! 511: char *zResult = 0;
! 512: int i;
! 513:
! 514: for(i=2; i<argc && (i==2 || zResult); i++){
! 515: zResult = sqlite3_mprintf("%z%s%s", zResult, argv[1], argv[i]);
! 516: }
! 517: Tcl_AppendResult(interp, zResult, 0);
! 518: sqlite3_free(zResult);
! 519: return TCL_OK;
! 520: }
! 521:
! 522: /*
! 523: ** Usage: sqlite3_mprintf_n_test STRING
! 524: **
! 525: ** Test the %n format of sqlite_mprintf(). Return the length of the
! 526: ** input string.
! 527: */
! 528: static int test_mprintf_n(
! 529: void *NotUsed,
! 530: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 531: int argc, /* Number of arguments */
! 532: char **argv /* Text of each argument */
! 533: ){
! 534: char *zStr;
! 535: int n = 0;
! 536: zStr = sqlite3_mprintf("%s%n", argv[1], &n);
! 537: sqlite3_free(zStr);
! 538: Tcl_SetObjResult(interp, Tcl_NewIntObj(n));
! 539: return TCL_OK;
! 540: }
! 541:
! 542: /*
! 543: ** Usage: sqlite3_snprintf_int SIZE FORMAT INT
! 544: **
! 545: ** Test the of sqlite3_snprintf() routine. SIZE is the size of the
! 546: ** output buffer in bytes. The maximum size is 100. FORMAT is the
! 547: ** format string. INT is a single integer argument. The FORMAT
! 548: ** string must require no more than this one integer argument. If
! 549: ** You pass in a format string that requires more than one argument,
! 550: ** bad things will happen.
! 551: */
! 552: static int test_snprintf_int(
! 553: void *NotUsed,
! 554: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 555: int argc, /* Number of arguments */
! 556: char **argv /* Text of each argument */
! 557: ){
! 558: char zStr[100];
! 559: int n = atoi(argv[1]);
! 560: const char *zFormat = argv[2];
! 561: int a1 = atoi(argv[3]);
! 562: if( n>sizeof(zStr) ) n = sizeof(zStr);
! 563: sqlite3_snprintf(sizeof(zStr), zStr, "abcdefghijklmnopqrstuvwxyz");
! 564: sqlite3_snprintf(n, zStr, zFormat, a1);
! 565: Tcl_AppendResult(interp, zStr, 0);
! 566: return TCL_OK;
! 567: }
! 568:
! 569: #ifndef SQLITE_OMIT_GET_TABLE
! 570:
! 571: /*
! 572: ** Usage: sqlite3_get_table_printf DB FORMAT STRING ?--no-counts?
! 573: **
! 574: ** Invoke the sqlite3_get_table_printf() interface using the open database
! 575: ** DB. The SQL is the string FORMAT. The format string should contain
! 576: ** one %s or %q. STRING is the value inserted into %s or %q.
! 577: */
! 578: static int test_get_table_printf(
! 579: void *NotUsed,
! 580: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 581: int argc, /* Number of arguments */
! 582: char **argv /* Text of each argument */
! 583: ){
! 584: sqlite3 *db;
! 585: Tcl_DString str;
! 586: int rc;
! 587: char *zErr = 0;
! 588: int nRow, nCol;
! 589: char **aResult;
! 590: int i;
! 591: char zBuf[30];
! 592: char *zSql;
! 593: int resCount = -1;
! 594: if( argc==5 ){
! 595: if( Tcl_GetInt(interp, argv[4], &resCount) ) return TCL_ERROR;
! 596: }
! 597: if( argc!=4 && argc!=5 ){
! 598: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 599: " DB FORMAT STRING ?COUNT?", 0);
! 600: return TCL_ERROR;
! 601: }
! 602: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 603: Tcl_DStringInit(&str);
! 604: zSql = sqlite3_mprintf(argv[2],argv[3]);
! 605: if( argc==5 ){
! 606: rc = sqlite3_get_table(db, zSql, &aResult, 0, 0, &zErr);
! 607: }else{
! 608: rc = sqlite3_get_table(db, zSql, &aResult, &nRow, &nCol, &zErr);
! 609: resCount = (nRow+1)*nCol;
! 610: }
! 611: sqlite3_free(zSql);
! 612: sprintf(zBuf, "%d", rc);
! 613: Tcl_AppendElement(interp, zBuf);
! 614: if( rc==SQLITE_OK ){
! 615: if( argc==4 ){
! 616: sprintf(zBuf, "%d", nRow);
! 617: Tcl_AppendElement(interp, zBuf);
! 618: sprintf(zBuf, "%d", nCol);
! 619: Tcl_AppendElement(interp, zBuf);
! 620: }
! 621: for(i=0; i<resCount; i++){
! 622: Tcl_AppendElement(interp, aResult[i] ? aResult[i] : "NULL");
! 623: }
! 624: }else{
! 625: Tcl_AppendElement(interp, zErr);
! 626: }
! 627: sqlite3_free_table(aResult);
! 628: if( zErr ) sqlite3_free(zErr);
! 629: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 630: return TCL_OK;
! 631: }
! 632:
! 633: #endif /* SQLITE_OMIT_GET_TABLE */
! 634:
! 635:
! 636: /*
! 637: ** Usage: sqlite3_last_insert_rowid DB
! 638: **
! 639: ** Returns the integer ROWID of the most recent insert.
! 640: */
! 641: static int test_last_rowid(
! 642: void *NotUsed,
! 643: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 644: int argc, /* Number of arguments */
! 645: char **argv /* Text of each argument */
! 646: ){
! 647: sqlite3 *db;
! 648: char zBuf[30];
! 649:
! 650: if( argc!=2 ){
! 651: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB\"", 0);
! 652: return TCL_ERROR;
! 653: }
! 654: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 655: sprintf(zBuf, "%lld", sqlite3_last_insert_rowid(db));
! 656: Tcl_AppendResult(interp, zBuf, 0);
! 657: return SQLITE_OK;
! 658: }
! 659:
! 660: /*
! 661: ** Usage: sqlite3_key DB KEY
! 662: **
! 663: ** Set the codec key.
! 664: */
! 665: static int test_key(
! 666: void *NotUsed,
! 667: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 668: int argc, /* Number of arguments */
! 669: char **argv /* Text of each argument */
! 670: ){
! 671: sqlite3 *db;
! 672: const char *zKey;
! 673: int nKey;
! 674: if( argc!=3 ){
! 675: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 676: " FILENAME\"", 0);
! 677: return TCL_ERROR;
! 678: }
! 679: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 680: zKey = argv[2];
! 681: nKey = strlen(zKey);
! 682: #ifdef SQLITE_HAS_CODEC
! 683: sqlite3_key(db, zKey, nKey);
! 684: #endif
! 685: return TCL_OK;
! 686: }
! 687:
! 688: /*
! 689: ** Usage: sqlite3_rekey DB KEY
! 690: **
! 691: ** Change the codec key.
! 692: */
! 693: static int test_rekey(
! 694: void *NotUsed,
! 695: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 696: int argc, /* Number of arguments */
! 697: char **argv /* Text of each argument */
! 698: ){
! 699: sqlite3 *db;
! 700: const char *zKey;
! 701: int nKey;
! 702: if( argc!=3 ){
! 703: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 704: " FILENAME\"", 0);
! 705: return TCL_ERROR;
! 706: }
! 707: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 708: zKey = argv[2];
! 709: nKey = strlen(zKey);
! 710: #ifdef SQLITE_HAS_CODEC
! 711: sqlite3_rekey(db, zKey, nKey);
! 712: #endif
! 713: return TCL_OK;
! 714: }
! 715:
! 716: /*
! 717: ** Usage: sqlite3_close DB
! 718: **
! 719: ** Closes the database opened by sqlite3_open.
! 720: */
! 721: static int sqlite_test_close(
! 722: void *NotUsed,
! 723: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 724: int argc, /* Number of arguments */
! 725: char **argv /* Text of each argument */
! 726: ){
! 727: sqlite3 *db;
! 728: int rc;
! 729: if( argc!=2 ){
! 730: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 731: " FILENAME\"", 0);
! 732: return TCL_ERROR;
! 733: }
! 734: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 735: rc = sqlite3_close(db);
! 736: Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
! 737: return TCL_OK;
! 738: }
! 739:
! 740: /*
! 741: ** Implementation of the x_coalesce() function.
! 742: ** Return the first argument non-NULL argument.
! 743: */
! 744: static void t1_ifnullFunc(
! 745: sqlite3_context *context,
! 746: int argc,
! 747: sqlite3_value **argv
! 748: ){
! 749: int i;
! 750: for(i=0; i<argc; i++){
! 751: if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){
! 752: int n = sqlite3_value_bytes(argv[i]);
! 753: sqlite3_result_text(context, (char*)sqlite3_value_text(argv[i]),
! 754: n, SQLITE_TRANSIENT);
! 755: break;
! 756: }
! 757: }
! 758: }
! 759:
! 760: /*
! 761: ** These are test functions. hex8() interprets its argument as
! 762: ** UTF8 and returns a hex encoding. hex16le() interprets its argument
! 763: ** as UTF16le and returns a hex encoding.
! 764: */
! 765: static void hex8Func(sqlite3_context *p, int argc, sqlite3_value **argv){
! 766: const unsigned char *z;
! 767: int i;
! 768: char zBuf[200];
! 769: z = sqlite3_value_text(argv[0]);
! 770: for(i=0; i<sizeof(zBuf)/2 - 2 && z[i]; i++){
! 771: sprintf(&zBuf[i*2], "%02x", z[i]&0xff);
! 772: }
! 773: zBuf[i*2] = 0;
! 774: sqlite3_result_text(p, (char*)zBuf, -1, SQLITE_TRANSIENT);
! 775: }
! 776: #ifndef SQLITE_OMIT_UTF16
! 777: static void hex16Func(sqlite3_context *p, int argc, sqlite3_value **argv){
! 778: const unsigned short int *z;
! 779: int i;
! 780: char zBuf[400];
! 781: z = sqlite3_value_text16(argv[0]);
! 782: for(i=0; i<sizeof(zBuf)/4 - 4 && z[i]; i++){
! 783: sprintf(&zBuf[i*4], "%04x", z[i]&0xff);
! 784: }
! 785: zBuf[i*4] = 0;
! 786: sqlite3_result_text(p, (char*)zBuf, -1, SQLITE_TRANSIENT);
! 787: }
! 788: #endif
! 789:
! 790: /*
! 791: ** A structure into which to accumulate text.
! 792: */
! 793: struct dstr {
! 794: int nAlloc; /* Space allocated */
! 795: int nUsed; /* Space used */
! 796: char *z; /* The space */
! 797: };
! 798:
! 799: /*
! 800: ** Append text to a dstr
! 801: */
! 802: static void dstrAppend(struct dstr *p, const char *z, int divider){
! 803: int n = strlen(z);
! 804: if( p->nUsed + n + 2 > p->nAlloc ){
! 805: char *zNew;
! 806: p->nAlloc = p->nAlloc*2 + n + 200;
! 807: zNew = sqlite3_realloc(p->z, p->nAlloc);
! 808: if( zNew==0 ){
! 809: sqlite3_free(p->z);
! 810: memset(p, 0, sizeof(*p));
! 811: return;
! 812: }
! 813: p->z = zNew;
! 814: }
! 815: if( divider && p->nUsed>0 ){
! 816: p->z[p->nUsed++] = divider;
! 817: }
! 818: memcpy(&p->z[p->nUsed], z, n+1);
! 819: p->nUsed += n;
! 820: }
! 821:
! 822: /*
! 823: ** Invoked for each callback from sqlite3ExecFunc
! 824: */
! 825: static int execFuncCallback(void *pData, int argc, char **argv, char **NotUsed){
! 826: struct dstr *p = (struct dstr*)pData;
! 827: int i;
! 828: for(i=0; i<argc; i++){
! 829: if( argv[i]==0 ){
! 830: dstrAppend(p, "NULL", ' ');
! 831: }else{
! 832: dstrAppend(p, argv[i], ' ');
! 833: }
! 834: }
! 835: return 0;
! 836: }
! 837:
! 838: /*
! 839: ** Implementation of the x_sqlite_exec() function. This function takes
! 840: ** a single argument and attempts to execute that argument as SQL code.
! 841: ** This is illegal and should set the SQLITE_MISUSE flag on the database.
! 842: **
! 843: ** 2004-Jan-07: We have changed this to make it legal to call sqlite3_exec()
! 844: ** from within a function call.
! 845: **
! 846: ** This routine simulates the effect of having two threads attempt to
! 847: ** use the same database at the same time.
! 848: */
! 849: static void sqlite3ExecFunc(
! 850: sqlite3_context *context,
! 851: int argc,
! 852: sqlite3_value **argv
! 853: ){
! 854: struct dstr x;
! 855: memset(&x, 0, sizeof(x));
! 856: (void)sqlite3_exec((sqlite3*)sqlite3_user_data(context),
! 857: (char*)sqlite3_value_text(argv[0]),
! 858: execFuncCallback, &x, 0);
! 859: sqlite3_result_text(context, x.z, x.nUsed, SQLITE_TRANSIENT);
! 860: sqlite3_free(x.z);
! 861: }
! 862:
! 863: /*
! 864: ** Implementation of tkt2213func(), a scalar function that takes exactly
! 865: ** one argument. It has two interesting features:
! 866: **
! 867: ** * It calls sqlite3_value_text() 3 times on the argument sqlite3_value*.
! 868: ** If the three pointers returned are not the same an SQL error is raised.
! 869: **
! 870: ** * Otherwise it returns a copy of the text representation of its
! 871: ** argument in such a way as the VDBE representation is a Mem* cell
! 872: ** with the MEM_Term flag clear.
! 873: **
! 874: ** Ticket #2213 can therefore be tested by evaluating the following
! 875: ** SQL expression:
! 876: **
! 877: ** tkt2213func(tkt2213func('a string'));
! 878: */
! 879: static void tkt2213Function(
! 880: sqlite3_context *context,
! 881: int argc,
! 882: sqlite3_value **argv
! 883: ){
! 884: int nText;
! 885: unsigned char const *zText1;
! 886: unsigned char const *zText2;
! 887: unsigned char const *zText3;
! 888:
! 889: nText = sqlite3_value_bytes(argv[0]);
! 890: zText1 = sqlite3_value_text(argv[0]);
! 891: zText2 = sqlite3_value_text(argv[0]);
! 892: zText3 = sqlite3_value_text(argv[0]);
! 893:
! 894: if( zText1!=zText2 || zText2!=zText3 ){
! 895: sqlite3_result_error(context, "tkt2213 is not fixed", -1);
! 896: }else{
! 897: char *zCopy = (char *)sqlite3_malloc(nText);
! 898: memcpy(zCopy, zText1, nText);
! 899: sqlite3_result_text(context, zCopy, nText, sqlite3_free);
! 900: }
! 901: }
! 902:
! 903: /*
! 904: ** The following SQL function takes 4 arguments. The 2nd and
! 905: ** 4th argument must be one of these strings: 'text', 'text16',
! 906: ** or 'blob' corresponding to API functions
! 907: **
! 908: ** sqlite3_value_text()
! 909: ** sqlite3_value_text16()
! 910: ** sqlite3_value_blob()
! 911: **
! 912: ** The third argument is a string, either 'bytes' or 'bytes16' or 'noop',
! 913: ** corresponding to APIs:
! 914: **
! 915: ** sqlite3_value_bytes()
! 916: ** sqlite3_value_bytes16()
! 917: ** noop
! 918: **
! 919: ** The APIs designated by the 2nd through 4th arguments are applied
! 920: ** to the first argument in order. If the pointers returned by the
! 921: ** second and fourth are different, this routine returns 1. Otherwise,
! 922: ** this routine returns 0.
! 923: **
! 924: ** This function is used to test to see when returned pointers from
! 925: ** the _text(), _text16() and _blob() APIs become invalidated.
! 926: */
! 927: static void ptrChngFunction(
! 928: sqlite3_context *context,
! 929: int argc,
! 930: sqlite3_value **argv
! 931: ){
! 932: const void *p1, *p2;
! 933: const char *zCmd;
! 934: if( argc!=4 ) return;
! 935: zCmd = (const char*)sqlite3_value_text(argv[1]);
! 936: if( zCmd==0 ) return;
! 937: if( strcmp(zCmd,"text")==0 ){
! 938: p1 = (const void*)sqlite3_value_text(argv[0]);
! 939: #ifndef SQLITE_OMIT_UTF16
! 940: }else if( strcmp(zCmd, "text16")==0 ){
! 941: p1 = (const void*)sqlite3_value_text16(argv[0]);
! 942: #endif
! 943: }else if( strcmp(zCmd, "blob")==0 ){
! 944: p1 = (const void*)sqlite3_value_blob(argv[0]);
! 945: }else{
! 946: return;
! 947: }
! 948: zCmd = (const char*)sqlite3_value_text(argv[2]);
! 949: if( zCmd==0 ) return;
! 950: if( strcmp(zCmd,"bytes")==0 ){
! 951: sqlite3_value_bytes(argv[0]);
! 952: #ifndef SQLITE_OMIT_UTF16
! 953: }else if( strcmp(zCmd, "bytes16")==0 ){
! 954: sqlite3_value_bytes16(argv[0]);
! 955: #endif
! 956: }else if( strcmp(zCmd, "noop")==0 ){
! 957: /* do nothing */
! 958: }else{
! 959: return;
! 960: }
! 961: zCmd = (const char*)sqlite3_value_text(argv[3]);
! 962: if( zCmd==0 ) return;
! 963: if( strcmp(zCmd,"text")==0 ){
! 964: p2 = (const void*)sqlite3_value_text(argv[0]);
! 965: #ifndef SQLITE_OMIT_UTF16
! 966: }else if( strcmp(zCmd, "text16")==0 ){
! 967: p2 = (const void*)sqlite3_value_text16(argv[0]);
! 968: #endif
! 969: }else if( strcmp(zCmd, "blob")==0 ){
! 970: p2 = (const void*)sqlite3_value_blob(argv[0]);
! 971: }else{
! 972: return;
! 973: }
! 974: sqlite3_result_int(context, p1!=p2);
! 975: }
! 976:
! 977:
! 978: /*
! 979: ** Usage: sqlite_test_create_function DB
! 980: **
! 981: ** Call the sqlite3_create_function API on the given database in order
! 982: ** to create a function named "x_coalesce". This function does the same thing
! 983: ** as the "coalesce" function. This function also registers an SQL function
! 984: ** named "x_sqlite_exec" that invokes sqlite3_exec(). Invoking sqlite3_exec()
! 985: ** in this way is illegal recursion and should raise an SQLITE_MISUSE error.
! 986: ** The effect is similar to trying to use the same database connection from
! 987: ** two threads at the same time.
! 988: **
! 989: ** The original motivation for this routine was to be able to call the
! 990: ** sqlite3_create_function function while a query is in progress in order
! 991: ** to test the SQLITE_MISUSE detection logic.
! 992: */
! 993: static int test_create_function(
! 994: void *NotUsed,
! 995: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 996: int argc, /* Number of arguments */
! 997: char **argv /* Text of each argument */
! 998: ){
! 999: int rc;
! 1000: sqlite3 *db;
! 1001:
! 1002: if( argc!=2 ){
! 1003: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 1004: " DB\"", 0);
! 1005: return TCL_ERROR;
! 1006: }
! 1007: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 1008: rc = sqlite3_create_function(db, "x_coalesce", -1, SQLITE_ANY, 0,
! 1009: t1_ifnullFunc, 0, 0);
! 1010: if( rc==SQLITE_OK ){
! 1011: rc = sqlite3_create_function(db, "hex8", 1, SQLITE_ANY, 0,
! 1012: hex8Func, 0, 0);
! 1013: }
! 1014: #ifndef SQLITE_OMIT_UTF16
! 1015: if( rc==SQLITE_OK ){
! 1016: rc = sqlite3_create_function(db, "hex16", 1, SQLITE_ANY, 0,
! 1017: hex16Func, 0, 0);
! 1018: }
! 1019: #endif
! 1020: if( rc==SQLITE_OK ){
! 1021: rc = sqlite3_create_function(db, "tkt2213func", 1, SQLITE_ANY, 0,
! 1022: tkt2213Function, 0, 0);
! 1023: }
! 1024: if( rc==SQLITE_OK ){
! 1025: rc = sqlite3_create_function(db, "pointer_change", 4, SQLITE_ANY, 0,
! 1026: ptrChngFunction, 0, 0);
! 1027: }
! 1028:
! 1029: #ifndef SQLITE_OMIT_UTF16
! 1030: /* Use the sqlite3_create_function16() API here. Mainly for fun, but also
! 1031: ** because it is not tested anywhere else. */
! 1032: if( rc==SQLITE_OK ){
! 1033: const void *zUtf16;
! 1034: sqlite3_value *pVal;
! 1035: sqlite3_mutex_enter(db->mutex);
! 1036: pVal = sqlite3ValueNew(db);
! 1037: sqlite3ValueSetStr(pVal, -1, "x_sqlite_exec", SQLITE_UTF8, SQLITE_STATIC);
! 1038: zUtf16 = sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
! 1039: if( db->mallocFailed ){
! 1040: rc = SQLITE_NOMEM;
! 1041: }else{
! 1042: rc = sqlite3_create_function16(db, zUtf16,
! 1043: 1, SQLITE_UTF16, db, sqlite3ExecFunc, 0, 0);
! 1044: }
! 1045: sqlite3ValueFree(pVal);
! 1046: sqlite3_mutex_leave(db->mutex);
! 1047: }
! 1048: #endif
! 1049:
! 1050: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 1051: Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
! 1052: return TCL_OK;
! 1053: }
! 1054:
! 1055: /*
! 1056: ** Routines to implement the x_count() aggregate function.
! 1057: **
! 1058: ** x_count() counts the number of non-null arguments. But there are
! 1059: ** some twists for testing purposes.
! 1060: **
! 1061: ** If the argument to x_count() is 40 then a UTF-8 error is reported
! 1062: ** on the step function. If x_count(41) is seen, then a UTF-16 error
! 1063: ** is reported on the step function. If the total count is 42, then
! 1064: ** a UTF-8 error is reported on the finalize function.
! 1065: */
! 1066: typedef struct t1CountCtx t1CountCtx;
! 1067: struct t1CountCtx {
! 1068: int n;
! 1069: };
! 1070: static void t1CountStep(
! 1071: sqlite3_context *context,
! 1072: int argc,
! 1073: sqlite3_value **argv
! 1074: ){
! 1075: t1CountCtx *p;
! 1076: p = sqlite3_aggregate_context(context, sizeof(*p));
! 1077: if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0]) ) && p ){
! 1078: p->n++;
! 1079: }
! 1080: if( argc>0 ){
! 1081: int v = sqlite3_value_int(argv[0]);
! 1082: if( v==40 ){
! 1083: sqlite3_result_error(context, "value of 40 handed to x_count", -1);
! 1084: #ifndef SQLITE_OMIT_UTF16
! 1085: }else if( v==41 ){
! 1086: const char zUtf16ErrMsg[] = { 0, 0x61, 0, 0x62, 0, 0x63, 0, 0, 0};
! 1087: sqlite3_result_error16(context, &zUtf16ErrMsg[1-SQLITE_BIGENDIAN], -1);
! 1088: #endif
! 1089: }
! 1090: }
! 1091: }
! 1092: static void t1CountFinalize(sqlite3_context *context){
! 1093: t1CountCtx *p;
! 1094: p = sqlite3_aggregate_context(context, sizeof(*p));
! 1095: if( p ){
! 1096: if( p->n==42 ){
! 1097: sqlite3_result_error(context, "x_count totals to 42", -1);
! 1098: }else{
! 1099: sqlite3_result_int(context, p ? p->n : 0);
! 1100: }
! 1101: }
! 1102: }
! 1103:
! 1104: #ifndef SQLITE_OMIT_DEPRECATED
! 1105: static void legacyCountStep(
! 1106: sqlite3_context *context,
! 1107: int argc,
! 1108: sqlite3_value **argv
! 1109: ){
! 1110: /* no-op */
! 1111: }
! 1112:
! 1113: static void legacyCountFinalize(sqlite3_context *context){
! 1114: sqlite3_result_int(context, sqlite3_aggregate_count(context));
! 1115: }
! 1116: #endif
! 1117:
! 1118: /*
! 1119: ** Usage: sqlite3_create_aggregate DB
! 1120: **
! 1121: ** Call the sqlite3_create_function API on the given database in order
! 1122: ** to create a function named "x_count". This function is similar
! 1123: ** to the built-in count() function, with a few special quirks
! 1124: ** for testing the sqlite3_result_error() APIs.
! 1125: **
! 1126: ** The original motivation for this routine was to be able to call the
! 1127: ** sqlite3_create_aggregate function while a query is in progress in order
! 1128: ** to test the SQLITE_MISUSE detection logic. See misuse.test.
! 1129: **
! 1130: ** This routine was later extended to test the use of sqlite3_result_error()
! 1131: ** within aggregate functions.
! 1132: **
! 1133: ** Later: It is now also extended to register the aggregate function
! 1134: ** "legacy_count()" with the supplied database handle. This is used
! 1135: ** to test the deprecated sqlite3_aggregate_count() API.
! 1136: */
! 1137: static int test_create_aggregate(
! 1138: void *NotUsed,
! 1139: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1140: int argc, /* Number of arguments */
! 1141: char **argv /* Text of each argument */
! 1142: ){
! 1143: sqlite3 *db;
! 1144: int rc;
! 1145: if( argc!=2 ){
! 1146: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 1147: " FILENAME\"", 0);
! 1148: return TCL_ERROR;
! 1149: }
! 1150: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 1151: rc = sqlite3_create_function(db, "x_count", 0, SQLITE_UTF8, 0, 0,
! 1152: t1CountStep,t1CountFinalize);
! 1153: if( rc==SQLITE_OK ){
! 1154: rc = sqlite3_create_function(db, "x_count", 1, SQLITE_UTF8, 0, 0,
! 1155: t1CountStep,t1CountFinalize);
! 1156: }
! 1157: #ifndef SQLITE_OMIT_DEPRECATED
! 1158: if( rc==SQLITE_OK ){
! 1159: rc = sqlite3_create_function(db, "legacy_count", 0, SQLITE_ANY, 0, 0,
! 1160: legacyCountStep, legacyCountFinalize
! 1161: );
! 1162: }
! 1163: #endif
! 1164: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 1165: Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
! 1166: return TCL_OK;
! 1167: }
! 1168:
! 1169:
! 1170: /*
! 1171: ** Usage: printf TEXT
! 1172: **
! 1173: ** Send output to printf. Use this rather than puts to merge the output
! 1174: ** in the correct sequence with debugging printfs inserted into C code.
! 1175: ** Puts uses a separate buffer and debugging statements will be out of
! 1176: ** sequence if it is used.
! 1177: */
! 1178: static int test_printf(
! 1179: void *NotUsed,
! 1180: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1181: int argc, /* Number of arguments */
! 1182: char **argv /* Text of each argument */
! 1183: ){
! 1184: if( argc!=2 ){
! 1185: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 1186: " TEXT\"", 0);
! 1187: return TCL_ERROR;
! 1188: }
! 1189: printf("%s\n", argv[1]);
! 1190: return TCL_OK;
! 1191: }
! 1192:
! 1193:
! 1194:
! 1195: /*
! 1196: ** Usage: sqlite3_mprintf_int FORMAT INTEGER INTEGER INTEGER
! 1197: **
! 1198: ** Call mprintf with three integer arguments
! 1199: */
! 1200: static int sqlite3_mprintf_int(
! 1201: void *NotUsed,
! 1202: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1203: int argc, /* Number of arguments */
! 1204: char **argv /* Text of each argument */
! 1205: ){
! 1206: int a[3], i;
! 1207: char *z;
! 1208: if( argc!=5 ){
! 1209: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 1210: " FORMAT INT INT INT\"", 0);
! 1211: return TCL_ERROR;
! 1212: }
! 1213: for(i=2; i<5; i++){
! 1214: if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
! 1215: }
! 1216: z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]);
! 1217: Tcl_AppendResult(interp, z, 0);
! 1218: sqlite3_free(z);
! 1219: return TCL_OK;
! 1220: }
! 1221:
! 1222: /*
! 1223: ** Usage: sqlite3_mprintf_int64 FORMAT INTEGER INTEGER INTEGER
! 1224: **
! 1225: ** Call mprintf with three 64-bit integer arguments
! 1226: */
! 1227: static int sqlite3_mprintf_int64(
! 1228: void *NotUsed,
! 1229: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1230: int argc, /* Number of arguments */
! 1231: char **argv /* Text of each argument */
! 1232: ){
! 1233: int i;
! 1234: sqlite_int64 a[3];
! 1235: char *z;
! 1236: if( argc!=5 ){
! 1237: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 1238: " FORMAT INT INT INT\"", 0);
! 1239: return TCL_ERROR;
! 1240: }
! 1241: for(i=2; i<5; i++){
! 1242: if( sqlite3Atoi64(argv[i], &a[i-2], 1000000, SQLITE_UTF8) ){
! 1243: Tcl_AppendResult(interp, "argument is not a valid 64-bit integer", 0);
! 1244: return TCL_ERROR;
! 1245: }
! 1246: }
! 1247: z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]);
! 1248: Tcl_AppendResult(interp, z, 0);
! 1249: sqlite3_free(z);
! 1250: return TCL_OK;
! 1251: }
! 1252:
! 1253: /*
! 1254: ** Usage: sqlite3_mprintf_long FORMAT INTEGER INTEGER INTEGER
! 1255: **
! 1256: ** Call mprintf with three long integer arguments. This might be the
! 1257: ** same as sqlite3_mprintf_int or sqlite3_mprintf_int64, depending on
! 1258: ** platform.
! 1259: */
! 1260: static int sqlite3_mprintf_long(
! 1261: void *NotUsed,
! 1262: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1263: int argc, /* Number of arguments */
! 1264: char **argv /* Text of each argument */
! 1265: ){
! 1266: int i;
! 1267: long int a[3];
! 1268: int b[3];
! 1269: char *z;
! 1270: if( argc!=5 ){
! 1271: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 1272: " FORMAT INT INT INT\"", 0);
! 1273: return TCL_ERROR;
! 1274: }
! 1275: for(i=2; i<5; i++){
! 1276: if( Tcl_GetInt(interp, argv[i], &b[i-2]) ) return TCL_ERROR;
! 1277: a[i-2] = (long int)b[i-2];
! 1278: a[i-2] &= (((u64)1)<<(sizeof(int)*8))-1;
! 1279: }
! 1280: z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]);
! 1281: Tcl_AppendResult(interp, z, 0);
! 1282: sqlite3_free(z);
! 1283: return TCL_OK;
! 1284: }
! 1285:
! 1286: /*
! 1287: ** Usage: sqlite3_mprintf_str FORMAT INTEGER INTEGER STRING
! 1288: **
! 1289: ** Call mprintf with two integer arguments and one string argument
! 1290: */
! 1291: static int sqlite3_mprintf_str(
! 1292: void *NotUsed,
! 1293: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1294: int argc, /* Number of arguments */
! 1295: char **argv /* Text of each argument */
! 1296: ){
! 1297: int a[3], i;
! 1298: char *z;
! 1299: if( argc<4 || argc>5 ){
! 1300: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 1301: " FORMAT INT INT ?STRING?\"", 0);
! 1302: return TCL_ERROR;
! 1303: }
! 1304: for(i=2; i<4; i++){
! 1305: if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
! 1306: }
! 1307: z = sqlite3_mprintf(argv[1], a[0], a[1], argc>4 ? argv[4] : NULL);
! 1308: Tcl_AppendResult(interp, z, 0);
! 1309: sqlite3_free(z);
! 1310: return TCL_OK;
! 1311: }
! 1312:
! 1313: /*
! 1314: ** Usage: sqlite3_snprintf_str INTEGER FORMAT INTEGER INTEGER STRING
! 1315: **
! 1316: ** Call mprintf with two integer arguments and one string argument
! 1317: */
! 1318: static int sqlite3_snprintf_str(
! 1319: void *NotUsed,
! 1320: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1321: int argc, /* Number of arguments */
! 1322: char **argv /* Text of each argument */
! 1323: ){
! 1324: int a[3], i;
! 1325: int n;
! 1326: char *z;
! 1327: if( argc<5 || argc>6 ){
! 1328: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 1329: " INT FORMAT INT INT ?STRING?\"", 0);
! 1330: return TCL_ERROR;
! 1331: }
! 1332: if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR;
! 1333: if( n<0 ){
! 1334: Tcl_AppendResult(interp, "N must be non-negative", 0);
! 1335: return TCL_ERROR;
! 1336: }
! 1337: for(i=3; i<5; i++){
! 1338: if( Tcl_GetInt(interp, argv[i], &a[i-3]) ) return TCL_ERROR;
! 1339: }
! 1340: z = sqlite3_malloc( n+1 );
! 1341: sqlite3_snprintf(n, z, argv[2], a[0], a[1], argc>4 ? argv[5] : NULL);
! 1342: Tcl_AppendResult(interp, z, 0);
! 1343: sqlite3_free(z);
! 1344: return TCL_OK;
! 1345: }
! 1346:
! 1347: /*
! 1348: ** Usage: sqlite3_mprintf_double FORMAT INTEGER INTEGER DOUBLE
! 1349: **
! 1350: ** Call mprintf with two integer arguments and one double argument
! 1351: */
! 1352: static int sqlite3_mprintf_double(
! 1353: void *NotUsed,
! 1354: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1355: int argc, /* Number of arguments */
! 1356: char **argv /* Text of each argument */
! 1357: ){
! 1358: int a[3], i;
! 1359: double r;
! 1360: char *z;
! 1361: if( argc!=5 ){
! 1362: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 1363: " FORMAT INT INT DOUBLE\"", 0);
! 1364: return TCL_ERROR;
! 1365: }
! 1366: for(i=2; i<4; i++){
! 1367: if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
! 1368: }
! 1369: if( Tcl_GetDouble(interp, argv[4], &r) ) return TCL_ERROR;
! 1370: z = sqlite3_mprintf(argv[1], a[0], a[1], r);
! 1371: Tcl_AppendResult(interp, z, 0);
! 1372: sqlite3_free(z);
! 1373: return TCL_OK;
! 1374: }
! 1375:
! 1376: /*
! 1377: ** Usage: sqlite3_mprintf_scaled FORMAT DOUBLE DOUBLE
! 1378: **
! 1379: ** Call mprintf with a single double argument which is the product of the
! 1380: ** two arguments given above. This is used to generate overflow and underflow
! 1381: ** doubles to test that they are converted properly.
! 1382: */
! 1383: static int sqlite3_mprintf_scaled(
! 1384: void *NotUsed,
! 1385: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1386: int argc, /* Number of arguments */
! 1387: char **argv /* Text of each argument */
! 1388: ){
! 1389: int i;
! 1390: double r[2];
! 1391: char *z;
! 1392: if( argc!=4 ){
! 1393: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 1394: " FORMAT DOUBLE DOUBLE\"", 0);
! 1395: return TCL_ERROR;
! 1396: }
! 1397: for(i=2; i<4; i++){
! 1398: if( Tcl_GetDouble(interp, argv[i], &r[i-2]) ) return TCL_ERROR;
! 1399: }
! 1400: z = sqlite3_mprintf(argv[1], r[0]*r[1]);
! 1401: Tcl_AppendResult(interp, z, 0);
! 1402: sqlite3_free(z);
! 1403: return TCL_OK;
! 1404: }
! 1405:
! 1406: /*
! 1407: ** Usage: sqlite3_mprintf_stronly FORMAT STRING
! 1408: **
! 1409: ** Call mprintf with a single double argument which is the product of the
! 1410: ** two arguments given above. This is used to generate overflow and underflow
! 1411: ** doubles to test that they are converted properly.
! 1412: */
! 1413: static int sqlite3_mprintf_stronly(
! 1414: void *NotUsed,
! 1415: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1416: int argc, /* Number of arguments */
! 1417: char **argv /* Text of each argument */
! 1418: ){
! 1419: char *z;
! 1420: if( argc!=3 ){
! 1421: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 1422: " FORMAT STRING\"", 0);
! 1423: return TCL_ERROR;
! 1424: }
! 1425: z = sqlite3_mprintf(argv[1], argv[2]);
! 1426: Tcl_AppendResult(interp, z, 0);
! 1427: sqlite3_free(z);
! 1428: return TCL_OK;
! 1429: }
! 1430:
! 1431: /*
! 1432: ** Usage: sqlite3_mprintf_hexdouble FORMAT HEX
! 1433: **
! 1434: ** Call mprintf with a single double argument which is derived from the
! 1435: ** hexadecimal encoding of an IEEE double.
! 1436: */
! 1437: static int sqlite3_mprintf_hexdouble(
! 1438: void *NotUsed,
! 1439: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1440: int argc, /* Number of arguments */
! 1441: char **argv /* Text of each argument */
! 1442: ){
! 1443: char *z;
! 1444: double r;
! 1445: unsigned int x1, x2;
! 1446: sqlite_uint64 d;
! 1447: if( argc!=3 ){
! 1448: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 1449: " FORMAT STRING\"", 0);
! 1450: return TCL_ERROR;
! 1451: }
! 1452: if( sscanf(argv[2], "%08x%08x", &x2, &x1)!=2 ){
! 1453: Tcl_AppendResult(interp, "2nd argument should be 16-characters of hex", 0);
! 1454: return TCL_ERROR;
! 1455: }
! 1456: d = x2;
! 1457: d = (d<<32) + x1;
! 1458: memcpy(&r, &d, sizeof(r));
! 1459: z = sqlite3_mprintf(argv[1], r);
! 1460: Tcl_AppendResult(interp, z, 0);
! 1461: sqlite3_free(z);
! 1462: return TCL_OK;
! 1463: }
! 1464:
! 1465: /*
! 1466: ** Usage: sqlite3_enable_shared_cache ?BOOLEAN?
! 1467: **
! 1468: */
! 1469: #if !defined(SQLITE_OMIT_SHARED_CACHE)
! 1470: static int test_enable_shared(
! 1471: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 1472: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1473: int objc, /* Number of arguments */
! 1474: Tcl_Obj *CONST objv[] /* Command arguments */
! 1475: ){
! 1476: int rc;
! 1477: int enable;
! 1478: int ret = 0;
! 1479:
! 1480: if( objc!=2 && objc!=1 ){
! 1481: Tcl_WrongNumArgs(interp, 1, objv, "?BOOLEAN?");
! 1482: return TCL_ERROR;
! 1483: }
! 1484: ret = sqlite3GlobalConfig.sharedCacheEnabled;
! 1485:
! 1486: if( objc==2 ){
! 1487: if( Tcl_GetBooleanFromObj(interp, objv[1], &enable) ){
! 1488: return TCL_ERROR;
! 1489: }
! 1490: rc = sqlite3_enable_shared_cache(enable);
! 1491: if( rc!=SQLITE_OK ){
! 1492: Tcl_SetResult(interp, (char *)sqlite3ErrStr(rc), TCL_STATIC);
! 1493: return TCL_ERROR;
! 1494: }
! 1495: }
! 1496: Tcl_SetObjResult(interp, Tcl_NewBooleanObj(ret));
! 1497: return TCL_OK;
! 1498: }
! 1499: #endif
! 1500:
! 1501:
! 1502:
! 1503: /*
! 1504: ** Usage: sqlite3_extended_result_codes DB BOOLEAN
! 1505: **
! 1506: */
! 1507: static int test_extended_result_codes(
! 1508: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 1509: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1510: int objc, /* Number of arguments */
! 1511: Tcl_Obj *CONST objv[] /* Command arguments */
! 1512: ){
! 1513: int enable;
! 1514: sqlite3 *db;
! 1515:
! 1516: if( objc!=3 ){
! 1517: Tcl_WrongNumArgs(interp, 1, objv, "DB BOOLEAN");
! 1518: return TCL_ERROR;
! 1519: }
! 1520: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 1521: if( Tcl_GetBooleanFromObj(interp, objv[2], &enable) ) return TCL_ERROR;
! 1522: sqlite3_extended_result_codes(db, enable);
! 1523: return TCL_OK;
! 1524: }
! 1525:
! 1526: /*
! 1527: ** Usage: sqlite3_libversion_number
! 1528: **
! 1529: */
! 1530: static int test_libversion_number(
! 1531: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 1532: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1533: int objc, /* Number of arguments */
! 1534: Tcl_Obj *CONST objv[] /* Command arguments */
! 1535: ){
! 1536: Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_libversion_number()));
! 1537: return TCL_OK;
! 1538: }
! 1539:
! 1540: /*
! 1541: ** Usage: sqlite3_table_column_metadata DB dbname tblname colname
! 1542: **
! 1543: */
! 1544: #ifdef SQLITE_ENABLE_COLUMN_METADATA
! 1545: static int test_table_column_metadata(
! 1546: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 1547: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1548: int objc, /* Number of arguments */
! 1549: Tcl_Obj *CONST objv[] /* Command arguments */
! 1550: ){
! 1551: sqlite3 *db;
! 1552: const char *zDb;
! 1553: const char *zTbl;
! 1554: const char *zCol;
! 1555: int rc;
! 1556: Tcl_Obj *pRet;
! 1557:
! 1558: const char *zDatatype;
! 1559: const char *zCollseq;
! 1560: int notnull;
! 1561: int primarykey;
! 1562: int autoincrement;
! 1563:
! 1564: if( objc!=5 ){
! 1565: Tcl_WrongNumArgs(interp, 1, objv, "DB dbname tblname colname");
! 1566: return TCL_ERROR;
! 1567: }
! 1568: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 1569: zDb = Tcl_GetString(objv[2]);
! 1570: zTbl = Tcl_GetString(objv[3]);
! 1571: zCol = Tcl_GetString(objv[4]);
! 1572:
! 1573: if( strlen(zDb)==0 ) zDb = 0;
! 1574:
! 1575: rc = sqlite3_table_column_metadata(db, zDb, zTbl, zCol,
! 1576: &zDatatype, &zCollseq, ¬null, &primarykey, &autoincrement);
! 1577:
! 1578: if( rc!=SQLITE_OK ){
! 1579: Tcl_AppendResult(interp, sqlite3_errmsg(db), 0);
! 1580: return TCL_ERROR;
! 1581: }
! 1582:
! 1583: pRet = Tcl_NewObj();
! 1584: Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zDatatype, -1));
! 1585: Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zCollseq, -1));
! 1586: Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(notnull));
! 1587: Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(primarykey));
! 1588: Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(autoincrement));
! 1589: Tcl_SetObjResult(interp, pRet);
! 1590:
! 1591: return TCL_OK;
! 1592: }
! 1593: #endif
! 1594:
! 1595: #ifndef SQLITE_OMIT_INCRBLOB
! 1596:
! 1597: static int blobHandleFromObj(
! 1598: Tcl_Interp *interp,
! 1599: Tcl_Obj *pObj,
! 1600: sqlite3_blob **ppBlob
! 1601: ){
! 1602: char *z;
! 1603: int n;
! 1604:
! 1605: z = Tcl_GetStringFromObj(pObj, &n);
! 1606: if( n==0 ){
! 1607: *ppBlob = 0;
! 1608: }else{
! 1609: int notUsed;
! 1610: Tcl_Channel channel;
! 1611: ClientData instanceData;
! 1612:
! 1613: channel = Tcl_GetChannel(interp, z, ¬Used);
! 1614: if( !channel ) return TCL_ERROR;
! 1615:
! 1616: Tcl_Flush(channel);
! 1617: Tcl_Seek(channel, 0, SEEK_SET);
! 1618:
! 1619: instanceData = Tcl_GetChannelInstanceData(channel);
! 1620: *ppBlob = *((sqlite3_blob **)instanceData);
! 1621: }
! 1622:
! 1623: return TCL_OK;
! 1624: }
! 1625:
! 1626: /*
! 1627: ** sqlite3_blob_bytes CHANNEL
! 1628: */
! 1629: static int test_blob_bytes(
! 1630: ClientData clientData, /* Not used */
! 1631: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1632: int objc, /* Number of arguments */
! 1633: Tcl_Obj *CONST objv[] /* Command arguments */
! 1634: ){
! 1635: sqlite3_blob *pBlob;
! 1636: int nByte;
! 1637:
! 1638: if( objc!=2 ){
! 1639: Tcl_WrongNumArgs(interp, 1, objv, "CHANNEL");
! 1640: return TCL_ERROR;
! 1641: }
! 1642:
! 1643: if( blobHandleFromObj(interp, objv[1], &pBlob) ) return TCL_ERROR;
! 1644: nByte = sqlite3_blob_bytes(pBlob);
! 1645: Tcl_SetObjResult(interp, Tcl_NewIntObj(nByte));
! 1646:
! 1647: return TCL_OK;
! 1648: }
! 1649:
! 1650: /*
! 1651: ** sqlite3_blob_close CHANNEL
! 1652: */
! 1653: static int test_blob_close(
! 1654: ClientData clientData, /* Not used */
! 1655: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1656: int objc, /* Number of arguments */
! 1657: Tcl_Obj *CONST objv[] /* Command arguments */
! 1658: ){
! 1659: sqlite3_blob *pBlob;
! 1660:
! 1661: if( objc!=2 ){
! 1662: Tcl_WrongNumArgs(interp, 1, objv, "CHANNEL");
! 1663: return TCL_ERROR;
! 1664: }
! 1665:
! 1666: if( blobHandleFromObj(interp, objv[1], &pBlob) ) return TCL_ERROR;
! 1667: sqlite3_blob_close(pBlob);
! 1668:
! 1669: return TCL_OK;
! 1670: }
! 1671:
! 1672: /*
! 1673: ** sqlite3_blob_read CHANNEL OFFSET N
! 1674: **
! 1675: ** This command is used to test the sqlite3_blob_read() in ways that
! 1676: ** the Tcl channel interface does not. The first argument should
! 1677: ** be the name of a valid channel created by the [incrblob] method
! 1678: ** of a database handle. This function calls sqlite3_blob_read()
! 1679: ** to read N bytes from offset OFFSET from the underlying SQLite
! 1680: ** blob handle.
! 1681: **
! 1682: ** On success, a byte-array object containing the read data is
! 1683: ** returned. On failure, the interpreter result is set to the
! 1684: ** text representation of the returned error code (i.e. "SQLITE_NOMEM")
! 1685: ** and a Tcl exception is thrown.
! 1686: */
! 1687: static int test_blob_read(
! 1688: ClientData clientData, /* Not used */
! 1689: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1690: int objc, /* Number of arguments */
! 1691: Tcl_Obj *CONST objv[] /* Command arguments */
! 1692: ){
! 1693: sqlite3_blob *pBlob;
! 1694: int nByte;
! 1695: int iOffset;
! 1696: unsigned char *zBuf = 0;
! 1697: int rc;
! 1698:
! 1699: if( objc!=4 ){
! 1700: Tcl_WrongNumArgs(interp, 1, objv, "CHANNEL OFFSET N");
! 1701: return TCL_ERROR;
! 1702: }
! 1703:
! 1704: if( blobHandleFromObj(interp, objv[1], &pBlob) ) return TCL_ERROR;
! 1705: if( TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &iOffset)
! 1706: || TCL_OK!=Tcl_GetIntFromObj(interp, objv[3], &nByte)
! 1707: ){
! 1708: return TCL_ERROR;
! 1709: }
! 1710:
! 1711: if( nByte>0 ){
! 1712: zBuf = (unsigned char *)Tcl_Alloc(nByte);
! 1713: }
! 1714: rc = sqlite3_blob_read(pBlob, zBuf, nByte, iOffset);
! 1715: if( rc==SQLITE_OK ){
! 1716: Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(zBuf, nByte));
! 1717: }else{
! 1718: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
! 1719: }
! 1720: Tcl_Free((char *)zBuf);
! 1721:
! 1722: return (rc==SQLITE_OK ? TCL_OK : TCL_ERROR);
! 1723: }
! 1724:
! 1725: /*
! 1726: ** sqlite3_blob_write CHANNEL OFFSET DATA ?NDATA?
! 1727: **
! 1728: ** This command is used to test the sqlite3_blob_write() in ways that
! 1729: ** the Tcl channel interface does not. The first argument should
! 1730: ** be the name of a valid channel created by the [incrblob] method
! 1731: ** of a database handle. This function calls sqlite3_blob_write()
! 1732: ** to write the DATA byte-array to the underlying SQLite blob handle.
! 1733: ** at offset OFFSET.
! 1734: **
! 1735: ** On success, an empty string is returned. On failure, the interpreter
! 1736: ** result is set to the text representation of the returned error code
! 1737: ** (i.e. "SQLITE_NOMEM") and a Tcl exception is thrown.
! 1738: */
! 1739: static int test_blob_write(
! 1740: ClientData clientData, /* Not used */
! 1741: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1742: int objc, /* Number of arguments */
! 1743: Tcl_Obj *CONST objv[] /* Command arguments */
! 1744: ){
! 1745: sqlite3_blob *pBlob;
! 1746: int iOffset;
! 1747: int rc;
! 1748:
! 1749: unsigned char *zBuf;
! 1750: int nBuf;
! 1751:
! 1752: if( objc!=4 && objc!=5 ){
! 1753: Tcl_WrongNumArgs(interp, 1, objv, "CHANNEL OFFSET DATA ?NDATA?");
! 1754: return TCL_ERROR;
! 1755: }
! 1756:
! 1757: if( blobHandleFromObj(interp, objv[1], &pBlob) ) return TCL_ERROR;
! 1758: if( TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &iOffset) ){
! 1759: return TCL_ERROR;
! 1760: }
! 1761:
! 1762: zBuf = Tcl_GetByteArrayFromObj(objv[3], &nBuf);
! 1763: if( objc==5 && Tcl_GetIntFromObj(interp, objv[4], &nBuf) ){
! 1764: return TCL_ERROR;
! 1765: }
! 1766: rc = sqlite3_blob_write(pBlob, zBuf, nBuf, iOffset);
! 1767: if( rc!=SQLITE_OK ){
! 1768: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
! 1769: }
! 1770:
! 1771: return (rc==SQLITE_OK ? TCL_OK : TCL_ERROR);
! 1772: }
! 1773:
! 1774: static int test_blob_reopen(
! 1775: ClientData clientData, /* Not used */
! 1776: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1777: int objc, /* Number of arguments */
! 1778: Tcl_Obj *CONST objv[] /* Command arguments */
! 1779: ){
! 1780: Tcl_WideInt iRowid;
! 1781: sqlite3_blob *pBlob;
! 1782: int rc;
! 1783:
! 1784: if( objc!=3 ){
! 1785: Tcl_WrongNumArgs(interp, 1, objv, "CHANNEL ROWID");
! 1786: return TCL_ERROR;
! 1787: }
! 1788:
! 1789: if( blobHandleFromObj(interp, objv[1], &pBlob) ) return TCL_ERROR;
! 1790: if( Tcl_GetWideIntFromObj(interp, objv[2], &iRowid) ) return TCL_ERROR;
! 1791:
! 1792: rc = sqlite3_blob_reopen(pBlob, iRowid);
! 1793: if( rc!=SQLITE_OK ){
! 1794: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
! 1795: }
! 1796:
! 1797: return (rc==SQLITE_OK ? TCL_OK : TCL_ERROR);
! 1798: }
! 1799:
! 1800: #endif
! 1801:
! 1802: /*
! 1803: ** Usage: sqlite3_create_collation_v2 DB-HANDLE NAME CMP-PROC DEL-PROC
! 1804: **
! 1805: ** This Tcl proc is used for testing the experimental
! 1806: ** sqlite3_create_collation_v2() interface.
! 1807: */
! 1808: struct TestCollationX {
! 1809: Tcl_Interp *interp;
! 1810: Tcl_Obj *pCmp;
! 1811: Tcl_Obj *pDel;
! 1812: };
! 1813: typedef struct TestCollationX TestCollationX;
! 1814: static void testCreateCollationDel(void *pCtx){
! 1815: TestCollationX *p = (TestCollationX *)pCtx;
! 1816:
! 1817: int rc = Tcl_EvalObjEx(p->interp, p->pDel, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL);
! 1818: if( rc!=TCL_OK ){
! 1819: Tcl_BackgroundError(p->interp);
! 1820: }
! 1821:
! 1822: Tcl_DecrRefCount(p->pCmp);
! 1823: Tcl_DecrRefCount(p->pDel);
! 1824: sqlite3_free((void *)p);
! 1825: }
! 1826: static int testCreateCollationCmp(
! 1827: void *pCtx,
! 1828: int nLeft,
! 1829: const void *zLeft,
! 1830: int nRight,
! 1831: const void *zRight
! 1832: ){
! 1833: TestCollationX *p = (TestCollationX *)pCtx;
! 1834: Tcl_Obj *pScript = Tcl_DuplicateObj(p->pCmp);
! 1835: int iRes = 0;
! 1836:
! 1837: Tcl_IncrRefCount(pScript);
! 1838: Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj((char *)zLeft, nLeft));
! 1839: Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj((char *)zRight,nRight));
! 1840:
! 1841: if( TCL_OK!=Tcl_EvalObjEx(p->interp, pScript, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL)
! 1842: || TCL_OK!=Tcl_GetIntFromObj(p->interp, Tcl_GetObjResult(p->interp), &iRes)
! 1843: ){
! 1844: Tcl_BackgroundError(p->interp);
! 1845: }
! 1846: Tcl_DecrRefCount(pScript);
! 1847:
! 1848: return iRes;
! 1849: }
! 1850: static int test_create_collation_v2(
! 1851: ClientData clientData, /* Not used */
! 1852: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1853: int objc, /* Number of arguments */
! 1854: Tcl_Obj *CONST objv[] /* Command arguments */
! 1855: ){
! 1856: TestCollationX *p;
! 1857: sqlite3 *db;
! 1858: int rc;
! 1859:
! 1860: if( objc!=5 ){
! 1861: Tcl_WrongNumArgs(interp, 1, objv, "DB-HANDLE NAME CMP-PROC DEL-PROC");
! 1862: return TCL_ERROR;
! 1863: }
! 1864: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 1865:
! 1866: p = (TestCollationX *)sqlite3_malloc(sizeof(TestCollationX));
! 1867: p->pCmp = objv[3];
! 1868: p->pDel = objv[4];
! 1869: p->interp = interp;
! 1870: Tcl_IncrRefCount(p->pCmp);
! 1871: Tcl_IncrRefCount(p->pDel);
! 1872:
! 1873: rc = sqlite3_create_collation_v2(db, Tcl_GetString(objv[2]), 16,
! 1874: (void *)p, testCreateCollationCmp, testCreateCollationDel
! 1875: );
! 1876: if( rc!=SQLITE_MISUSE ){
! 1877: Tcl_AppendResult(interp, "sqlite3_create_collate_v2() failed to detect "
! 1878: "an invalid encoding", (char*)0);
! 1879: return TCL_ERROR;
! 1880: }
! 1881: rc = sqlite3_create_collation_v2(db, Tcl_GetString(objv[2]), SQLITE_UTF8,
! 1882: (void *)p, testCreateCollationCmp, testCreateCollationDel
! 1883: );
! 1884: return TCL_OK;
! 1885: }
! 1886:
! 1887: /*
! 1888: ** USAGE: sqlite3_create_function_v2 DB NAME NARG ENC ?SWITCHES?
! 1889: **
! 1890: ** Available switches are:
! 1891: **
! 1892: ** -func SCRIPT
! 1893: ** -step SCRIPT
! 1894: ** -final SCRIPT
! 1895: ** -destroy SCRIPT
! 1896: */
! 1897: typedef struct CreateFunctionV2 CreateFunctionV2;
! 1898: struct CreateFunctionV2 {
! 1899: Tcl_Interp *interp;
! 1900: Tcl_Obj *pFunc; /* Script for function invocation */
! 1901: Tcl_Obj *pStep; /* Script for agg. step invocation */
! 1902: Tcl_Obj *pFinal; /* Script for agg. finalization invocation */
! 1903: Tcl_Obj *pDestroy; /* Destructor script */
! 1904: };
! 1905: static void cf2Func(sqlite3_context *ctx, int nArg, sqlite3_value **aArg){
! 1906: }
! 1907: static void cf2Step(sqlite3_context *ctx, int nArg, sqlite3_value **aArg){
! 1908: }
! 1909: static void cf2Final(sqlite3_context *ctx){
! 1910: }
! 1911: static void cf2Destroy(void *pUser){
! 1912: CreateFunctionV2 *p = (CreateFunctionV2 *)pUser;
! 1913:
! 1914: if( p->interp && p->pDestroy ){
! 1915: int rc = Tcl_EvalObjEx(p->interp, p->pDestroy, 0);
! 1916: if( rc!=TCL_OK ) Tcl_BackgroundError(p->interp);
! 1917: }
! 1918:
! 1919: if( p->pFunc ) Tcl_DecrRefCount(p->pFunc);
! 1920: if( p->pStep ) Tcl_DecrRefCount(p->pStep);
! 1921: if( p->pFinal ) Tcl_DecrRefCount(p->pFinal);
! 1922: if( p->pDestroy ) Tcl_DecrRefCount(p->pDestroy);
! 1923: sqlite3_free(p);
! 1924: }
! 1925: static int test_create_function_v2(
! 1926: ClientData clientData, /* Not used */
! 1927: Tcl_Interp *interp, /* The invoking TCL interpreter */
! 1928: int objc, /* Number of arguments */
! 1929: Tcl_Obj *CONST objv[] /* Command arguments */
! 1930: ){
! 1931: sqlite3 *db;
! 1932: const char *zFunc;
! 1933: int nArg;
! 1934: int enc;
! 1935: CreateFunctionV2 *p;
! 1936: int i;
! 1937: int rc;
! 1938:
! 1939: struct EncTable {
! 1940: const char *zEnc;
! 1941: int enc;
! 1942: } aEnc[] = {
! 1943: {"utf8", SQLITE_UTF8 },
! 1944: {"utf16", SQLITE_UTF16 },
! 1945: {"utf16le", SQLITE_UTF16LE },
! 1946: {"utf16be", SQLITE_UTF16BE },
! 1947: {"any", SQLITE_ANY },
! 1948: {"0", 0 }
! 1949: };
! 1950:
! 1951: if( objc<5 || (objc%2)==0 ){
! 1952: Tcl_WrongNumArgs(interp, 1, objv, "DB NAME NARG ENC SWITCHES...");
! 1953: return TCL_ERROR;
! 1954: }
! 1955:
! 1956: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 1957: zFunc = Tcl_GetString(objv[2]);
! 1958: if( Tcl_GetIntFromObj(interp, objv[3], &nArg) ) return TCL_ERROR;
! 1959: if( Tcl_GetIndexFromObjStruct(interp, objv[4], aEnc, sizeof(aEnc[0]),
! 1960: "encoding", 0, &enc)
! 1961: ){
! 1962: return TCL_ERROR;
! 1963: }
! 1964: enc = aEnc[enc].enc;
! 1965:
! 1966: p = sqlite3_malloc(sizeof(CreateFunctionV2));
! 1967: assert( p );
! 1968: memset(p, 0, sizeof(CreateFunctionV2));
! 1969: p->interp = interp;
! 1970:
! 1971: for(i=5; i<objc; i+=2){
! 1972: int iSwitch;
! 1973: const char *azSwitch[] = {"-func", "-step", "-final", "-destroy", 0};
! 1974: if( Tcl_GetIndexFromObj(interp, objv[i], azSwitch, "switch", 0, &iSwitch) ){
! 1975: sqlite3_free(p);
! 1976: return TCL_ERROR;
! 1977: }
! 1978:
! 1979: switch( iSwitch ){
! 1980: case 0: p->pFunc = objv[i+1]; break;
! 1981: case 1: p->pStep = objv[i+1]; break;
! 1982: case 2: p->pFinal = objv[i+1]; break;
! 1983: case 3: p->pDestroy = objv[i+1]; break;
! 1984: }
! 1985: }
! 1986: if( p->pFunc ) p->pFunc = Tcl_DuplicateObj(p->pFunc);
! 1987: if( p->pStep ) p->pStep = Tcl_DuplicateObj(p->pStep);
! 1988: if( p->pFinal ) p->pFinal = Tcl_DuplicateObj(p->pFinal);
! 1989: if( p->pDestroy ) p->pDestroy = Tcl_DuplicateObj(p->pDestroy);
! 1990:
! 1991: if( p->pFunc ) Tcl_IncrRefCount(p->pFunc);
! 1992: if( p->pStep ) Tcl_IncrRefCount(p->pStep);
! 1993: if( p->pFinal ) Tcl_IncrRefCount(p->pFinal);
! 1994: if( p->pDestroy ) Tcl_IncrRefCount(p->pDestroy);
! 1995:
! 1996: rc = sqlite3_create_function_v2(db, zFunc, nArg, enc, (void *)p,
! 1997: (p->pFunc ? cf2Func : 0),
! 1998: (p->pStep ? cf2Step : 0),
! 1999: (p->pFinal ? cf2Final : 0),
! 2000: cf2Destroy
! 2001: );
! 2002: if( rc!=SQLITE_OK ){
! 2003: Tcl_ResetResult(interp);
! 2004: Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
! 2005: return TCL_ERROR;
! 2006: }
! 2007: return TCL_OK;
! 2008: }
! 2009:
! 2010: /*
! 2011: ** Usage: sqlite3_load_extension DB-HANDLE FILE ?PROC?
! 2012: */
! 2013: static int test_load_extension(
! 2014: ClientData clientData, /* Not used */
! 2015: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 2016: int objc, /* Number of arguments */
! 2017: Tcl_Obj *CONST objv[] /* Command arguments */
! 2018: ){
! 2019: Tcl_CmdInfo cmdInfo;
! 2020: sqlite3 *db;
! 2021: int rc;
! 2022: char *zDb;
! 2023: char *zFile;
! 2024: char *zProc = 0;
! 2025: char *zErr = 0;
! 2026:
! 2027: if( objc!=4 && objc!=3 ){
! 2028: Tcl_WrongNumArgs(interp, 1, objv, "DB-HANDLE FILE ?PROC?");
! 2029: return TCL_ERROR;
! 2030: }
! 2031: zDb = Tcl_GetString(objv[1]);
! 2032: zFile = Tcl_GetString(objv[2]);
! 2033: if( objc==4 ){
! 2034: zProc = Tcl_GetString(objv[3]);
! 2035: }
! 2036:
! 2037: /* Extract the C database handle from the Tcl command name */
! 2038: if( !Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){
! 2039: Tcl_AppendResult(interp, "command not found: ", zDb, (char*)0);
! 2040: return TCL_ERROR;
! 2041: }
! 2042: db = ((struct SqliteDb*)cmdInfo.objClientData)->db;
! 2043: assert(db);
! 2044:
! 2045: /* Call the underlying C function. If an error occurs, set rc to
! 2046: ** TCL_ERROR and load any error string into the interpreter. If no
! 2047: ** error occurs, set rc to TCL_OK.
! 2048: */
! 2049: #ifdef SQLITE_OMIT_LOAD_EXTENSION
! 2050: rc = SQLITE_ERROR;
! 2051: zErr = sqlite3_mprintf("this build omits sqlite3_load_extension()");
! 2052: #else
! 2053: rc = sqlite3_load_extension(db, zFile, zProc, &zErr);
! 2054: #endif
! 2055: if( rc!=SQLITE_OK ){
! 2056: Tcl_SetResult(interp, zErr ? zErr : "", TCL_VOLATILE);
! 2057: rc = TCL_ERROR;
! 2058: }else{
! 2059: rc = TCL_OK;
! 2060: }
! 2061: sqlite3_free(zErr);
! 2062:
! 2063: return rc;
! 2064: }
! 2065:
! 2066: /*
! 2067: ** Usage: sqlite3_enable_load_extension DB-HANDLE ONOFF
! 2068: */
! 2069: static int test_enable_load(
! 2070: ClientData clientData, /* Not used */
! 2071: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 2072: int objc, /* Number of arguments */
! 2073: Tcl_Obj *CONST objv[] /* Command arguments */
! 2074: ){
! 2075: Tcl_CmdInfo cmdInfo;
! 2076: sqlite3 *db;
! 2077: char *zDb;
! 2078: int onoff;
! 2079:
! 2080: if( objc!=3 ){
! 2081: Tcl_WrongNumArgs(interp, 1, objv, "DB-HANDLE ONOFF");
! 2082: return TCL_ERROR;
! 2083: }
! 2084: zDb = Tcl_GetString(objv[1]);
! 2085:
! 2086: /* Extract the C database handle from the Tcl command name */
! 2087: if( !Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){
! 2088: Tcl_AppendResult(interp, "command not found: ", zDb, (char*)0);
! 2089: return TCL_ERROR;
! 2090: }
! 2091: db = ((struct SqliteDb*)cmdInfo.objClientData)->db;
! 2092: assert(db);
! 2093:
! 2094: /* Get the onoff parameter */
! 2095: if( Tcl_GetBooleanFromObj(interp, objv[2], &onoff) ){
! 2096: return TCL_ERROR;
! 2097: }
! 2098:
! 2099: #ifdef SQLITE_OMIT_LOAD_EXTENSION
! 2100: Tcl_AppendResult(interp, "this build omits sqlite3_load_extension()");
! 2101: return TCL_ERROR;
! 2102: #else
! 2103: sqlite3_enable_load_extension(db, onoff);
! 2104: return TCL_OK;
! 2105: #endif
! 2106: }
! 2107:
! 2108: /*
! 2109: ** Usage: sqlite_abort
! 2110: **
! 2111: ** Shutdown the process immediately. This is not a clean shutdown.
! 2112: ** This command is used to test the recoverability of a database in
! 2113: ** the event of a program crash.
! 2114: */
! 2115: static int sqlite_abort(
! 2116: void *NotUsed,
! 2117: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 2118: int argc, /* Number of arguments */
! 2119: char **argv /* Text of each argument */
! 2120: ){
! 2121: #if defined(_MSC_VER)
! 2122: /* We do this, otherwise the test will halt with a popup message
! 2123: * that we have to click away before the test will continue.
! 2124: */
! 2125: _set_abort_behavior( 0, _CALL_REPORTFAULT );
! 2126: #endif
! 2127: exit(255);
! 2128: assert( interp==0 ); /* This will always fail */
! 2129: return TCL_OK;
! 2130: }
! 2131:
! 2132: /*
! 2133: ** The following routine is a user-defined SQL function whose purpose
! 2134: ** is to test the sqlite_set_result() API.
! 2135: */
! 2136: static void testFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
! 2137: while( argc>=2 ){
! 2138: const char *zArg0 = (char*)sqlite3_value_text(argv[0]);
! 2139: if( zArg0 ){
! 2140: if( 0==sqlite3StrICmp(zArg0, "int") ){
! 2141: sqlite3_result_int(context, sqlite3_value_int(argv[1]));
! 2142: }else if( sqlite3StrICmp(zArg0,"int64")==0 ){
! 2143: sqlite3_result_int64(context, sqlite3_value_int64(argv[1]));
! 2144: }else if( sqlite3StrICmp(zArg0,"string")==0 ){
! 2145: sqlite3_result_text(context, (char*)sqlite3_value_text(argv[1]), -1,
! 2146: SQLITE_TRANSIENT);
! 2147: }else if( sqlite3StrICmp(zArg0,"double")==0 ){
! 2148: sqlite3_result_double(context, sqlite3_value_double(argv[1]));
! 2149: }else if( sqlite3StrICmp(zArg0,"null")==0 ){
! 2150: sqlite3_result_null(context);
! 2151: }else if( sqlite3StrICmp(zArg0,"value")==0 ){
! 2152: sqlite3_result_value(context, argv[sqlite3_value_int(argv[1])]);
! 2153: }else{
! 2154: goto error_out;
! 2155: }
! 2156: }else{
! 2157: goto error_out;
! 2158: }
! 2159: argc -= 2;
! 2160: argv += 2;
! 2161: }
! 2162: return;
! 2163:
! 2164: error_out:
! 2165: sqlite3_result_error(context,"first argument should be one of: "
! 2166: "int int64 string double null value", -1);
! 2167: }
! 2168:
! 2169: /*
! 2170: ** Usage: sqlite_register_test_function DB NAME
! 2171: **
! 2172: ** Register the test SQL function on the database DB under the name NAME.
! 2173: */
! 2174: static int test_register_func(
! 2175: void *NotUsed,
! 2176: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 2177: int argc, /* Number of arguments */
! 2178: char **argv /* Text of each argument */
! 2179: ){
! 2180: sqlite3 *db;
! 2181: int rc;
! 2182: if( argc!=3 ){
! 2183: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 2184: " DB FUNCTION-NAME", 0);
! 2185: return TCL_ERROR;
! 2186: }
! 2187: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 2188: rc = sqlite3_create_function(db, argv[2], -1, SQLITE_UTF8, 0,
! 2189: testFunc, 0, 0);
! 2190: if( rc!=0 ){
! 2191: Tcl_AppendResult(interp, sqlite3ErrStr(rc), 0);
! 2192: return TCL_ERROR;
! 2193: }
! 2194: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 2195: return TCL_OK;
! 2196: }
! 2197:
! 2198: /*
! 2199: ** Usage: sqlite3_finalize STMT
! 2200: **
! 2201: ** Finalize a statement handle.
! 2202: */
! 2203: static int test_finalize(
! 2204: void * clientData,
! 2205: Tcl_Interp *interp,
! 2206: int objc,
! 2207: Tcl_Obj *CONST objv[]
! 2208: ){
! 2209: sqlite3_stmt *pStmt;
! 2210: int rc;
! 2211: sqlite3 *db = 0;
! 2212:
! 2213: if( objc!=2 ){
! 2214: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 2215: Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0);
! 2216: return TCL_ERROR;
! 2217: }
! 2218:
! 2219: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 2220:
! 2221: if( pStmt ){
! 2222: db = StmtToDb(pStmt);
! 2223: }
! 2224: rc = sqlite3_finalize(pStmt);
! 2225: Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
! 2226: if( db && sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 2227: return TCL_OK;
! 2228: }
! 2229:
! 2230: /*
! 2231: ** Usage: sqlite3_stmt_status STMT CODE RESETFLAG
! 2232: **
! 2233: ** Get the value of a status counter from a statement.
! 2234: */
! 2235: static int test_stmt_status(
! 2236: void * clientData,
! 2237: Tcl_Interp *interp,
! 2238: int objc,
! 2239: Tcl_Obj *CONST objv[]
! 2240: ){
! 2241: int iValue;
! 2242: int i, op, resetFlag;
! 2243: const char *zOpName;
! 2244: sqlite3_stmt *pStmt;
! 2245:
! 2246: static const struct {
! 2247: const char *zName;
! 2248: int op;
! 2249: } aOp[] = {
! 2250: { "SQLITE_STMTSTATUS_FULLSCAN_STEP", SQLITE_STMTSTATUS_FULLSCAN_STEP },
! 2251: { "SQLITE_STMTSTATUS_SORT", SQLITE_STMTSTATUS_SORT },
! 2252: { "SQLITE_STMTSTATUS_AUTOINDEX", SQLITE_STMTSTATUS_AUTOINDEX },
! 2253: };
! 2254: if( objc!=4 ){
! 2255: Tcl_WrongNumArgs(interp, 1, objv, "STMT PARAMETER RESETFLAG");
! 2256: return TCL_ERROR;
! 2257: }
! 2258: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 2259: zOpName = Tcl_GetString(objv[2]);
! 2260: for(i=0; i<ArraySize(aOp); i++){
! 2261: if( strcmp(aOp[i].zName, zOpName)==0 ){
! 2262: op = aOp[i].op;
! 2263: break;
! 2264: }
! 2265: }
! 2266: if( i>=ArraySize(aOp) ){
! 2267: if( Tcl_GetIntFromObj(interp, objv[2], &op) ) return TCL_ERROR;
! 2268: }
! 2269: if( Tcl_GetBooleanFromObj(interp, objv[3], &resetFlag) ) return TCL_ERROR;
! 2270: iValue = sqlite3_stmt_status(pStmt, op, resetFlag);
! 2271: Tcl_SetObjResult(interp, Tcl_NewIntObj(iValue));
! 2272: return TCL_OK;
! 2273: }
! 2274:
! 2275: /*
! 2276: ** Usage: sqlite3_next_stmt DB STMT
! 2277: **
! 2278: ** Return the next statment in sequence after STMT.
! 2279: */
! 2280: static int test_next_stmt(
! 2281: void * clientData,
! 2282: Tcl_Interp *interp,
! 2283: int objc,
! 2284: Tcl_Obj *CONST objv[]
! 2285: ){
! 2286: sqlite3_stmt *pStmt;
! 2287: sqlite3 *db = 0;
! 2288: char zBuf[50];
! 2289:
! 2290: if( objc!=3 ){
! 2291: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 2292: Tcl_GetStringFromObj(objv[0], 0), " DB STMT", 0);
! 2293: return TCL_ERROR;
! 2294: }
! 2295:
! 2296: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 2297: if( getStmtPointer(interp, Tcl_GetString(objv[2]), &pStmt) ) return TCL_ERROR;
! 2298: pStmt = sqlite3_next_stmt(db, pStmt);
! 2299: if( pStmt ){
! 2300: if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
! 2301: Tcl_AppendResult(interp, zBuf, 0);
! 2302: }
! 2303: return TCL_OK;
! 2304: }
! 2305:
! 2306: /*
! 2307: ** Usage: sqlite3_stmt_readonly STMT
! 2308: **
! 2309: ** Return true if STMT is a NULL pointer or a pointer to a statement
! 2310: ** that is guaranteed to leave the database unmodified.
! 2311: */
! 2312: static int test_stmt_readonly(
! 2313: void * clientData,
! 2314: Tcl_Interp *interp,
! 2315: int objc,
! 2316: Tcl_Obj *CONST objv[]
! 2317: ){
! 2318: sqlite3_stmt *pStmt;
! 2319: int rc;
! 2320:
! 2321: if( objc!=2 ){
! 2322: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 2323: Tcl_GetStringFromObj(objv[0], 0), " STMT", 0);
! 2324: return TCL_ERROR;
! 2325: }
! 2326:
! 2327: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 2328: rc = sqlite3_stmt_readonly(pStmt);
! 2329: Tcl_SetObjResult(interp, Tcl_NewBooleanObj(rc));
! 2330: return TCL_OK;
! 2331: }
! 2332:
! 2333: /*
! 2334: ** Usage: sqlite3_stmt_busy STMT
! 2335: **
! 2336: ** Return true if STMT is a non-NULL pointer to a statement
! 2337: ** that has been stepped but not to completion.
! 2338: */
! 2339: static int test_stmt_busy(
! 2340: void * clientData,
! 2341: Tcl_Interp *interp,
! 2342: int objc,
! 2343: Tcl_Obj *CONST objv[]
! 2344: ){
! 2345: sqlite3_stmt *pStmt;
! 2346: int rc;
! 2347:
! 2348: if( objc!=2 ){
! 2349: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 2350: Tcl_GetStringFromObj(objv[0], 0), " STMT", 0);
! 2351: return TCL_ERROR;
! 2352: }
! 2353:
! 2354: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 2355: rc = sqlite3_stmt_busy(pStmt);
! 2356: Tcl_SetObjResult(interp, Tcl_NewBooleanObj(rc));
! 2357: return TCL_OK;
! 2358: }
! 2359:
! 2360: /*
! 2361: ** Usage: uses_stmt_journal STMT
! 2362: **
! 2363: ** Return true if STMT uses a statement journal.
! 2364: */
! 2365: static int uses_stmt_journal(
! 2366: void * clientData,
! 2367: Tcl_Interp *interp,
! 2368: int objc,
! 2369: Tcl_Obj *CONST objv[]
! 2370: ){
! 2371: sqlite3_stmt *pStmt;
! 2372: int rc;
! 2373:
! 2374: if( objc!=2 ){
! 2375: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 2376: Tcl_GetStringFromObj(objv[0], 0), " STMT", 0);
! 2377: return TCL_ERROR;
! 2378: }
! 2379:
! 2380: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 2381: rc = sqlite3_stmt_readonly(pStmt);
! 2382: Tcl_SetObjResult(interp, Tcl_NewBooleanObj(((Vdbe *)pStmt)->usesStmtJournal));
! 2383: return TCL_OK;
! 2384: }
! 2385:
! 2386:
! 2387: /*
! 2388: ** Usage: sqlite3_reset STMT
! 2389: **
! 2390: ** Reset a statement handle.
! 2391: */
! 2392: static int test_reset(
! 2393: void * clientData,
! 2394: Tcl_Interp *interp,
! 2395: int objc,
! 2396: Tcl_Obj *CONST objv[]
! 2397: ){
! 2398: sqlite3_stmt *pStmt;
! 2399: int rc;
! 2400:
! 2401: if( objc!=2 ){
! 2402: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 2403: Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0);
! 2404: return TCL_ERROR;
! 2405: }
! 2406:
! 2407: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 2408:
! 2409: rc = sqlite3_reset(pStmt);
! 2410: if( pStmt && sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ){
! 2411: return TCL_ERROR;
! 2412: }
! 2413: Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
! 2414: /*
! 2415: if( rc ){
! 2416: return TCL_ERROR;
! 2417: }
! 2418: */
! 2419: return TCL_OK;
! 2420: }
! 2421:
! 2422: /*
! 2423: ** Usage: sqlite3_expired STMT
! 2424: **
! 2425: ** Return TRUE if a recompilation of the statement is recommended.
! 2426: */
! 2427: static int test_expired(
! 2428: void * clientData,
! 2429: Tcl_Interp *interp,
! 2430: int objc,
! 2431: Tcl_Obj *CONST objv[]
! 2432: ){
! 2433: #ifndef SQLITE_OMIT_DEPRECATED
! 2434: sqlite3_stmt *pStmt;
! 2435: if( objc!=2 ){
! 2436: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 2437: Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0);
! 2438: return TCL_ERROR;
! 2439: }
! 2440: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 2441: Tcl_SetObjResult(interp, Tcl_NewBooleanObj(sqlite3_expired(pStmt)));
! 2442: #endif
! 2443: return TCL_OK;
! 2444: }
! 2445:
! 2446: /*
! 2447: ** Usage: sqlite3_transfer_bindings FROMSTMT TOSTMT
! 2448: **
! 2449: ** Transfer all bindings from FROMSTMT over to TOSTMT
! 2450: */
! 2451: static int test_transfer_bind(
! 2452: void * clientData,
! 2453: Tcl_Interp *interp,
! 2454: int objc,
! 2455: Tcl_Obj *CONST objv[]
! 2456: ){
! 2457: #ifndef SQLITE_OMIT_DEPRECATED
! 2458: sqlite3_stmt *pStmt1, *pStmt2;
! 2459: if( objc!=3 ){
! 2460: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 2461: Tcl_GetStringFromObj(objv[0], 0), " FROM-STMT TO-STMT", 0);
! 2462: return TCL_ERROR;
! 2463: }
! 2464: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt1)) return TCL_ERROR;
! 2465: if( getStmtPointer(interp, Tcl_GetString(objv[2]), &pStmt2)) return TCL_ERROR;
! 2466: Tcl_SetObjResult(interp,
! 2467: Tcl_NewIntObj(sqlite3_transfer_bindings(pStmt1,pStmt2)));
! 2468: #endif
! 2469: return TCL_OK;
! 2470: }
! 2471:
! 2472: /*
! 2473: ** Usage: sqlite3_changes DB
! 2474: **
! 2475: ** Return the number of changes made to the database by the last SQL
! 2476: ** execution.
! 2477: */
! 2478: static int test_changes(
! 2479: void * clientData,
! 2480: Tcl_Interp *interp,
! 2481: int objc,
! 2482: Tcl_Obj *CONST objv[]
! 2483: ){
! 2484: sqlite3 *db;
! 2485: if( objc!=2 ){
! 2486: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 2487: Tcl_GetString(objv[0]), " DB", 0);
! 2488: return TCL_ERROR;
! 2489: }
! 2490: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 2491: Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_changes(db)));
! 2492: return TCL_OK;
! 2493: }
! 2494:
! 2495: /*
! 2496: ** This is the "static_bind_value" that variables are bound to when
! 2497: ** the FLAG option of sqlite3_bind is "static"
! 2498: */
! 2499: static char *sqlite_static_bind_value = 0;
! 2500: static int sqlite_static_bind_nbyte = 0;
! 2501:
! 2502: /*
! 2503: ** Usage: sqlite3_bind VM IDX VALUE FLAGS
! 2504: **
! 2505: ** Sets the value of the IDX-th occurance of "?" in the original SQL
! 2506: ** string. VALUE is the new value. If FLAGS=="null" then VALUE is
! 2507: ** ignored and the value is set to NULL. If FLAGS=="static" then
! 2508: ** the value is set to the value of a static variable named
! 2509: ** "sqlite_static_bind_value". If FLAGS=="normal" then a copy
! 2510: ** of the VALUE is made. If FLAGS=="blob10" then a VALUE is ignored
! 2511: ** an a 10-byte blob "abc\000xyz\000pq" is inserted.
! 2512: */
! 2513: static int test_bind(
! 2514: void *NotUsed,
! 2515: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 2516: int argc, /* Number of arguments */
! 2517: char **argv /* Text of each argument */
! 2518: ){
! 2519: sqlite3_stmt *pStmt;
! 2520: int rc;
! 2521: int idx;
! 2522: if( argc!=5 ){
! 2523: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 2524: " VM IDX VALUE (null|static|normal)\"", 0);
! 2525: return TCL_ERROR;
! 2526: }
! 2527: if( getStmtPointer(interp, argv[1], &pStmt) ) return TCL_ERROR;
! 2528: if( Tcl_GetInt(interp, argv[2], &idx) ) return TCL_ERROR;
! 2529: if( strcmp(argv[4],"null")==0 ){
! 2530: rc = sqlite3_bind_null(pStmt, idx);
! 2531: }else if( strcmp(argv[4],"static")==0 ){
! 2532: rc = sqlite3_bind_text(pStmt, idx, sqlite_static_bind_value, -1, 0);
! 2533: }else if( strcmp(argv[4],"static-nbytes")==0 ){
! 2534: rc = sqlite3_bind_text(pStmt, idx, sqlite_static_bind_value,
! 2535: sqlite_static_bind_nbyte, 0);
! 2536: }else if( strcmp(argv[4],"normal")==0 ){
! 2537: rc = sqlite3_bind_text(pStmt, idx, argv[3], -1, SQLITE_TRANSIENT);
! 2538: }else if( strcmp(argv[4],"blob10")==0 ){
! 2539: rc = sqlite3_bind_text(pStmt, idx, "abc\000xyz\000pq", 10, SQLITE_STATIC);
! 2540: }else{
! 2541: Tcl_AppendResult(interp, "4th argument should be "
! 2542: "\"null\" or \"static\" or \"normal\"", 0);
! 2543: return TCL_ERROR;
! 2544: }
! 2545: if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
! 2546: if( rc ){
! 2547: char zBuf[50];
! 2548: sprintf(zBuf, "(%d) ", rc);
! 2549: Tcl_AppendResult(interp, zBuf, sqlite3ErrStr(rc), 0);
! 2550: return TCL_ERROR;
! 2551: }
! 2552: return TCL_OK;
! 2553: }
! 2554:
! 2555: #ifndef SQLITE_OMIT_UTF16
! 2556: /*
! 2557: ** Usage: add_test_collate <db ptr> <utf8> <utf16le> <utf16be>
! 2558: **
! 2559: ** This function is used to test that SQLite selects the correct collation
! 2560: ** sequence callback when multiple versions (for different text encodings)
! 2561: ** are available.
! 2562: **
! 2563: ** Calling this routine registers the collation sequence "test_collate"
! 2564: ** with database handle <db>. The second argument must be a list of three
! 2565: ** boolean values. If the first is true, then a version of test_collate is
! 2566: ** registered for UTF-8, if the second is true, a version is registered for
! 2567: ** UTF-16le, if the third is true, a UTF-16be version is available.
! 2568: ** Previous versions of test_collate are deleted.
! 2569: **
! 2570: ** The collation sequence test_collate is implemented by calling the
! 2571: ** following TCL script:
! 2572: **
! 2573: ** "test_collate <enc> <lhs> <rhs>"
! 2574: **
! 2575: ** The <lhs> and <rhs> are the two values being compared, encoded in UTF-8.
! 2576: ** The <enc> parameter is the encoding of the collation function that
! 2577: ** SQLite selected to call. The TCL test script implements the
! 2578: ** "test_collate" proc.
! 2579: **
! 2580: ** Note that this will only work with one intepreter at a time, as the
! 2581: ** interp pointer to use when evaluating the TCL script is stored in
! 2582: ** pTestCollateInterp.
! 2583: */
! 2584: static Tcl_Interp* pTestCollateInterp;
! 2585: static int test_collate_func(
! 2586: void *pCtx,
! 2587: int nA, const void *zA,
! 2588: int nB, const void *zB
! 2589: ){
! 2590: Tcl_Interp *i = pTestCollateInterp;
! 2591: int encin = SQLITE_PTR_TO_INT(pCtx);
! 2592: int res;
! 2593: int n;
! 2594:
! 2595: sqlite3_value *pVal;
! 2596: Tcl_Obj *pX;
! 2597:
! 2598: pX = Tcl_NewStringObj("test_collate", -1);
! 2599: Tcl_IncrRefCount(pX);
! 2600:
! 2601: switch( encin ){
! 2602: case SQLITE_UTF8:
! 2603: Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-8",-1));
! 2604: break;
! 2605: case SQLITE_UTF16LE:
! 2606: Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-16LE",-1));
! 2607: break;
! 2608: case SQLITE_UTF16BE:
! 2609: Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-16BE",-1));
! 2610: break;
! 2611: default:
! 2612: assert(0);
! 2613: }
! 2614:
! 2615: sqlite3BeginBenignMalloc();
! 2616: pVal = sqlite3ValueNew(0);
! 2617: if( pVal ){
! 2618: sqlite3ValueSetStr(pVal, nA, zA, encin, SQLITE_STATIC);
! 2619: n = sqlite3_value_bytes(pVal);
! 2620: Tcl_ListObjAppendElement(i,pX,
! 2621: Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n));
! 2622: sqlite3ValueSetStr(pVal, nB, zB, encin, SQLITE_STATIC);
! 2623: n = sqlite3_value_bytes(pVal);
! 2624: Tcl_ListObjAppendElement(i,pX,
! 2625: Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n));
! 2626: sqlite3ValueFree(pVal);
! 2627: }
! 2628: sqlite3EndBenignMalloc();
! 2629:
! 2630: Tcl_EvalObjEx(i, pX, 0);
! 2631: Tcl_DecrRefCount(pX);
! 2632: Tcl_GetIntFromObj(i, Tcl_GetObjResult(i), &res);
! 2633: return res;
! 2634: }
! 2635: static int test_collate(
! 2636: void * clientData,
! 2637: Tcl_Interp *interp,
! 2638: int objc,
! 2639: Tcl_Obj *CONST objv[]
! 2640: ){
! 2641: sqlite3 *db;
! 2642: int val;
! 2643: sqlite3_value *pVal;
! 2644: int rc;
! 2645:
! 2646: if( objc!=5 ) goto bad_args;
! 2647: pTestCollateInterp = interp;
! 2648: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 2649:
! 2650: if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR;
! 2651: rc = sqlite3_create_collation(db, "test_collate", SQLITE_UTF8,
! 2652: (void *)SQLITE_UTF8, val?test_collate_func:0);
! 2653: if( rc==SQLITE_OK ){
! 2654: const void *zUtf16;
! 2655: if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &val) ) return TCL_ERROR;
! 2656: rc = sqlite3_create_collation(db, "test_collate", SQLITE_UTF16LE,
! 2657: (void *)SQLITE_UTF16LE, val?test_collate_func:0);
! 2658: if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[4], &val) ) return TCL_ERROR;
! 2659:
! 2660: #if 0
! 2661: if( sqlite3_iMallocFail>0 ){
! 2662: sqlite3_iMallocFail++;
! 2663: }
! 2664: #endif
! 2665: sqlite3_mutex_enter(db->mutex);
! 2666: pVal = sqlite3ValueNew(db);
! 2667: sqlite3ValueSetStr(pVal, -1, "test_collate", SQLITE_UTF8, SQLITE_STATIC);
! 2668: zUtf16 = sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
! 2669: if( db->mallocFailed ){
! 2670: rc = SQLITE_NOMEM;
! 2671: }else{
! 2672: rc = sqlite3_create_collation16(db, zUtf16, SQLITE_UTF16BE,
! 2673: (void *)SQLITE_UTF16BE, val?test_collate_func:0);
! 2674: }
! 2675: sqlite3ValueFree(pVal);
! 2676: sqlite3_mutex_leave(db->mutex);
! 2677: }
! 2678: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 2679:
! 2680: if( rc!=SQLITE_OK ){
! 2681: Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
! 2682: return TCL_ERROR;
! 2683: }
! 2684: return TCL_OK;
! 2685:
! 2686: bad_args:
! 2687: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 2688: Tcl_GetStringFromObj(objv[0], 0), " <DB> <utf8> <utf16le> <utf16be>", 0);
! 2689: return TCL_ERROR;
! 2690: }
! 2691:
! 2692: /*
! 2693: ** When the collation needed callback is invoked, record the name of
! 2694: ** the requested collating function here. The recorded name is linked
! 2695: ** to a TCL variable and used to make sure that the requested collation
! 2696: ** name is correct.
! 2697: */
! 2698: static char zNeededCollation[200];
! 2699: static char *pzNeededCollation = zNeededCollation;
! 2700:
! 2701:
! 2702: /*
! 2703: ** Called when a collating sequence is needed. Registered using
! 2704: ** sqlite3_collation_needed16().
! 2705: */
! 2706: static void test_collate_needed_cb(
! 2707: void *pCtx,
! 2708: sqlite3 *db,
! 2709: int eTextRep,
! 2710: const void *pName
! 2711: ){
! 2712: int enc = ENC(db);
! 2713: int i;
! 2714: char *z;
! 2715: for(z = (char*)pName, i=0; *z || z[1]; z++){
! 2716: if( *z ) zNeededCollation[i++] = *z;
! 2717: }
! 2718: zNeededCollation[i] = 0;
! 2719: sqlite3_create_collation(
! 2720: db, "test_collate", ENC(db), SQLITE_INT_TO_PTR(enc), test_collate_func);
! 2721: }
! 2722:
! 2723: /*
! 2724: ** Usage: add_test_collate_needed DB
! 2725: */
! 2726: static int test_collate_needed(
! 2727: void * clientData,
! 2728: Tcl_Interp *interp,
! 2729: int objc,
! 2730: Tcl_Obj *CONST objv[]
! 2731: ){
! 2732: sqlite3 *db;
! 2733: int rc;
! 2734:
! 2735: if( objc!=2 ) goto bad_args;
! 2736: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 2737: rc = sqlite3_collation_needed16(db, 0, test_collate_needed_cb);
! 2738: zNeededCollation[0] = 0;
! 2739: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 2740: return TCL_OK;
! 2741:
! 2742: bad_args:
! 2743: Tcl_WrongNumArgs(interp, 1, objv, "DB");
! 2744: return TCL_ERROR;
! 2745: }
! 2746:
! 2747: /*
! 2748: ** tclcmd: add_alignment_test_collations DB
! 2749: **
! 2750: ** Add two new collating sequences to the database DB
! 2751: **
! 2752: ** utf16_aligned
! 2753: ** utf16_unaligned
! 2754: **
! 2755: ** Both collating sequences use the same sort order as BINARY.
! 2756: ** The only difference is that the utf16_aligned collating
! 2757: ** sequence is declared with the SQLITE_UTF16_ALIGNED flag.
! 2758: ** Both collating functions increment the unaligned utf16 counter
! 2759: ** whenever they see a string that begins on an odd byte boundary.
! 2760: */
! 2761: static int unaligned_string_counter = 0;
! 2762: static int alignmentCollFunc(
! 2763: void *NotUsed,
! 2764: int nKey1, const void *pKey1,
! 2765: int nKey2, const void *pKey2
! 2766: ){
! 2767: int rc, n;
! 2768: n = nKey1<nKey2 ? nKey1 : nKey2;
! 2769: if( nKey1>0 && 1==(1&(SQLITE_PTR_TO_INT(pKey1))) ) unaligned_string_counter++;
! 2770: if( nKey2>0 && 1==(1&(SQLITE_PTR_TO_INT(pKey2))) ) unaligned_string_counter++;
! 2771: rc = memcmp(pKey1, pKey2, n);
! 2772: if( rc==0 ){
! 2773: rc = nKey1 - nKey2;
! 2774: }
! 2775: return rc;
! 2776: }
! 2777: static int add_alignment_test_collations(
! 2778: void * clientData,
! 2779: Tcl_Interp *interp,
! 2780: int objc,
! 2781: Tcl_Obj *CONST objv[]
! 2782: ){
! 2783: sqlite3 *db;
! 2784: if( objc>=2 ){
! 2785: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 2786: sqlite3_create_collation(db, "utf16_unaligned", SQLITE_UTF16,
! 2787: 0, alignmentCollFunc);
! 2788: sqlite3_create_collation(db, "utf16_aligned", SQLITE_UTF16_ALIGNED,
! 2789: 0, alignmentCollFunc);
! 2790: }
! 2791: return SQLITE_OK;
! 2792: }
! 2793: #endif /* !defined(SQLITE_OMIT_UTF16) */
! 2794:
! 2795: /*
! 2796: ** Usage: add_test_function <db ptr> <utf8> <utf16le> <utf16be>
! 2797: **
! 2798: ** This function is used to test that SQLite selects the correct user
! 2799: ** function callback when multiple versions (for different text encodings)
! 2800: ** are available.
! 2801: **
! 2802: ** Calling this routine registers up to three versions of the user function
! 2803: ** "test_function" with database handle <db>. If the second argument is
! 2804: ** true, then a version of test_function is registered for UTF-8, if the
! 2805: ** third is true, a version is registered for UTF-16le, if the fourth is
! 2806: ** true, a UTF-16be version is available. Previous versions of
! 2807: ** test_function are deleted.
! 2808: **
! 2809: ** The user function is implemented by calling the following TCL script:
! 2810: **
! 2811: ** "test_function <enc> <arg>"
! 2812: **
! 2813: ** Where <enc> is one of UTF-8, UTF-16LE or UTF16BE, and <arg> is the
! 2814: ** single argument passed to the SQL function. The value returned by
! 2815: ** the TCL script is used as the return value of the SQL function. It
! 2816: ** is passed to SQLite using UTF-16BE for a UTF-8 test_function(), UTF-8
! 2817: ** for a UTF-16LE test_function(), and UTF-16LE for an implementation that
! 2818: ** prefers UTF-16BE.
! 2819: */
! 2820: #ifndef SQLITE_OMIT_UTF16
! 2821: static void test_function_utf8(
! 2822: sqlite3_context *pCtx,
! 2823: int nArg,
! 2824: sqlite3_value **argv
! 2825: ){
! 2826: Tcl_Interp *interp;
! 2827: Tcl_Obj *pX;
! 2828: sqlite3_value *pVal;
! 2829: interp = (Tcl_Interp *)sqlite3_user_data(pCtx);
! 2830: pX = Tcl_NewStringObj("test_function", -1);
! 2831: Tcl_IncrRefCount(pX);
! 2832: Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-8", -1));
! 2833: Tcl_ListObjAppendElement(interp, pX,
! 2834: Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
! 2835: Tcl_EvalObjEx(interp, pX, 0);
! 2836: Tcl_DecrRefCount(pX);
! 2837: sqlite3_result_text(pCtx, Tcl_GetStringResult(interp), -1, SQLITE_TRANSIENT);
! 2838: pVal = sqlite3ValueNew(0);
! 2839: sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp),
! 2840: SQLITE_UTF8, SQLITE_STATIC);
! 2841: sqlite3_result_text16be(pCtx, sqlite3_value_text16be(pVal),
! 2842: -1, SQLITE_TRANSIENT);
! 2843: sqlite3ValueFree(pVal);
! 2844: }
! 2845: static void test_function_utf16le(
! 2846: sqlite3_context *pCtx,
! 2847: int nArg,
! 2848: sqlite3_value **argv
! 2849: ){
! 2850: Tcl_Interp *interp;
! 2851: Tcl_Obj *pX;
! 2852: sqlite3_value *pVal;
! 2853: interp = (Tcl_Interp *)sqlite3_user_data(pCtx);
! 2854: pX = Tcl_NewStringObj("test_function", -1);
! 2855: Tcl_IncrRefCount(pX);
! 2856: Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-16LE", -1));
! 2857: Tcl_ListObjAppendElement(interp, pX,
! 2858: Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
! 2859: Tcl_EvalObjEx(interp, pX, 0);
! 2860: Tcl_DecrRefCount(pX);
! 2861: pVal = sqlite3ValueNew(0);
! 2862: sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp),
! 2863: SQLITE_UTF8, SQLITE_STATIC);
! 2864: sqlite3_result_text(pCtx,(char*)sqlite3_value_text(pVal),-1,SQLITE_TRANSIENT);
! 2865: sqlite3ValueFree(pVal);
! 2866: }
! 2867: static void test_function_utf16be(
! 2868: sqlite3_context *pCtx,
! 2869: int nArg,
! 2870: sqlite3_value **argv
! 2871: ){
! 2872: Tcl_Interp *interp;
! 2873: Tcl_Obj *pX;
! 2874: sqlite3_value *pVal;
! 2875: interp = (Tcl_Interp *)sqlite3_user_data(pCtx);
! 2876: pX = Tcl_NewStringObj("test_function", -1);
! 2877: Tcl_IncrRefCount(pX);
! 2878: Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-16BE", -1));
! 2879: Tcl_ListObjAppendElement(interp, pX,
! 2880: Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
! 2881: Tcl_EvalObjEx(interp, pX, 0);
! 2882: Tcl_DecrRefCount(pX);
! 2883: pVal = sqlite3ValueNew(0);
! 2884: sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp),
! 2885: SQLITE_UTF8, SQLITE_STATIC);
! 2886: sqlite3_result_text16(pCtx, sqlite3_value_text16le(pVal),
! 2887: -1, SQLITE_TRANSIENT);
! 2888: sqlite3_result_text16be(pCtx, sqlite3_value_text16le(pVal),
! 2889: -1, SQLITE_TRANSIENT);
! 2890: sqlite3_result_text16le(pCtx, sqlite3_value_text16le(pVal),
! 2891: -1, SQLITE_TRANSIENT);
! 2892: sqlite3ValueFree(pVal);
! 2893: }
! 2894: #endif /* SQLITE_OMIT_UTF16 */
! 2895: static int test_function(
! 2896: void * clientData,
! 2897: Tcl_Interp *interp,
! 2898: int objc,
! 2899: Tcl_Obj *CONST objv[]
! 2900: ){
! 2901: #ifndef SQLITE_OMIT_UTF16
! 2902: sqlite3 *db;
! 2903: int val;
! 2904:
! 2905: if( objc!=5 ) goto bad_args;
! 2906: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 2907:
! 2908: if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR;
! 2909: if( val ){
! 2910: sqlite3_create_function(db, "test_function", 1, SQLITE_UTF8,
! 2911: interp, test_function_utf8, 0, 0);
! 2912: }
! 2913: if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &val) ) return TCL_ERROR;
! 2914: if( val ){
! 2915: sqlite3_create_function(db, "test_function", 1, SQLITE_UTF16LE,
! 2916: interp, test_function_utf16le, 0, 0);
! 2917: }
! 2918: if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[4], &val) ) return TCL_ERROR;
! 2919: if( val ){
! 2920: sqlite3_create_function(db, "test_function", 1, SQLITE_UTF16BE,
! 2921: interp, test_function_utf16be, 0, 0);
! 2922: }
! 2923:
! 2924: return TCL_OK;
! 2925: bad_args:
! 2926: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 2927: Tcl_GetStringFromObj(objv[0], 0), " <DB> <utf8> <utf16le> <utf16be>", 0);
! 2928: #endif /* SQLITE_OMIT_UTF16 */
! 2929: return TCL_ERROR;
! 2930: }
! 2931:
! 2932: /*
! 2933: ** Usage: sqlite3_test_errstr <err code>
! 2934: **
! 2935: ** Test that the english language string equivalents for sqlite error codes
! 2936: ** are sane. The parameter is an integer representing an sqlite error code.
! 2937: ** The result is a list of two elements, the string representation of the
! 2938: ** error code and the english language explanation.
! 2939: */
! 2940: static int test_errstr(
! 2941: void * clientData,
! 2942: Tcl_Interp *interp,
! 2943: int objc,
! 2944: Tcl_Obj *CONST objv[]
! 2945: ){
! 2946: char *zCode;
! 2947: int i;
! 2948: if( objc!=1 ){
! 2949: Tcl_WrongNumArgs(interp, 1, objv, "<error code>");
! 2950: }
! 2951:
! 2952: zCode = Tcl_GetString(objv[1]);
! 2953: for(i=0; i<200; i++){
! 2954: if( 0==strcmp(t1ErrorName(i), zCode) ) break;
! 2955: }
! 2956: Tcl_SetResult(interp, (char *)sqlite3ErrStr(i), 0);
! 2957: return TCL_OK;
! 2958: }
! 2959:
! 2960: /*
! 2961: ** Usage: breakpoint
! 2962: **
! 2963: ** This routine exists for one purpose - to provide a place to put a
! 2964: ** breakpoint with GDB that can be triggered using TCL code. The use
! 2965: ** for this is when a particular test fails on (say) the 1485th iteration.
! 2966: ** In the TCL test script, we can add code like this:
! 2967: **
! 2968: ** if {$i==1485} breakpoint
! 2969: **
! 2970: ** Then run testfixture in the debugger and wait for the breakpoint to
! 2971: ** fire. Then additional breakpoints can be set to trace down the bug.
! 2972: */
! 2973: static int test_breakpoint(
! 2974: void *NotUsed,
! 2975: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 2976: int argc, /* Number of arguments */
! 2977: char **argv /* Text of each argument */
! 2978: ){
! 2979: return TCL_OK; /* Do nothing */
! 2980: }
! 2981:
! 2982: /*
! 2983: ** Usage: sqlite3_bind_zeroblob STMT IDX N
! 2984: **
! 2985: ** Test the sqlite3_bind_zeroblob interface. STMT is a prepared statement.
! 2986: ** IDX is the index of a wildcard in the prepared statement. This command
! 2987: ** binds a N-byte zero-filled BLOB to the wildcard.
! 2988: */
! 2989: static int test_bind_zeroblob(
! 2990: void * clientData,
! 2991: Tcl_Interp *interp,
! 2992: int objc,
! 2993: Tcl_Obj *CONST objv[]
! 2994: ){
! 2995: sqlite3_stmt *pStmt;
! 2996: int idx;
! 2997: int n;
! 2998: int rc;
! 2999:
! 3000: if( objc!=4 ){
! 3001: Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX N");
! 3002: return TCL_ERROR;
! 3003: }
! 3004:
! 3005: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 3006: if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
! 3007: if( Tcl_GetIntFromObj(interp, objv[3], &n) ) return TCL_ERROR;
! 3008:
! 3009: rc = sqlite3_bind_zeroblob(pStmt, idx, n);
! 3010: if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
! 3011: if( rc!=SQLITE_OK ){
! 3012: return TCL_ERROR;
! 3013: }
! 3014:
! 3015: return TCL_OK;
! 3016: }
! 3017:
! 3018: /*
! 3019: ** Usage: sqlite3_bind_int STMT N VALUE
! 3020: **
! 3021: ** Test the sqlite3_bind_int interface. STMT is a prepared statement.
! 3022: ** N is the index of a wildcard in the prepared statement. This command
! 3023: ** binds a 32-bit integer VALUE to that wildcard.
! 3024: */
! 3025: static int test_bind_int(
! 3026: void * clientData,
! 3027: Tcl_Interp *interp,
! 3028: int objc,
! 3029: Tcl_Obj *CONST objv[]
! 3030: ){
! 3031: sqlite3_stmt *pStmt;
! 3032: int idx;
! 3033: int value;
! 3034: int rc;
! 3035:
! 3036: if( objc!=4 ){
! 3037: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3038: Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0);
! 3039: return TCL_ERROR;
! 3040: }
! 3041:
! 3042: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 3043: if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
! 3044: if( Tcl_GetIntFromObj(interp, objv[3], &value) ) return TCL_ERROR;
! 3045:
! 3046: rc = sqlite3_bind_int(pStmt, idx, value);
! 3047: if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
! 3048: if( rc!=SQLITE_OK ){
! 3049: return TCL_ERROR;
! 3050: }
! 3051:
! 3052: return TCL_OK;
! 3053: }
! 3054:
! 3055:
! 3056: /*
! 3057: ** Usage: sqlite3_bind_int64 STMT N VALUE
! 3058: **
! 3059: ** Test the sqlite3_bind_int64 interface. STMT is a prepared statement.
! 3060: ** N is the index of a wildcard in the prepared statement. This command
! 3061: ** binds a 64-bit integer VALUE to that wildcard.
! 3062: */
! 3063: static int test_bind_int64(
! 3064: void * clientData,
! 3065: Tcl_Interp *interp,
! 3066: int objc,
! 3067: Tcl_Obj *CONST objv[]
! 3068: ){
! 3069: sqlite3_stmt *pStmt;
! 3070: int idx;
! 3071: i64 value;
! 3072: int rc;
! 3073:
! 3074: if( objc!=4 ){
! 3075: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3076: Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0);
! 3077: return TCL_ERROR;
! 3078: }
! 3079:
! 3080: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 3081: if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
! 3082: if( Tcl_GetWideIntFromObj(interp, objv[3], &value) ) return TCL_ERROR;
! 3083:
! 3084: rc = sqlite3_bind_int64(pStmt, idx, value);
! 3085: if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
! 3086: if( rc!=SQLITE_OK ){
! 3087: return TCL_ERROR;
! 3088: }
! 3089:
! 3090: return TCL_OK;
! 3091: }
! 3092:
! 3093:
! 3094: /*
! 3095: ** Usage: sqlite3_bind_double STMT N VALUE
! 3096: **
! 3097: ** Test the sqlite3_bind_double interface. STMT is a prepared statement.
! 3098: ** N is the index of a wildcard in the prepared statement. This command
! 3099: ** binds a 64-bit integer VALUE to that wildcard.
! 3100: */
! 3101: static int test_bind_double(
! 3102: void * clientData,
! 3103: Tcl_Interp *interp,
! 3104: int objc,
! 3105: Tcl_Obj *CONST objv[]
! 3106: ){
! 3107: sqlite3_stmt *pStmt;
! 3108: int idx;
! 3109: double value;
! 3110: int rc;
! 3111: const char *zVal;
! 3112: int i;
! 3113: static const struct {
! 3114: const char *zName; /* Name of the special floating point value */
! 3115: unsigned int iUpper; /* Upper 32 bits */
! 3116: unsigned int iLower; /* Lower 32 bits */
! 3117: } aSpecialFp[] = {
! 3118: { "NaN", 0x7fffffff, 0xffffffff },
! 3119: { "SNaN", 0x7ff7ffff, 0xffffffff },
! 3120: { "-NaN", 0xffffffff, 0xffffffff },
! 3121: { "-SNaN", 0xfff7ffff, 0xffffffff },
! 3122: { "+Inf", 0x7ff00000, 0x00000000 },
! 3123: { "-Inf", 0xfff00000, 0x00000000 },
! 3124: { "Epsilon", 0x00000000, 0x00000001 },
! 3125: { "-Epsilon", 0x80000000, 0x00000001 },
! 3126: { "NaN0", 0x7ff80000, 0x00000000 },
! 3127: { "-NaN0", 0xfff80000, 0x00000000 },
! 3128: };
! 3129:
! 3130: if( objc!=4 ){
! 3131: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3132: Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0);
! 3133: return TCL_ERROR;
! 3134: }
! 3135:
! 3136: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 3137: if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
! 3138:
! 3139: /* Intercept the string "NaN" and generate a NaN value for it.
! 3140: ** All other strings are passed through to Tcl_GetDoubleFromObj().
! 3141: ** Tcl_GetDoubleFromObj() should understand "NaN" but some versions
! 3142: ** contain a bug.
! 3143: */
! 3144: zVal = Tcl_GetString(objv[3]);
! 3145: for(i=0; i<sizeof(aSpecialFp)/sizeof(aSpecialFp[0]); i++){
! 3146: if( strcmp(aSpecialFp[i].zName, zVal)==0 ){
! 3147: sqlite3_uint64 x;
! 3148: x = aSpecialFp[i].iUpper;
! 3149: x <<= 32;
! 3150: x |= aSpecialFp[i].iLower;
! 3151: assert( sizeof(value)==8 );
! 3152: assert( sizeof(x)==8 );
! 3153: memcpy(&value, &x, 8);
! 3154: break;
! 3155: }
! 3156: }
! 3157: if( i>=sizeof(aSpecialFp)/sizeof(aSpecialFp[0]) &&
! 3158: Tcl_GetDoubleFromObj(interp, objv[3], &value) ){
! 3159: return TCL_ERROR;
! 3160: }
! 3161: rc = sqlite3_bind_double(pStmt, idx, value);
! 3162: if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
! 3163: if( rc!=SQLITE_OK ){
! 3164: return TCL_ERROR;
! 3165: }
! 3166:
! 3167: return TCL_OK;
! 3168: }
! 3169:
! 3170: /*
! 3171: ** Usage: sqlite3_bind_null STMT N
! 3172: **
! 3173: ** Test the sqlite3_bind_null interface. STMT is a prepared statement.
! 3174: ** N is the index of a wildcard in the prepared statement. This command
! 3175: ** binds a NULL to the wildcard.
! 3176: */
! 3177: static int test_bind_null(
! 3178: void * clientData,
! 3179: Tcl_Interp *interp,
! 3180: int objc,
! 3181: Tcl_Obj *CONST objv[]
! 3182: ){
! 3183: sqlite3_stmt *pStmt;
! 3184: int idx;
! 3185: int rc;
! 3186:
! 3187: if( objc!=3 ){
! 3188: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3189: Tcl_GetStringFromObj(objv[0], 0), " STMT N", 0);
! 3190: return TCL_ERROR;
! 3191: }
! 3192:
! 3193: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 3194: if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
! 3195:
! 3196: rc = sqlite3_bind_null(pStmt, idx);
! 3197: if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
! 3198: if( rc!=SQLITE_OK ){
! 3199: return TCL_ERROR;
! 3200: }
! 3201:
! 3202: return TCL_OK;
! 3203: }
! 3204:
! 3205: /*
! 3206: ** Usage: sqlite3_bind_text STMT N STRING BYTES
! 3207: **
! 3208: ** Test the sqlite3_bind_text interface. STMT is a prepared statement.
! 3209: ** N is the index of a wildcard in the prepared statement. This command
! 3210: ** binds a UTF-8 string STRING to the wildcard. The string is BYTES bytes
! 3211: ** long.
! 3212: */
! 3213: static int test_bind_text(
! 3214: void * clientData,
! 3215: Tcl_Interp *interp,
! 3216: int objc,
! 3217: Tcl_Obj *CONST objv[]
! 3218: ){
! 3219: sqlite3_stmt *pStmt;
! 3220: int idx;
! 3221: int bytes;
! 3222: char *value;
! 3223: int rc;
! 3224:
! 3225: if( objc!=5 ){
! 3226: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3227: Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE BYTES", 0);
! 3228: return TCL_ERROR;
! 3229: }
! 3230:
! 3231: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 3232: if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
! 3233: value = (char*)Tcl_GetByteArrayFromObj(objv[3], &bytes);
! 3234: if( Tcl_GetIntFromObj(interp, objv[4], &bytes) ) return TCL_ERROR;
! 3235:
! 3236: rc = sqlite3_bind_text(pStmt, idx, value, bytes, SQLITE_TRANSIENT);
! 3237: if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
! 3238: if( rc!=SQLITE_OK ){
! 3239: Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
! 3240: return TCL_ERROR;
! 3241: }
! 3242:
! 3243: return TCL_OK;
! 3244: }
! 3245:
! 3246: /*
! 3247: ** Usage: sqlite3_bind_text16 ?-static? STMT N STRING BYTES
! 3248: **
! 3249: ** Test the sqlite3_bind_text16 interface. STMT is a prepared statement.
! 3250: ** N is the index of a wildcard in the prepared statement. This command
! 3251: ** binds a UTF-16 string STRING to the wildcard. The string is BYTES bytes
! 3252: ** long.
! 3253: */
! 3254: static int test_bind_text16(
! 3255: void * clientData,
! 3256: Tcl_Interp *interp,
! 3257: int objc,
! 3258: Tcl_Obj *CONST objv[]
! 3259: ){
! 3260: #ifndef SQLITE_OMIT_UTF16
! 3261: sqlite3_stmt *pStmt;
! 3262: int idx;
! 3263: int bytes;
! 3264: char *value;
! 3265: int rc;
! 3266:
! 3267: void (*xDel)() = (objc==6?SQLITE_STATIC:SQLITE_TRANSIENT);
! 3268: Tcl_Obj *oStmt = objv[objc-4];
! 3269: Tcl_Obj *oN = objv[objc-3];
! 3270: Tcl_Obj *oString = objv[objc-2];
! 3271: Tcl_Obj *oBytes = objv[objc-1];
! 3272:
! 3273: if( objc!=5 && objc!=6){
! 3274: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3275: Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE BYTES", 0);
! 3276: return TCL_ERROR;
! 3277: }
! 3278:
! 3279: if( getStmtPointer(interp, Tcl_GetString(oStmt), &pStmt) ) return TCL_ERROR;
! 3280: if( Tcl_GetIntFromObj(interp, oN, &idx) ) return TCL_ERROR;
! 3281: value = (char*)Tcl_GetByteArrayFromObj(oString, 0);
! 3282: if( Tcl_GetIntFromObj(interp, oBytes, &bytes) ) return TCL_ERROR;
! 3283:
! 3284: rc = sqlite3_bind_text16(pStmt, idx, (void *)value, bytes, xDel);
! 3285: if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
! 3286: if( rc!=SQLITE_OK ){
! 3287: Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
! 3288: return TCL_ERROR;
! 3289: }
! 3290:
! 3291: #endif /* SQLITE_OMIT_UTF16 */
! 3292: return TCL_OK;
! 3293: }
! 3294:
! 3295: /*
! 3296: ** Usage: sqlite3_bind_blob ?-static? STMT N DATA BYTES
! 3297: **
! 3298: ** Test the sqlite3_bind_blob interface. STMT is a prepared statement.
! 3299: ** N is the index of a wildcard in the prepared statement. This command
! 3300: ** binds a BLOB to the wildcard. The BLOB is BYTES bytes in size.
! 3301: */
! 3302: static int test_bind_blob(
! 3303: void * clientData,
! 3304: Tcl_Interp *interp,
! 3305: int objc,
! 3306: Tcl_Obj *CONST objv[]
! 3307: ){
! 3308: sqlite3_stmt *pStmt;
! 3309: int idx;
! 3310: int bytes;
! 3311: char *value;
! 3312: int rc;
! 3313: sqlite3_destructor_type xDestructor = SQLITE_TRANSIENT;
! 3314:
! 3315: if( objc!=5 && objc!=6 ){
! 3316: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3317: Tcl_GetStringFromObj(objv[0], 0), " STMT N DATA BYTES", 0);
! 3318: return TCL_ERROR;
! 3319: }
! 3320:
! 3321: if( objc==6 ){
! 3322: xDestructor = SQLITE_STATIC;
! 3323: objv++;
! 3324: }
! 3325:
! 3326: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 3327: if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
! 3328: value = Tcl_GetString(objv[3]);
! 3329: if( Tcl_GetIntFromObj(interp, objv[4], &bytes) ) return TCL_ERROR;
! 3330:
! 3331: rc = sqlite3_bind_blob(pStmt, idx, value, bytes, xDestructor);
! 3332: if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
! 3333: if( rc!=SQLITE_OK ){
! 3334: return TCL_ERROR;
! 3335: }
! 3336:
! 3337: return TCL_OK;
! 3338: }
! 3339:
! 3340: /*
! 3341: ** Usage: sqlite3_bind_parameter_count STMT
! 3342: **
! 3343: ** Return the number of wildcards in the given statement.
! 3344: */
! 3345: static int test_bind_parameter_count(
! 3346: void * clientData,
! 3347: Tcl_Interp *interp,
! 3348: int objc,
! 3349: Tcl_Obj *CONST objv[]
! 3350: ){
! 3351: sqlite3_stmt *pStmt;
! 3352:
! 3353: if( objc!=2 ){
! 3354: Tcl_WrongNumArgs(interp, 1, objv, "STMT");
! 3355: return TCL_ERROR;
! 3356: }
! 3357: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 3358: Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_bind_parameter_count(pStmt)));
! 3359: return TCL_OK;
! 3360: }
! 3361:
! 3362: /*
! 3363: ** Usage: sqlite3_bind_parameter_name STMT N
! 3364: **
! 3365: ** Return the name of the Nth wildcard. The first wildcard is 1.
! 3366: ** An empty string is returned if N is out of range or if the wildcard
! 3367: ** is nameless.
! 3368: */
! 3369: static int test_bind_parameter_name(
! 3370: void * clientData,
! 3371: Tcl_Interp *interp,
! 3372: int objc,
! 3373: Tcl_Obj *CONST objv[]
! 3374: ){
! 3375: sqlite3_stmt *pStmt;
! 3376: int i;
! 3377:
! 3378: if( objc!=3 ){
! 3379: Tcl_WrongNumArgs(interp, 1, objv, "STMT N");
! 3380: return TCL_ERROR;
! 3381: }
! 3382: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 3383: if( Tcl_GetIntFromObj(interp, objv[2], &i) ) return TCL_ERROR;
! 3384: Tcl_SetObjResult(interp,
! 3385: Tcl_NewStringObj(sqlite3_bind_parameter_name(pStmt,i),-1)
! 3386: );
! 3387: return TCL_OK;
! 3388: }
! 3389:
! 3390: /*
! 3391: ** Usage: sqlite3_bind_parameter_index STMT NAME
! 3392: **
! 3393: ** Return the index of the wildcard called NAME. Return 0 if there is
! 3394: ** no such wildcard.
! 3395: */
! 3396: static int test_bind_parameter_index(
! 3397: void * clientData,
! 3398: Tcl_Interp *interp,
! 3399: int objc,
! 3400: Tcl_Obj *CONST objv[]
! 3401: ){
! 3402: sqlite3_stmt *pStmt;
! 3403:
! 3404: if( objc!=3 ){
! 3405: Tcl_WrongNumArgs(interp, 1, objv, "STMT NAME");
! 3406: return TCL_ERROR;
! 3407: }
! 3408: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 3409: Tcl_SetObjResult(interp,
! 3410: Tcl_NewIntObj(
! 3411: sqlite3_bind_parameter_index(pStmt,Tcl_GetString(objv[2]))
! 3412: )
! 3413: );
! 3414: return TCL_OK;
! 3415: }
! 3416:
! 3417: /*
! 3418: ** Usage: sqlite3_clear_bindings STMT
! 3419: **
! 3420: */
! 3421: static int test_clear_bindings(
! 3422: void * clientData,
! 3423: Tcl_Interp *interp,
! 3424: int objc,
! 3425: Tcl_Obj *CONST objv[]
! 3426: ){
! 3427: sqlite3_stmt *pStmt;
! 3428:
! 3429: if( objc!=2 ){
! 3430: Tcl_WrongNumArgs(interp, 1, objv, "STMT");
! 3431: return TCL_ERROR;
! 3432: }
! 3433: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 3434: Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_clear_bindings(pStmt)));
! 3435: return TCL_OK;
! 3436: }
! 3437:
! 3438: /*
! 3439: ** Usage: sqlite3_sleep MILLISECONDS
! 3440: */
! 3441: static int test_sleep(
! 3442: void * clientData,
! 3443: Tcl_Interp *interp,
! 3444: int objc,
! 3445: Tcl_Obj *CONST objv[]
! 3446: ){
! 3447: int ms;
! 3448:
! 3449: if( objc!=2 ){
! 3450: Tcl_WrongNumArgs(interp, 1, objv, "MILLISECONDS");
! 3451: return TCL_ERROR;
! 3452: }
! 3453: if( Tcl_GetIntFromObj(interp, objv[1], &ms) ){
! 3454: return TCL_ERROR;
! 3455: }
! 3456: Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_sleep(ms)));
! 3457: return TCL_OK;
! 3458: }
! 3459:
! 3460: /*
! 3461: ** Usage: sqlite3_extended_errcode DB
! 3462: **
! 3463: ** Return the string representation of the most recent sqlite3_* API
! 3464: ** error code. e.g. "SQLITE_ERROR".
! 3465: */
! 3466: static int test_ex_errcode(
! 3467: void * clientData,
! 3468: Tcl_Interp *interp,
! 3469: int objc,
! 3470: Tcl_Obj *CONST objv[]
! 3471: ){
! 3472: sqlite3 *db;
! 3473: int rc;
! 3474:
! 3475: if( objc!=2 ){
! 3476: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3477: Tcl_GetString(objv[0]), " DB", 0);
! 3478: return TCL_ERROR;
! 3479: }
! 3480: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 3481: rc = sqlite3_extended_errcode(db);
! 3482: Tcl_AppendResult(interp, (char *)t1ErrorName(rc), 0);
! 3483: return TCL_OK;
! 3484: }
! 3485:
! 3486:
! 3487: /*
! 3488: ** Usage: sqlite3_errcode DB
! 3489: **
! 3490: ** Return the string representation of the most recent sqlite3_* API
! 3491: ** error code. e.g. "SQLITE_ERROR".
! 3492: */
! 3493: static int test_errcode(
! 3494: void * clientData,
! 3495: Tcl_Interp *interp,
! 3496: int objc,
! 3497: Tcl_Obj *CONST objv[]
! 3498: ){
! 3499: sqlite3 *db;
! 3500: int rc;
! 3501:
! 3502: if( objc!=2 ){
! 3503: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3504: Tcl_GetString(objv[0]), " DB", 0);
! 3505: return TCL_ERROR;
! 3506: }
! 3507: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 3508: rc = sqlite3_errcode(db);
! 3509: Tcl_AppendResult(interp, (char *)t1ErrorName(rc), 0);
! 3510: return TCL_OK;
! 3511: }
! 3512:
! 3513: /*
! 3514: ** Usage: sqlite3_errmsg DB
! 3515: **
! 3516: ** Returns the UTF-8 representation of the error message string for the
! 3517: ** most recent sqlite3_* API call.
! 3518: */
! 3519: static int test_errmsg(
! 3520: void * clientData,
! 3521: Tcl_Interp *interp,
! 3522: int objc,
! 3523: Tcl_Obj *CONST objv[]
! 3524: ){
! 3525: sqlite3 *db;
! 3526: const char *zErr;
! 3527:
! 3528: if( objc!=2 ){
! 3529: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3530: Tcl_GetString(objv[0]), " DB", 0);
! 3531: return TCL_ERROR;
! 3532: }
! 3533: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 3534:
! 3535: zErr = sqlite3_errmsg(db);
! 3536: Tcl_SetObjResult(interp, Tcl_NewStringObj(zErr, -1));
! 3537: return TCL_OK;
! 3538: }
! 3539:
! 3540: /*
! 3541: ** Usage: test_errmsg16 DB
! 3542: **
! 3543: ** Returns the UTF-16 representation of the error message string for the
! 3544: ** most recent sqlite3_* API call. This is a byte array object at the TCL
! 3545: ** level, and it includes the 0x00 0x00 terminator bytes at the end of the
! 3546: ** UTF-16 string.
! 3547: */
! 3548: static int test_errmsg16(
! 3549: void * clientData,
! 3550: Tcl_Interp *interp,
! 3551: int objc,
! 3552: Tcl_Obj *CONST objv[]
! 3553: ){
! 3554: #ifndef SQLITE_OMIT_UTF16
! 3555: sqlite3 *db;
! 3556: const void *zErr;
! 3557: const char *z;
! 3558: int bytes = 0;
! 3559:
! 3560: if( objc!=2 ){
! 3561: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3562: Tcl_GetString(objv[0]), " DB", 0);
! 3563: return TCL_ERROR;
! 3564: }
! 3565: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 3566:
! 3567: zErr = sqlite3_errmsg16(db);
! 3568: if( zErr ){
! 3569: z = zErr;
! 3570: for(bytes=0; z[bytes] || z[bytes+1]; bytes+=2){}
! 3571: }
! 3572: Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(zErr, bytes));
! 3573: #endif /* SQLITE_OMIT_UTF16 */
! 3574: return TCL_OK;
! 3575: }
! 3576:
! 3577: /*
! 3578: ** Usage: sqlite3_prepare DB sql bytes ?tailvar?
! 3579: **
! 3580: ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
! 3581: ** database handle <DB>. The parameter <tailval> is the name of a global
! 3582: ** variable that is set to the unused portion of <sql> (if any). A
! 3583: ** STMT handle is returned.
! 3584: */
! 3585: static int test_prepare(
! 3586: void * clientData,
! 3587: Tcl_Interp *interp,
! 3588: int objc,
! 3589: Tcl_Obj *CONST objv[]
! 3590: ){
! 3591: sqlite3 *db;
! 3592: const char *zSql;
! 3593: int bytes;
! 3594: const char *zTail = 0;
! 3595: sqlite3_stmt *pStmt = 0;
! 3596: char zBuf[50];
! 3597: int rc;
! 3598:
! 3599: if( objc!=5 && objc!=4 ){
! 3600: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3601: Tcl_GetString(objv[0]), " DB sql bytes ?tailvar?", 0);
! 3602: return TCL_ERROR;
! 3603: }
! 3604: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 3605: zSql = Tcl_GetString(objv[2]);
! 3606: if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
! 3607:
! 3608: rc = sqlite3_prepare(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0);
! 3609: Tcl_ResetResult(interp);
! 3610: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 3611: if( zTail && objc>=5 ){
! 3612: if( bytes>=0 ){
! 3613: bytes = bytes - (zTail-zSql);
! 3614: }
! 3615: if( strlen(zTail)<bytes ){
! 3616: bytes = strlen(zTail);
! 3617: }
! 3618: Tcl_ObjSetVar2(interp, objv[4], 0, Tcl_NewStringObj(zTail, bytes), 0);
! 3619: }
! 3620: if( rc!=SQLITE_OK ){
! 3621: assert( pStmt==0 );
! 3622: sprintf(zBuf, "(%d) ", rc);
! 3623: Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0);
! 3624: return TCL_ERROR;
! 3625: }
! 3626:
! 3627: if( pStmt ){
! 3628: if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
! 3629: Tcl_AppendResult(interp, zBuf, 0);
! 3630: }
! 3631: return TCL_OK;
! 3632: }
! 3633:
! 3634: /*
! 3635: ** Usage: sqlite3_prepare_v2 DB sql bytes ?tailvar?
! 3636: **
! 3637: ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
! 3638: ** database handle <DB>. The parameter <tailval> is the name of a global
! 3639: ** variable that is set to the unused portion of <sql> (if any). A
! 3640: ** STMT handle is returned.
! 3641: */
! 3642: static int test_prepare_v2(
! 3643: void * clientData,
! 3644: Tcl_Interp *interp,
! 3645: int objc,
! 3646: Tcl_Obj *CONST objv[]
! 3647: ){
! 3648: sqlite3 *db;
! 3649: const char *zSql;
! 3650: int bytes;
! 3651: const char *zTail = 0;
! 3652: sqlite3_stmt *pStmt = 0;
! 3653: char zBuf[50];
! 3654: int rc;
! 3655:
! 3656: if( objc!=5 && objc!=4 ){
! 3657: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3658: Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0);
! 3659: return TCL_ERROR;
! 3660: }
! 3661: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 3662: zSql = Tcl_GetString(objv[2]);
! 3663: if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
! 3664:
! 3665: rc = sqlite3_prepare_v2(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0);
! 3666: assert(rc==SQLITE_OK || pStmt==0);
! 3667: Tcl_ResetResult(interp);
! 3668: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 3669: if( zTail && objc>=5 ){
! 3670: if( bytes>=0 ){
! 3671: bytes = bytes - (zTail-zSql);
! 3672: }
! 3673: Tcl_ObjSetVar2(interp, objv[4], 0, Tcl_NewStringObj(zTail, bytes), 0);
! 3674: }
! 3675: if( rc!=SQLITE_OK ){
! 3676: assert( pStmt==0 );
! 3677: sprintf(zBuf, "(%d) ", rc);
! 3678: Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0);
! 3679: return TCL_ERROR;
! 3680: }
! 3681:
! 3682: if( pStmt ){
! 3683: if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
! 3684: Tcl_AppendResult(interp, zBuf, 0);
! 3685: }
! 3686: return TCL_OK;
! 3687: }
! 3688:
! 3689: /*
! 3690: ** Usage: sqlite3_prepare_tkt3134 DB
! 3691: **
! 3692: ** Generate a prepared statement for a zero-byte string as a test
! 3693: ** for ticket #3134. The string should be preceeded by a zero byte.
! 3694: */
! 3695: static int test_prepare_tkt3134(
! 3696: void * clientData,
! 3697: Tcl_Interp *interp,
! 3698: int objc,
! 3699: Tcl_Obj *CONST objv[]
! 3700: ){
! 3701: sqlite3 *db;
! 3702: static const char zSql[] = "\000SELECT 1";
! 3703: sqlite3_stmt *pStmt = 0;
! 3704: char zBuf[50];
! 3705: int rc;
! 3706:
! 3707: if( objc!=2 ){
! 3708: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3709: Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0);
! 3710: return TCL_ERROR;
! 3711: }
! 3712: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 3713: rc = sqlite3_prepare_v2(db, &zSql[1], 0, &pStmt, 0);
! 3714: assert(rc==SQLITE_OK || pStmt==0);
! 3715: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 3716: if( rc!=SQLITE_OK ){
! 3717: assert( pStmt==0 );
! 3718: sprintf(zBuf, "(%d) ", rc);
! 3719: Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0);
! 3720: return TCL_ERROR;
! 3721: }
! 3722:
! 3723: if( pStmt ){
! 3724: if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
! 3725: Tcl_AppendResult(interp, zBuf, 0);
! 3726: }
! 3727: return TCL_OK;
! 3728: }
! 3729:
! 3730: /*
! 3731: ** Usage: sqlite3_prepare16 DB sql bytes tailvar
! 3732: **
! 3733: ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
! 3734: ** database handle <DB>. The parameter <tailval> is the name of a global
! 3735: ** variable that is set to the unused portion of <sql> (if any). A
! 3736: ** STMT handle is returned.
! 3737: */
! 3738: static int test_prepare16(
! 3739: void * clientData,
! 3740: Tcl_Interp *interp,
! 3741: int objc,
! 3742: Tcl_Obj *CONST objv[]
! 3743: ){
! 3744: #ifndef SQLITE_OMIT_UTF16
! 3745: sqlite3 *db;
! 3746: const void *zSql;
! 3747: const void *zTail = 0;
! 3748: Tcl_Obj *pTail = 0;
! 3749: sqlite3_stmt *pStmt = 0;
! 3750: char zBuf[50];
! 3751: int rc;
! 3752: int bytes; /* The integer specified as arg 3 */
! 3753: int objlen; /* The byte-array length of arg 2 */
! 3754:
! 3755: if( objc!=5 && objc!=4 ){
! 3756: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3757: Tcl_GetString(objv[0]), " DB sql bytes ?tailvar?", 0);
! 3758: return TCL_ERROR;
! 3759: }
! 3760: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 3761: zSql = Tcl_GetByteArrayFromObj(objv[2], &objlen);
! 3762: if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
! 3763:
! 3764: rc = sqlite3_prepare16(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0);
! 3765: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 3766: if( rc ){
! 3767: return TCL_ERROR;
! 3768: }
! 3769:
! 3770: if( objc>=5 ){
! 3771: if( zTail ){
! 3772: objlen = objlen - ((u8 *)zTail-(u8 *)zSql);
! 3773: }else{
! 3774: objlen = 0;
! 3775: }
! 3776: pTail = Tcl_NewByteArrayObj((u8 *)zTail, objlen);
! 3777: Tcl_IncrRefCount(pTail);
! 3778: Tcl_ObjSetVar2(interp, objv[4], 0, pTail, 0);
! 3779: Tcl_DecrRefCount(pTail);
! 3780: }
! 3781:
! 3782: if( pStmt ){
! 3783: if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
! 3784: }
! 3785: Tcl_AppendResult(interp, zBuf, 0);
! 3786: #endif /* SQLITE_OMIT_UTF16 */
! 3787: return TCL_OK;
! 3788: }
! 3789:
! 3790: /*
! 3791: ** Usage: sqlite3_prepare16_v2 DB sql bytes ?tailvar?
! 3792: **
! 3793: ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
! 3794: ** database handle <DB>. The parameter <tailval> is the name of a global
! 3795: ** variable that is set to the unused portion of <sql> (if any). A
! 3796: ** STMT handle is returned.
! 3797: */
! 3798: static int test_prepare16_v2(
! 3799: void * clientData,
! 3800: Tcl_Interp *interp,
! 3801: int objc,
! 3802: Tcl_Obj *CONST objv[]
! 3803: ){
! 3804: #ifndef SQLITE_OMIT_UTF16
! 3805: sqlite3 *db;
! 3806: const void *zSql;
! 3807: const void *zTail = 0;
! 3808: Tcl_Obj *pTail = 0;
! 3809: sqlite3_stmt *pStmt = 0;
! 3810: char zBuf[50];
! 3811: int rc;
! 3812: int bytes; /* The integer specified as arg 3 */
! 3813: int objlen; /* The byte-array length of arg 2 */
! 3814:
! 3815: if( objc!=5 && objc!=4 ){
! 3816: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3817: Tcl_GetString(objv[0]), " DB sql bytes ?tailvar?", 0);
! 3818: return TCL_ERROR;
! 3819: }
! 3820: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 3821: zSql = Tcl_GetByteArrayFromObj(objv[2], &objlen);
! 3822: if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
! 3823:
! 3824: rc = sqlite3_prepare16_v2(db, zSql, bytes, &pStmt, objc>=5 ? &zTail : 0);
! 3825: if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
! 3826: if( rc ){
! 3827: return TCL_ERROR;
! 3828: }
! 3829:
! 3830: if( objc>=5 ){
! 3831: if( zTail ){
! 3832: objlen = objlen - ((u8 *)zTail-(u8 *)zSql);
! 3833: }else{
! 3834: objlen = 0;
! 3835: }
! 3836: pTail = Tcl_NewByteArrayObj((u8 *)zTail, objlen);
! 3837: Tcl_IncrRefCount(pTail);
! 3838: Tcl_ObjSetVar2(interp, objv[4], 0, pTail, 0);
! 3839: Tcl_DecrRefCount(pTail);
! 3840: }
! 3841:
! 3842: if( pStmt ){
! 3843: if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
! 3844: }
! 3845: Tcl_AppendResult(interp, zBuf, 0);
! 3846: #endif /* SQLITE_OMIT_UTF16 */
! 3847: return TCL_OK;
! 3848: }
! 3849:
! 3850: /*
! 3851: ** Usage: sqlite3_open filename ?options-list?
! 3852: */
! 3853: static int test_open(
! 3854: void * clientData,
! 3855: Tcl_Interp *interp,
! 3856: int objc,
! 3857: Tcl_Obj *CONST objv[]
! 3858: ){
! 3859: const char *zFilename;
! 3860: sqlite3 *db;
! 3861: int rc;
! 3862: char zBuf[100];
! 3863:
! 3864: if( objc!=3 && objc!=2 && objc!=1 ){
! 3865: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3866: Tcl_GetString(objv[0]), " filename options-list", 0);
! 3867: return TCL_ERROR;
! 3868: }
! 3869:
! 3870: zFilename = objc>1 ? Tcl_GetString(objv[1]) : 0;
! 3871: rc = sqlite3_open(zFilename, &db);
! 3872:
! 3873: if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
! 3874: Tcl_AppendResult(interp, zBuf, 0);
! 3875: return TCL_OK;
! 3876: }
! 3877:
! 3878: /*
! 3879: ** Usage: sqlite3_open_v2 FILENAME FLAGS VFS
! 3880: */
! 3881: static int test_open_v2(
! 3882: void * clientData,
! 3883: Tcl_Interp *interp,
! 3884: int objc,
! 3885: Tcl_Obj *CONST objv[]
! 3886: ){
! 3887: const char *zFilename;
! 3888: const char *zVfs;
! 3889: int flags = 0;
! 3890: sqlite3 *db;
! 3891: int rc;
! 3892: char zBuf[100];
! 3893:
! 3894: int nFlag;
! 3895: Tcl_Obj **apFlag;
! 3896: int i;
! 3897:
! 3898: if( objc!=4 ){
! 3899: Tcl_WrongNumArgs(interp, 1, objv, "FILENAME FLAGS VFS");
! 3900: return TCL_ERROR;
! 3901: }
! 3902: zFilename = Tcl_GetString(objv[1]);
! 3903: zVfs = Tcl_GetString(objv[3]);
! 3904: if( zVfs[0]==0x00 ) zVfs = 0;
! 3905:
! 3906: rc = Tcl_ListObjGetElements(interp, objv[2], &nFlag, &apFlag);
! 3907: if( rc!=TCL_OK ) return rc;
! 3908: for(i=0; i<nFlag; i++){
! 3909: int iFlag;
! 3910: struct OpenFlag {
! 3911: const char *zFlag;
! 3912: int flag;
! 3913: } aFlag[] = {
! 3914: { "SQLITE_OPEN_READONLY", SQLITE_OPEN_READONLY },
! 3915: { "SQLITE_OPEN_READWRITE", SQLITE_OPEN_READWRITE },
! 3916: { "SQLITE_OPEN_CREATE", SQLITE_OPEN_CREATE },
! 3917: { "SQLITE_OPEN_DELETEONCLOSE", SQLITE_OPEN_DELETEONCLOSE },
! 3918: { "SQLITE_OPEN_EXCLUSIVE", SQLITE_OPEN_EXCLUSIVE },
! 3919: { "SQLITE_OPEN_AUTOPROXY", SQLITE_OPEN_AUTOPROXY },
! 3920: { "SQLITE_OPEN_MAIN_DB", SQLITE_OPEN_MAIN_DB },
! 3921: { "SQLITE_OPEN_TEMP_DB", SQLITE_OPEN_TEMP_DB },
! 3922: { "SQLITE_OPEN_TRANSIENT_DB", SQLITE_OPEN_TRANSIENT_DB },
! 3923: { "SQLITE_OPEN_MAIN_JOURNAL", SQLITE_OPEN_MAIN_JOURNAL },
! 3924: { "SQLITE_OPEN_TEMP_JOURNAL", SQLITE_OPEN_TEMP_JOURNAL },
! 3925: { "SQLITE_OPEN_SUBJOURNAL", SQLITE_OPEN_SUBJOURNAL },
! 3926: { "SQLITE_OPEN_MASTER_JOURNAL", SQLITE_OPEN_MASTER_JOURNAL },
! 3927: { "SQLITE_OPEN_NOMUTEX", SQLITE_OPEN_NOMUTEX },
! 3928: { "SQLITE_OPEN_FULLMUTEX", SQLITE_OPEN_FULLMUTEX },
! 3929: { "SQLITE_OPEN_SHAREDCACHE", SQLITE_OPEN_SHAREDCACHE },
! 3930: { "SQLITE_OPEN_PRIVATECACHE", SQLITE_OPEN_PRIVATECACHE },
! 3931: { "SQLITE_OPEN_WAL", SQLITE_OPEN_WAL },
! 3932: { "SQLITE_OPEN_URI", SQLITE_OPEN_URI },
! 3933: { 0, 0 }
! 3934: };
! 3935: rc = Tcl_GetIndexFromObjStruct(interp, apFlag[i], aFlag, sizeof(aFlag[0]),
! 3936: "flag", 0, &iFlag
! 3937: );
! 3938: if( rc!=TCL_OK ) return rc;
! 3939: flags |= aFlag[iFlag].flag;
! 3940: }
! 3941:
! 3942: rc = sqlite3_open_v2(zFilename, &db, flags, zVfs);
! 3943: if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
! 3944: Tcl_AppendResult(interp, zBuf, 0);
! 3945: return TCL_OK;
! 3946: }
! 3947:
! 3948: /*
! 3949: ** Usage: sqlite3_open16 filename options
! 3950: */
! 3951: static int test_open16(
! 3952: void * clientData,
! 3953: Tcl_Interp *interp,
! 3954: int objc,
! 3955: Tcl_Obj *CONST objv[]
! 3956: ){
! 3957: #ifndef SQLITE_OMIT_UTF16
! 3958: const void *zFilename;
! 3959: sqlite3 *db;
! 3960: int rc;
! 3961: char zBuf[100];
! 3962:
! 3963: if( objc!=3 ){
! 3964: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 3965: Tcl_GetString(objv[0]), " filename options-list", 0);
! 3966: return TCL_ERROR;
! 3967: }
! 3968:
! 3969: zFilename = Tcl_GetByteArrayFromObj(objv[1], 0);
! 3970: rc = sqlite3_open16(zFilename, &db);
! 3971:
! 3972: if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
! 3973: Tcl_AppendResult(interp, zBuf, 0);
! 3974: #endif /* SQLITE_OMIT_UTF16 */
! 3975: return TCL_OK;
! 3976: }
! 3977:
! 3978: /*
! 3979: ** Usage: sqlite3_complete16 <UTF-16 string>
! 3980: **
! 3981: ** Return 1 if the supplied argument is a complete SQL statement, or zero
! 3982: ** otherwise.
! 3983: */
! 3984: static int test_complete16(
! 3985: void * clientData,
! 3986: Tcl_Interp *interp,
! 3987: int objc,
! 3988: Tcl_Obj *CONST objv[]
! 3989: ){
! 3990: #if !defined(SQLITE_OMIT_COMPLETE) && !defined(SQLITE_OMIT_UTF16)
! 3991: char *zBuf;
! 3992:
! 3993: if( objc!=2 ){
! 3994: Tcl_WrongNumArgs(interp, 1, objv, "<utf-16 sql>");
! 3995: return TCL_ERROR;
! 3996: }
! 3997:
! 3998: zBuf = (char*)Tcl_GetByteArrayFromObj(objv[1], 0);
! 3999: Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_complete16(zBuf)));
! 4000: #endif /* SQLITE_OMIT_COMPLETE && SQLITE_OMIT_UTF16 */
! 4001: return TCL_OK;
! 4002: }
! 4003:
! 4004: /*
! 4005: ** Usage: sqlite3_step STMT
! 4006: **
! 4007: ** Advance the statement to the next row.
! 4008: */
! 4009: static int test_step(
! 4010: void * clientData,
! 4011: Tcl_Interp *interp,
! 4012: int objc,
! 4013: Tcl_Obj *CONST objv[]
! 4014: ){
! 4015: sqlite3_stmt *pStmt;
! 4016: int rc;
! 4017:
! 4018: if( objc!=2 ){
! 4019: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 4020: Tcl_GetString(objv[0]), " STMT", 0);
! 4021: return TCL_ERROR;
! 4022: }
! 4023:
! 4024: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 4025: rc = sqlite3_step(pStmt);
! 4026:
! 4027: /* if( rc!=SQLITE_DONE && rc!=SQLITE_ROW ) return TCL_ERROR; */
! 4028: Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
! 4029: return TCL_OK;
! 4030: }
! 4031:
! 4032: static int test_sql(
! 4033: void * clientData,
! 4034: Tcl_Interp *interp,
! 4035: int objc,
! 4036: Tcl_Obj *CONST objv[]
! 4037: ){
! 4038: sqlite3_stmt *pStmt;
! 4039:
! 4040: if( objc!=2 ){
! 4041: Tcl_WrongNumArgs(interp, 1, objv, "STMT");
! 4042: return TCL_ERROR;
! 4043: }
! 4044:
! 4045: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 4046: Tcl_SetResult(interp, (char *)sqlite3_sql(pStmt), TCL_VOLATILE);
! 4047: return TCL_OK;
! 4048: }
! 4049:
! 4050: /*
! 4051: ** Usage: sqlite3_column_count STMT
! 4052: **
! 4053: ** Return the number of columns returned by the sql statement STMT.
! 4054: */
! 4055: static int test_column_count(
! 4056: void * clientData,
! 4057: Tcl_Interp *interp,
! 4058: int objc,
! 4059: Tcl_Obj *CONST objv[]
! 4060: ){
! 4061: sqlite3_stmt *pStmt;
! 4062:
! 4063: if( objc!=2 ){
! 4064: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 4065: Tcl_GetString(objv[0]), " STMT column", 0);
! 4066: return TCL_ERROR;
! 4067: }
! 4068:
! 4069: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 4070:
! 4071: Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_column_count(pStmt)));
! 4072: return TCL_OK;
! 4073: }
! 4074:
! 4075: /*
! 4076: ** Usage: sqlite3_column_type STMT column
! 4077: **
! 4078: ** Return the type of the data in column 'column' of the current row.
! 4079: */
! 4080: static int test_column_type(
! 4081: void * clientData,
! 4082: Tcl_Interp *interp,
! 4083: int objc,
! 4084: Tcl_Obj *CONST objv[]
! 4085: ){
! 4086: sqlite3_stmt *pStmt;
! 4087: int col;
! 4088: int tp;
! 4089:
! 4090: if( objc!=3 ){
! 4091: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 4092: Tcl_GetString(objv[0]), " STMT column", 0);
! 4093: return TCL_ERROR;
! 4094: }
! 4095:
! 4096: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 4097: if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
! 4098:
! 4099: tp = sqlite3_column_type(pStmt, col);
! 4100: switch( tp ){
! 4101: case SQLITE_INTEGER:
! 4102: Tcl_SetResult(interp, "INTEGER", TCL_STATIC);
! 4103: break;
! 4104: case SQLITE_NULL:
! 4105: Tcl_SetResult(interp, "NULL", TCL_STATIC);
! 4106: break;
! 4107: case SQLITE_FLOAT:
! 4108: Tcl_SetResult(interp, "FLOAT", TCL_STATIC);
! 4109: break;
! 4110: case SQLITE_TEXT:
! 4111: Tcl_SetResult(interp, "TEXT", TCL_STATIC);
! 4112: break;
! 4113: case SQLITE_BLOB:
! 4114: Tcl_SetResult(interp, "BLOB", TCL_STATIC);
! 4115: break;
! 4116: default:
! 4117: assert(0);
! 4118: }
! 4119:
! 4120: return TCL_OK;
! 4121: }
! 4122:
! 4123: /*
! 4124: ** Usage: sqlite3_column_int64 STMT column
! 4125: **
! 4126: ** Return the data in column 'column' of the current row cast as an
! 4127: ** wide (64-bit) integer.
! 4128: */
! 4129: static int test_column_int64(
! 4130: void * clientData,
! 4131: Tcl_Interp *interp,
! 4132: int objc,
! 4133: Tcl_Obj *CONST objv[]
! 4134: ){
! 4135: sqlite3_stmt *pStmt;
! 4136: int col;
! 4137: i64 iVal;
! 4138:
! 4139: if( objc!=3 ){
! 4140: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 4141: Tcl_GetString(objv[0]), " STMT column", 0);
! 4142: return TCL_ERROR;
! 4143: }
! 4144:
! 4145: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 4146: if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
! 4147:
! 4148: iVal = sqlite3_column_int64(pStmt, col);
! 4149: Tcl_SetObjResult(interp, Tcl_NewWideIntObj(iVal));
! 4150: return TCL_OK;
! 4151: }
! 4152:
! 4153: /*
! 4154: ** Usage: sqlite3_column_blob STMT column
! 4155: */
! 4156: static int test_column_blob(
! 4157: void * clientData,
! 4158: Tcl_Interp *interp,
! 4159: int objc,
! 4160: Tcl_Obj *CONST objv[]
! 4161: ){
! 4162: sqlite3_stmt *pStmt;
! 4163: int col;
! 4164:
! 4165: int len;
! 4166: const void *pBlob;
! 4167:
! 4168: if( objc!=3 ){
! 4169: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 4170: Tcl_GetString(objv[0]), " STMT column", 0);
! 4171: return TCL_ERROR;
! 4172: }
! 4173:
! 4174: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 4175: if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
! 4176:
! 4177: len = sqlite3_column_bytes(pStmt, col);
! 4178: pBlob = sqlite3_column_blob(pStmt, col);
! 4179: Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pBlob, len));
! 4180: return TCL_OK;
! 4181: }
! 4182:
! 4183: /*
! 4184: ** Usage: sqlite3_column_double STMT column
! 4185: **
! 4186: ** Return the data in column 'column' of the current row cast as a double.
! 4187: */
! 4188: static int test_column_double(
! 4189: void * clientData,
! 4190: Tcl_Interp *interp,
! 4191: int objc,
! 4192: Tcl_Obj *CONST objv[]
! 4193: ){
! 4194: sqlite3_stmt *pStmt;
! 4195: int col;
! 4196: double rVal;
! 4197:
! 4198: if( objc!=3 ){
! 4199: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 4200: Tcl_GetString(objv[0]), " STMT column", 0);
! 4201: return TCL_ERROR;
! 4202: }
! 4203:
! 4204: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 4205: if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
! 4206:
! 4207: rVal = sqlite3_column_double(pStmt, col);
! 4208: Tcl_SetObjResult(interp, Tcl_NewDoubleObj(rVal));
! 4209: return TCL_OK;
! 4210: }
! 4211:
! 4212: /*
! 4213: ** Usage: sqlite3_data_count STMT
! 4214: **
! 4215: ** Return the number of columns returned by the sql statement STMT.
! 4216: */
! 4217: static int test_data_count(
! 4218: void * clientData,
! 4219: Tcl_Interp *interp,
! 4220: int objc,
! 4221: Tcl_Obj *CONST objv[]
! 4222: ){
! 4223: sqlite3_stmt *pStmt;
! 4224:
! 4225: if( objc!=2 ){
! 4226: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 4227: Tcl_GetString(objv[0]), " STMT column", 0);
! 4228: return TCL_ERROR;
! 4229: }
! 4230:
! 4231: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 4232:
! 4233: Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_data_count(pStmt)));
! 4234: return TCL_OK;
! 4235: }
! 4236:
! 4237: /*
! 4238: ** Usage: sqlite3_column_text STMT column
! 4239: **
! 4240: ** Usage: sqlite3_column_decltype STMT column
! 4241: **
! 4242: ** Usage: sqlite3_column_name STMT column
! 4243: */
! 4244: static int test_stmt_utf8(
! 4245: void * clientData, /* Pointer to SQLite API function to be invoke */
! 4246: Tcl_Interp *interp,
! 4247: int objc,
! 4248: Tcl_Obj *CONST objv[]
! 4249: ){
! 4250: sqlite3_stmt *pStmt;
! 4251: int col;
! 4252: const char *(*xFunc)(sqlite3_stmt*, int);
! 4253: const char *zRet;
! 4254:
! 4255: xFunc = (const char *(*)(sqlite3_stmt*, int))clientData;
! 4256: if( objc!=3 ){
! 4257: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 4258: Tcl_GetString(objv[0]), " STMT column", 0);
! 4259: return TCL_ERROR;
! 4260: }
! 4261:
! 4262: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 4263: if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
! 4264: zRet = xFunc(pStmt, col);
! 4265: if( zRet ){
! 4266: Tcl_SetResult(interp, (char *)zRet, 0);
! 4267: }
! 4268: return TCL_OK;
! 4269: }
! 4270:
! 4271: static int test_global_recover(
! 4272: void * clientData,
! 4273: Tcl_Interp *interp,
! 4274: int objc,
! 4275: Tcl_Obj *CONST objv[]
! 4276: ){
! 4277: #ifndef SQLITE_OMIT_DEPRECATED
! 4278: int rc;
! 4279: if( objc!=1 ){
! 4280: Tcl_WrongNumArgs(interp, 1, objv, "");
! 4281: return TCL_ERROR;
! 4282: }
! 4283: rc = sqlite3_global_recover();
! 4284: Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
! 4285: #endif
! 4286: return TCL_OK;
! 4287: }
! 4288:
! 4289: /*
! 4290: ** Usage: sqlite3_column_text STMT column
! 4291: **
! 4292: ** Usage: sqlite3_column_decltype STMT column
! 4293: **
! 4294: ** Usage: sqlite3_column_name STMT column
! 4295: */
! 4296: static int test_stmt_utf16(
! 4297: void * clientData, /* Pointer to SQLite API function to be invoked */
! 4298: Tcl_Interp *interp,
! 4299: int objc,
! 4300: Tcl_Obj *CONST objv[]
! 4301: ){
! 4302: #ifndef SQLITE_OMIT_UTF16
! 4303: sqlite3_stmt *pStmt;
! 4304: int col;
! 4305: Tcl_Obj *pRet;
! 4306: const void *zName16;
! 4307: const void *(*xFunc)(sqlite3_stmt*, int);
! 4308:
! 4309: xFunc = (const void *(*)(sqlite3_stmt*, int))clientData;
! 4310: if( objc!=3 ){
! 4311: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 4312: Tcl_GetString(objv[0]), " STMT column", 0);
! 4313: return TCL_ERROR;
! 4314: }
! 4315:
! 4316: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 4317: if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
! 4318:
! 4319: zName16 = xFunc(pStmt, col);
! 4320: if( zName16 ){
! 4321: int n;
! 4322: const char *z = zName16;
! 4323: for(n=0; z[n] || z[n+1]; n+=2){}
! 4324: pRet = Tcl_NewByteArrayObj(zName16, n+2);
! 4325: Tcl_SetObjResult(interp, pRet);
! 4326: }
! 4327: #endif /* SQLITE_OMIT_UTF16 */
! 4328:
! 4329: return TCL_OK;
! 4330: }
! 4331:
! 4332: /*
! 4333: ** Usage: sqlite3_column_int STMT column
! 4334: **
! 4335: ** Usage: sqlite3_column_bytes STMT column
! 4336: **
! 4337: ** Usage: sqlite3_column_bytes16 STMT column
! 4338: **
! 4339: */
! 4340: static int test_stmt_int(
! 4341: void * clientData, /* Pointer to SQLite API function to be invoked */
! 4342: Tcl_Interp *interp,
! 4343: int objc,
! 4344: Tcl_Obj *CONST objv[]
! 4345: ){
! 4346: sqlite3_stmt *pStmt;
! 4347: int col;
! 4348: int (*xFunc)(sqlite3_stmt*, int);
! 4349:
! 4350: xFunc = (int (*)(sqlite3_stmt*, int))clientData;
! 4351: if( objc!=3 ){
! 4352: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 4353: Tcl_GetString(objv[0]), " STMT column", 0);
! 4354: return TCL_ERROR;
! 4355: }
! 4356:
! 4357: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 4358: if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
! 4359:
! 4360: Tcl_SetObjResult(interp, Tcl_NewIntObj(xFunc(pStmt, col)));
! 4361: return TCL_OK;
! 4362: }
! 4363:
! 4364: /*
! 4365: ** Usage: sqlite_set_magic DB MAGIC-NUMBER
! 4366: **
! 4367: ** Set the db->magic value. This is used to test error recovery logic.
! 4368: */
! 4369: static int sqlite_set_magic(
! 4370: void * clientData,
! 4371: Tcl_Interp *interp,
! 4372: int argc,
! 4373: char **argv
! 4374: ){
! 4375: sqlite3 *db;
! 4376: if( argc!=3 ){
! 4377: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 4378: " DB MAGIC", 0);
! 4379: return TCL_ERROR;
! 4380: }
! 4381: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 4382: if( strcmp(argv[2], "SQLITE_MAGIC_OPEN")==0 ){
! 4383: db->magic = SQLITE_MAGIC_OPEN;
! 4384: }else if( strcmp(argv[2], "SQLITE_MAGIC_CLOSED")==0 ){
! 4385: db->magic = SQLITE_MAGIC_CLOSED;
! 4386: }else if( strcmp(argv[2], "SQLITE_MAGIC_BUSY")==0 ){
! 4387: db->magic = SQLITE_MAGIC_BUSY;
! 4388: }else if( strcmp(argv[2], "SQLITE_MAGIC_ERROR")==0 ){
! 4389: db->magic = SQLITE_MAGIC_ERROR;
! 4390: }else if( Tcl_GetInt(interp, argv[2], (int*)&db->magic) ){
! 4391: return TCL_ERROR;
! 4392: }
! 4393: return TCL_OK;
! 4394: }
! 4395:
! 4396: /*
! 4397: ** Usage: sqlite3_interrupt DB
! 4398: **
! 4399: ** Trigger an interrupt on DB
! 4400: */
! 4401: static int test_interrupt(
! 4402: void * clientData,
! 4403: Tcl_Interp *interp,
! 4404: int argc,
! 4405: char **argv
! 4406: ){
! 4407: sqlite3 *db;
! 4408: if( argc!=2 ){
! 4409: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB", 0);
! 4410: return TCL_ERROR;
! 4411: }
! 4412: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 4413: sqlite3_interrupt(db);
! 4414: return TCL_OK;
! 4415: }
! 4416:
! 4417: static u8 *sqlite3_stack_baseline = 0;
! 4418:
! 4419: /*
! 4420: ** Fill the stack with a known bitpattern.
! 4421: */
! 4422: static void prepStack(void){
! 4423: int i;
! 4424: u32 bigBuf[65536];
! 4425: for(i=0; i<sizeof(bigBuf)/sizeof(bigBuf[0]); i++) bigBuf[i] = 0xdeadbeef;
! 4426: sqlite3_stack_baseline = (u8*)&bigBuf[65536];
! 4427: }
! 4428:
! 4429: /*
! 4430: ** Get the current stack depth. Used for debugging only.
! 4431: */
! 4432: u64 sqlite3StackDepth(void){
! 4433: u8 x;
! 4434: return (u64)(sqlite3_stack_baseline - &x);
! 4435: }
! 4436:
! 4437: /*
! 4438: ** Usage: sqlite3_stack_used DB SQL
! 4439: **
! 4440: ** Try to measure the amount of stack space used by a call to sqlite3_exec
! 4441: */
! 4442: static int test_stack_used(
! 4443: void * clientData,
! 4444: Tcl_Interp *interp,
! 4445: int argc,
! 4446: char **argv
! 4447: ){
! 4448: sqlite3 *db;
! 4449: int i;
! 4450: if( argc!=3 ){
! 4451: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 4452: " DB SQL", 0);
! 4453: return TCL_ERROR;
! 4454: }
! 4455: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 4456: prepStack();
! 4457: (void)sqlite3_exec(db, argv[2], 0, 0, 0);
! 4458: for(i=65535; i>=0 && ((u32*)sqlite3_stack_baseline)[-i]==0xdeadbeef; i--){}
! 4459: Tcl_SetObjResult(interp, Tcl_NewIntObj(i*4));
! 4460: return TCL_OK;
! 4461: }
! 4462:
! 4463: /*
! 4464: ** Usage: sqlite_delete_function DB function-name
! 4465: **
! 4466: ** Delete the user function 'function-name' from database handle DB. It
! 4467: ** is assumed that the user function was created as UTF8, any number of
! 4468: ** arguments (the way the TCL interface does it).
! 4469: */
! 4470: static int delete_function(
! 4471: void * clientData,
! 4472: Tcl_Interp *interp,
! 4473: int argc,
! 4474: char **argv
! 4475: ){
! 4476: int rc;
! 4477: sqlite3 *db;
! 4478: if( argc!=3 ){
! 4479: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 4480: " DB function-name", 0);
! 4481: return TCL_ERROR;
! 4482: }
! 4483: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 4484: rc = sqlite3_create_function(db, argv[2], -1, SQLITE_UTF8, 0, 0, 0, 0);
! 4485: Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
! 4486: return TCL_OK;
! 4487: }
! 4488:
! 4489: /*
! 4490: ** Usage: sqlite_delete_collation DB collation-name
! 4491: **
! 4492: ** Delete the collation sequence 'collation-name' from database handle
! 4493: ** DB. It is assumed that the collation sequence was created as UTF8 (the
! 4494: ** way the TCL interface does it).
! 4495: */
! 4496: static int delete_collation(
! 4497: void * clientData,
! 4498: Tcl_Interp *interp,
! 4499: int argc,
! 4500: char **argv
! 4501: ){
! 4502: int rc;
! 4503: sqlite3 *db;
! 4504: if( argc!=3 ){
! 4505: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 4506: " DB function-name", 0);
! 4507: return TCL_ERROR;
! 4508: }
! 4509: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 4510: rc = sqlite3_create_collation(db, argv[2], SQLITE_UTF8, 0, 0);
! 4511: Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
! 4512: return TCL_OK;
! 4513: }
! 4514:
! 4515: /*
! 4516: ** Usage: sqlite3_get_autocommit DB
! 4517: **
! 4518: ** Return true if the database DB is currently in auto-commit mode.
! 4519: ** Return false if not.
! 4520: */
! 4521: static int get_autocommit(
! 4522: void * clientData,
! 4523: Tcl_Interp *interp,
! 4524: int argc,
! 4525: char **argv
! 4526: ){
! 4527: char zBuf[30];
! 4528: sqlite3 *db;
! 4529: if( argc!=2 ){
! 4530: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 4531: " DB", 0);
! 4532: return TCL_ERROR;
! 4533: }
! 4534: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 4535: sprintf(zBuf, "%d", sqlite3_get_autocommit(db));
! 4536: Tcl_AppendResult(interp, zBuf, 0);
! 4537: return TCL_OK;
! 4538: }
! 4539:
! 4540: /*
! 4541: ** Usage: sqlite3_busy_timeout DB MS
! 4542: **
! 4543: ** Set the busy timeout. This is more easily done using the timeout
! 4544: ** method of the TCL interface. But we need a way to test the case
! 4545: ** where it returns SQLITE_MISUSE.
! 4546: */
! 4547: static int test_busy_timeout(
! 4548: void * clientData,
! 4549: Tcl_Interp *interp,
! 4550: int argc,
! 4551: char **argv
! 4552: ){
! 4553: int rc, ms;
! 4554: sqlite3 *db;
! 4555: if( argc!=3 ){
! 4556: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 4557: " DB", 0);
! 4558: return TCL_ERROR;
! 4559: }
! 4560: if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
! 4561: if( Tcl_GetInt(interp, argv[2], &ms) ) return TCL_ERROR;
! 4562: rc = sqlite3_busy_timeout(db, ms);
! 4563: Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
! 4564: return TCL_OK;
! 4565: }
! 4566:
! 4567: /*
! 4568: ** Usage: tcl_variable_type VARIABLENAME
! 4569: **
! 4570: ** Return the name of the internal representation for the
! 4571: ** value of the given variable.
! 4572: */
! 4573: static int tcl_variable_type(
! 4574: void * clientData,
! 4575: Tcl_Interp *interp,
! 4576: int objc,
! 4577: Tcl_Obj *CONST objv[]
! 4578: ){
! 4579: Tcl_Obj *pVar;
! 4580: if( objc!=2 ){
! 4581: Tcl_WrongNumArgs(interp, 1, objv, "VARIABLE");
! 4582: return TCL_ERROR;
! 4583: }
! 4584: pVar = Tcl_GetVar2Ex(interp, Tcl_GetString(objv[1]), 0, TCL_LEAVE_ERR_MSG);
! 4585: if( pVar==0 ) return TCL_ERROR;
! 4586: if( pVar->typePtr ){
! 4587: Tcl_SetObjResult(interp, Tcl_NewStringObj(pVar->typePtr->name, -1));
! 4588: }
! 4589: return TCL_OK;
! 4590: }
! 4591:
! 4592: /*
! 4593: ** Usage: sqlite3_release_memory ?N?
! 4594: **
! 4595: ** Attempt to release memory currently held but not actually required.
! 4596: ** The integer N is the number of bytes we are trying to release. The
! 4597: ** return value is the amount of memory actually released.
! 4598: */
! 4599: static int test_release_memory(
! 4600: void * clientData,
! 4601: Tcl_Interp *interp,
! 4602: int objc,
! 4603: Tcl_Obj *CONST objv[]
! 4604: ){
! 4605: #if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) && !defined(SQLITE_OMIT_DISKIO)
! 4606: int N;
! 4607: int amt;
! 4608: if( objc!=1 && objc!=2 ){
! 4609: Tcl_WrongNumArgs(interp, 1, objv, "?N?");
! 4610: return TCL_ERROR;
! 4611: }
! 4612: if( objc==2 ){
! 4613: if( Tcl_GetIntFromObj(interp, objv[1], &N) ) return TCL_ERROR;
! 4614: }else{
! 4615: N = -1;
! 4616: }
! 4617: amt = sqlite3_release_memory(N);
! 4618: Tcl_SetObjResult(interp, Tcl_NewIntObj(amt));
! 4619: #endif
! 4620: return TCL_OK;
! 4621: }
! 4622:
! 4623:
! 4624: /*
! 4625: ** Usage: sqlite3_db_release_memory DB
! 4626: **
! 4627: ** Attempt to release memory currently held by database DB. Return the
! 4628: ** result code (which in the current implementation is always zero).
! 4629: */
! 4630: static int test_db_release_memory(
! 4631: void * clientData,
! 4632: Tcl_Interp *interp,
! 4633: int objc,
! 4634: Tcl_Obj *CONST objv[]
! 4635: ){
! 4636: sqlite3 *db;
! 4637: int rc;
! 4638: if( objc!=2 ){
! 4639: Tcl_WrongNumArgs(interp, 1, objv, "DB");
! 4640: return TCL_ERROR;
! 4641: }
! 4642: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 4643: rc = sqlite3_db_release_memory(db);
! 4644: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
! 4645: return TCL_OK;
! 4646: }
! 4647:
! 4648: /*
! 4649: ** Usage: sqlite3_db_filename DB DBNAME
! 4650: **
! 4651: ** Return the name of a file associated with a database.
! 4652: */
! 4653: static int test_db_filename(
! 4654: void * clientData,
! 4655: Tcl_Interp *interp,
! 4656: int objc,
! 4657: Tcl_Obj *CONST objv[]
! 4658: ){
! 4659: sqlite3 *db;
! 4660: const char *zDbName;
! 4661: if( objc!=3 ){
! 4662: Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME");
! 4663: return TCL_ERROR;
! 4664: }
! 4665: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 4666: zDbName = Tcl_GetString(objv[2]);
! 4667: Tcl_AppendResult(interp, sqlite3_db_filename(db, zDbName), (void*)0);
! 4668: return TCL_OK;
! 4669: }
! 4670:
! 4671: /*
! 4672: ** Usage: sqlite3_soft_heap_limit ?N?
! 4673: **
! 4674: ** Query or set the soft heap limit for the current thread. The
! 4675: ** limit is only changed if the N is present. The previous limit
! 4676: ** is returned.
! 4677: */
! 4678: static int test_soft_heap_limit(
! 4679: void * clientData,
! 4680: Tcl_Interp *interp,
! 4681: int objc,
! 4682: Tcl_Obj *CONST objv[]
! 4683: ){
! 4684: sqlite3_int64 amt;
! 4685: sqlite3_int64 N = -1;
! 4686: if( objc!=1 && objc!=2 ){
! 4687: Tcl_WrongNumArgs(interp, 1, objv, "?N?");
! 4688: return TCL_ERROR;
! 4689: }
! 4690: if( objc==2 ){
! 4691: if( Tcl_GetWideIntFromObj(interp, objv[1], &N) ) return TCL_ERROR;
! 4692: }
! 4693: amt = sqlite3_soft_heap_limit64(N);
! 4694: Tcl_SetObjResult(interp, Tcl_NewWideIntObj(amt));
! 4695: return TCL_OK;
! 4696: }
! 4697:
! 4698: /*
! 4699: ** Usage: sqlite3_thread_cleanup
! 4700: **
! 4701: ** Call the sqlite3_thread_cleanup API.
! 4702: */
! 4703: static int test_thread_cleanup(
! 4704: void * clientData,
! 4705: Tcl_Interp *interp,
! 4706: int objc,
! 4707: Tcl_Obj *CONST objv[]
! 4708: ){
! 4709: #ifndef SQLITE_OMIT_DEPRECATED
! 4710: sqlite3_thread_cleanup();
! 4711: #endif
! 4712: return TCL_OK;
! 4713: }
! 4714:
! 4715: /*
! 4716: ** Usage: sqlite3_pager_refcounts DB
! 4717: **
! 4718: ** Return a list of numbers which are the PagerRefcount for all
! 4719: ** pagers on each database connection.
! 4720: */
! 4721: static int test_pager_refcounts(
! 4722: void * clientData,
! 4723: Tcl_Interp *interp,
! 4724: int objc,
! 4725: Tcl_Obj *CONST objv[]
! 4726: ){
! 4727: sqlite3 *db;
! 4728: int i;
! 4729: int v, *a;
! 4730: Tcl_Obj *pResult;
! 4731:
! 4732: if( objc!=2 ){
! 4733: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 4734: Tcl_GetStringFromObj(objv[0], 0), " DB", 0);
! 4735: return TCL_ERROR;
! 4736: }
! 4737: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 4738: pResult = Tcl_NewObj();
! 4739: for(i=0; i<db->nDb; i++){
! 4740: if( db->aDb[i].pBt==0 ){
! 4741: v = -1;
! 4742: }else{
! 4743: sqlite3_mutex_enter(db->mutex);
! 4744: a = sqlite3PagerStats(sqlite3BtreePager(db->aDb[i].pBt));
! 4745: v = a[0];
! 4746: sqlite3_mutex_leave(db->mutex);
! 4747: }
! 4748: Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(v));
! 4749: }
! 4750: Tcl_SetObjResult(interp, pResult);
! 4751: return TCL_OK;
! 4752: }
! 4753:
! 4754:
! 4755: /*
! 4756: ** tclcmd: working_64bit_int
! 4757: **
! 4758: ** Some TCL builds (ex: cygwin) do not support 64-bit integers. This
! 4759: ** leads to a number of test failures. The present command checks the
! 4760: ** TCL build to see whether or not it supports 64-bit integers. It
! 4761: ** returns TRUE if it does and FALSE if not.
! 4762: **
! 4763: ** This command is used to warn users that their TCL build is defective
! 4764: ** and that the errors they are seeing in the test scripts might be
! 4765: ** a result of their defective TCL rather than problems in SQLite.
! 4766: */
! 4767: static int working_64bit_int(
! 4768: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 4769: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 4770: int objc, /* Number of arguments */
! 4771: Tcl_Obj *CONST objv[] /* Command arguments */
! 4772: ){
! 4773: Tcl_Obj *pTestObj;
! 4774: int working = 0;
! 4775:
! 4776: pTestObj = Tcl_NewWideIntObj(1000000*(i64)1234567890);
! 4777: working = strcmp(Tcl_GetString(pTestObj), "1234567890000000")==0;
! 4778: Tcl_DecrRefCount(pTestObj);
! 4779: Tcl_SetObjResult(interp, Tcl_NewBooleanObj(working));
! 4780: return TCL_OK;
! 4781: }
! 4782:
! 4783:
! 4784: /*
! 4785: ** tclcmd: vfs_unlink_test
! 4786: **
! 4787: ** This TCL command unregisters the primary VFS and then registers
! 4788: ** it back again. This is used to test the ability to register a
! 4789: ** VFS when none are previously registered, and the ability to
! 4790: ** unregister the only available VFS. Ticket #2738
! 4791: */
! 4792: static int vfs_unlink_test(
! 4793: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 4794: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 4795: int objc, /* Number of arguments */
! 4796: Tcl_Obj *CONST objv[] /* Command arguments */
! 4797: ){
! 4798: int i;
! 4799: sqlite3_vfs *pMain;
! 4800: sqlite3_vfs *apVfs[20];
! 4801: sqlite3_vfs one, two;
! 4802:
! 4803: sqlite3_vfs_unregister(0); /* Unregister of NULL is harmless */
! 4804: one.zName = "__one";
! 4805: two.zName = "__two";
! 4806:
! 4807: /* Calling sqlite3_vfs_register with 2nd argument of 0 does not
! 4808: ** change the default VFS
! 4809: */
! 4810: pMain = sqlite3_vfs_find(0);
! 4811: sqlite3_vfs_register(&one, 0);
! 4812: assert( pMain==0 || pMain==sqlite3_vfs_find(0) );
! 4813: sqlite3_vfs_register(&two, 0);
! 4814: assert( pMain==0 || pMain==sqlite3_vfs_find(0) );
! 4815:
! 4816: /* We can find a VFS by its name */
! 4817: assert( sqlite3_vfs_find("__one")==&one );
! 4818: assert( sqlite3_vfs_find("__two")==&two );
! 4819:
! 4820: /* Calling sqlite_vfs_register with non-zero second parameter changes the
! 4821: ** default VFS, even if the 1st parameter is an existig VFS that is
! 4822: ** previously registered as the non-default.
! 4823: */
! 4824: sqlite3_vfs_register(&one, 1);
! 4825: assert( sqlite3_vfs_find("__one")==&one );
! 4826: assert( sqlite3_vfs_find("__two")==&two );
! 4827: assert( sqlite3_vfs_find(0)==&one );
! 4828: sqlite3_vfs_register(&two, 1);
! 4829: assert( sqlite3_vfs_find("__one")==&one );
! 4830: assert( sqlite3_vfs_find("__two")==&two );
! 4831: assert( sqlite3_vfs_find(0)==&two );
! 4832: if( pMain ){
! 4833: sqlite3_vfs_register(pMain, 1);
! 4834: assert( sqlite3_vfs_find("__one")==&one );
! 4835: assert( sqlite3_vfs_find("__two")==&two );
! 4836: assert( sqlite3_vfs_find(0)==pMain );
! 4837: }
! 4838:
! 4839: /* Unlink the default VFS. Repeat until there are no more VFSes
! 4840: ** registered.
! 4841: */
! 4842: for(i=0; i<sizeof(apVfs)/sizeof(apVfs[0]); i++){
! 4843: apVfs[i] = sqlite3_vfs_find(0);
! 4844: if( apVfs[i] ){
! 4845: assert( apVfs[i]==sqlite3_vfs_find(apVfs[i]->zName) );
! 4846: sqlite3_vfs_unregister(apVfs[i]);
! 4847: assert( 0==sqlite3_vfs_find(apVfs[i]->zName) );
! 4848: }
! 4849: }
! 4850: assert( 0==sqlite3_vfs_find(0) );
! 4851:
! 4852: /* Register the main VFS as non-default (will be made default, since
! 4853: ** it'll be the only one in existence).
! 4854: */
! 4855: sqlite3_vfs_register(pMain, 0);
! 4856: assert( sqlite3_vfs_find(0)==pMain );
! 4857:
! 4858: /* Un-register the main VFS again to restore an empty VFS list */
! 4859: sqlite3_vfs_unregister(pMain);
! 4860: assert( 0==sqlite3_vfs_find(0) );
! 4861:
! 4862: /* Relink all VFSes in reverse order. */
! 4863: for(i=sizeof(apVfs)/sizeof(apVfs[0])-1; i>=0; i--){
! 4864: if( apVfs[i] ){
! 4865: sqlite3_vfs_register(apVfs[i], 1);
! 4866: assert( apVfs[i]==sqlite3_vfs_find(0) );
! 4867: assert( apVfs[i]==sqlite3_vfs_find(apVfs[i]->zName) );
! 4868: }
! 4869: }
! 4870:
! 4871: /* Unregister out sample VFSes. */
! 4872: sqlite3_vfs_unregister(&one);
! 4873: sqlite3_vfs_unregister(&two);
! 4874:
! 4875: /* Unregistering a VFS that is not currently registered is harmless */
! 4876: sqlite3_vfs_unregister(&one);
! 4877: sqlite3_vfs_unregister(&two);
! 4878: assert( sqlite3_vfs_find("__one")==0 );
! 4879: assert( sqlite3_vfs_find("__two")==0 );
! 4880:
! 4881: /* We should be left with the original default VFS back as the
! 4882: ** original */
! 4883: assert( sqlite3_vfs_find(0)==pMain );
! 4884:
! 4885: return TCL_OK;
! 4886: }
! 4887:
! 4888: /*
! 4889: ** tclcmd: vfs_initfail_test
! 4890: **
! 4891: ** This TCL command attempts to vfs_find and vfs_register when the
! 4892: ** sqlite3_initialize() interface is failing. All calls should fail.
! 4893: */
! 4894: static int vfs_initfail_test(
! 4895: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 4896: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 4897: int objc, /* Number of arguments */
! 4898: Tcl_Obj *CONST objv[] /* Command arguments */
! 4899: ){
! 4900: sqlite3_vfs one;
! 4901: one.zName = "__one";
! 4902:
! 4903: if( sqlite3_vfs_find(0) ) return TCL_ERROR;
! 4904: sqlite3_vfs_register(&one, 0);
! 4905: if( sqlite3_vfs_find(0) ) return TCL_ERROR;
! 4906: sqlite3_vfs_register(&one, 1);
! 4907: if( sqlite3_vfs_find(0) ) return TCL_ERROR;
! 4908: return TCL_OK;
! 4909: }
! 4910:
! 4911: /*
! 4912: ** Saved VFSes
! 4913: */
! 4914: static sqlite3_vfs *apVfs[20];
! 4915: static int nVfs = 0;
! 4916:
! 4917: /*
! 4918: ** tclcmd: vfs_unregister_all
! 4919: **
! 4920: ** Unregister all VFSes.
! 4921: */
! 4922: static int vfs_unregister_all(
! 4923: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 4924: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 4925: int objc, /* Number of arguments */
! 4926: Tcl_Obj *CONST objv[] /* Command arguments */
! 4927: ){
! 4928: int i;
! 4929: for(i=0; i<ArraySize(apVfs); i++){
! 4930: apVfs[i] = sqlite3_vfs_find(0);
! 4931: if( apVfs[i]==0 ) break;
! 4932: sqlite3_vfs_unregister(apVfs[i]);
! 4933: }
! 4934: nVfs = i;
! 4935: return TCL_OK;
! 4936: }
! 4937: /*
! 4938: ** tclcmd: vfs_reregister_all
! 4939: **
! 4940: ** Restore all VFSes that were removed using vfs_unregister_all
! 4941: */
! 4942: static int vfs_reregister_all(
! 4943: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 4944: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 4945: int objc, /* Number of arguments */
! 4946: Tcl_Obj *CONST objv[] /* Command arguments */
! 4947: ){
! 4948: int i;
! 4949: for(i=0; i<nVfs; i++){
! 4950: sqlite3_vfs_register(apVfs[i], i==0);
! 4951: }
! 4952: return TCL_OK;
! 4953: }
! 4954:
! 4955:
! 4956: /*
! 4957: ** tclcmd: file_control_test DB
! 4958: **
! 4959: ** This TCL command runs the sqlite3_file_control interface and
! 4960: ** verifies correct operation of the same.
! 4961: */
! 4962: static int file_control_test(
! 4963: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 4964: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 4965: int objc, /* Number of arguments */
! 4966: Tcl_Obj *CONST objv[] /* Command arguments */
! 4967: ){
! 4968: int iArg = 0;
! 4969: sqlite3 *db;
! 4970: int rc;
! 4971:
! 4972: if( objc!=2 ){
! 4973: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 4974: Tcl_GetStringFromObj(objv[0], 0), " DB", 0);
! 4975: return TCL_ERROR;
! 4976: }
! 4977: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 4978: rc = sqlite3_file_control(db, 0, 0, &iArg);
! 4979: assert( rc==SQLITE_NOTFOUND );
! 4980: rc = sqlite3_file_control(db, "notadatabase", SQLITE_FCNTL_LOCKSTATE, &iArg);
! 4981: assert( rc==SQLITE_ERROR );
! 4982: rc = sqlite3_file_control(db, "main", -1, &iArg);
! 4983: assert( rc==SQLITE_NOTFOUND );
! 4984: rc = sqlite3_file_control(db, "temp", -1, &iArg);
! 4985: assert( rc==SQLITE_NOTFOUND || rc==SQLITE_ERROR );
! 4986:
! 4987: return TCL_OK;
! 4988: }
! 4989:
! 4990:
! 4991: /*
! 4992: ** tclcmd: file_control_lasterrno_test DB
! 4993: **
! 4994: ** This TCL command runs the sqlite3_file_control interface and
! 4995: ** verifies correct operation of the SQLITE_LAST_ERRNO verb.
! 4996: */
! 4997: static int file_control_lasterrno_test(
! 4998: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 4999: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5000: int objc, /* Number of arguments */
! 5001: Tcl_Obj *CONST objv[] /* Command arguments */
! 5002: ){
! 5003: int iArg = 0;
! 5004: sqlite3 *db;
! 5005: int rc;
! 5006:
! 5007: if( objc!=2 ){
! 5008: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 5009: Tcl_GetStringFromObj(objv[0], 0), " DB", 0);
! 5010: return TCL_ERROR;
! 5011: }
! 5012: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
! 5013: return TCL_ERROR;
! 5014: }
! 5015: rc = sqlite3_file_control(db, NULL, SQLITE_LAST_ERRNO, &iArg);
! 5016: if( rc ){
! 5017: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
! 5018: return TCL_ERROR;
! 5019: }
! 5020: if( iArg!=0 ) {
! 5021: Tcl_AppendResult(interp, "Unexpected non-zero errno: ",
! 5022: Tcl_GetStringFromObj(Tcl_NewIntObj(iArg), 0), " ", 0);
! 5023: return TCL_ERROR;
! 5024: }
! 5025: return TCL_OK;
! 5026: }
! 5027:
! 5028: /*
! 5029: ** tclcmd: file_control_chunksize_test DB DBNAME SIZE
! 5030: **
! 5031: ** This TCL command runs the sqlite3_file_control interface and
! 5032: ** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and
! 5033: ** SQLITE_SET_LOCKPROXYFILE verbs.
! 5034: */
! 5035: static int file_control_chunksize_test(
! 5036: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5037: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5038: int objc, /* Number of arguments */
! 5039: Tcl_Obj *CONST objv[] /* Command arguments */
! 5040: ){
! 5041: int nSize; /* New chunk size */
! 5042: char *zDb; /* Db name ("main", "temp" etc.) */
! 5043: sqlite3 *db; /* Database handle */
! 5044: int rc; /* file_control() return code */
! 5045:
! 5046: if( objc!=4 ){
! 5047: Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SIZE");
! 5048: return TCL_ERROR;
! 5049: }
! 5050: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
! 5051: || Tcl_GetIntFromObj(interp, objv[3], &nSize)
! 5052: ){
! 5053: return TCL_ERROR;
! 5054: }
! 5055: zDb = Tcl_GetString(objv[2]);
! 5056: if( zDb[0]=='\0' ) zDb = NULL;
! 5057:
! 5058: rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_CHUNK_SIZE, (void *)&nSize);
! 5059: if( rc ){
! 5060: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
! 5061: return TCL_ERROR;
! 5062: }
! 5063: return TCL_OK;
! 5064: }
! 5065:
! 5066: /*
! 5067: ** tclcmd: file_control_sizehint_test DB DBNAME SIZE
! 5068: **
! 5069: ** This TCL command runs the sqlite3_file_control interface
! 5070: ** with SQLITE_FCNTL_SIZE_HINT
! 5071: */
! 5072: static int file_control_sizehint_test(
! 5073: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5074: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5075: int objc, /* Number of arguments */
! 5076: Tcl_Obj *CONST objv[] /* Command arguments */
! 5077: ){
! 5078: sqlite3_int64 nSize; /* Hinted size */
! 5079: char *zDb; /* Db name ("main", "temp" etc.) */
! 5080: sqlite3 *db; /* Database handle */
! 5081: int rc; /* file_control() return code */
! 5082:
! 5083: if( objc!=4 ){
! 5084: Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SIZE");
! 5085: return TCL_ERROR;
! 5086: }
! 5087: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
! 5088: || Tcl_GetWideIntFromObj(interp, objv[3], &nSize)
! 5089: ){
! 5090: return TCL_ERROR;
! 5091: }
! 5092: zDb = Tcl_GetString(objv[2]);
! 5093: if( zDb[0]=='\0' ) zDb = NULL;
! 5094:
! 5095: rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_SIZE_HINT, (void *)&nSize);
! 5096: if( rc ){
! 5097: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
! 5098: return TCL_ERROR;
! 5099: }
! 5100: return TCL_OK;
! 5101: }
! 5102:
! 5103: /*
! 5104: ** tclcmd: file_control_lockproxy_test DB PWD
! 5105: **
! 5106: ** This TCL command runs the sqlite3_file_control interface and
! 5107: ** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and
! 5108: ** SQLITE_SET_LOCKPROXYFILE verbs.
! 5109: */
! 5110: static int file_control_lockproxy_test(
! 5111: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5112: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5113: int objc, /* Number of arguments */
! 5114: Tcl_Obj *CONST objv[] /* Command arguments */
! 5115: ){
! 5116: sqlite3 *db;
! 5117: const char *zPwd;
! 5118: int nPwd;
! 5119:
! 5120: if( objc!=3 ){
! 5121: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 5122: Tcl_GetStringFromObj(objv[0], 0), " DB PWD", 0);
! 5123: return TCL_ERROR;
! 5124: }
! 5125: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
! 5126: return TCL_ERROR;
! 5127: }
! 5128: zPwd = Tcl_GetStringFromObj(objv[2], &nPwd);
! 5129:
! 5130: #if !defined(SQLITE_ENABLE_LOCKING_STYLE)
! 5131: # if defined(__APPLE__)
! 5132: # define SQLITE_ENABLE_LOCKING_STYLE 1
! 5133: # else
! 5134: # define SQLITE_ENABLE_LOCKING_STYLE 0
! 5135: # endif
! 5136: #endif
! 5137: #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
! 5138: {
! 5139: char *testPath;
! 5140: int rc;
! 5141: char proxyPath[400];
! 5142:
! 5143: if( sizeof(proxyPath)<nPwd+20 ){
! 5144: Tcl_AppendResult(interp, "PWD too big", (void*)0);
! 5145: return TCL_ERROR;
! 5146: }
! 5147: sprintf(proxyPath, "%s/test.proxy", zPwd);
! 5148: rc = sqlite3_file_control(db, NULL, SQLITE_SET_LOCKPROXYFILE, proxyPath);
! 5149: if( rc ){
! 5150: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
! 5151: return TCL_ERROR;
! 5152: }
! 5153: rc = sqlite3_file_control(db, NULL, SQLITE_GET_LOCKPROXYFILE, &testPath);
! 5154: if( strncmp(proxyPath,testPath,11) ){
! 5155: Tcl_AppendResult(interp, "Lock proxy file did not match the "
! 5156: "previously assigned value", 0);
! 5157: return TCL_ERROR;
! 5158: }
! 5159: if( rc ){
! 5160: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
! 5161: return TCL_ERROR;
! 5162: }
! 5163: rc = sqlite3_file_control(db, NULL, SQLITE_SET_LOCKPROXYFILE, proxyPath);
! 5164: if( rc ){
! 5165: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
! 5166: return TCL_ERROR;
! 5167: }
! 5168: }
! 5169: #endif
! 5170: return TCL_OK;
! 5171: }
! 5172:
! 5173: /*
! 5174: ** tclcmd: file_control_win32_av_retry DB NRETRY DELAY
! 5175: **
! 5176: ** This TCL command runs the sqlite3_file_control interface with
! 5177: ** the SQLITE_FCNTL_WIN32_AV_RETRY opcode.
! 5178: */
! 5179: static int file_control_win32_av_retry(
! 5180: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5181: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5182: int objc, /* Number of arguments */
! 5183: Tcl_Obj *CONST objv[] /* Command arguments */
! 5184: ){
! 5185: sqlite3 *db;
! 5186: int rc;
! 5187: int a[2];
! 5188: char z[100];
! 5189:
! 5190: if( objc!=4 ){
! 5191: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 5192: Tcl_GetStringFromObj(objv[0], 0), " DB NRETRY DELAY", 0);
! 5193: return TCL_ERROR;
! 5194: }
! 5195: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
! 5196: return TCL_ERROR;
! 5197: }
! 5198: if( Tcl_GetIntFromObj(interp, objv[2], &a[0]) ) return TCL_ERROR;
! 5199: if( Tcl_GetIntFromObj(interp, objv[3], &a[1]) ) return TCL_ERROR;
! 5200: rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_WIN32_AV_RETRY, (void*)a);
! 5201: sqlite3_snprintf(sizeof(z), z, "%d %d %d", rc, a[0], a[1]);
! 5202: Tcl_AppendResult(interp, z, (char*)0);
! 5203: return TCL_OK;
! 5204: }
! 5205:
! 5206: /*
! 5207: ** tclcmd: file_control_persist_wal DB PERSIST-FLAG
! 5208: **
! 5209: ** This TCL command runs the sqlite3_file_control interface with
! 5210: ** the SQLITE_FCNTL_PERSIST_WAL opcode.
! 5211: */
! 5212: static int file_control_persist_wal(
! 5213: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5214: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5215: int objc, /* Number of arguments */
! 5216: Tcl_Obj *CONST objv[] /* Command arguments */
! 5217: ){
! 5218: sqlite3 *db;
! 5219: int rc;
! 5220: int bPersist;
! 5221: char z[100];
! 5222:
! 5223: if( objc!=3 ){
! 5224: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 5225: Tcl_GetStringFromObj(objv[0], 0), " DB FLAG", 0);
! 5226: return TCL_ERROR;
! 5227: }
! 5228: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
! 5229: return TCL_ERROR;
! 5230: }
! 5231: if( Tcl_GetIntFromObj(interp, objv[2], &bPersist) ) return TCL_ERROR;
! 5232: rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_PERSIST_WAL, (void*)&bPersist);
! 5233: sqlite3_snprintf(sizeof(z), z, "%d %d", rc, bPersist);
! 5234: Tcl_AppendResult(interp, z, (char*)0);
! 5235: return TCL_OK;
! 5236: }
! 5237:
! 5238: /*
! 5239: ** tclcmd: file_control_powersafe_overwrite DB PSOW-FLAG
! 5240: **
! 5241: ** This TCL command runs the sqlite3_file_control interface with
! 5242: ** the SQLITE_FCNTL_POWERSAFE_OVERWRITE opcode.
! 5243: */
! 5244: static int file_control_powersafe_overwrite(
! 5245: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5246: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5247: int objc, /* Number of arguments */
! 5248: Tcl_Obj *CONST objv[] /* Command arguments */
! 5249: ){
! 5250: sqlite3 *db;
! 5251: int rc;
! 5252: int b;
! 5253: char z[100];
! 5254:
! 5255: if( objc!=3 ){
! 5256: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 5257: Tcl_GetStringFromObj(objv[0], 0), " DB FLAG", 0);
! 5258: return TCL_ERROR;
! 5259: }
! 5260: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
! 5261: return TCL_ERROR;
! 5262: }
! 5263: if( Tcl_GetIntFromObj(interp, objv[2], &b) ) return TCL_ERROR;
! 5264: rc = sqlite3_file_control(db,NULL,SQLITE_FCNTL_POWERSAFE_OVERWRITE,(void*)&b);
! 5265: sqlite3_snprintf(sizeof(z), z, "%d %d", rc, b);
! 5266: Tcl_AppendResult(interp, z, (char*)0);
! 5267: return TCL_OK;
! 5268: }
! 5269:
! 5270:
! 5271: /*
! 5272: ** tclcmd: file_control_vfsname DB ?AUXDB?
! 5273: **
! 5274: ** Return a string that describes the stack of VFSes.
! 5275: */
! 5276: static int file_control_vfsname(
! 5277: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5278: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5279: int objc, /* Number of arguments */
! 5280: Tcl_Obj *CONST objv[] /* Command arguments */
! 5281: ){
! 5282: sqlite3 *db;
! 5283: const char *zDbName = "main";
! 5284: char *zVfsName = 0;
! 5285:
! 5286: if( objc!=2 && objc!=3 ){
! 5287: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 5288: Tcl_GetStringFromObj(objv[0], 0), " DB ?AUXDB?", 0);
! 5289: return TCL_ERROR;
! 5290: }
! 5291: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
! 5292: return TCL_ERROR;
! 5293: }
! 5294: if( objc==3 ){
! 5295: zDbName = Tcl_GetString(objv[2]);
! 5296: }
! 5297: sqlite3_file_control(db, zDbName, SQLITE_FCNTL_VFSNAME,(void*)&zVfsName);
! 5298: Tcl_AppendResult(interp, zVfsName, (char*)0);
! 5299: sqlite3_free(zVfsName);
! 5300: return TCL_OK;
! 5301: }
! 5302:
! 5303:
! 5304: /*
! 5305: ** tclcmd: sqlite3_vfs_list
! 5306: **
! 5307: ** Return a tcl list containing the names of all registered vfs's.
! 5308: */
! 5309: static int vfs_list(
! 5310: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5311: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5312: int objc, /* Number of arguments */
! 5313: Tcl_Obj *CONST objv[] /* Command arguments */
! 5314: ){
! 5315: sqlite3_vfs *pVfs;
! 5316: Tcl_Obj *pRet = Tcl_NewObj();
! 5317: if( objc!=1 ){
! 5318: Tcl_WrongNumArgs(interp, 1, objv, "");
! 5319: return TCL_ERROR;
! 5320: }
! 5321: for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
! 5322: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj(pVfs->zName, -1));
! 5323: }
! 5324: Tcl_SetObjResult(interp, pRet);
! 5325: return TCL_OK;
! 5326: }
! 5327:
! 5328: /*
! 5329: ** tclcmd: sqlite3_limit DB ID VALUE
! 5330: **
! 5331: ** This TCL command runs the sqlite3_limit interface and
! 5332: ** verifies correct operation of the same.
! 5333: */
! 5334: static int test_limit(
! 5335: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5336: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5337: int objc, /* Number of arguments */
! 5338: Tcl_Obj *CONST objv[] /* Command arguments */
! 5339: ){
! 5340: sqlite3 *db;
! 5341: int rc;
! 5342: static const struct {
! 5343: char *zName;
! 5344: int id;
! 5345: } aId[] = {
! 5346: { "SQLITE_LIMIT_LENGTH", SQLITE_LIMIT_LENGTH },
! 5347: { "SQLITE_LIMIT_SQL_LENGTH", SQLITE_LIMIT_SQL_LENGTH },
! 5348: { "SQLITE_LIMIT_COLUMN", SQLITE_LIMIT_COLUMN },
! 5349: { "SQLITE_LIMIT_EXPR_DEPTH", SQLITE_LIMIT_EXPR_DEPTH },
! 5350: { "SQLITE_LIMIT_COMPOUND_SELECT", SQLITE_LIMIT_COMPOUND_SELECT },
! 5351: { "SQLITE_LIMIT_VDBE_OP", SQLITE_LIMIT_VDBE_OP },
! 5352: { "SQLITE_LIMIT_FUNCTION_ARG", SQLITE_LIMIT_FUNCTION_ARG },
! 5353: { "SQLITE_LIMIT_ATTACHED", SQLITE_LIMIT_ATTACHED },
! 5354: { "SQLITE_LIMIT_LIKE_PATTERN_LENGTH", SQLITE_LIMIT_LIKE_PATTERN_LENGTH },
! 5355: { "SQLITE_LIMIT_VARIABLE_NUMBER", SQLITE_LIMIT_VARIABLE_NUMBER },
! 5356: { "SQLITE_LIMIT_TRIGGER_DEPTH", SQLITE_LIMIT_TRIGGER_DEPTH },
! 5357:
! 5358: /* Out of range test cases */
! 5359: { "SQLITE_LIMIT_TOOSMALL", -1, },
! 5360: { "SQLITE_LIMIT_TOOBIG", SQLITE_LIMIT_TRIGGER_DEPTH+1 },
! 5361: };
! 5362: int i, id;
! 5363: int val;
! 5364: const char *zId;
! 5365:
! 5366: if( objc!=4 ){
! 5367: Tcl_AppendResult(interp, "wrong # args: should be \"",
! 5368: Tcl_GetStringFromObj(objv[0], 0), " DB ID VALUE", 0);
! 5369: return TCL_ERROR;
! 5370: }
! 5371: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 5372: zId = Tcl_GetString(objv[2]);
! 5373: for(i=0; i<sizeof(aId)/sizeof(aId[0]); i++){
! 5374: if( strcmp(zId, aId[i].zName)==0 ){
! 5375: id = aId[i].id;
! 5376: break;
! 5377: }
! 5378: }
! 5379: if( i>=sizeof(aId)/sizeof(aId[0]) ){
! 5380: Tcl_AppendResult(interp, "unknown limit type: ", zId, (char*)0);
! 5381: return TCL_ERROR;
! 5382: }
! 5383: if( Tcl_GetIntFromObj(interp, objv[3], &val) ) return TCL_ERROR;
! 5384: rc = sqlite3_limit(db, id, val);
! 5385: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
! 5386: return TCL_OK;
! 5387: }
! 5388:
! 5389: /*
! 5390: ** tclcmd: save_prng_state
! 5391: **
! 5392: ** Save the state of the pseudo-random number generator.
! 5393: ** At the same time, verify that sqlite3_test_control works even when
! 5394: ** called with an out-of-range opcode.
! 5395: */
! 5396: static int save_prng_state(
! 5397: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5398: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5399: int objc, /* Number of arguments */
! 5400: Tcl_Obj *CONST objv[] /* Command arguments */
! 5401: ){
! 5402: int rc = sqlite3_test_control(9999);
! 5403: assert( rc==0 );
! 5404: rc = sqlite3_test_control(-1);
! 5405: assert( rc==0 );
! 5406: sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SAVE);
! 5407: return TCL_OK;
! 5408: }
! 5409: /*
! 5410: ** tclcmd: restore_prng_state
! 5411: */
! 5412: static int restore_prng_state(
! 5413: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5414: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5415: int objc, /* Number of arguments */
! 5416: Tcl_Obj *CONST objv[] /* Command arguments */
! 5417: ){
! 5418: sqlite3_test_control(SQLITE_TESTCTRL_PRNG_RESTORE);
! 5419: return TCL_OK;
! 5420: }
! 5421: /*
! 5422: ** tclcmd: reset_prng_state
! 5423: */
! 5424: static int reset_prng_state(
! 5425: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5426: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5427: int objc, /* Number of arguments */
! 5428: Tcl_Obj *CONST objv[] /* Command arguments */
! 5429: ){
! 5430: sqlite3_test_control(SQLITE_TESTCTRL_PRNG_RESET);
! 5431: return TCL_OK;
! 5432: }
! 5433:
! 5434: /*
! 5435: ** tclcmd: pcache_stats
! 5436: */
! 5437: static int test_pcache_stats(
! 5438: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 5439: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5440: int objc, /* Number of arguments */
! 5441: Tcl_Obj *CONST objv[] /* Command arguments */
! 5442: ){
! 5443: int nMin;
! 5444: int nMax;
! 5445: int nCurrent;
! 5446: int nRecyclable;
! 5447: Tcl_Obj *pRet;
! 5448:
! 5449: sqlite3PcacheStats(&nCurrent, &nMax, &nMin, &nRecyclable);
! 5450:
! 5451: pRet = Tcl_NewObj();
! 5452: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("current", -1));
! 5453: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nCurrent));
! 5454: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("max", -1));
! 5455: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nMax));
! 5456: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("min", -1));
! 5457: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nMin));
! 5458: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj("recyclable", -1));
! 5459: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nRecyclable));
! 5460:
! 5461: Tcl_SetObjResult(interp, pRet);
! 5462:
! 5463: return TCL_OK;
! 5464: }
! 5465:
! 5466: #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
! 5467: static void test_unlock_notify_cb(void **aArg, int nArg){
! 5468: int ii;
! 5469: for(ii=0; ii<nArg; ii++){
! 5470: Tcl_EvalEx((Tcl_Interp *)aArg[ii], "unlock_notify", -1, TCL_EVAL_GLOBAL);
! 5471: }
! 5472: }
! 5473: #endif /* SQLITE_ENABLE_UNLOCK_NOTIFY */
! 5474:
! 5475: /*
! 5476: ** tclcmd: sqlite3_unlock_notify db
! 5477: */
! 5478: #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
! 5479: static int test_unlock_notify(
! 5480: ClientData clientData, /* Unused */
! 5481: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5482: int objc, /* Number of arguments */
! 5483: Tcl_Obj *CONST objv[] /* Command arguments */
! 5484: ){
! 5485: sqlite3 *db;
! 5486: int rc;
! 5487:
! 5488: if( objc!=2 ){
! 5489: Tcl_WrongNumArgs(interp, 1, objv, "DB");
! 5490: return TCL_ERROR;
! 5491: }
! 5492:
! 5493: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
! 5494: return TCL_ERROR;
! 5495: }
! 5496: rc = sqlite3_unlock_notify(db, test_unlock_notify_cb, (void *)interp);
! 5497: Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
! 5498: return TCL_OK;
! 5499: }
! 5500: #endif
! 5501:
! 5502: /*
! 5503: ** tclcmd: sqlite3_wal_checkpoint db ?NAME?
! 5504: */
! 5505: static int test_wal_checkpoint(
! 5506: ClientData clientData, /* Unused */
! 5507: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5508: int objc, /* Number of arguments */
! 5509: Tcl_Obj *CONST objv[] /* Command arguments */
! 5510: ){
! 5511: char *zDb = 0;
! 5512: sqlite3 *db;
! 5513: int rc;
! 5514:
! 5515: if( objc!=3 && objc!=2 ){
! 5516: Tcl_WrongNumArgs(interp, 1, objv, "DB ?NAME?");
! 5517: return TCL_ERROR;
! 5518: }
! 5519:
! 5520: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
! 5521: return TCL_ERROR;
! 5522: }
! 5523: if( objc==3 ){
! 5524: zDb = Tcl_GetString(objv[2]);
! 5525: }
! 5526: rc = sqlite3_wal_checkpoint(db, zDb);
! 5527: Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
! 5528: return TCL_OK;
! 5529: }
! 5530:
! 5531: /*
! 5532: ** tclcmd: sqlite3_wal_checkpoint_v2 db MODE ?NAME?
! 5533: **
! 5534: ** This command calls the wal_checkpoint_v2() function with the specified
! 5535: ** mode argument (passive, full or restart). If present, the database name
! 5536: ** NAME is passed as the second argument to wal_checkpoint_v2(). If it the
! 5537: ** NAME argument is not present, a NULL pointer is passed instead.
! 5538: **
! 5539: ** If wal_checkpoint_v2() returns any value other than SQLITE_BUSY or
! 5540: ** SQLITE_OK, then this command returns TCL_ERROR. The Tcl result is set
! 5541: ** to the error message obtained from sqlite3_errmsg().
! 5542: **
! 5543: ** Otherwise, this command returns a list of three integers. The first integer
! 5544: ** is 1 if SQLITE_BUSY was returned, or 0 otherwise. The following two integers
! 5545: ** are the values returned via the output paramaters by wal_checkpoint_v2() -
! 5546: ** the number of frames in the log and the number of frames in the log
! 5547: ** that have been checkpointed.
! 5548: */
! 5549: static int test_wal_checkpoint_v2(
! 5550: ClientData clientData, /* Unused */
! 5551: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5552: int objc, /* Number of arguments */
! 5553: Tcl_Obj *CONST objv[] /* Command arguments */
! 5554: ){
! 5555: char *zDb = 0;
! 5556: sqlite3 *db;
! 5557: int rc;
! 5558:
! 5559: int eMode;
! 5560: int nLog = -555;
! 5561: int nCkpt = -555;
! 5562: Tcl_Obj *pRet;
! 5563:
! 5564: const char * aMode[] = { "passive", "full", "restart", 0 };
! 5565: assert( SQLITE_CHECKPOINT_PASSIVE==0 );
! 5566: assert( SQLITE_CHECKPOINT_FULL==1 );
! 5567: assert( SQLITE_CHECKPOINT_RESTART==2 );
! 5568:
! 5569: if( objc!=3 && objc!=4 ){
! 5570: Tcl_WrongNumArgs(interp, 1, objv, "DB MODE ?NAME?");
! 5571: return TCL_ERROR;
! 5572: }
! 5573:
! 5574: if( objc==4 ){
! 5575: zDb = Tcl_GetString(objv[3]);
! 5576: }
! 5577: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
! 5578: || Tcl_GetIndexFromObj(interp, objv[2], aMode, "mode", 0, &eMode)
! 5579: ){
! 5580: return TCL_ERROR;
! 5581: }
! 5582:
! 5583: rc = sqlite3_wal_checkpoint_v2(db, zDb, eMode, &nLog, &nCkpt);
! 5584: if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){
! 5585: Tcl_SetResult(interp, (char *)sqlite3_errmsg(db), TCL_VOLATILE);
! 5586: return TCL_ERROR;
! 5587: }
! 5588:
! 5589: pRet = Tcl_NewObj();
! 5590: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(rc==SQLITE_BUSY?1:0));
! 5591: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nLog));
! 5592: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nCkpt));
! 5593: Tcl_SetObjResult(interp, pRet);
! 5594:
! 5595: return TCL_OK;
! 5596: }
! 5597:
! 5598: /*
! 5599: ** tclcmd: test_sqlite3_log ?SCRIPT?
! 5600: */
! 5601: static struct LogCallback {
! 5602: Tcl_Interp *pInterp;
! 5603: Tcl_Obj *pObj;
! 5604: } logcallback = {0, 0};
! 5605: static void xLogcallback(void *unused, int err, char *zMsg){
! 5606: Tcl_Obj *pNew = Tcl_DuplicateObj(logcallback.pObj);
! 5607: Tcl_IncrRefCount(pNew);
! 5608: Tcl_ListObjAppendElement(
! 5609: 0, pNew, Tcl_NewStringObj(sqlite3TestErrorName(err), -1)
! 5610: );
! 5611: Tcl_ListObjAppendElement(0, pNew, Tcl_NewStringObj(zMsg, -1));
! 5612: Tcl_EvalObjEx(logcallback.pInterp, pNew, TCL_EVAL_GLOBAL|TCL_EVAL_DIRECT);
! 5613: Tcl_DecrRefCount(pNew);
! 5614: }
! 5615: static int test_sqlite3_log(
! 5616: ClientData clientData,
! 5617: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 5618: int objc, /* Number of arguments */
! 5619: Tcl_Obj *CONST objv[] /* Command arguments */
! 5620: ){
! 5621: if( objc>2 ){
! 5622: Tcl_WrongNumArgs(interp, 1, objv, "SCRIPT");
! 5623: return TCL_ERROR;
! 5624: }
! 5625: if( logcallback.pObj ){
! 5626: Tcl_DecrRefCount(logcallback.pObj);
! 5627: logcallback.pObj = 0;
! 5628: logcallback.pInterp = 0;
! 5629: sqlite3_config(SQLITE_CONFIG_LOG, 0, 0);
! 5630: }
! 5631: if( objc>1 ){
! 5632: logcallback.pObj = objv[1];
! 5633: Tcl_IncrRefCount(logcallback.pObj);
! 5634: logcallback.pInterp = interp;
! 5635: sqlite3_config(SQLITE_CONFIG_LOG, xLogcallback, 0);
! 5636: }
! 5637: return TCL_OK;
! 5638: }
! 5639:
! 5640: /*
! 5641: ** tcl_objproc COMMANDNAME ARGS...
! 5642: **
! 5643: ** Run a TCL command using its objProc interface. Throw an error if
! 5644: ** the command has no objProc interface.
! 5645: */
! 5646: static int runAsObjProc(
! 5647: void * clientData,
! 5648: Tcl_Interp *interp,
! 5649: int objc,
! 5650: Tcl_Obj *CONST objv[]
! 5651: ){
! 5652: Tcl_CmdInfo cmdInfo;
! 5653: if( objc<2 ){
! 5654: Tcl_WrongNumArgs(interp, 1, objv, "COMMAND ...");
! 5655: return TCL_ERROR;
! 5656: }
! 5657: if( !Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){
! 5658: Tcl_AppendResult(interp, "command not found: ",
! 5659: Tcl_GetString(objv[1]), (char*)0);
! 5660: return TCL_ERROR;
! 5661: }
! 5662: if( cmdInfo.objProc==0 ){
! 5663: Tcl_AppendResult(interp, "command has no objProc: ",
! 5664: Tcl_GetString(objv[1]), (char*)0);
! 5665: return TCL_ERROR;
! 5666: }
! 5667: return cmdInfo.objProc(cmdInfo.objClientData, interp, objc-1, objv+1);
! 5668: }
! 5669:
! 5670: #ifndef SQLITE_OMIT_EXPLAIN
! 5671: /*
! 5672: ** WARNING: The following function, printExplainQueryPlan() is an exact
! 5673: ** copy of example code from eqp.in (eqp.html). If this code is modified,
! 5674: ** then the documentation copy needs to be modified as well.
! 5675: */
! 5676: /*
! 5677: ** Argument pStmt is a prepared SQL statement. This function compiles
! 5678: ** an EXPLAIN QUERY PLAN command to report on the prepared statement,
! 5679: ** and prints the report to stdout using printf().
! 5680: */
! 5681: int printExplainQueryPlan(sqlite3_stmt *pStmt){
! 5682: const char *zSql; /* Input SQL */
! 5683: char *zExplain; /* SQL with EXPLAIN QUERY PLAN prepended */
! 5684: sqlite3_stmt *pExplain; /* Compiled EXPLAIN QUERY PLAN command */
! 5685: int rc; /* Return code from sqlite3_prepare_v2() */
! 5686:
! 5687: zSql = sqlite3_sql(pStmt);
! 5688: if( zSql==0 ) return SQLITE_ERROR;
! 5689:
! 5690: zExplain = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zSql);
! 5691: if( zExplain==0 ) return SQLITE_NOMEM;
! 5692:
! 5693: rc = sqlite3_prepare_v2(sqlite3_db_handle(pStmt), zExplain, -1, &pExplain, 0);
! 5694: sqlite3_free(zExplain);
! 5695: if( rc!=SQLITE_OK ) return rc;
! 5696:
! 5697: while( SQLITE_ROW==sqlite3_step(pExplain) ){
! 5698: int iSelectid = sqlite3_column_int(pExplain, 0);
! 5699: int iOrder = sqlite3_column_int(pExplain, 1);
! 5700: int iFrom = sqlite3_column_int(pExplain, 2);
! 5701: const char *zDetail = (const char *)sqlite3_column_text(pExplain, 3);
! 5702:
! 5703: printf("%d %d %d %s\n", iSelectid, iOrder, iFrom, zDetail);
! 5704: }
! 5705:
! 5706: return sqlite3_finalize(pExplain);
! 5707: }
! 5708:
! 5709: static int test_print_eqp(
! 5710: void * clientData,
! 5711: Tcl_Interp *interp,
! 5712: int objc,
! 5713: Tcl_Obj *CONST objv[]
! 5714: ){
! 5715: int rc;
! 5716: sqlite3_stmt *pStmt;
! 5717:
! 5718: if( objc!=2 ){
! 5719: Tcl_WrongNumArgs(interp, 1, objv, "STMT");
! 5720: return TCL_ERROR;
! 5721: }
! 5722: if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
! 5723: rc = printExplainQueryPlan(pStmt);
! 5724: /* This is needed on Windows so that a test case using this
! 5725: ** function can open a read pipe and get the output of
! 5726: ** printExplainQueryPlan() immediately.
! 5727: */
! 5728: fflush(stdout);
! 5729: Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
! 5730: return TCL_OK;
! 5731: }
! 5732: #endif /* SQLITE_OMIT_EXPLAIN */
! 5733:
! 5734: /*
! 5735: ** sqlite3_test_control VERB ARGS...
! 5736: */
! 5737: static int test_test_control(
! 5738: void * clientData,
! 5739: Tcl_Interp *interp,
! 5740: int objc,
! 5741: Tcl_Obj *CONST objv[]
! 5742: ){
! 5743: struct Verb {
! 5744: const char *zName;
! 5745: int i;
! 5746: } aVerb[] = {
! 5747: { "SQLITE_TESTCTRL_LOCALTIME_FAULT", SQLITE_TESTCTRL_LOCALTIME_FAULT },
! 5748: };
! 5749: int iVerb;
! 5750: int iFlag;
! 5751: int rc;
! 5752:
! 5753: if( objc<2 ){
! 5754: Tcl_WrongNumArgs(interp, 1, objv, "VERB ARGS...");
! 5755: return TCL_ERROR;
! 5756: }
! 5757:
! 5758: rc = Tcl_GetIndexFromObjStruct(
! 5759: interp, objv[1], aVerb, sizeof(aVerb[0]), "VERB", 0, &iVerb
! 5760: );
! 5761: if( rc!=TCL_OK ) return rc;
! 5762:
! 5763: iFlag = aVerb[iVerb].i;
! 5764: switch( iFlag ){
! 5765: case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
! 5766: int val;
! 5767: if( objc!=3 ){
! 5768: Tcl_WrongNumArgs(interp, 2, objv, "ONOFF");
! 5769: return TCL_ERROR;
! 5770: }
! 5771: if( Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR;
! 5772: sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, val);
! 5773: break;
! 5774: }
! 5775: }
! 5776:
! 5777: Tcl_ResetResult(interp);
! 5778: return TCL_OK;
! 5779: }
! 5780:
! 5781: #if SQLITE_OS_WIN
! 5782: /*
! 5783: ** Information passed from the main thread into the windows file locker
! 5784: ** background thread.
! 5785: */
! 5786: struct win32FileLocker {
! 5787: char *evName; /* Name of event to signal thread startup */
! 5788: HANDLE h; /* Handle of the file to be locked */
! 5789: int delay1; /* Delay before locking */
! 5790: int delay2; /* Delay before unlocking */
! 5791: int ok; /* Finished ok */
! 5792: int err; /* True if an error occurs */
! 5793: };
! 5794: #endif
! 5795:
! 5796:
! 5797: #if SQLITE_OS_WIN
! 5798: /*
! 5799: ** The background thread that does file locking.
! 5800: */
! 5801: static void win32_file_locker(void *pAppData){
! 5802: struct win32FileLocker *p = (struct win32FileLocker*)pAppData;
! 5803: if( p->evName ){
! 5804: HANDLE ev = OpenEvent(EVENT_MODIFY_STATE, FALSE, p->evName);
! 5805: if ( ev ){
! 5806: SetEvent(ev);
! 5807: CloseHandle(ev);
! 5808: }
! 5809: }
! 5810: if( p->delay1 ) Sleep(p->delay1);
! 5811: if( LockFile(p->h, 0, 0, 100000000, 0) ){
! 5812: Sleep(p->delay2);
! 5813: UnlockFile(p->h, 0, 0, 100000000, 0);
! 5814: p->ok = 1;
! 5815: }else{
! 5816: p->err = 1;
! 5817: }
! 5818: CloseHandle(p->h);
! 5819: p->h = 0;
! 5820: p->delay1 = 0;
! 5821: p->delay2 = 0;
! 5822: }
! 5823: #endif
! 5824:
! 5825: #if SQLITE_OS_WIN
! 5826: /*
! 5827: ** lock_win32_file FILENAME DELAY1 DELAY2
! 5828: **
! 5829: ** Get an exclusive manditory lock on file for DELAY2 milliseconds.
! 5830: ** Wait DELAY1 milliseconds before acquiring the lock.
! 5831: */
! 5832: static int win32_file_lock(
! 5833: void * clientData,
! 5834: Tcl_Interp *interp,
! 5835: int objc,
! 5836: Tcl_Obj *CONST objv[]
! 5837: ){
! 5838: static struct win32FileLocker x = { "win32_file_lock", 0, 0, 0, 0, 0 };
! 5839: const char *zFilename;
! 5840: char zBuf[200];
! 5841: int retry = 0;
! 5842: HANDLE ev;
! 5843: DWORD wResult;
! 5844:
! 5845: if( objc!=4 && objc!=1 ){
! 5846: Tcl_WrongNumArgs(interp, 1, objv, "FILENAME DELAY1 DELAY2");
! 5847: return TCL_ERROR;
! 5848: }
! 5849: if( objc==1 ){
! 5850: sqlite3_snprintf(sizeof(zBuf), zBuf, "%d %d %d %d %d",
! 5851: x.ok, x.err, x.delay1, x.delay2, x.h);
! 5852: Tcl_AppendResult(interp, zBuf, (char*)0);
! 5853: return TCL_OK;
! 5854: }
! 5855: while( x.h && retry<30 ){
! 5856: retry++;
! 5857: Sleep(100);
! 5858: }
! 5859: if( x.h ){
! 5860: Tcl_AppendResult(interp, "busy", (char*)0);
! 5861: return TCL_ERROR;
! 5862: }
! 5863: if( Tcl_GetIntFromObj(interp, objv[2], &x.delay1) ) return TCL_ERROR;
! 5864: if( Tcl_GetIntFromObj(interp, objv[3], &x.delay2) ) return TCL_ERROR;
! 5865: zFilename = Tcl_GetString(objv[1]);
! 5866: x.h = CreateFile(zFilename, GENERIC_READ|GENERIC_WRITE,
! 5867: FILE_SHARE_READ|FILE_SHARE_WRITE, 0, OPEN_ALWAYS,
! 5868: FILE_ATTRIBUTE_NORMAL, 0);
! 5869: if( !x.h ){
! 5870: Tcl_AppendResult(interp, "cannot open file: ", zFilename, (char*)0);
! 5871: return TCL_ERROR;
! 5872: }
! 5873: ev = CreateEvent(NULL, TRUE, FALSE, x.evName);
! 5874: if ( !ev ){
! 5875: Tcl_AppendResult(interp, "cannot create event: ", x.evName, (char*)0);
! 5876: return TCL_ERROR;
! 5877: }
! 5878: _beginthread(win32_file_locker, 0, (void*)&x);
! 5879: Sleep(0);
! 5880: if ( (wResult = WaitForSingleObject(ev, 10000))!=WAIT_OBJECT_0 ){
! 5881: sqlite3_snprintf(sizeof(zBuf), zBuf, "0x%x", wResult);
! 5882: Tcl_AppendResult(interp, "wait failed: ", zBuf, (char*)0);
! 5883: CloseHandle(ev);
! 5884: return TCL_ERROR;
! 5885: }
! 5886: CloseHandle(ev);
! 5887: return TCL_OK;
! 5888: }
! 5889: #endif
! 5890:
! 5891:
! 5892: /*
! 5893: ** optimization_control DB OPT BOOLEAN
! 5894: **
! 5895: ** Enable or disable query optimizations using the sqlite3_test_control()
! 5896: ** interface. Disable if BOOLEAN is false and enable if BOOLEAN is true.
! 5897: ** OPT is the name of the optimization to be disabled.
! 5898: */
! 5899: static int optimization_control(
! 5900: void * clientData,
! 5901: Tcl_Interp *interp,
! 5902: int objc,
! 5903: Tcl_Obj *CONST objv[]
! 5904: ){
! 5905: int i;
! 5906: sqlite3 *db;
! 5907: const char *zOpt;
! 5908: int onoff;
! 5909: int mask;
! 5910: static const struct {
! 5911: const char *zOptName;
! 5912: int mask;
! 5913: } aOpt[] = {
! 5914: { "all", SQLITE_OptMask },
! 5915: { "query-flattener", SQLITE_QueryFlattener },
! 5916: { "column-cache", SQLITE_ColumnCache },
! 5917: { "index-sort", SQLITE_IndexSort },
! 5918: { "index-search", SQLITE_IndexSearch },
! 5919: { "index-cover", SQLITE_IndexCover },
! 5920: { "groupby-order", SQLITE_GroupByOrder },
! 5921: { "factor-constants", SQLITE_FactorOutConst },
! 5922: { "real-as-int", SQLITE_IdxRealAsInt },
! 5923: };
! 5924:
! 5925: if( objc!=4 ){
! 5926: Tcl_WrongNumArgs(interp, 1, objv, "DB OPT BOOLEAN");
! 5927: return TCL_ERROR;
! 5928: }
! 5929: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 5930: if( Tcl_GetBooleanFromObj(interp, objv[3], &onoff) ) return TCL_ERROR;
! 5931: zOpt = Tcl_GetString(objv[2]);
! 5932: for(i=0; i<sizeof(aOpt)/sizeof(aOpt[0]); i++){
! 5933: if( strcmp(zOpt, aOpt[i].zOptName)==0 ){
! 5934: mask = aOpt[i].mask;
! 5935: break;
! 5936: }
! 5937: }
! 5938: if( onoff ) mask = ~mask;
! 5939: if( i>=sizeof(aOpt)/sizeof(aOpt[0]) ){
! 5940: Tcl_AppendResult(interp, "unknown optimization - should be one of:",
! 5941: (char*)0);
! 5942: for(i=0; i<sizeof(aOpt)/sizeof(aOpt[0]); i++){
! 5943: Tcl_AppendResult(interp, " ", aOpt[i].zOptName);
! 5944: }
! 5945: return TCL_ERROR;
! 5946: }
! 5947: sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, db, mask);
! 5948: return TCL_OK;
! 5949: }
! 5950:
! 5951: /*
! 5952: ** Register commands with the TCL interpreter.
! 5953: */
! 5954: int Sqlitetest1_Init(Tcl_Interp *interp){
! 5955: extern int sqlite3_search_count;
! 5956: extern int sqlite3_found_count;
! 5957: extern int sqlite3_interrupt_count;
! 5958: extern int sqlite3_open_file_count;
! 5959: extern int sqlite3_sort_count;
! 5960: extern int sqlite3_current_time;
! 5961: #if SQLITE_OS_UNIX && defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
! 5962: extern int sqlite3_hostid_num;
! 5963: #endif
! 5964: extern int sqlite3_max_blobsize;
! 5965: extern int sqlite3BtreeSharedCacheReport(void*,
! 5966: Tcl_Interp*,int,Tcl_Obj*CONST*);
! 5967: static struct {
! 5968: char *zName;
! 5969: Tcl_CmdProc *xProc;
! 5970: } aCmd[] = {
! 5971: { "db_enter", (Tcl_CmdProc*)db_enter },
! 5972: { "db_leave", (Tcl_CmdProc*)db_leave },
! 5973: { "sqlite3_mprintf_int", (Tcl_CmdProc*)sqlite3_mprintf_int },
! 5974: { "sqlite3_mprintf_int64", (Tcl_CmdProc*)sqlite3_mprintf_int64 },
! 5975: { "sqlite3_mprintf_long", (Tcl_CmdProc*)sqlite3_mprintf_long },
! 5976: { "sqlite3_mprintf_str", (Tcl_CmdProc*)sqlite3_mprintf_str },
! 5977: { "sqlite3_snprintf_str", (Tcl_CmdProc*)sqlite3_snprintf_str },
! 5978: { "sqlite3_mprintf_stronly", (Tcl_CmdProc*)sqlite3_mprintf_stronly},
! 5979: { "sqlite3_mprintf_double", (Tcl_CmdProc*)sqlite3_mprintf_double },
! 5980: { "sqlite3_mprintf_scaled", (Tcl_CmdProc*)sqlite3_mprintf_scaled },
! 5981: { "sqlite3_mprintf_hexdouble", (Tcl_CmdProc*)sqlite3_mprintf_hexdouble},
! 5982: { "sqlite3_mprintf_z_test", (Tcl_CmdProc*)test_mprintf_z },
! 5983: { "sqlite3_mprintf_n_test", (Tcl_CmdProc*)test_mprintf_n },
! 5984: { "sqlite3_snprintf_int", (Tcl_CmdProc*)test_snprintf_int },
! 5985: { "sqlite3_last_insert_rowid", (Tcl_CmdProc*)test_last_rowid },
! 5986: { "sqlite3_exec_printf", (Tcl_CmdProc*)test_exec_printf },
! 5987: { "sqlite3_exec_hex", (Tcl_CmdProc*)test_exec_hex },
! 5988: { "sqlite3_exec", (Tcl_CmdProc*)test_exec },
! 5989: { "sqlite3_exec_nr", (Tcl_CmdProc*)test_exec_nr },
! 5990: #ifndef SQLITE_OMIT_GET_TABLE
! 5991: { "sqlite3_get_table_printf", (Tcl_CmdProc*)test_get_table_printf },
! 5992: #endif
! 5993: { "sqlite3_close", (Tcl_CmdProc*)sqlite_test_close },
! 5994: { "sqlite3_create_function", (Tcl_CmdProc*)test_create_function },
! 5995: { "sqlite3_create_aggregate", (Tcl_CmdProc*)test_create_aggregate },
! 5996: { "sqlite_register_test_function", (Tcl_CmdProc*)test_register_func },
! 5997: { "sqlite_abort", (Tcl_CmdProc*)sqlite_abort },
! 5998: { "sqlite_bind", (Tcl_CmdProc*)test_bind },
! 5999: { "breakpoint", (Tcl_CmdProc*)test_breakpoint },
! 6000: { "sqlite3_key", (Tcl_CmdProc*)test_key },
! 6001: { "sqlite3_rekey", (Tcl_CmdProc*)test_rekey },
! 6002: { "sqlite_set_magic", (Tcl_CmdProc*)sqlite_set_magic },
! 6003: { "sqlite3_interrupt", (Tcl_CmdProc*)test_interrupt },
! 6004: { "sqlite_delete_function", (Tcl_CmdProc*)delete_function },
! 6005: { "sqlite_delete_collation", (Tcl_CmdProc*)delete_collation },
! 6006: { "sqlite3_get_autocommit", (Tcl_CmdProc*)get_autocommit },
! 6007: { "sqlite3_stack_used", (Tcl_CmdProc*)test_stack_used },
! 6008: { "sqlite3_busy_timeout", (Tcl_CmdProc*)test_busy_timeout },
! 6009: { "printf", (Tcl_CmdProc*)test_printf },
! 6010: { "sqlite3IoTrace", (Tcl_CmdProc*)test_io_trace },
! 6011: };
! 6012: static struct {
! 6013: char *zName;
! 6014: Tcl_ObjCmdProc *xProc;
! 6015: void *clientData;
! 6016: } aObjCmd[] = {
! 6017: { "sqlite3_connection_pointer", get_sqlite_pointer, 0 },
! 6018: { "sqlite3_bind_int", test_bind_int, 0 },
! 6019: { "sqlite3_bind_zeroblob", test_bind_zeroblob, 0 },
! 6020: { "sqlite3_bind_int64", test_bind_int64, 0 },
! 6021: { "sqlite3_bind_double", test_bind_double, 0 },
! 6022: { "sqlite3_bind_null", test_bind_null ,0 },
! 6023: { "sqlite3_bind_text", test_bind_text ,0 },
! 6024: { "sqlite3_bind_text16", test_bind_text16 ,0 },
! 6025: { "sqlite3_bind_blob", test_bind_blob ,0 },
! 6026: { "sqlite3_bind_parameter_count", test_bind_parameter_count, 0},
! 6027: { "sqlite3_bind_parameter_name", test_bind_parameter_name, 0},
! 6028: { "sqlite3_bind_parameter_index", test_bind_parameter_index, 0},
! 6029: { "sqlite3_clear_bindings", test_clear_bindings, 0},
! 6030: { "sqlite3_sleep", test_sleep, 0},
! 6031: { "sqlite3_errcode", test_errcode ,0 },
! 6032: { "sqlite3_extended_errcode", test_ex_errcode ,0 },
! 6033: { "sqlite3_errmsg", test_errmsg ,0 },
! 6034: { "sqlite3_errmsg16", test_errmsg16 ,0 },
! 6035: { "sqlite3_open", test_open ,0 },
! 6036: { "sqlite3_open16", test_open16 ,0 },
! 6037: { "sqlite3_open_v2", test_open_v2 ,0 },
! 6038: { "sqlite3_complete16", test_complete16 ,0 },
! 6039:
! 6040: { "sqlite3_prepare", test_prepare ,0 },
! 6041: { "sqlite3_prepare16", test_prepare16 ,0 },
! 6042: { "sqlite3_prepare_v2", test_prepare_v2 ,0 },
! 6043: { "sqlite3_prepare_tkt3134", test_prepare_tkt3134, 0},
! 6044: { "sqlite3_prepare16_v2", test_prepare16_v2 ,0 },
! 6045: { "sqlite3_finalize", test_finalize ,0 },
! 6046: { "sqlite3_stmt_status", test_stmt_status ,0 },
! 6047: { "sqlite3_reset", test_reset ,0 },
! 6048: { "sqlite3_expired", test_expired ,0 },
! 6049: { "sqlite3_transfer_bindings", test_transfer_bind ,0 },
! 6050: { "sqlite3_changes", test_changes ,0 },
! 6051: { "sqlite3_step", test_step ,0 },
! 6052: { "sqlite3_sql", test_sql ,0 },
! 6053: { "sqlite3_next_stmt", test_next_stmt ,0 },
! 6054: { "sqlite3_stmt_readonly", test_stmt_readonly ,0 },
! 6055: { "sqlite3_stmt_busy", test_stmt_busy ,0 },
! 6056: { "uses_stmt_journal", uses_stmt_journal ,0 },
! 6057:
! 6058: { "sqlite3_release_memory", test_release_memory, 0},
! 6059: { "sqlite3_db_release_memory", test_db_release_memory, 0},
! 6060: { "sqlite3_db_filename", test_db_filename, 0},
! 6061: { "sqlite3_soft_heap_limit", test_soft_heap_limit, 0},
! 6062: { "sqlite3_thread_cleanup", test_thread_cleanup, 0},
! 6063: { "sqlite3_pager_refcounts", test_pager_refcounts, 0},
! 6064:
! 6065: { "sqlite3_load_extension", test_load_extension, 0},
! 6066: { "sqlite3_enable_load_extension", test_enable_load, 0},
! 6067: { "sqlite3_extended_result_codes", test_extended_result_codes, 0},
! 6068: { "sqlite3_limit", test_limit, 0},
! 6069:
! 6070: { "save_prng_state", save_prng_state, 0 },
! 6071: { "restore_prng_state", restore_prng_state, 0 },
! 6072: { "reset_prng_state", reset_prng_state, 0 },
! 6073: { "optimization_control", optimization_control,0},
! 6074: #if SQLITE_OS_WIN
! 6075: { "lock_win32_file", win32_file_lock, 0 },
! 6076: #endif
! 6077: { "tcl_objproc", runAsObjProc, 0 },
! 6078:
! 6079: /* sqlite3_column_*() API */
! 6080: { "sqlite3_column_count", test_column_count ,0 },
! 6081: { "sqlite3_data_count", test_data_count ,0 },
! 6082: { "sqlite3_column_type", test_column_type ,0 },
! 6083: { "sqlite3_column_blob", test_column_blob ,0 },
! 6084: { "sqlite3_column_double", test_column_double ,0 },
! 6085: { "sqlite3_column_int64", test_column_int64 ,0 },
! 6086: { "sqlite3_column_text", test_stmt_utf8, (void*)sqlite3_column_text },
! 6087: { "sqlite3_column_name", test_stmt_utf8, (void*)sqlite3_column_name },
! 6088: { "sqlite3_column_int", test_stmt_int, (void*)sqlite3_column_int },
! 6089: { "sqlite3_column_bytes", test_stmt_int, (void*)sqlite3_column_bytes},
! 6090: #ifndef SQLITE_OMIT_DECLTYPE
! 6091: { "sqlite3_column_decltype",test_stmt_utf8,(void*)sqlite3_column_decltype},
! 6092: #endif
! 6093: #ifdef SQLITE_ENABLE_COLUMN_METADATA
! 6094: { "sqlite3_column_database_name",test_stmt_utf8,(void*)sqlite3_column_database_name},
! 6095: { "sqlite3_column_table_name",test_stmt_utf8,(void*)sqlite3_column_table_name},
! 6096: { "sqlite3_column_origin_name",test_stmt_utf8,(void*)sqlite3_column_origin_name},
! 6097: #endif
! 6098:
! 6099: #ifndef SQLITE_OMIT_UTF16
! 6100: { "sqlite3_column_bytes16", test_stmt_int, (void*)sqlite3_column_bytes16 },
! 6101: { "sqlite3_column_text16", test_stmt_utf16, (void*)sqlite3_column_text16},
! 6102: { "sqlite3_column_name16", test_stmt_utf16, (void*)sqlite3_column_name16},
! 6103: { "add_alignment_test_collations", add_alignment_test_collations, 0 },
! 6104: #ifndef SQLITE_OMIT_DECLTYPE
! 6105: { "sqlite3_column_decltype16",test_stmt_utf16,(void*)sqlite3_column_decltype16},
! 6106: #endif
! 6107: #ifdef SQLITE_ENABLE_COLUMN_METADATA
! 6108: {"sqlite3_column_database_name16",
! 6109: test_stmt_utf16, sqlite3_column_database_name16},
! 6110: {"sqlite3_column_table_name16", test_stmt_utf16, (void*)sqlite3_column_table_name16},
! 6111: {"sqlite3_column_origin_name16", test_stmt_utf16, (void*)sqlite3_column_origin_name16},
! 6112: #endif
! 6113: #endif
! 6114: { "sqlite3_create_collation_v2", test_create_collation_v2, 0 },
! 6115: { "sqlite3_global_recover", test_global_recover, 0 },
! 6116: { "working_64bit_int", working_64bit_int, 0 },
! 6117: { "vfs_unlink_test", vfs_unlink_test, 0 },
! 6118: { "vfs_initfail_test", vfs_initfail_test, 0 },
! 6119: { "vfs_unregister_all", vfs_unregister_all, 0 },
! 6120: { "vfs_reregister_all", vfs_reregister_all, 0 },
! 6121: { "file_control_test", file_control_test, 0 },
! 6122: { "file_control_lasterrno_test", file_control_lasterrno_test, 0 },
! 6123: { "file_control_lockproxy_test", file_control_lockproxy_test, 0 },
! 6124: { "file_control_chunksize_test", file_control_chunksize_test, 0 },
! 6125: { "file_control_sizehint_test", file_control_sizehint_test, 0 },
! 6126: { "file_control_win32_av_retry", file_control_win32_av_retry, 0 },
! 6127: { "file_control_persist_wal", file_control_persist_wal, 0 },
! 6128: { "file_control_powersafe_overwrite",file_control_powersafe_overwrite,0},
! 6129: { "file_control_vfsname", file_control_vfsname, 0 },
! 6130: { "sqlite3_vfs_list", vfs_list, 0 },
! 6131: { "sqlite3_create_function_v2", test_create_function_v2, 0 },
! 6132:
! 6133: /* Functions from os.h */
! 6134: #ifndef SQLITE_OMIT_UTF16
! 6135: { "add_test_collate", test_collate, 0 },
! 6136: { "add_test_collate_needed", test_collate_needed, 0 },
! 6137: { "add_test_function", test_function, 0 },
! 6138: #endif
! 6139: { "sqlite3_test_errstr", test_errstr, 0 },
! 6140: { "tcl_variable_type", tcl_variable_type, 0 },
! 6141: #ifndef SQLITE_OMIT_SHARED_CACHE
! 6142: { "sqlite3_enable_shared_cache", test_enable_shared, 0 },
! 6143: { "sqlite3_shared_cache_report", sqlite3BtreeSharedCacheReport, 0},
! 6144: #endif
! 6145: { "sqlite3_libversion_number", test_libversion_number, 0 },
! 6146: #ifdef SQLITE_ENABLE_COLUMN_METADATA
! 6147: { "sqlite3_table_column_metadata", test_table_column_metadata, 0 },
! 6148: #endif
! 6149: #ifndef SQLITE_OMIT_INCRBLOB
! 6150: { "sqlite3_blob_read", test_blob_read, 0 },
! 6151: { "sqlite3_blob_write", test_blob_write, 0 },
! 6152: { "sqlite3_blob_reopen", test_blob_reopen, 0 },
! 6153: { "sqlite3_blob_bytes", test_blob_bytes, 0 },
! 6154: { "sqlite3_blob_close", test_blob_close, 0 },
! 6155: #endif
! 6156: { "pcache_stats", test_pcache_stats, 0 },
! 6157: #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
! 6158: { "sqlite3_unlock_notify", test_unlock_notify, 0 },
! 6159: #endif
! 6160: { "sqlite3_wal_checkpoint", test_wal_checkpoint, 0 },
! 6161: { "sqlite3_wal_checkpoint_v2",test_wal_checkpoint_v2, 0 },
! 6162: { "test_sqlite3_log", test_sqlite3_log, 0 },
! 6163: #ifndef SQLITE_OMIT_EXPLAIN
! 6164: { "print_explain_query_plan", test_print_eqp, 0 },
! 6165: #endif
! 6166: { "sqlite3_test_control", test_test_control },
! 6167: };
! 6168: static int bitmask_size = sizeof(Bitmask)*8;
! 6169: int i;
! 6170: extern int sqlite3_sync_count, sqlite3_fullsync_count;
! 6171: extern int sqlite3_opentemp_count;
! 6172: extern int sqlite3_like_count;
! 6173: extern int sqlite3_xferopt_count;
! 6174: extern int sqlite3_pager_readdb_count;
! 6175: extern int sqlite3_pager_writedb_count;
! 6176: extern int sqlite3_pager_writej_count;
! 6177: #if SQLITE_OS_WIN
! 6178: extern int sqlite3_os_type;
! 6179: #endif
! 6180: #ifdef SQLITE_DEBUG
! 6181: extern int sqlite3WhereTrace;
! 6182: extern int sqlite3OSTrace;
! 6183: extern int sqlite3VdbeAddopTrace;
! 6184: extern int sqlite3WalTrace;
! 6185: #endif
! 6186: #ifdef SQLITE_TEST
! 6187: extern char sqlite3_query_plan[];
! 6188: static char *query_plan = sqlite3_query_plan;
! 6189: #ifdef SQLITE_ENABLE_FTS3
! 6190: extern int sqlite3_fts3_enable_parentheses;
! 6191: #endif
! 6192: #endif
! 6193:
! 6194: for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
! 6195: Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
! 6196: }
! 6197: for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
! 6198: Tcl_CreateObjCommand(interp, aObjCmd[i].zName,
! 6199: aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
! 6200: }
! 6201: Tcl_LinkVar(interp, "sqlite_search_count",
! 6202: (char*)&sqlite3_search_count, TCL_LINK_INT);
! 6203: Tcl_LinkVar(interp, "sqlite_found_count",
! 6204: (char*)&sqlite3_found_count, TCL_LINK_INT);
! 6205: Tcl_LinkVar(interp, "sqlite_sort_count",
! 6206: (char*)&sqlite3_sort_count, TCL_LINK_INT);
! 6207: Tcl_LinkVar(interp, "sqlite3_max_blobsize",
! 6208: (char*)&sqlite3_max_blobsize, TCL_LINK_INT);
! 6209: Tcl_LinkVar(interp, "sqlite_like_count",
! 6210: (char*)&sqlite3_like_count, TCL_LINK_INT);
! 6211: Tcl_LinkVar(interp, "sqlite_interrupt_count",
! 6212: (char*)&sqlite3_interrupt_count, TCL_LINK_INT);
! 6213: Tcl_LinkVar(interp, "sqlite_open_file_count",
! 6214: (char*)&sqlite3_open_file_count, TCL_LINK_INT);
! 6215: Tcl_LinkVar(interp, "sqlite_current_time",
! 6216: (char*)&sqlite3_current_time, TCL_LINK_INT);
! 6217: #if SQLITE_OS_UNIX && defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
! 6218: Tcl_LinkVar(interp, "sqlite_hostid_num",
! 6219: (char*)&sqlite3_hostid_num, TCL_LINK_INT);
! 6220: #endif
! 6221: Tcl_LinkVar(interp, "sqlite3_xferopt_count",
! 6222: (char*)&sqlite3_xferopt_count, TCL_LINK_INT);
! 6223: Tcl_LinkVar(interp, "sqlite3_pager_readdb_count",
! 6224: (char*)&sqlite3_pager_readdb_count, TCL_LINK_INT);
! 6225: Tcl_LinkVar(interp, "sqlite3_pager_writedb_count",
! 6226: (char*)&sqlite3_pager_writedb_count, TCL_LINK_INT);
! 6227: Tcl_LinkVar(interp, "sqlite3_pager_writej_count",
! 6228: (char*)&sqlite3_pager_writej_count, TCL_LINK_INT);
! 6229: #ifndef SQLITE_OMIT_UTF16
! 6230: Tcl_LinkVar(interp, "unaligned_string_counter",
! 6231: (char*)&unaligned_string_counter, TCL_LINK_INT);
! 6232: #endif
! 6233: #ifndef SQLITE_OMIT_UTF16
! 6234: Tcl_LinkVar(interp, "sqlite_last_needed_collation",
! 6235: (char*)&pzNeededCollation, TCL_LINK_STRING|TCL_LINK_READ_ONLY);
! 6236: #endif
! 6237: #if SQLITE_OS_WIN
! 6238: Tcl_LinkVar(interp, "sqlite_os_type",
! 6239: (char*)&sqlite3_os_type, TCL_LINK_INT);
! 6240: #endif
! 6241: #ifdef SQLITE_TEST
! 6242: Tcl_LinkVar(interp, "sqlite_query_plan",
! 6243: (char*)&query_plan, TCL_LINK_STRING|TCL_LINK_READ_ONLY);
! 6244: #endif
! 6245: #ifdef SQLITE_DEBUG
! 6246: Tcl_LinkVar(interp, "sqlite_addop_trace",
! 6247: (char*)&sqlite3VdbeAddopTrace, TCL_LINK_INT);
! 6248: Tcl_LinkVar(interp, "sqlite_where_trace",
! 6249: (char*)&sqlite3WhereTrace, TCL_LINK_INT);
! 6250: Tcl_LinkVar(interp, "sqlite_os_trace",
! 6251: (char*)&sqlite3OSTrace, TCL_LINK_INT);
! 6252: #ifndef SQLITE_OMIT_WAL
! 6253: Tcl_LinkVar(interp, "sqlite_wal_trace",
! 6254: (char*)&sqlite3WalTrace, TCL_LINK_INT);
! 6255: #endif
! 6256: #endif
! 6257: #ifndef SQLITE_OMIT_DISKIO
! 6258: Tcl_LinkVar(interp, "sqlite_opentemp_count",
! 6259: (char*)&sqlite3_opentemp_count, TCL_LINK_INT);
! 6260: #endif
! 6261: Tcl_LinkVar(interp, "sqlite_static_bind_value",
! 6262: (char*)&sqlite_static_bind_value, TCL_LINK_STRING);
! 6263: Tcl_LinkVar(interp, "sqlite_static_bind_nbyte",
! 6264: (char*)&sqlite_static_bind_nbyte, TCL_LINK_INT);
! 6265: Tcl_LinkVar(interp, "sqlite_temp_directory",
! 6266: (char*)&sqlite3_temp_directory, TCL_LINK_STRING);
! 6267: Tcl_LinkVar(interp, "bitmask_size",
! 6268: (char*)&bitmask_size, TCL_LINK_INT|TCL_LINK_READ_ONLY);
! 6269: Tcl_LinkVar(interp, "sqlite_sync_count",
! 6270: (char*)&sqlite3_sync_count, TCL_LINK_INT);
! 6271: Tcl_LinkVar(interp, "sqlite_fullsync_count",
! 6272: (char*)&sqlite3_fullsync_count, TCL_LINK_INT);
! 6273: #if defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_TEST)
! 6274: Tcl_LinkVar(interp, "sqlite_fts3_enable_parentheses",
! 6275: (char*)&sqlite3_fts3_enable_parentheses, TCL_LINK_INT);
! 6276: #endif
! 6277: return TCL_OK;
! 6278: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test1.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src