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 pager.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 "tcl.h"
18: #include <stdlib.h>
19: #include <string.h>
20: #include <ctype.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_SCHEMA: zName = "SQLITE_SCHEMA"; break;
43: case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
44: case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
45: case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
46: case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
47: default: zName = "SQLITE_Unknown"; break;
48: }
49: return zName;
50: }
51:
52: /*
53: ** Page size and reserved size used for testing.
54: */
55: static int test_pagesize = 1024;
56:
57: /*
58: ** Dummy page reinitializer
59: */
60: static void pager_test_reiniter(DbPage *pNotUsed){
61: return;
62: }
63:
64: /*
65: ** Usage: pager_open FILENAME N-PAGE
66: **
67: ** Open a new pager
68: */
69: static int pager_open(
70: void *NotUsed,
71: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
72: int argc, /* Number of arguments */
73: const char **argv /* Text of each argument */
74: ){
75: u32 pageSize;
76: Pager *pPager;
77: int nPage;
78: int rc;
79: char zBuf[100];
80: if( argc!=3 ){
81: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
82: " FILENAME N-PAGE\"", 0);
83: return TCL_ERROR;
84: }
85: if( Tcl_GetInt(interp, argv[2], &nPage) ) return TCL_ERROR;
86: rc = sqlite3PagerOpen(sqlite3_vfs_find(0), &pPager, argv[1], 0, 0,
87: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MAIN_DB,
88: pager_test_reiniter);
89: if( rc!=SQLITE_OK ){
90: Tcl_AppendResult(interp, errorName(rc), 0);
91: return TCL_ERROR;
92: }
93: sqlite3PagerSetCachesize(pPager, nPage);
94: pageSize = test_pagesize;
95: sqlite3PagerSetPagesize(pPager, &pageSize, -1);
96: sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPager);
97: Tcl_AppendResult(interp, zBuf, 0);
98: return TCL_OK;
99: }
100:
101: /*
102: ** Usage: pager_close ID
103: **
104: ** Close the given pager.
105: */
106: static int pager_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: Pager *pPager;
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: pPager = sqlite3TestTextToPtr(argv[1]);
120: rc = sqlite3PagerClose(pPager);
121: if( rc!=SQLITE_OK ){
122: Tcl_AppendResult(interp, errorName(rc), 0);
123: return TCL_ERROR;
124: }
125: return TCL_OK;
126: }
127:
128: /*
129: ** Usage: pager_rollback ID
130: **
131: ** Rollback changes
132: */
133: static int pager_rollback(
134: void *NotUsed,
135: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
136: int argc, /* Number of arguments */
137: const char **argv /* Text of each argument */
138: ){
139: Pager *pPager;
140: int rc;
141: if( argc!=2 ){
142: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
143: " ID\"", 0);
144: return TCL_ERROR;
145: }
146: pPager = sqlite3TestTextToPtr(argv[1]);
147: rc = sqlite3PagerRollback(pPager);
148: if( rc!=SQLITE_OK ){
149: Tcl_AppendResult(interp, errorName(rc), 0);
150: return TCL_ERROR;
151: }
152: return TCL_OK;
153: }
154:
155: /*
156: ** Usage: pager_commit ID
157: **
158: ** Commit all changes
159: */
160: static int pager_commit(
161: void *NotUsed,
162: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
163: int argc, /* Number of arguments */
164: const char **argv /* Text of each argument */
165: ){
166: Pager *pPager;
167: int rc;
168: if( argc!=2 ){
169: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
170: " ID\"", 0);
171: return TCL_ERROR;
172: }
173: pPager = sqlite3TestTextToPtr(argv[1]);
174: rc = sqlite3PagerCommitPhaseOne(pPager, 0, 0);
175: if( rc!=SQLITE_OK ){
176: Tcl_AppendResult(interp, errorName(rc), 0);
177: return TCL_ERROR;
178: }
179: rc = sqlite3PagerCommitPhaseTwo(pPager);
180: if( rc!=SQLITE_OK ){
181: Tcl_AppendResult(interp, errorName(rc), 0);
182: return TCL_ERROR;
183: }
184: return TCL_OK;
185: }
186:
187: /*
188: ** Usage: pager_stmt_begin ID
189: **
190: ** Start a new checkpoint.
191: */
192: static int pager_stmt_begin(
193: void *NotUsed,
194: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
195: int argc, /* Number of arguments */
196: const char **argv /* Text of each argument */
197: ){
198: Pager *pPager;
199: int rc;
200: if( argc!=2 ){
201: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
202: " ID\"", 0);
203: return TCL_ERROR;
204: }
205: pPager = sqlite3TestTextToPtr(argv[1]);
206: rc = sqlite3PagerOpenSavepoint(pPager, 1);
207: if( rc!=SQLITE_OK ){
208: Tcl_AppendResult(interp, errorName(rc), 0);
209: return TCL_ERROR;
210: }
211: return TCL_OK;
212: }
213:
214: /*
215: ** Usage: pager_stmt_rollback ID
216: **
217: ** Rollback changes to a checkpoint
218: */
219: static int pager_stmt_rollback(
220: void *NotUsed,
221: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
222: int argc, /* Number of arguments */
223: const char **argv /* Text of each argument */
224: ){
225: Pager *pPager;
226: int rc;
227: if( argc!=2 ){
228: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
229: " ID\"", 0);
230: return TCL_ERROR;
231: }
232: pPager = sqlite3TestTextToPtr(argv[1]);
233: rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, 0);
234: sqlite3PagerSavepoint(pPager, SAVEPOINT_RELEASE, 0);
235: if( rc!=SQLITE_OK ){
236: Tcl_AppendResult(interp, errorName(rc), 0);
237: return TCL_ERROR;
238: }
239: return TCL_OK;
240: }
241:
242: /*
243: ** Usage: pager_stmt_commit ID
244: **
245: ** Commit changes to a checkpoint
246: */
247: static int pager_stmt_commit(
248: void *NotUsed,
249: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
250: int argc, /* Number of arguments */
251: const char **argv /* Text of each argument */
252: ){
253: Pager *pPager;
254: int rc;
255: if( argc!=2 ){
256: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
257: " ID\"", 0);
258: return TCL_ERROR;
259: }
260: pPager = sqlite3TestTextToPtr(argv[1]);
261: rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_RELEASE, 0);
262: if( rc!=SQLITE_OK ){
263: Tcl_AppendResult(interp, errorName(rc), 0);
264: return TCL_ERROR;
265: }
266: return TCL_OK;
267: }
268:
269: /*
270: ** Usage: pager_stats ID
271: **
272: ** Return pager statistics.
273: */
274: static int pager_stats(
275: void *NotUsed,
276: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
277: int argc, /* Number of arguments */
278: const char **argv /* Text of each argument */
279: ){
280: Pager *pPager;
281: int i, *a;
282: if( argc!=2 ){
283: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
284: " ID\"", 0);
285: return TCL_ERROR;
286: }
287: pPager = sqlite3TestTextToPtr(argv[1]);
288: a = sqlite3PagerStats(pPager);
289: for(i=0; i<9; i++){
290: static char *zName[] = {
291: "ref", "page", "max", "size", "state", "err",
292: "hit", "miss", "ovfl",
293: };
294: char zBuf[100];
295: Tcl_AppendElement(interp, zName[i]);
296: sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",a[i]);
297: Tcl_AppendElement(interp, zBuf);
298: }
299: return TCL_OK;
300: }
301:
302: /*
303: ** Usage: pager_pagecount ID
304: **
305: ** Return the size of the database file.
306: */
307: static int pager_pagecount(
308: void *NotUsed,
309: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
310: int argc, /* Number of arguments */
311: const char **argv /* Text of each argument */
312: ){
313: Pager *pPager;
314: char zBuf[100];
315: int nPage;
316: if( argc!=2 ){
317: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
318: " ID\"", 0);
319: return TCL_ERROR;
320: }
321: pPager = sqlite3TestTextToPtr(argv[1]);
322: sqlite3PagerPagecount(pPager, &nPage);
323: sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", nPage);
324: Tcl_AppendResult(interp, zBuf, 0);
325: return TCL_OK;
326: }
327:
328: /*
329: ** Usage: page_get ID PGNO
330: **
331: ** Return a pointer to a page from the database.
332: */
333: static int page_get(
334: void *NotUsed,
335: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
336: int argc, /* Number of arguments */
337: const char **argv /* Text of each argument */
338: ){
339: Pager *pPager;
340: char zBuf[100];
341: DbPage *pPage;
342: int pgno;
343: int rc;
344: if( argc!=3 ){
345: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
346: " ID PGNO\"", 0);
347: return TCL_ERROR;
348: }
349: pPager = sqlite3TestTextToPtr(argv[1]);
350: if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
351: rc = sqlite3PagerSharedLock(pPager);
352: if( rc==SQLITE_OK ){
353: rc = sqlite3PagerGet(pPager, pgno, &pPage);
354: }
355: if( rc!=SQLITE_OK ){
356: Tcl_AppendResult(interp, errorName(rc), 0);
357: return TCL_ERROR;
358: }
359: sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPage);
360: Tcl_AppendResult(interp, zBuf, 0);
361: return TCL_OK;
362: }
363:
364: /*
365: ** Usage: page_lookup ID PGNO
366: **
367: ** Return a pointer to a page if the page is already in cache.
368: ** If not in cache, return an empty string.
369: */
370: static int page_lookup(
371: void *NotUsed,
372: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
373: int argc, /* Number of arguments */
374: const char **argv /* Text of each argument */
375: ){
376: Pager *pPager;
377: char zBuf[100];
378: DbPage *pPage;
379: int pgno;
380: if( argc!=3 ){
381: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
382: " ID PGNO\"", 0);
383: return TCL_ERROR;
384: }
385: pPager = sqlite3TestTextToPtr(argv[1]);
386: if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
387: pPage = sqlite3PagerLookup(pPager, pgno);
388: if( pPage ){
389: sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPage);
390: Tcl_AppendResult(interp, zBuf, 0);
391: }
392: return TCL_OK;
393: }
394:
395: /*
396: ** Usage: pager_truncate ID PGNO
397: */
398: static int pager_truncate(
399: void *NotUsed,
400: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
401: int argc, /* Number of arguments */
402: const char **argv /* Text of each argument */
403: ){
404: Pager *pPager;
405: int pgno;
406: if( argc!=3 ){
407: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
408: " ID PGNO\"", 0);
409: return TCL_ERROR;
410: }
411: pPager = sqlite3TestTextToPtr(argv[1]);
412: if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
413: sqlite3PagerTruncateImage(pPager, pgno);
414: return TCL_OK;
415: }
416:
417:
418: /*
419: ** Usage: page_unref PAGE
420: **
421: ** Drop a pointer to a page.
422: */
423: static int page_unref(
424: void *NotUsed,
425: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
426: int argc, /* Number of arguments */
427: const char **argv /* Text of each argument */
428: ){
429: DbPage *pPage;
430: if( argc!=2 ){
431: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
432: " PAGE\"", 0);
433: return TCL_ERROR;
434: }
435: pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
436: sqlite3PagerUnref(pPage);
437: return TCL_OK;
438: }
439:
440: /*
441: ** Usage: page_read PAGE
442: **
443: ** Return the content of a page
444: */
445: static int page_read(
446: void *NotUsed,
447: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
448: int argc, /* Number of arguments */
449: const char **argv /* Text of each argument */
450: ){
451: char zBuf[100];
452: DbPage *pPage;
453: if( argc!=2 ){
454: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
455: " PAGE\"", 0);
456: return TCL_ERROR;
457: }
458: pPage = sqlite3TestTextToPtr(argv[1]);
459: memcpy(zBuf, sqlite3PagerGetData(pPage), sizeof(zBuf));
460: Tcl_AppendResult(interp, zBuf, 0);
461: return TCL_OK;
462: }
463:
464: /*
465: ** Usage: page_number PAGE
466: **
467: ** Return the page number for a page.
468: */
469: static int page_number(
470: void *NotUsed,
471: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
472: int argc, /* Number of arguments */
473: const char **argv /* Text of each argument */
474: ){
475: char zBuf[100];
476: DbPage *pPage;
477: if( argc!=2 ){
478: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
479: " PAGE\"", 0);
480: return TCL_ERROR;
481: }
482: pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
483: sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", sqlite3PagerPagenumber(pPage));
484: Tcl_AppendResult(interp, zBuf, 0);
485: return TCL_OK;
486: }
487:
488: /*
489: ** Usage: page_write PAGE DATA
490: **
491: ** Write something into a page.
492: */
493: static int page_write(
494: void *NotUsed,
495: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
496: int argc, /* Number of arguments */
497: const char **argv /* Text of each argument */
498: ){
499: DbPage *pPage;
500: char *pData;
501: int rc;
502: if( argc!=3 ){
503: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
504: " PAGE DATA\"", 0);
505: return TCL_ERROR;
506: }
507: pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
508: rc = sqlite3PagerWrite(pPage);
509: if( rc!=SQLITE_OK ){
510: Tcl_AppendResult(interp, errorName(rc), 0);
511: return TCL_ERROR;
512: }
513: pData = sqlite3PagerGetData(pPage);
514: strncpy(pData, argv[2], test_pagesize-1);
515: pData[test_pagesize-1] = 0;
516: return TCL_OK;
517: }
518:
519: #ifndef SQLITE_OMIT_DISKIO
520: /*
521: ** Usage: fake_big_file N FILENAME
522: **
523: ** Write a few bytes at the N megabyte point of FILENAME. This will
524: ** create a large file. If the file was a valid SQLite database, then
525: ** the next time the database is opened, SQLite will begin allocating
526: ** new pages after N. If N is 2096 or bigger, this will test the
527: ** ability of SQLite to write to large files.
528: */
529: static int fake_big_file(
530: void *NotUsed,
531: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
532: int argc, /* Number of arguments */
533: const char **argv /* Text of each argument */
534: ){
535: sqlite3_vfs *pVfs;
536: sqlite3_file *fd = 0;
537: int rc;
538: int n;
539: i64 offset;
540: char *zFile;
541: int nFile;
542: if( argc!=3 ){
543: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
544: " N-MEGABYTES FILE\"", 0);
545: return TCL_ERROR;
546: }
547: if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR;
548:
549: pVfs = sqlite3_vfs_find(0);
550: nFile = strlen(argv[2]);
551: zFile = sqlite3_malloc( nFile+2 );
552: if( zFile==0 ) return TCL_ERROR;
553: memcpy(zFile, argv[2], nFile+1);
554: zFile[nFile+1] = 0;
555: rc = sqlite3OsOpenMalloc(pVfs, zFile, &fd,
556: (SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB), 0
557: );
558: if( rc ){
559: Tcl_AppendResult(interp, "open failed: ", errorName(rc), 0);
560: sqlite3_free(zFile);
561: return TCL_ERROR;
562: }
563: offset = n;
564: offset *= 1024*1024;
565: rc = sqlite3OsWrite(fd, "Hello, World!", 14, offset);
566: sqlite3OsCloseFree(fd);
567: sqlite3_free(zFile);
568: if( rc ){
569: Tcl_AppendResult(interp, "write failed: ", errorName(rc), 0);
570: return TCL_ERROR;
571: }
572: return TCL_OK;
573: }
574: #endif
575:
576:
577: /*
578: ** test_control_pending_byte PENDING_BYTE
579: **
580: ** Set the PENDING_BYTE using the sqlite3_test_control() interface.
581: */
582: static int testPendingByte(
583: void *NotUsed,
584: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
585: int argc, /* Number of arguments */
586: const char **argv /* Text of each argument */
587: ){
588: int pbyte;
589: int rc;
590: if( argc!=2 ){
591: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
592: " PENDING-BYTE\"", (void*)0);
593: return TCL_ERROR;
594: }
595: if( Tcl_GetInt(interp, argv[1], &pbyte) ) return TCL_ERROR;
596: rc = sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, pbyte);
597: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
598: return TCL_OK;
599: }
600:
601: /*
602: ** sqlite3BitvecBuiltinTest SIZE PROGRAM
603: **
604: ** Invoke the SQLITE_TESTCTRL_BITVEC_TEST operator on test_control.
605: ** See comments on sqlite3BitvecBuiltinTest() for additional information.
606: */
607: static int testBitvecBuiltinTest(
608: void *NotUsed,
609: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
610: int argc, /* Number of arguments */
611: const char **argv /* Text of each argument */
612: ){
613: int sz, rc;
614: int nProg = 0;
615: int aProg[100];
616: const char *z;
617: if( argc!=3 ){
618: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
619: " SIZE PROGRAM\"", (void*)0);
620: }
621: if( Tcl_GetInt(interp, argv[1], &sz) ) return TCL_ERROR;
622: z = argv[2];
623: while( nProg<99 && *z ){
624: while( *z && !sqlite3Isdigit(*z) ){ z++; }
625: if( *z==0 ) break;
626: aProg[nProg++] = atoi(z);
627: while( sqlite3Isdigit(*z) ){ z++; }
628: }
629: aProg[nProg] = 0;
630: rc = sqlite3_test_control(SQLITE_TESTCTRL_BITVEC_TEST, sz, aProg);
631: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
632: return TCL_OK;
633: }
634:
635: /*
636: ** Register commands with the TCL interpreter.
637: */
638: int Sqlitetest2_Init(Tcl_Interp *interp){
639: extern int sqlite3_io_error_persist;
640: extern int sqlite3_io_error_pending;
641: extern int sqlite3_io_error_hit;
642: extern int sqlite3_io_error_hardhit;
643: extern int sqlite3_diskfull_pending;
644: extern int sqlite3_diskfull;
645: static struct {
646: char *zName;
647: Tcl_CmdProc *xProc;
648: } aCmd[] = {
649: { "pager_open", (Tcl_CmdProc*)pager_open },
650: { "pager_close", (Tcl_CmdProc*)pager_close },
651: { "pager_commit", (Tcl_CmdProc*)pager_commit },
652: { "pager_rollback", (Tcl_CmdProc*)pager_rollback },
653: { "pager_stmt_begin", (Tcl_CmdProc*)pager_stmt_begin },
654: { "pager_stmt_commit", (Tcl_CmdProc*)pager_stmt_commit },
655: { "pager_stmt_rollback", (Tcl_CmdProc*)pager_stmt_rollback },
656: { "pager_stats", (Tcl_CmdProc*)pager_stats },
657: { "pager_pagecount", (Tcl_CmdProc*)pager_pagecount },
658: { "page_get", (Tcl_CmdProc*)page_get },
659: { "page_lookup", (Tcl_CmdProc*)page_lookup },
660: { "page_unref", (Tcl_CmdProc*)page_unref },
661: { "page_read", (Tcl_CmdProc*)page_read },
662: { "page_write", (Tcl_CmdProc*)page_write },
663: { "page_number", (Tcl_CmdProc*)page_number },
664: { "pager_truncate", (Tcl_CmdProc*)pager_truncate },
665: #ifndef SQLITE_OMIT_DISKIO
666: { "fake_big_file", (Tcl_CmdProc*)fake_big_file },
667: #endif
668: { "sqlite3BitvecBuiltinTest",(Tcl_CmdProc*)testBitvecBuiltinTest },
669: { "sqlite3_test_control_pending_byte", (Tcl_CmdProc*)testPendingByte },
670: };
671: int i;
672: for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
673: Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
674: }
675: Tcl_LinkVar(interp, "sqlite_io_error_pending",
676: (char*)&sqlite3_io_error_pending, TCL_LINK_INT);
677: Tcl_LinkVar(interp, "sqlite_io_error_persist",
678: (char*)&sqlite3_io_error_persist, TCL_LINK_INT);
679: Tcl_LinkVar(interp, "sqlite_io_error_hit",
680: (char*)&sqlite3_io_error_hit, TCL_LINK_INT);
681: Tcl_LinkVar(interp, "sqlite_io_error_hardhit",
682: (char*)&sqlite3_io_error_hardhit, TCL_LINK_INT);
683: Tcl_LinkVar(interp, "sqlite_diskfull_pending",
684: (char*)&sqlite3_diskfull_pending, TCL_LINK_INT);
685: Tcl_LinkVar(interp, "sqlite_diskfull",
686: (char*)&sqlite3_diskfull, TCL_LINK_INT);
687: #ifndef SQLITE_OMIT_WSD
688: Tcl_LinkVar(interp, "sqlite_pending_byte",
689: (char*)&sqlite3PendingByte, TCL_LINK_INT | TCL_LINK_READ_ONLY);
690: #endif
691: return TCL_OK;
692: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test2.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