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