Thanks to visit codestin.com
Credit goes to chromium.googlesource.com

Google Git
Sign in
chromium / external / github.com / sqlite / sqlite / HEAD / . / src / test2.c
blob: 899728ead93cb040adbb4ed7fbbb7a4cfed8c565 [file] [log] [blame]
drh5c4d9702001-08-20 00:33:58[diff] [blame]1/*
drhb19a2bc2001-09-16 00:13:26[diff] [blame]2** 2001 September 15
drh5c4d9702001-08-20 00:33:58[diff] [blame]3**
drhb19a2bc2001-09-16 00:13:26[diff] [blame]4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drh5c4d9702001-08-20 00:33:58[diff] [blame]6**
drhb19a2bc2001-09-16 00:13:26[diff] [blame]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.
drh5c4d9702001-08-20 00:33:58[diff] [blame]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.
drh5c4d9702001-08-20 00:33:58[diff] [blame]15*/
16#include "sqliteInt.h"
drh064b6812024-07-30 15:49:02[diff] [blame]17#include "tclsqlite.h"
drh5c4d9702001-08-20 00:33:58[diff] [blame]18#include <stdlib.h>
19#include <string.h>
drh3088d592008-03-21 16:45:47[diff] [blame]20#include <ctype.h>
drh5c4d9702001-08-20 00:33:58[diff] [blame]21
mistachkine84d8d32013-04-29 03:09:10[diff] [blame]22extern const char *sqlite3ErrName(int);
drh5c4d9702001-08-20 00:33:58[diff] [blame]23
24/*
drh90f5ecb2004-07-22 01:19:35[diff] [blame]25** Page size and reserved size used for testing.
26*/
27static int test_pagesize = 1024;
28
29/*
drh4775ecd2009-07-24 19:01:19[diff] [blame]30** Dummy page reinitializer
31*/
32static void pager_test_reiniter(DbPage *pNotUsed){
33 return;
34}
35
36/*
drh5c4d9702001-08-20 00:33:58[diff] [blame]37** Usage: pager_open FILENAME N-PAGE
38**
39** Open a new pager
40*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]41static int SQLITE_TCLAPI pager_open(
drh5c4d9702001-08-20 00:33:58[diff] [blame]42 void *NotUsed,
43 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
44 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]45 const char **argv /* Text of each argument */
drh5c4d9702001-08-20 00:33:58[diff] [blame]46){
drhb2eced52010-08-12 02:41:12[diff] [blame]47 u32 pageSize;
drh5c4d9702001-08-20 00:33:58[diff] [blame]48 Pager *pPager;
49 int nPage;
50 int rc;
51 char zBuf[100];
52 if( argc!=3 ){
53 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]54 " FILENAME N-PAGE\"", NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]55 return TCL_ERROR;
56 }
57 if( Tcl_GetInt(interp, argv[2], &nPage) ) return TCL_ERROR;
danielk197771d5d2c2008-09-29 11:49:47[diff] [blame]58 rc = sqlite3PagerOpen(sqlite3_vfs_find(0), &pPager, argv[1], 0, 0,
drh4775ecd2009-07-24 19:01:19[diff] [blame]59 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MAIN_DB,
60 pager_test_reiniter);
drh5c4d9702001-08-20 00:33:58[diff] [blame]61 if( rc!=SQLITE_OK ){
stephanb6503f12025-03-06 13:38:07[diff] [blame]62 Tcl_AppendResult(interp, sqlite3ErrName(rc), NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]63 return TCL_ERROR;
64 }
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]65 sqlite3PagerSetCachesize(pPager, nPage);
danielk1977a1644fd2007-08-29 12:31:25[diff] [blame]66 pageSize = test_pagesize;
drhfa9601a2009-06-18 17:22:39[diff] [blame]67 sqlite3PagerSetPagesize(pPager, &pageSize, -1);
drhfe63d1c2004-09-08 20:13:04[diff] [blame]68 sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPager);
stephanb6503f12025-03-06 13:38:07[diff] [blame]69 Tcl_AppendResult(interp, zBuf, NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]70 return TCL_OK;
71}
72
73/*
74** Usage: pager_close ID
75**
76** Close the given pager.
77*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]78static int SQLITE_TCLAPI pager_close(
drh5c4d9702001-08-20 00:33:58[diff] [blame]79 void *NotUsed,
80 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
81 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]82 const char **argv /* Text of each argument */
drh5c4d9702001-08-20 00:33:58[diff] [blame]83){
84 Pager *pPager;
85 int rc;
86 if( argc!=2 ){
87 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]88 " ID\"", NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]89 return TCL_ERROR;
90 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]91 pPager = sqlite3TestTextToPtr(argv[1]);
dan7fb89902016-08-12 16:21:15[diff] [blame]92 rc = sqlite3PagerClose(pPager, 0);
drh5c4d9702001-08-20 00:33:58[diff] [blame]93 if( rc!=SQLITE_OK ){
stephanb6503f12025-03-06 13:38:07[diff] [blame]94 Tcl_AppendResult(interp, sqlite3ErrName(rc), NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]95 return TCL_ERROR;
96 }
97 return TCL_OK;
98}
99
100/*
101** Usage: pager_rollback ID
102**
103** Rollback changes
104*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]105static int SQLITE_TCLAPI pager_rollback(
drh5c4d9702001-08-20 00:33:58[diff] [blame]106 void *NotUsed,
107 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
108 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]109 const char **argv /* Text of each argument */
drh5c4d9702001-08-20 00:33:58[diff] [blame]110){
111 Pager *pPager;
112 int rc;
113 if( argc!=2 ){
114 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]115 " ID\"", NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]116 return TCL_ERROR;
117 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]118 pPager = sqlite3TestTextToPtr(argv[1]);
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]119 rc = sqlite3PagerRollback(pPager);
drh5c4d9702001-08-20 00:33:58[diff] [blame]120 if( rc!=SQLITE_OK ){
stephanb6503f12025-03-06 13:38:07[diff] [blame]121 Tcl_AppendResult(interp, sqlite3ErrName(rc), NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]122 return TCL_ERROR;
123 }
124 return TCL_OK;
125}
126
127/*
128** Usage: pager_commit ID
129**
130** Commit all changes
131*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]132static int SQLITE_TCLAPI pager_commit(
drh5c4d9702001-08-20 00:33:58[diff] [blame]133 void *NotUsed,
134 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
135 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]136 const char **argv /* Text of each argument */
drh5c4d9702001-08-20 00:33:58[diff] [blame]137){
138 Pager *pPager;
139 int rc;
140 if( argc!=2 ){
141 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]142 " ID\"", NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]143 return TCL_ERROR;
144 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]145 pPager = sqlite3TestTextToPtr(argv[1]);
drh49b9d332009-01-02 18:10:42[diff] [blame]146 rc = sqlite3PagerCommitPhaseOne(pPager, 0, 0);
drh80e35f42007-03-30 14:06:34[diff] [blame]147 if( rc!=SQLITE_OK ){
stephanb6503f12025-03-06 13:38:07[diff] [blame]148 Tcl_AppendResult(interp, sqlite3ErrName(rc), NULL);
drh80e35f42007-03-30 14:06:34[diff] [blame]149 return TCL_ERROR;
150 }
151 rc = sqlite3PagerCommitPhaseTwo(pPager);
drh5c4d9702001-08-20 00:33:58[diff] [blame]152 if( rc!=SQLITE_OK ){
stephanb6503f12025-03-06 13:38:07[diff] [blame]153 Tcl_AppendResult(interp, sqlite3ErrName(rc), NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]154 return TCL_ERROR;
155 }
156 return TCL_OK;
157}
158
159/*
drh3aac2dd2004-04-26 14:10:20[diff] [blame]160** Usage: pager_stmt_begin ID
drhfa86c412002-02-02 15:01:15[diff] [blame]161**
162** Start a new checkpoint.
163*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]164static int SQLITE_TCLAPI pager_stmt_begin(
drhfa86c412002-02-02 15:01:15[diff] [blame]165 void *NotUsed,
166 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
167 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]168 const char **argv /* Text of each argument */
drhfa86c412002-02-02 15:01:15[diff] [blame]169){
170 Pager *pPager;
171 int rc;
172 if( argc!=2 ){
173 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]174 " ID\"", NULL);
drhfa86c412002-02-02 15:01:15[diff] [blame]175 return TCL_ERROR;
176 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]177 pPager = sqlite3TestTextToPtr(argv[1]);
danielk1977fd7f0452008-12-17 17:30:26[diff] [blame]178 rc = sqlite3PagerOpenSavepoint(pPager, 1);
drhfa86c412002-02-02 15:01:15[diff] [blame]179 if( rc!=SQLITE_OK ){
stephanb6503f12025-03-06 13:38:07[diff] [blame]180 Tcl_AppendResult(interp, sqlite3ErrName(rc), NULL);
drhfa86c412002-02-02 15:01:15[diff] [blame]181 return TCL_ERROR;
182 }
183 return TCL_OK;
184}
185
186/*
drh3aac2dd2004-04-26 14:10:20[diff] [blame]187** Usage: pager_stmt_rollback ID
drhfa86c412002-02-02 15:01:15[diff] [blame]188**
189** Rollback changes to a checkpoint
190*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]191static int SQLITE_TCLAPI pager_stmt_rollback(
drhfa86c412002-02-02 15:01:15[diff] [blame]192 void *NotUsed,
193 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
194 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]195 const char **argv /* Text of each argument */
drhfa86c412002-02-02 15:01:15[diff] [blame]196){
197 Pager *pPager;
198 int rc;
199 if( argc!=2 ){
200 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]201 " ID\"", NULL);
drhfa86c412002-02-02 15:01:15[diff] [blame]202 return TCL_ERROR;
203 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]204 pPager = sqlite3TestTextToPtr(argv[1]);
danielk1977fd7f0452008-12-17 17:30:26[diff] [blame]205 rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, 0);
206 sqlite3PagerSavepoint(pPager, SAVEPOINT_RELEASE, 0);
drhfa86c412002-02-02 15:01:15[diff] [blame]207 if( rc!=SQLITE_OK ){
stephanb6503f12025-03-06 13:38:07[diff] [blame]208 Tcl_AppendResult(interp, sqlite3ErrName(rc), NULL);
drhfa86c412002-02-02 15:01:15[diff] [blame]209 return TCL_ERROR;
210 }
211 return TCL_OK;
212}
213
214/*
drh3aac2dd2004-04-26 14:10:20[diff] [blame]215** Usage: pager_stmt_commit ID
drhfa86c412002-02-02 15:01:15[diff] [blame]216**
217** Commit changes to a checkpoint
218*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]219static int SQLITE_TCLAPI pager_stmt_commit(
drhfa86c412002-02-02 15:01:15[diff] [blame]220 void *NotUsed,
221 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
222 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]223 const char **argv /* Text of each argument */
drhfa86c412002-02-02 15:01:15[diff] [blame]224){
225 Pager *pPager;
226 int rc;
227 if( argc!=2 ){
228 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]229 " ID\"", NULL);
drhfa86c412002-02-02 15:01:15[diff] [blame]230 return TCL_ERROR;
231 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]232 pPager = sqlite3TestTextToPtr(argv[1]);
danielk1977fd7f0452008-12-17 17:30:26[diff] [blame]233 rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_RELEASE, 0);
drhfa86c412002-02-02 15:01:15[diff] [blame]234 if( rc!=SQLITE_OK ){
stephanb6503f12025-03-06 13:38:07[diff] [blame]235 Tcl_AppendResult(interp, sqlite3ErrName(rc), NULL);
drhfa86c412002-02-02 15:01:15[diff] [blame]236 return TCL_ERROR;
237 }
238 return TCL_OK;
239}
240
241/*
drh5c4d9702001-08-20 00:33:58[diff] [blame]242** Usage: pager_stats ID
243**
244** Return pager statistics.
245*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]246static int SQLITE_TCLAPI pager_stats(
drh5c4d9702001-08-20 00:33:58[diff] [blame]247 void *NotUsed,
248 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
249 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]250 const char **argv /* Text of each argument */
drh5c4d9702001-08-20 00:33:58[diff] [blame]251){
252 Pager *pPager;
253 int i, *a;
254 if( argc!=2 ){
255 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]256 " ID\"", NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]257 return TCL_ERROR;
258 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]259 pPager = sqlite3TestTextToPtr(argv[1]);
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]260 a = sqlite3PagerStats(pPager);
drh5c4d9702001-08-20 00:33:58[diff] [blame]261 for(i=0; i<9; i++){
262 static char *zName[] = {
263 "ref", "page", "max", "size", "state", "err",
264 "hit", "miss", "ovfl",
265 };
266 char zBuf[100];
267 Tcl_AppendElement(interp, zName[i]);
drhfe63d1c2004-09-08 20:13:04[diff] [blame]268 sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",a[i]);
drh5c4d9702001-08-20 00:33:58[diff] [blame]269 Tcl_AppendElement(interp, zBuf);
270 }
271 return TCL_OK;
272}
273
274/*
275** Usage: pager_pagecount ID
276**
277** Return the size of the database file.
278*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]279static int SQLITE_TCLAPI pager_pagecount(
drh5c4d9702001-08-20 00:33:58[diff] [blame]280 void *NotUsed,
281 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
282 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]283 const char **argv /* Text of each argument */
drh5c4d9702001-08-20 00:33:58[diff] [blame]284){
285 Pager *pPager;
286 char zBuf[100];
danielk1977ad0132d2008-06-07 08:58:22[diff] [blame]287 int nPage;
drh5c4d9702001-08-20 00:33:58[diff] [blame]288 if( argc!=2 ){
289 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]290 " ID\"", NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]291 return TCL_ERROR;
292 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]293 pPager = sqlite3TestTextToPtr(argv[1]);
danielk1977ad0132d2008-06-07 08:58:22[diff] [blame]294 sqlite3PagerPagecount(pPager, &nPage);
295 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", nPage);
stephanb6503f12025-03-06 13:38:07[diff] [blame]296 Tcl_AppendResult(interp, zBuf, NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]297 return TCL_OK;
298}
299
300/*
301** Usage: page_get ID PGNO
302**
303** Return a pointer to a page from the database.
304*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]305static int SQLITE_TCLAPI page_get(
drh5c4d9702001-08-20 00:33:58[diff] [blame]306 void *NotUsed,
307 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
308 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]309 const char **argv /* Text of each argument */
drh5c4d9702001-08-20 00:33:58[diff] [blame]310){
311 Pager *pPager;
312 char zBuf[100];
mistachkin27b2f052015-01-12 19:49:46[diff] [blame]313 DbPage *pPage = 0;
drh5c4d9702001-08-20 00:33:58[diff] [blame]314 int pgno;
315 int rc;
316 if( argc!=3 ){
317 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]318 " ID PGNO\"", NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]319 return TCL_ERROR;
320 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]321 pPager = sqlite3TestTextToPtr(argv[1]);
drh5c4d9702001-08-20 00:33:58[diff] [blame]322 if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
danielk197789bc4bc2009-07-21 19:25:24[diff] [blame]323 rc = sqlite3PagerSharedLock(pPager);
324 if( rc==SQLITE_OK ){
drh9584f582015-11-04 20:22:37[diff] [blame]325 rc = sqlite3PagerGet(pPager, pgno, &pPage, 0);
danielk197789bc4bc2009-07-21 19:25:24[diff] [blame]326 }
drh5c4d9702001-08-20 00:33:58[diff] [blame]327 if( rc!=SQLITE_OK ){
stephanb6503f12025-03-06 13:38:07[diff] [blame]328 Tcl_AppendResult(interp, sqlite3ErrName(rc), NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]329 return TCL_ERROR;
330 }
drhfe63d1c2004-09-08 20:13:04[diff] [blame]331 sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPage);
stephanb6503f12025-03-06 13:38:07[diff] [blame]332 Tcl_AppendResult(interp, zBuf, NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]333 return TCL_OK;
334}
335
336/*
337** Usage: page_lookup ID PGNO
338**
339** Return a pointer to a page if the page is already in cache.
340** If not in cache, return an empty string.
341*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]342static int SQLITE_TCLAPI page_lookup(
drh5c4d9702001-08-20 00:33:58[diff] [blame]343 void *NotUsed,
344 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
345 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]346 const char **argv /* Text of each argument */
drh5c4d9702001-08-20 00:33:58[diff] [blame]347){
348 Pager *pPager;
349 char zBuf[100];
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]350 DbPage *pPage;
drh5c4d9702001-08-20 00:33:58[diff] [blame]351 int pgno;
352 if( argc!=3 ){
353 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]354 " ID PGNO\"", NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]355 return TCL_ERROR;
356 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]357 pPager = sqlite3TestTextToPtr(argv[1]);
drh5c4d9702001-08-20 00:33:58[diff] [blame]358 if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]359 pPage = sqlite3PagerLookup(pPager, pgno);
drh5c4d9702001-08-20 00:33:58[diff] [blame]360 if( pPage ){
drhfe63d1c2004-09-08 20:13:04[diff] [blame]361 sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPage);
stephanb6503f12025-03-06 13:38:07[diff] [blame]362 Tcl_AppendResult(interp, zBuf, NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]363 }
364 return TCL_OK;
365}
366
367/*
danielk1977aca790a2005-01-13 11:07:52[diff] [blame]368** Usage: pager_truncate ID PGNO
369*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]370static int SQLITE_TCLAPI pager_truncate(
danielk1977aca790a2005-01-13 11:07:52[diff] [blame]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;
danielk1977aca790a2005-01-13 11:07:52[diff] [blame]377 int pgno;
378 if( argc!=3 ){
379 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]380 " ID PGNO\"", NULL);
danielk1977aca790a2005-01-13 11:07:52[diff] [blame]381 return TCL_ERROR;
382 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]383 pPager = sqlite3TestTextToPtr(argv[1]);
danielk1977aca790a2005-01-13 11:07:52[diff] [blame]384 if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
danielk1977f90b7262009-01-07 15:18:20[diff] [blame]385 sqlite3PagerTruncateImage(pPager, pgno);
danielk1977aca790a2005-01-13 11:07:52[diff] [blame]386 return TCL_OK;
387}
388
389
390/*
drh5c4d9702001-08-20 00:33:58[diff] [blame]391** Usage: page_unref PAGE
392**
393** Drop a pointer to a page.
394*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]395static int SQLITE_TCLAPI page_unref(
drh5c4d9702001-08-20 00:33:58[diff] [blame]396 void *NotUsed,
397 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
398 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]399 const char **argv /* Text of each argument */
drh5c4d9702001-08-20 00:33:58[diff] [blame]400){
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]401 DbPage *pPage;
drh5c4d9702001-08-20 00:33:58[diff] [blame]402 if( argc!=2 ){
403 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]404 " PAGE\"", NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]405 return TCL_ERROR;
406 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]407 pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
danielk1977bea2a942009-01-20 17:06:27[diff] [blame]408 sqlite3PagerUnref(pPage);
drh5c4d9702001-08-20 00:33:58[diff] [blame]409 return TCL_OK;
410}
411
412/*
413** Usage: page_read PAGE
414**
415** Return the content of a page
416*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]417static int SQLITE_TCLAPI page_read(
drh5c4d9702001-08-20 00:33:58[diff] [blame]418 void *NotUsed,
419 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
420 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]421 const char **argv /* Text of each argument */
drh5c4d9702001-08-20 00:33:58[diff] [blame]422){
423 char zBuf[100];
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]424 DbPage *pPage;
drh5c4d9702001-08-20 00:33:58[diff] [blame]425 if( argc!=2 ){
426 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]427 " PAGE\"", NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]428 return TCL_ERROR;
429 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]430 pPage = sqlite3TestTextToPtr(argv[1]);
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]431 memcpy(zBuf, sqlite3PagerGetData(pPage), sizeof(zBuf));
stephanb6503f12025-03-06 13:38:07[diff] [blame]432 Tcl_AppendResult(interp, zBuf, NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]433 return TCL_OK;
434}
435
436/*
437** Usage: page_number PAGE
438**
439** Return the page number for a page.
440*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]441static int SQLITE_TCLAPI page_number(
drh5c4d9702001-08-20 00:33:58[diff] [blame]442 void *NotUsed,
443 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
444 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]445 const char **argv /* Text of each argument */
drh5c4d9702001-08-20 00:33:58[diff] [blame]446){
447 char zBuf[100];
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]448 DbPage *pPage;
drh5c4d9702001-08-20 00:33:58[diff] [blame]449 if( argc!=2 ){
450 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]451 " PAGE\"", NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]452 return TCL_ERROR;
453 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]454 pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]455 sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", sqlite3PagerPagenumber(pPage));
stephanb6503f12025-03-06 13:38:07[diff] [blame]456 Tcl_AppendResult(interp, zBuf, NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]457 return TCL_OK;
458}
459
460/*
461** Usage: page_write PAGE DATA
462**
463** Write something into a page.
464*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]465static int SQLITE_TCLAPI page_write(
drh5c4d9702001-08-20 00:33:58[diff] [blame]466 void *NotUsed,
467 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
468 int argc, /* Number of arguments */
drhc2eef3b2002-08-31 18:53:06[diff] [blame]469 const char **argv /* Text of each argument */
drh5c4d9702001-08-20 00:33:58[diff] [blame]470){
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]471 DbPage *pPage;
472 char *pData;
drh5c4d9702001-08-20 00:33:58[diff] [blame]473 int rc;
474 if( argc!=3 ){
475 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]476 " PAGE DATA\"", NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]477 return TCL_ERROR;
478 }
drhe8f52c52008-07-12 14:52:20[diff] [blame]479 pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]480 rc = sqlite3PagerWrite(pPage);
drh5c4d9702001-08-20 00:33:58[diff] [blame]481 if( rc!=SQLITE_OK ){
stephanb6503f12025-03-06 13:38:07[diff] [blame]482 Tcl_AppendResult(interp, sqlite3ErrName(rc), NULL);
drh5c4d9702001-08-20 00:33:58[diff] [blame]483 return TCL_ERROR;
484 }
danielk19773b8a05f2007-03-19 17:44:26[diff] [blame]485 pData = sqlite3PagerGetData(pPage);
486 strncpy(pData, argv[2], test_pagesize-1);
487 pData[test_pagesize-1] = 0;
drh5c4d9702001-08-20 00:33:58[diff] [blame]488 return TCL_OK;
489}
490
danielk197744ee5bf2005-05-27 09:41:12[diff] [blame]491#ifndef SQLITE_OMIT_DISKIO
drh5c4d9702001-08-20 00:33:58[diff] [blame]492/*
drhd0d006e2002-12-01 02:00:57[diff] [blame]493** Usage: fake_big_file N FILENAME
494**
495** Write a few bytes at the N megabyte point of FILENAME. This will
496** create a large file. If the file was a valid SQLite database, then
497** the next time the database is opened, SQLite will begin allocating
498** new pages after N. If N is 2096 or bigger, this will test the
499** ability of SQLite to write to large files.
500*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]501static int SQLITE_TCLAPI fake_big_file(
drhd0d006e2002-12-01 02:00:57[diff] [blame]502 void *NotUsed,
503 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
504 int argc, /* Number of arguments */
505 const char **argv /* Text of each argument */
506){
danielk1977b4b47412007-08-17 15:53:36[diff] [blame]507 sqlite3_vfs *pVfs;
508 sqlite3_file *fd = 0;
drhd0d006e2002-12-01 02:00:57[diff] [blame]509 int rc;
510 int n;
drheb206252004-10-01 02:00:31[diff] [blame]511 i64 offset;
drh69578ac2012-01-11 00:38:51[diff] [blame]512 char *zFile;
513 int nFile;
drhd0d006e2002-12-01 02:00:57[diff] [blame]514 if( argc!=3 ){
515 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
stephan065c0a62025-03-08 06:53:06[diff] [blame]516 " N-MEGABYTES FILE\"", NULL);
drhd0d006e2002-12-01 02:00:57[diff] [blame]517 return TCL_ERROR;
518 }
519 if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR;
drh1da477d2022-11-14 18:57:21[diff] [blame]520#if defined(_WIN32)
521 if( n>2 ){
drha70a01d2022-11-14 19:42:01[diff] [blame]522 Tcl_AppendResult(interp, "cannot create ", argv[1],
523 "MB file because Windows "
524 "does not support sparse files", (void*)0);
drh1da477d2022-11-14 18:57:21[diff] [blame]525 return TCL_ERROR;
526 }
527#endif
danielk1977b4b47412007-08-17 15:53:36[diff] [blame]528
drhd677b3d2007-08-20 22:48:41[diff] [blame]529 pVfs = sqlite3_vfs_find(0);
drh83cc1392012-04-19 18:04:28[diff] [blame]530 nFile = (int)strlen(argv[2]);
drh69578ac2012-01-11 00:38:51[diff] [blame]531 zFile = sqlite3_malloc( nFile+2 );
532 if( zFile==0 ) return TCL_ERROR;
533 memcpy(zFile, argv[2], nFile+1);
534 zFile[nFile+1] = 0;
535 rc = sqlite3OsOpenMalloc(pVfs, zFile, &fd,
danielk1977967a4a12007-08-20 14:23:44[diff] [blame]536 (SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB), 0
danielk1977fee2d252007-08-18 10:59:19[diff] [blame]537 );
drhd0d006e2002-12-01 02:00:57[diff] [blame]538 if( rc ){
stephanb6503f12025-03-06 13:38:07[diff] [blame]539 Tcl_AppendResult(interp, "open failed: ", sqlite3ErrName(rc), NULL);
drh69578ac2012-01-11 00:38:51[diff] [blame]540 sqlite3_free(zFile);
drhd0d006e2002-12-01 02:00:57[diff] [blame]541 return TCL_ERROR;
542 }
543 offset = n;
544 offset *= 1024*1024;
danielk197762079062007-08-15 17:08:46[diff] [blame]545 rc = sqlite3OsWrite(fd, "Hello, World!", 14, offset);
danielk1977b4b47412007-08-17 15:53:36[diff] [blame]546 sqlite3OsCloseFree(fd);
drh69578ac2012-01-11 00:38:51[diff] [blame]547 sqlite3_free(zFile);
drhd0d006e2002-12-01 02:00:57[diff] [blame]548 if( rc ){
stephanb6503f12025-03-06 13:38:07[diff] [blame]549 Tcl_AppendResult(interp, "write failed: ", sqlite3ErrName(rc), NULL);
drhd0d006e2002-12-01 02:00:57[diff] [blame]550 return TCL_ERROR;
551 }
drhd0d006e2002-12-01 02:00:57[diff] [blame]552 return TCL_OK;
553}
danielk197744ee5bf2005-05-27 09:41:12[diff] [blame]554#endif
drhd0d006e2002-12-01 02:00:57[diff] [blame]555
drh3088d592008-03-21 16:45:47[diff] [blame]556
drhd0d006e2002-12-01 02:00:57[diff] [blame]557/*
drhc7a3bb92009-02-05 16:31:45[diff] [blame]558** test_control_pending_byte PENDING_BYTE
559**
560** Set the PENDING_BYTE using the sqlite3_test_control() interface.
561*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]562static int SQLITE_TCLAPI testPendingByte(
drhc7a3bb92009-02-05 16:31:45[diff] [blame]563 void *NotUsed,
564 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
565 int argc, /* Number of arguments */
566 const char **argv /* Text of each argument */
567){
568 int pbyte;
569 int rc;
570 if( argc!=2 ){
571 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
572 " PENDING-BYTE\"", (void*)0);
dan8d6ad1c2010-05-04 10:36:20[diff] [blame]573 return TCL_ERROR;
drhc7a3bb92009-02-05 16:31:45[diff] [blame]574 }
575 if( Tcl_GetInt(interp, argv[1], &pbyte) ) return TCL_ERROR;
576 rc = sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, pbyte);
577 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
578 return TCL_OK;
drhc007f612014-05-16 14:17:01[diff] [blame]579}
580
581/*
582** The sqlite3FaultSim() callback:
583*/
584static Tcl_Interp *faultSimInterp = 0;
585static int faultSimScriptSize = 0;
586static char *faultSimScript;
587static int faultSimCallback(int x){
588 char zInt[30];
589 int i;
590 int isNeg;
591 int rc;
592 if( x==0 ){
593 memcpy(faultSimScript+faultSimScriptSize, "0", 2);
594 }else{
595 /* Convert x to text without using any sqlite3 routines */
596 if( x<0 ){
597 isNeg = 1;
598 x = -x;
599 }else{
600 isNeg = 0;
601 }
602 zInt[sizeof(zInt)-1] = 0;
603 for(i=sizeof(zInt)-2; i>0 && x>0; i--, x /= 10){
604 zInt[i] = (x%10) + '0';
605 }
606 if( isNeg ) zInt[i--] = '-';
danf0c1ea92023-08-15 10:57:08[diff] [blame]607 memcpy(faultSimScript+faultSimScriptSize, zInt+i+1, sizeof(zInt)-i-1);
drhc007f612014-05-16 14:17:01[diff] [blame]608 }
609 rc = Tcl_Eval(faultSimInterp, faultSimScript);
610 if( rc ){
611 fprintf(stderr, "fault simulator script failed: [%s]", faultSimScript);
612 rc = SQLITE_ERROR;
613 }else{
614 rc = atoi(Tcl_GetStringResult(faultSimInterp));
615 }
616 Tcl_ResetResult(faultSimInterp);
617 return rc;
618}
619
620/*
621** sqlite3_test_control_fault_install SCRIPT
622**
623** Arrange to invoke SCRIPT with the integer argument to sqlite3FaultSim()
624** appended, whenever sqlite3FaultSim() is called. Or, if SCRIPT is the
625** empty string, cancel the sqlite3FaultSim() callback.
626*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]627static int SQLITE_TCLAPI faultInstallCmd(
drhc007f612014-05-16 14:17:01[diff] [blame]628 void *NotUsed,
629 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
630 int argc, /* Number of arguments */
631 const char **argv /* Text of each argument */
632){
633 const char *zScript;
634 int nScript;
635 int rc;
636 if( argc!=1 && argc!=2 ){
637 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
638 " SCRIPT\"", (void*)0);
639 }
640 zScript = argc==2 ? argv[1] : "";
641 nScript = (int)strlen(zScript);
642 if( faultSimScript ){
643 free(faultSimScript);
644 faultSimScript = 0;
645 }
646 if( nScript==0 ){
647 rc = sqlite3_test_control(SQLITE_TESTCTRL_FAULT_INSTALL, 0);
648 }else{
649 faultSimScript = malloc( nScript+100 );
650 if( faultSimScript==0 ){
651 Tcl_AppendResult(interp, "out of memory", (void*)0);
652 return SQLITE_ERROR;
653 }
654 memcpy(faultSimScript, zScript, nScript);
655 faultSimScript[nScript] = ' ';
656 faultSimScriptSize = nScript+1;
657 faultSimInterp = interp;
658 rc = sqlite3_test_control(SQLITE_TESTCTRL_FAULT_INSTALL, faultSimCallback);
659 }
660 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
661 return SQLITE_OK;
662}
drhc7a3bb92009-02-05 16:31:45[diff] [blame]663
664/*
drh3088d592008-03-21 16:45:47[diff] [blame]665** sqlite3BitvecBuiltinTest SIZE PROGRAM
666**
667** Invoke the SQLITE_TESTCTRL_BITVEC_TEST operator on test_control.
668** See comments on sqlite3BitvecBuiltinTest() for additional information.
drhf5e7bb52008-02-18 14:47:33[diff] [blame]669*/
mistachkin7617e4a2016-07-28 17:11:20[diff] [blame]670static int SQLITE_TCLAPI testBitvecBuiltinTest(
drhf5e7bb52008-02-18 14:47:33[diff] [blame]671 void *NotUsed,
672 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
673 int argc, /* Number of arguments */
674 const char **argv /* Text of each argument */
675){
drh3088d592008-03-21 16:45:47[diff] [blame]676 int sz, rc;
677 int nProg = 0;
678 int aProg[100];
679 const char *z;
drhf5e7bb52008-02-18 14:47:33[diff] [blame]680 if( argc!=3 ){
drh3088d592008-03-21 16:45:47[diff] [blame]681 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
682 " SIZE PROGRAM\"", (void*)0);
drhf5e7bb52008-02-18 14:47:33[diff] [blame]683 }
drh3088d592008-03-21 16:45:47[diff] [blame]684 if( Tcl_GetInt(interp, argv[1], &sz) ) return TCL_ERROR;
685 z = argv[2];
686 while( nProg<99 && *z ){
danielk197778ca0e72009-01-20 16:53:39[diff] [blame]687 while( *z && !sqlite3Isdigit(*z) ){ z++; }
drh3088d592008-03-21 16:45:47[diff] [blame]688 if( *z==0 ) break;
689 aProg[nProg++] = atoi(z);
danielk197778ca0e72009-01-20 16:53:39[diff] [blame]690 while( sqlite3Isdigit(*z) ){ z++; }
drh3088d592008-03-21 16:45:47[diff] [blame]691 }
692 aProg[nProg] = 0;
693 rc = sqlite3_test_control(SQLITE_TESTCTRL_BITVEC_TEST, sz, aProg);
694 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
drhf5e7bb52008-02-18 14:47:33[diff] [blame]695 return TCL_OK;
696}
drhf5e7bb52008-02-18 14:47:33[diff] [blame]697
698/*
drh5c4d9702001-08-20 00:33:58[diff] [blame]699** Register commands with the TCL interpreter.
700*/
701int Sqlitetest2_Init(Tcl_Interp *interp){
drhd5eb79e2007-03-15 12:17:42[diff] [blame]702 extern int sqlite3_io_error_persist;
danielk19776f8a5032004-05-10 10:34:51[diff] [blame]703 extern int sqlite3_io_error_pending;
drhc9ac5ca2005-11-04 22:03:30[diff] [blame]704 extern int sqlite3_io_error_hit;
drh1aa5af12008-03-07 19:51:14[diff] [blame]705 extern int sqlite3_io_error_hardhit;
drh047d4832004-10-01 14:38:02[diff] [blame]706 extern int sqlite3_diskfull_pending;
drhf307a4a2005-09-09 10:46:19[diff] [blame]707 extern int sqlite3_diskfull;
drhc2eef3b2002-08-31 18:53:06[diff] [blame]708 static struct {
709 char *zName;
710 Tcl_CmdProc *xProc;
711 } aCmd[] = {
712 { "pager_open", (Tcl_CmdProc*)pager_open },
713 { "pager_close", (Tcl_CmdProc*)pager_close },
714 { "pager_commit", (Tcl_CmdProc*)pager_commit },
715 { "pager_rollback", (Tcl_CmdProc*)pager_rollback },
drh3aac2dd2004-04-26 14:10:20[diff] [blame]716 { "pager_stmt_begin", (Tcl_CmdProc*)pager_stmt_begin },
717 { "pager_stmt_commit", (Tcl_CmdProc*)pager_stmt_commit },
718 { "pager_stmt_rollback", (Tcl_CmdProc*)pager_stmt_rollback },
drhc2eef3b2002-08-31 18:53:06[diff] [blame]719 { "pager_stats", (Tcl_CmdProc*)pager_stats },
720 { "pager_pagecount", (Tcl_CmdProc*)pager_pagecount },
721 { "page_get", (Tcl_CmdProc*)page_get },
722 { "page_lookup", (Tcl_CmdProc*)page_lookup },
723 { "page_unref", (Tcl_CmdProc*)page_unref },
724 { "page_read", (Tcl_CmdProc*)page_read },
725 { "page_write", (Tcl_CmdProc*)page_write },
726 { "page_number", (Tcl_CmdProc*)page_number },
danielk1977aca790a2005-01-13 11:07:52[diff] [blame]727 { "pager_truncate", (Tcl_CmdProc*)pager_truncate },
danielk197744ee5bf2005-05-27 09:41:12[diff] [blame]728#ifndef SQLITE_OMIT_DISKIO
drhd0d006e2002-12-01 02:00:57[diff] [blame]729 { "fake_big_file", (Tcl_CmdProc*)fake_big_file },
danielk197744ee5bf2005-05-27 09:41:12[diff] [blame]730#endif
drhc7a3bb92009-02-05 16:31:45[diff] [blame]731 { "sqlite3BitvecBuiltinTest",(Tcl_CmdProc*)testBitvecBuiltinTest },
drhc007f612014-05-16 14:17:01[diff] [blame]732 { "sqlite3_test_control_pending_byte", (Tcl_CmdProc*)testPendingByte },
733 { "sqlite3_test_control_fault_install", (Tcl_CmdProc*)faultInstallCmd },
drhc2eef3b2002-08-31 18:53:06[diff] [blame]734 };
735 int i;
736 for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
737 Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
738 }
danielk1977369f27e2004-06-15 11:40:04[diff] [blame]739 Tcl_LinkVar(interp, "sqlite_io_error_pending",
danielk19776f8a5032004-05-10 10:34:51[diff] [blame]740 (char*)&sqlite3_io_error_pending, TCL_LINK_INT);
drhd5eb79e2007-03-15 12:17:42[diff] [blame]741 Tcl_LinkVar(interp, "sqlite_io_error_persist",
742 (char*)&sqlite3_io_error_persist, TCL_LINK_INT);
drhc9ac5ca2005-11-04 22:03:30[diff] [blame]743 Tcl_LinkVar(interp, "sqlite_io_error_hit",
744 (char*)&sqlite3_io_error_hit, TCL_LINK_INT);
drh1aa5af12008-03-07 19:51:14[diff] [blame]745 Tcl_LinkVar(interp, "sqlite_io_error_hardhit",
746 (char*)&sqlite3_io_error_hardhit, TCL_LINK_INT);
drh047d4832004-10-01 14:38:02[diff] [blame]747 Tcl_LinkVar(interp, "sqlite_diskfull_pending",
748 (char*)&sqlite3_diskfull_pending, TCL_LINK_INT);
drhf307a4a2005-09-09 10:46:19[diff] [blame]749 Tcl_LinkVar(interp, "sqlite_diskfull",
750 (char*)&sqlite3_diskfull, TCL_LINK_INT);
drhf83dc1e2010-06-03 12:09:52[diff] [blame]751#ifndef SQLITE_OMIT_WSD
danielk1977fd5f5b62005-09-16 09:52:29[diff] [blame]752 Tcl_LinkVar(interp, "sqlite_pending_byte",
drhc7a3bb92009-02-05 16:31:45[diff] [blame]753 (char*)&sqlite3PendingByte, TCL_LINK_INT | TCL_LINK_READ_ONLY);
drhf83dc1e2010-06-03 12:09:52[diff] [blame]754#endif
drh5c4d9702001-08-20 00:33:58[diff] [blame]755 return TCL_OK;
756}