Annotation of embedaddon/sqlite3/src/test3.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 the btree.c module in SQLite. 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 "btreeInt.h"
! 18: #include "tcl.h"
! 19: #include <stdlib.h>
! 20: #include <string.h>
! 21:
! 22: /*
! 23: ** Interpret an SQLite error number
! 24: */
! 25: static char *errorName(int rc){
! 26: char *zName;
! 27: switch( rc ){
! 28: case SQLITE_OK: zName = "SQLITE_OK"; break;
! 29: case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
! 30: case SQLITE_PERM: zName = "SQLITE_PERM"; break;
! 31: case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
! 32: case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
! 33: case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
! 34: case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
! 35: case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
! 36: case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
! 37: case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
! 38: case SQLITE_FULL: zName = "SQLITE_FULL"; break;
! 39: case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
! 40: case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
! 41: case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
! 42: case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
! 43: default: zName = "SQLITE_Unknown"; break;
! 44: }
! 45: return zName;
! 46: }
! 47:
! 48: /*
! 49: ** A bogus sqlite3 connection structure for use in the btree
! 50: ** tests.
! 51: */
! 52: static sqlite3 sDb;
! 53: static int nRefSqlite3 = 0;
! 54:
! 55: /*
! 56: ** Usage: btree_open FILENAME NCACHE
! 57: **
! 58: ** Open a new database
! 59: */
! 60: static int btree_open(
! 61: void *NotUsed,
! 62: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 63: int argc, /* Number of arguments */
! 64: const char **argv /* Text of each argument */
! 65: ){
! 66: Btree *pBt;
! 67: int rc, nCache;
! 68: char zBuf[100];
! 69: int n;
! 70: char *zFilename;
! 71: if( argc!=3 ){
! 72: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 73: " FILENAME NCACHE FLAGS\"", 0);
! 74: return TCL_ERROR;
! 75: }
! 76: if( Tcl_GetInt(interp, argv[2], &nCache) ) return TCL_ERROR;
! 77: nRefSqlite3++;
! 78: if( nRefSqlite3==1 ){
! 79: sDb.pVfs = sqlite3_vfs_find(0);
! 80: sDb.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
! 81: sqlite3_mutex_enter(sDb.mutex);
! 82: }
! 83: n = strlen(argv[1]);
! 84: zFilename = sqlite3_malloc( n+2 );
! 85: if( zFilename==0 ) return TCL_ERROR;
! 86: memcpy(zFilename, argv[1], n+1);
! 87: zFilename[n+1] = 0;
! 88: rc = sqlite3BtreeOpen(sDb.pVfs, zFilename, &sDb, &pBt, 0,
! 89: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MAIN_DB);
! 90: sqlite3_free(zFilename);
! 91: if( rc!=SQLITE_OK ){
! 92: Tcl_AppendResult(interp, errorName(rc), 0);
! 93: return TCL_ERROR;
! 94: }
! 95: sqlite3BtreeSetCacheSize(pBt, nCache);
! 96: sqlite3_snprintf(sizeof(zBuf), zBuf,"%p", pBt);
! 97: Tcl_AppendResult(interp, zBuf, 0);
! 98: return TCL_OK;
! 99: }
! 100:
! 101: /*
! 102: ** Usage: btree_close ID
! 103: **
! 104: ** Close the given database.
! 105: */
! 106: static int btree_close(
! 107: void *NotUsed,
! 108: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 109: int argc, /* Number of arguments */
! 110: const char **argv /* Text of each argument */
! 111: ){
! 112: Btree *pBt;
! 113: int rc;
! 114: if( argc!=2 ){
! 115: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 116: " ID\"", 0);
! 117: return TCL_ERROR;
! 118: }
! 119: pBt = sqlite3TestTextToPtr(argv[1]);
! 120: rc = sqlite3BtreeClose(pBt);
! 121: if( rc!=SQLITE_OK ){
! 122: Tcl_AppendResult(interp, errorName(rc), 0);
! 123: return TCL_ERROR;
! 124: }
! 125: nRefSqlite3--;
! 126: if( nRefSqlite3==0 ){
! 127: sqlite3_mutex_leave(sDb.mutex);
! 128: sqlite3_mutex_free(sDb.mutex);
! 129: sDb.mutex = 0;
! 130: sDb.pVfs = 0;
! 131: }
! 132: return TCL_OK;
! 133: }
! 134:
! 135:
! 136: /*
! 137: ** Usage: btree_begin_transaction ID
! 138: **
! 139: ** Start a new transaction
! 140: */
! 141: static int btree_begin_transaction(
! 142: void *NotUsed,
! 143: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 144: int argc, /* Number of arguments */
! 145: const char **argv /* Text of each argument */
! 146: ){
! 147: Btree *pBt;
! 148: int rc;
! 149: if( argc!=2 ){
! 150: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 151: " ID\"", 0);
! 152: return TCL_ERROR;
! 153: }
! 154: pBt = sqlite3TestTextToPtr(argv[1]);
! 155: sqlite3BtreeEnter(pBt);
! 156: rc = sqlite3BtreeBeginTrans(pBt, 1);
! 157: sqlite3BtreeLeave(pBt);
! 158: if( rc!=SQLITE_OK ){
! 159: Tcl_AppendResult(interp, errorName(rc), 0);
! 160: return TCL_ERROR;
! 161: }
! 162: return TCL_OK;
! 163: }
! 164:
! 165: /*
! 166: ** Usage: btree_pager_stats ID
! 167: **
! 168: ** Returns pager statistics
! 169: */
! 170: static int btree_pager_stats(
! 171: void *NotUsed,
! 172: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 173: int argc, /* Number of arguments */
! 174: const char **argv /* Text of each argument */
! 175: ){
! 176: Btree *pBt;
! 177: int i;
! 178: int *a;
! 179:
! 180: if( argc!=2 ){
! 181: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 182: " ID\"", 0);
! 183: return TCL_ERROR;
! 184: }
! 185: pBt = sqlite3TestTextToPtr(argv[1]);
! 186:
! 187: /* Normally in this file, with a b-tree handle opened using the
! 188: ** [btree_open] command it is safe to call sqlite3BtreeEnter() directly.
! 189: ** But this function is sometimes called with a btree handle obtained
! 190: ** from an open SQLite connection (using [btree_from_db]). In this case
! 191: ** we need to obtain the mutex for the controlling SQLite handle before
! 192: ** it is safe to call sqlite3BtreeEnter().
! 193: */
! 194: sqlite3_mutex_enter(pBt->db->mutex);
! 195:
! 196: sqlite3BtreeEnter(pBt);
! 197: a = sqlite3PagerStats(sqlite3BtreePager(pBt));
! 198: for(i=0; i<11; i++){
! 199: static char *zName[] = {
! 200: "ref", "page", "max", "size", "state", "err",
! 201: "hit", "miss", "ovfl", "read", "write"
! 202: };
! 203: char zBuf[100];
! 204: Tcl_AppendElement(interp, zName[i]);
! 205: sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",a[i]);
! 206: Tcl_AppendElement(interp, zBuf);
! 207: }
! 208: sqlite3BtreeLeave(pBt);
! 209:
! 210: /* Release the mutex on the SQLite handle that controls this b-tree */
! 211: sqlite3_mutex_leave(pBt->db->mutex);
! 212: return TCL_OK;
! 213: }
! 214:
! 215: /*
! 216: ** Usage: btree_cursor ID TABLENUM WRITEABLE
! 217: **
! 218: ** Create a new cursor. Return the ID for the cursor.
! 219: */
! 220: static int btree_cursor(
! 221: void *NotUsed,
! 222: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 223: int argc, /* Number of arguments */
! 224: const char **argv /* Text of each argument */
! 225: ){
! 226: Btree *pBt;
! 227: int iTable;
! 228: BtCursor *pCur;
! 229: int rc = SQLITE_OK;
! 230: int wrFlag;
! 231: char zBuf[30];
! 232:
! 233: if( argc!=4 ){
! 234: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 235: " ID TABLENUM WRITEABLE\"", 0);
! 236: return TCL_ERROR;
! 237: }
! 238: pBt = sqlite3TestTextToPtr(argv[1]);
! 239: if( Tcl_GetInt(interp, argv[2], &iTable) ) return TCL_ERROR;
! 240: if( Tcl_GetBoolean(interp, argv[3], &wrFlag) ) return TCL_ERROR;
! 241: pCur = (BtCursor *)ckalloc(sqlite3BtreeCursorSize());
! 242: memset(pCur, 0, sqlite3BtreeCursorSize());
! 243: sqlite3BtreeEnter(pBt);
! 244: #ifndef SQLITE_OMIT_SHARED_CACHE
! 245: rc = sqlite3BtreeLockTable(pBt, iTable, wrFlag);
! 246: #endif
! 247: if( rc==SQLITE_OK ){
! 248: rc = sqlite3BtreeCursor(pBt, iTable, wrFlag, 0, pCur);
! 249: }
! 250: sqlite3BtreeLeave(pBt);
! 251: if( rc ){
! 252: ckfree((char *)pCur);
! 253: Tcl_AppendResult(interp, errorName(rc), 0);
! 254: return TCL_ERROR;
! 255: }
! 256: sqlite3_snprintf(sizeof(zBuf), zBuf,"%p", pCur);
! 257: Tcl_AppendResult(interp, zBuf, 0);
! 258: return SQLITE_OK;
! 259: }
! 260:
! 261: /*
! 262: ** Usage: btree_close_cursor ID
! 263: **
! 264: ** Close a cursor opened using btree_cursor.
! 265: */
! 266: static int btree_close_cursor(
! 267: void *NotUsed,
! 268: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 269: int argc, /* Number of arguments */
! 270: const char **argv /* Text of each argument */
! 271: ){
! 272: BtCursor *pCur;
! 273: Btree *pBt;
! 274: int rc;
! 275:
! 276: if( argc!=2 ){
! 277: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 278: " ID\"", 0);
! 279: return TCL_ERROR;
! 280: }
! 281: pCur = sqlite3TestTextToPtr(argv[1]);
! 282: pBt = pCur->pBtree;
! 283: sqlite3BtreeEnter(pBt);
! 284: rc = sqlite3BtreeCloseCursor(pCur);
! 285: sqlite3BtreeLeave(pBt);
! 286: ckfree((char *)pCur);
! 287: if( rc ){
! 288: Tcl_AppendResult(interp, errorName(rc), 0);
! 289: return TCL_ERROR;
! 290: }
! 291: return SQLITE_OK;
! 292: }
! 293:
! 294: /*
! 295: ** Usage: btree_next ID
! 296: **
! 297: ** Move the cursor to the next entry in the table. Return 0 on success
! 298: ** or 1 if the cursor was already on the last entry in the table or if
! 299: ** the table is empty.
! 300: */
! 301: static int btree_next(
! 302: void *NotUsed,
! 303: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 304: int argc, /* Number of arguments */
! 305: const char **argv /* Text of each argument */
! 306: ){
! 307: BtCursor *pCur;
! 308: int rc;
! 309: int res = 0;
! 310: char zBuf[100];
! 311:
! 312: if( argc!=2 ){
! 313: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 314: " ID\"", 0);
! 315: return TCL_ERROR;
! 316: }
! 317: pCur = sqlite3TestTextToPtr(argv[1]);
! 318: sqlite3BtreeEnter(pCur->pBtree);
! 319: rc = sqlite3BtreeNext(pCur, &res);
! 320: sqlite3BtreeLeave(pCur->pBtree);
! 321: if( rc ){
! 322: Tcl_AppendResult(interp, errorName(rc), 0);
! 323: return TCL_ERROR;
! 324: }
! 325: sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);
! 326: Tcl_AppendResult(interp, zBuf, 0);
! 327: return SQLITE_OK;
! 328: }
! 329:
! 330: /*
! 331: ** Usage: btree_first ID
! 332: **
! 333: ** Move the cursor to the first entry in the table. Return 0 if the
! 334: ** cursor was left point to something and 1 if the table is empty.
! 335: */
! 336: static int btree_first(
! 337: void *NotUsed,
! 338: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 339: int argc, /* Number of arguments */
! 340: const char **argv /* Text of each argument */
! 341: ){
! 342: BtCursor *pCur;
! 343: int rc;
! 344: int res = 0;
! 345: char zBuf[100];
! 346:
! 347: if( argc!=2 ){
! 348: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 349: " ID\"", 0);
! 350: return TCL_ERROR;
! 351: }
! 352: pCur = sqlite3TestTextToPtr(argv[1]);
! 353: sqlite3BtreeEnter(pCur->pBtree);
! 354: rc = sqlite3BtreeFirst(pCur, &res);
! 355: sqlite3BtreeLeave(pCur->pBtree);
! 356: if( rc ){
! 357: Tcl_AppendResult(interp, errorName(rc), 0);
! 358: return TCL_ERROR;
! 359: }
! 360: sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);
! 361: Tcl_AppendResult(interp, zBuf, 0);
! 362: return SQLITE_OK;
! 363: }
! 364:
! 365: /*
! 366: ** Usage: btree_eof ID
! 367: **
! 368: ** Return TRUE if the given cursor is not pointing at a valid entry.
! 369: ** Return FALSE if the cursor does point to a valid entry.
! 370: */
! 371: static int btree_eof(
! 372: void *NotUsed,
! 373: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 374: int argc, /* Number of arguments */
! 375: const char **argv /* Text of each argument */
! 376: ){
! 377: BtCursor *pCur;
! 378: int rc;
! 379: char zBuf[50];
! 380:
! 381: if( argc!=2 ){
! 382: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 383: " ID\"", 0);
! 384: return TCL_ERROR;
! 385: }
! 386: pCur = sqlite3TestTextToPtr(argv[1]);
! 387: sqlite3BtreeEnter(pCur->pBtree);
! 388: rc = sqlite3BtreeEof(pCur);
! 389: sqlite3BtreeLeave(pCur->pBtree);
! 390: sqlite3_snprintf(sizeof(zBuf),zBuf, "%d", rc);
! 391: Tcl_AppendResult(interp, zBuf, 0);
! 392: return SQLITE_OK;
! 393: }
! 394:
! 395: /*
! 396: ** Usage: btree_payload_size ID
! 397: **
! 398: ** Return the number of bytes of payload
! 399: */
! 400: static int btree_payload_size(
! 401: void *NotUsed,
! 402: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 403: int argc, /* Number of arguments */
! 404: const char **argv /* Text of each argument */
! 405: ){
! 406: BtCursor *pCur;
! 407: int n2;
! 408: u64 n1;
! 409: char zBuf[50];
! 410:
! 411: if( argc!=2 ){
! 412: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 413: " ID\"", 0);
! 414: return TCL_ERROR;
! 415: }
! 416: pCur = sqlite3TestTextToPtr(argv[1]);
! 417: sqlite3BtreeEnter(pCur->pBtree);
! 418:
! 419: /* The cursor may be in "require-seek" state. If this is the case, the
! 420: ** call to BtreeDataSize() will fix it. */
! 421: sqlite3BtreeDataSize(pCur, (u32*)&n2);
! 422: if( pCur->apPage[pCur->iPage]->intKey ){
! 423: n1 = 0;
! 424: }else{
! 425: sqlite3BtreeKeySize(pCur, (i64*)&n1);
! 426: }
! 427: sqlite3BtreeLeave(pCur->pBtree);
! 428: sqlite3_snprintf(sizeof(zBuf),zBuf, "%d", (int)(n1+n2));
! 429: Tcl_AppendResult(interp, zBuf, 0);
! 430: return SQLITE_OK;
! 431: }
! 432:
! 433: /*
! 434: ** usage: varint_test START MULTIPLIER COUNT INCREMENT
! 435: **
! 436: ** This command tests the putVarint() and getVarint()
! 437: ** routines, both for accuracy and for speed.
! 438: **
! 439: ** An integer is written using putVarint() and read back with
! 440: ** getVarint() and varified to be unchanged. This repeats COUNT
! 441: ** times. The first integer is START*MULTIPLIER. Each iteration
! 442: ** increases the integer by INCREMENT.
! 443: **
! 444: ** This command returns nothing if it works. It returns an error message
! 445: ** if something goes wrong.
! 446: */
! 447: static int btree_varint_test(
! 448: void *NotUsed,
! 449: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 450: int argc, /* Number of arguments */
! 451: const char **argv /* Text of each argument */
! 452: ){
! 453: u32 start, mult, count, incr;
! 454: u64 in, out;
! 455: int n1, n2, i, j;
! 456: unsigned char zBuf[100];
! 457: if( argc!=5 ){
! 458: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 459: " START MULTIPLIER COUNT INCREMENT\"", 0);
! 460: return TCL_ERROR;
! 461: }
! 462: if( Tcl_GetInt(interp, argv[1], (int*)&start) ) return TCL_ERROR;
! 463: if( Tcl_GetInt(interp, argv[2], (int*)&mult) ) return TCL_ERROR;
! 464: if( Tcl_GetInt(interp, argv[3], (int*)&count) ) return TCL_ERROR;
! 465: if( Tcl_GetInt(interp, argv[4], (int*)&incr) ) return TCL_ERROR;
! 466: in = start;
! 467: in *= mult;
! 468: for(i=0; i<count; i++){
! 469: char zErr[200];
! 470: n1 = putVarint(zBuf, in);
! 471: if( n1>9 || n1<1 ){
! 472: sprintf(zErr, "putVarint returned %d - should be between 1 and 9", n1);
! 473: Tcl_AppendResult(interp, zErr, 0);
! 474: return TCL_ERROR;
! 475: }
! 476: n2 = getVarint(zBuf, &out);
! 477: if( n1!=n2 ){
! 478: sprintf(zErr, "putVarint returned %d and getVarint returned %d", n1, n2);
! 479: Tcl_AppendResult(interp, zErr, 0);
! 480: return TCL_ERROR;
! 481: }
! 482: if( in!=out ){
! 483: sprintf(zErr, "Wrote 0x%016llx and got back 0x%016llx", in, out);
! 484: Tcl_AppendResult(interp, zErr, 0);
! 485: return TCL_ERROR;
! 486: }
! 487: if( (in & 0xffffffff)==in ){
! 488: u32 out32;
! 489: n2 = getVarint32(zBuf, out32);
! 490: out = out32;
! 491: if( n1!=n2 ){
! 492: sprintf(zErr, "putVarint returned %d and GetVarint32 returned %d",
! 493: n1, n2);
! 494: Tcl_AppendResult(interp, zErr, 0);
! 495: return TCL_ERROR;
! 496: }
! 497: if( in!=out ){
! 498: sprintf(zErr, "Wrote 0x%016llx and got back 0x%016llx from GetVarint32",
! 499: in, out);
! 500: Tcl_AppendResult(interp, zErr, 0);
! 501: return TCL_ERROR;
! 502: }
! 503: }
! 504:
! 505: /* In order to get realistic timings, run getVarint 19 more times.
! 506: ** This is because getVarint is called about 20 times more often
! 507: ** than putVarint.
! 508: */
! 509: for(j=0; j<19; j++){
! 510: getVarint(zBuf, &out);
! 511: }
! 512: in += incr;
! 513: }
! 514: return TCL_OK;
! 515: }
! 516:
! 517: /*
! 518: ** usage: btree_from_db DB-HANDLE
! 519: **
! 520: ** This command returns the btree handle for the main database associated
! 521: ** with the database-handle passed as the argument. Example usage:
! 522: **
! 523: ** sqlite3 db test.db
! 524: ** set bt [btree_from_db db]
! 525: */
! 526: static int btree_from_db(
! 527: void *NotUsed,
! 528: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 529: int argc, /* Number of arguments */
! 530: const char **argv /* Text of each argument */
! 531: ){
! 532: char zBuf[100];
! 533: Tcl_CmdInfo info;
! 534: sqlite3 *db;
! 535: Btree *pBt;
! 536: int iDb = 0;
! 537:
! 538: if( argc!=2 && argc!=3 ){
! 539: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 540: " DB-HANDLE ?N?\"", 0);
! 541: return TCL_ERROR;
! 542: }
! 543:
! 544: if( 1!=Tcl_GetCommandInfo(interp, argv[1], &info) ){
! 545: Tcl_AppendResult(interp, "No such db-handle: \"", argv[1], "\"", 0);
! 546: return TCL_ERROR;
! 547: }
! 548: if( argc==3 ){
! 549: iDb = atoi(argv[2]);
! 550: }
! 551:
! 552: db = *((sqlite3 **)info.objClientData);
! 553: assert( db );
! 554:
! 555: pBt = db->aDb[iDb].pBt;
! 556: sqlite3_snprintf(sizeof(zBuf), zBuf, "%p", pBt);
! 557: Tcl_SetResult(interp, zBuf, TCL_VOLATILE);
! 558: return TCL_OK;
! 559: }
! 560:
! 561: /*
! 562: ** Usage: btree_ismemdb ID
! 563: **
! 564: ** Return true if the B-Tree is in-memory.
! 565: */
! 566: static int btree_ismemdb(
! 567: void *NotUsed,
! 568: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 569: int argc, /* Number of arguments */
! 570: const char **argv /* Text of each argument */
! 571: ){
! 572: Btree *pBt;
! 573: int res;
! 574:
! 575: if( argc!=2 ){
! 576: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
! 577: " ID\"", 0);
! 578: return TCL_ERROR;
! 579: }
! 580: pBt = sqlite3TestTextToPtr(argv[1]);
! 581: sqlite3_mutex_enter(pBt->db->mutex);
! 582: sqlite3BtreeEnter(pBt);
! 583: res = sqlite3PagerIsMemdb(sqlite3BtreePager(pBt));
! 584: sqlite3BtreeLeave(pBt);
! 585: sqlite3_mutex_leave(pBt->db->mutex);
! 586: Tcl_SetObjResult(interp, Tcl_NewBooleanObj(res));
! 587: return SQLITE_OK;
! 588: }
! 589:
! 590: /*
! 591: ** usage: btree_set_cache_size ID NCACHE
! 592: **
! 593: ** Set the size of the cache used by btree $ID.
! 594: */
! 595: static int btree_set_cache_size(
! 596: void *NotUsed,
! 597: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 598: int argc, /* Number of arguments */
! 599: const char **argv /* Text of each argument */
! 600: ){
! 601: int nCache;
! 602: Btree *pBt;
! 603:
! 604: if( argc!=3 ){
! 605: Tcl_AppendResult(
! 606: interp, "wrong # args: should be \"", argv[0], " BT NCACHE\"", 0);
! 607: return TCL_ERROR;
! 608: }
! 609: pBt = sqlite3TestTextToPtr(argv[1]);
! 610: if( Tcl_GetInt(interp, argv[2], &nCache) ) return TCL_ERROR;
! 611:
! 612: sqlite3_mutex_enter(pBt->db->mutex);
! 613: sqlite3BtreeEnter(pBt);
! 614: sqlite3BtreeSetCacheSize(pBt, nCache);
! 615: sqlite3BtreeLeave(pBt);
! 616: sqlite3_mutex_leave(pBt->db->mutex);
! 617: return TCL_OK;
! 618: }
! 619:
! 620:
! 621:
! 622: /*
! 623: ** Register commands with the TCL interpreter.
! 624: */
! 625: int Sqlitetest3_Init(Tcl_Interp *interp){
! 626: static struct {
! 627: char *zName;
! 628: Tcl_CmdProc *xProc;
! 629: } aCmd[] = {
! 630: { "btree_open", (Tcl_CmdProc*)btree_open },
! 631: { "btree_close", (Tcl_CmdProc*)btree_close },
! 632: { "btree_begin_transaction", (Tcl_CmdProc*)btree_begin_transaction },
! 633: { "btree_pager_stats", (Tcl_CmdProc*)btree_pager_stats },
! 634: { "btree_cursor", (Tcl_CmdProc*)btree_cursor },
! 635: { "btree_close_cursor", (Tcl_CmdProc*)btree_close_cursor },
! 636: { "btree_next", (Tcl_CmdProc*)btree_next },
! 637: { "btree_eof", (Tcl_CmdProc*)btree_eof },
! 638: { "btree_payload_size", (Tcl_CmdProc*)btree_payload_size },
! 639: { "btree_first", (Tcl_CmdProc*)btree_first },
! 640: { "btree_varint_test", (Tcl_CmdProc*)btree_varint_test },
! 641: { "btree_from_db", (Tcl_CmdProc*)btree_from_db },
! 642: { "btree_ismemdb", (Tcl_CmdProc*)btree_ismemdb },
! 643: { "btree_set_cache_size", (Tcl_CmdProc*)btree_set_cache_size }
! 644: };
! 645: int i;
! 646:
! 647: for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
! 648: Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
! 649: }
! 650:
! 651: return TCL_OK;
! 652: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test3.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