Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | The first test file for BTree added. Simple insert and delete tests pass. There is still a lot of work to be done, though. (CVS 228) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
85f015c9750a5eab274e82f0e2c6e8f0 |
User & Date: | drh 2001-06-24 20:39:41.000 |
Context
2001-06-25
| ||
02:11 | More tests and bug fixes in btree.c (CVS 229) (check-in: 6b9b298b28 user: drh tags: trunk) | |
2001-06-24
| ||
20:39 | The first test file for BTree added. Simple insert and delete tests pass. There is still a lot of work to be done, though. (CVS 228) (check-in: 85f015c975 user: drh tags: trunk) | |
2001-06-23
| ||
11:36 | Fix a bug in pager.c introduced in the previous delta. (CVS 227) (check-in: f4df666403 user: drh tags: trunk) | |
Changes
Changes to src/btree.c.
︙ | ︙ | |||
17 18 19 20 21 22 23 | ** Boston, MA 02111-1307, USA. ** ** Author contact information: ** drh@hwaci.com ** http://www.hwaci.com/drh/ ** ************************************************************************* | | | 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | ** Boston, MA 02111-1307, USA. ** ** Author contact information: ** drh@hwaci.com ** http://www.hwaci.com/drh/ ** ************************************************************************* ** $Id: btree.c,v 1.14 2001/06/24 20:39:41 drh Exp $ ** ** This file implements a external (disk-based) database using BTrees. ** For a detailed discussion of BTrees, refer to ** ** Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3: ** "Sorting And Searching", pages 473-480. Addison-Wesley ** Publishing Company, Reading, Massachusetts. |
︙ | ︙ | |||
77 78 79 80 81 82 83 | typedef unsigned short int u16; typedef unsigned char u8; /* ** This macro casts a pointer to an integer. Useful for doing ** pointer arithmetic. */ | | | 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 | typedef unsigned short int u16; typedef unsigned char u8; /* ** This macro casts a pointer to an integer. Useful for doing ** pointer arithmetic. */ #define Addr(X) ((uptr)X) /* ** Forward declarations of structures used only in this file. */ typedef struct PageOne PageOne; typedef struct MemPage MemPage; typedef struct PageHdr PageHdr; |
︙ | ︙ | |||
364 365 366 367 368 369 370 | pPage->u.hdr.firstCell = pc; memcpy(newPage, pPage->u.aDisk, pc); for(i=0; i<pPage->nCell; i++){ Cell *pCell = (Cell*)&pPage->apCell[i]; /* This routine should never be called on an overfull page. The ** following asserts verify that constraint. */ | | | | 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 | pPage->u.hdr.firstCell = pc; memcpy(newPage, pPage->u.aDisk, pc); for(i=0; i<pPage->nCell; i++){ Cell *pCell = (Cell*)&pPage->apCell[i]; /* This routine should never be called on an overfull page. The ** following asserts verify that constraint. */ assert( Addr(pCell) > Addr(pPage) ); assert( Addr(pCell) < Addr(pPage) + SQLITE_PAGE_SIZE ); n = cellSize(pCell); pCell->h.iNext = i<pPage->nCell-1 ? pc + n : 0; memcpy(&newPage[pc], pCell, n); pPage->apCell[i] = (Cell*)&pPage->u.aDisk[pc]; pc += n; } |
︙ | ︙ | |||
530 531 532 533 534 535 536 | pPage->nFree = 0; idx = pPage->u.hdr.firstFree; while( idx!=0 ){ if( idx>SQLITE_PAGE_SIZE-sizeof(FreeBlk) ) goto page_format_error; if( idx<sizeof(PageHdr) ) goto page_format_error; pFBlk = (FreeBlk*)&pPage->u.aDisk[idx]; pPage->nFree += pFBlk->iSize; | | | 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 | pPage->nFree = 0; idx = pPage->u.hdr.firstFree; while( idx!=0 ){ if( idx>SQLITE_PAGE_SIZE-sizeof(FreeBlk) ) goto page_format_error; if( idx<sizeof(PageHdr) ) goto page_format_error; pFBlk = (FreeBlk*)&pPage->u.aDisk[idx]; pPage->nFree += pFBlk->iSize; if( pFBlk->iNext>0 && pFBlk->iNext <= idx ) goto page_format_error; idx = pFBlk->iNext; } if( pPage->nCell==0 && pPage->nFree==0 ){ /* As a special case, an uninitialized root page appears to be ** an empty database */ return SQLITE_OK; } |
︙ | ︙ | |||
662 663 664 665 666 667 668 | ** Create a new database by initializing the first two pages of the ** file. */ static int newDatabase(Btree *pBt){ MemPage *pRoot; PageOne *pP1; int rc; | | | 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 | ** Create a new database by initializing the first two pages of the ** file. */ static int newDatabase(Btree *pBt){ MemPage *pRoot; PageOne *pP1; int rc; if( sqlitepager_pagecount(pBt->pPager)>1 ) return SQLITE_OK; pP1 = pBt->page1; rc = sqlitepager_write(pBt->page1); if( rc ) return rc; rc = sqlitepager_get(pBt->pPager, 2, (void**)&pRoot); if( rc ) return rc; rc = sqlitepager_write(pRoot); if( rc ){ |
︙ | ︙ | |||
717 718 719 720 721 722 723 | } /* ** Remove the last reference to the database file. This will ** remove the read lock. */ static void unlockBtree(Btree *pBt){ | | | > > > | 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 | } /* ** Remove the last reference to the database file. This will ** remove the read lock. */ static void unlockBtree(Btree *pBt){ if( pBt->inTrans==0 && pBt->pCursor==0 && pBt->page1!=0 ){ sqlitepager_unref(pBt->page1); pBt->page1 = 0; pBt->inTrans = 0; } } /* ** Commit the transaction currently in progress. All cursors ** must be closed before this routine is called. */ int sqliteBtreeCommit(Btree *pBt){ int rc; if( pBt->pCursor!=0 || pBt->inTrans==0 ) return SQLITE_ERROR; rc = sqlitepager_commit(pBt->pPager); pBt->inTrans = 0; unlockBtree(pBt); return rc; } /* ** Rollback the transaction in progress. All cursors must be ** closed before this routine is called. */ int sqliteBtreeRollback(Btree *pBt){ int rc; if( pBt->pCursor!=0 ) return SQLITE_ERROR; if( pBt->inTrans==0 ) return SQLITE_OK; pBt->inTrans = 0; rc = sqlitepager_rollback(pBt->pPager); unlockBtree(pBt); return rc; } /* ** Create a new cursor for the BTree whose root is on the page |
︙ | ︙ | |||
1140 1141 1142 1143 1144 1145 1146 | ** ** The result of comparing the key with the entry to which the ** cursor is left pointing is stored in pCur->iMatch. The same ** value is also written to *pRes if pRes!=NULL. The meaning of ** this value is as follows: ** ** *pRes<0 The cursor is left pointing at an entry that | | | > | 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 | ** ** The result of comparing the key with the entry to which the ** cursor is left pointing is stored in pCur->iMatch. The same ** value is also written to *pRes if pRes!=NULL. The meaning of ** this value is as follows: ** ** *pRes<0 The cursor is left pointing at an entry that ** is smaller than pKey. ** ** *pRes==0 The cursor is left pointing at an entry that ** exactly matches pKey. ** ** *pRes>0 The cursor is left pointing at an entry that ** is larger than pKey. */ int sqliteBtreeMoveto(BtCursor *pCur, void *pKey, int nKey, int *pRes){ int rc; pCur->bSkipNext = 0; rc = moveToRoot(pCur); if( rc ) return rc; for(;;){ int lwr, upr; Pgno chldPg; MemPage *pPage = pCur->pPage; int c = -1; |
︙ | ︙ | |||
1445 1446 1447 1448 1449 1450 1451 | ** routine will be called soon after this routine in order to rebuild ** the linked list. */ static void dropCell(MemPage *pPage, int idx, int sz){ int j; assert( idx>=0 && idx<pPage->nCell ); assert( sz==cellSize(pPage->apCell[idx]) ); | | | | 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 | ** routine will be called soon after this routine in order to rebuild ** the linked list. */ static void dropCell(MemPage *pPage, int idx, int sz){ int j; assert( idx>=0 && idx<pPage->nCell ); assert( sz==cellSize(pPage->apCell[idx]) ); freeSpace(pPage, Addr(pPage->apCell[idx]) - Addr(pPage), sz); for(j=idx; j<pPage->nCell-1; j++){ pPage->apCell[j] = pPage->apCell[j+1]; } pPage->nCell--; } /* ** Insert a new cell on pPage at cell index "i". pCell points to the |
︙ | ︙ | |||
1494 1495 1496 1497 1498 1499 1500 | ** invocations of either insertCell() or dropCell(). */ static void relinkCellList(MemPage *pPage){ int i; u16 *pIdx; pIdx = &pPage->u.hdr.firstCell; for(i=0; i<pPage->nCell; i++){ | | | 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 | ** invocations of either insertCell() or dropCell(). */ static void relinkCellList(MemPage *pPage){ int i; u16 *pIdx; pIdx = &pPage->u.hdr.firstCell; for(i=0; i<pPage->nCell; i++){ int idx = Addr(pPage->apCell[i]) - Addr(pPage); assert( idx>0 && idx<SQLITE_PAGE_SIZE ); *pIdx = idx; pIdx = &pPage->apCell[i]->h.iNext; } *pIdx = 0; } |
︙ | ︙ | |||
1517 1518 1519 1520 1521 1522 1523 | int i; memcpy(pTo->u.aDisk, pFrom->u.aDisk, SQLITE_PAGE_SIZE); pTo->pParent = pFrom->pParent; pTo->isInit = 1; pTo->nCell = pFrom->nCell; pTo->nFree = pFrom->nFree; pTo->isOverfull = pFrom->isOverfull; | | | | | 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 | int i; memcpy(pTo->u.aDisk, pFrom->u.aDisk, SQLITE_PAGE_SIZE); pTo->pParent = pFrom->pParent; pTo->isInit = 1; pTo->nCell = pFrom->nCell; pTo->nFree = pFrom->nFree; pTo->isOverfull = pFrom->isOverfull; to = Addr(pTo); from = Addr(pFrom); for(i=0; i<pTo->nCell; i++){ uptr x = Addr(pFrom->apCell[i]); if( x>from && x<from+SQLITE_PAGE_SIZE ){ *((uptr*)&pTo->apCell[i]) = x + to - from; } } } /* |
︙ | ︙ | |||
1899 1900 1901 1902 1903 1904 1905 | if( rc ) return rc; szNew = cellSize(&newCell); if( loc==0 ){ newCell.h.leftChild = pPage->apCell[pCur->idx]->h.leftChild; rc = clearCell(pBt, pPage->apCell[pCur->idx]); if( rc ) return rc; dropCell(pPage, pCur->idx, cellSize(pPage->apCell[pCur->idx])); | | | | 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 | if( rc ) return rc; szNew = cellSize(&newCell); if( loc==0 ){ newCell.h.leftChild = pPage->apCell[pCur->idx]->h.leftChild; rc = clearCell(pBt, pPage->apCell[pCur->idx]); if( rc ) return rc; dropCell(pPage, pCur->idx, cellSize(pPage->apCell[pCur->idx])); }else if( loc<0 && pPage->nCell>0 ){ assert( pPage->u.hdr.rightChild==0 ); /* Must be a leaf page */ pCur->idx++; }else{ assert( pPage->u.hdr.rightChild==0 ); /* Must be a leaf page */ } insertCell(pPage, pCur->idx, &newCell, szNew); rc = balance(pCur->pBt, pPage, pCur); return rc; } /* ** Delete the entry that the cursor is pointing to. ** |
︙ | ︙ | |||
2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 | } payload[sz] = 0; printf( "cell %2d: i=%-10s chld=%-4d nk=%-3d nd=%-3d payload=%s\n", i, range, (int)pCell->h.leftChild, pCell->h.nKey, pCell->h.nData, pCell->aPayload ); idx = pCell->h.iNext; } if( idx!=0 ){ printf("ERROR: next cell index out of range: %d\n", idx); } printf("right_child: %d\n", pPage->u.hdr.rightChild); nFree = 0; | > | 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 | } payload[sz] = 0; printf( "cell %2d: i=%-10s chld=%-4d nk=%-3d nd=%-3d payload=%s\n", i, range, (int)pCell->h.leftChild, pCell->h.nKey, pCell->h.nData, pCell->aPayload ); i++; idx = pCell->h.iNext; } if( idx!=0 ){ printf("ERROR: next cell index out of range: %d\n", idx); } printf("right_child: %d\n", pPage->u.hdr.rightChild); nFree = 0; |
︙ | ︙ |
Changes to src/pager.c.
︙ | ︙ | |||
23 24 25 26 27 28 29 | ************************************************************************* ** This is the implementation of the page cache subsystem. ** ** The page cache is used to access a database file. The pager journals ** all writes in order to support rollback. Locking is used to limit ** access to one or more reader or one writer. ** | | | 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | ************************************************************************* ** This is the implementation of the page cache subsystem. ** ** The page cache is used to access a database file. The pager journals ** all writes in order to support rollback. Locking is used to limit ** access to one or more reader or one writer. ** ** @(#) $Id: pager.c,v 1.11 2001/06/24 20:39:41 drh Exp $ */ #include "sqliteInt.h" #include "pager.h" #include <fcntl.h> #include <sys/stat.h> #include <unistd.h> #include <assert.h> |
︙ | ︙ | |||
472 473 474 475 476 477 478 479 480 481 482 483 484 485 | pPager->dbSize = -1; pPager->nPage = 0; pPager->mxPage = mxPage>5 ? mxPage : 10; pPager->state = SQLITE_UNLOCK; pPager->errMask = 0; pPager->pFirst = 0; pPager->pLast = 0; memset(pPager->aHash, 0, sizeof(pPager->aHash)); *ppPager = pPager; return SQLITE_OK; } /* ** Set the destructor for this pager. If not NULL, the destructor is called | > | 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 | pPager->dbSize = -1; pPager->nPage = 0; pPager->mxPage = mxPage>5 ? mxPage : 10; pPager->state = SQLITE_UNLOCK; pPager->errMask = 0; pPager->pFirst = 0; pPager->pLast = 0; pPager->nExtra = nExtra; memset(pPager->aHash, 0, sizeof(pPager->aHash)); *ppPager = pPager; return SQLITE_OK; } /* ** Set the destructor for this pager. If not NULL, the destructor is called |
︙ | ︙ |
Added test/btree.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 | # Copyright (c) 1999, 2000 D. Richard Hipp # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public # License along with this library; if not, write to the # Free Software Foundation, Inc., 59 Temple Place - Suite 330, # Boston, MA 02111-1307, USA. # # Author contact information: # drh@hwaci.com # http://www.hwaci.com/drh/ # #*********************************************************************** # This file implements regression tests for SQLite library. The # focus of this script is btree database backend # # $Id: btree.test,v 1.1 2001/06/24 20:39:41 drh Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl if {$dbprefix!="memory:" && [info commands btree_open]!=""} { # Basic functionality. Open and close a database. # do_test btree-1.1 { file delete -force test1.bt file delete -force test1.bt-journal set rc [catch {btree_open test1.bt} ::b1] } {0} do_test btree-1.2 { set rc [catch {btree_open test1.bt} ::b2] } {0} do_test btree-1.3 { set rc [catch {btree_close $::b2} msg] lappend rc $msg } {0 {}} # Do an insert and verify that the database file grows in size. # do_test btree-1.4 { set rc [catch {btree_begin_transaction $::b1} msg] lappend rc $msg } {0 {}} do_test btree-1.5 { set rc [catch {btree_cursor $::b1 2} ::c1] if {$rc} {lappend rc $::c1} set rc } {0} do_test btree-1.6 { set rc [catch {btree_insert $::c1 one 1.00} msg] lappend rc $msg } {0 {}} do_test btree-1.7 { btree_key $::c1 } {one} do_test btree-1.8 { btree_data $::c1 } {1.00} do_test btree-1.9 { set rc [catch {btree_close_cursor $::c1} msg] lappend rc $msg } {0 {}} do_test btree-1.10 { set rc [catch {btree_commit $::b1} msg] lappend rc $msg } {0 {}} do_test btree-1.11 { file size test1.bt } {2048} # Reopen the database and attempt to read the record that we wrote. # do_test btree-2.1 { set rc [catch {btree_cursor $::b1 2} ::c1] if {$rc} {lappend rc $::c1} set rc } {0} do_test btree-2.2 { btree_move_to $::c1 abc } {1} do_test btree-2.3 { btree_move_to $::c1 xyz } {-1} do_test btree-2.4 { btree_move_to $::c1 one } {0} do_test btree-2.5 { btree_key $::c1 } {one} do_test btree-2.6 { btree_data $::c1 } {1.00} # Do some additional inserts # do_test btree-3.1 { btree_begin_transaction $::b1 btree_insert $::c1 two 2.00 btree_key $::c1 } {two} do_test btree-3.2 { btree_insert $::c1 three 3.00 btree_key $::c1 } {three} do_test btree-3.4 { btree_insert $::c1 four 4.00 btree_key $::c1 } {four} do_test btree-3.5 { btree_insert $::c1 five 5.00 btree_key $::c1 } {five} do_test btree-3.6 { btree_insert $::c1 six 6.00 btree_key $::c1 } {six} #btree_page_dump $::b1 2 do_test btree-3.7 { set rc [btree_move_to $::c1 {}] expr {$rc>0} } {1} do_test btree-3.8 { btree_key $::c1 } {five} do_test btree-3.9 { btree_data $::c1 } {5.00} do_test btree-3.10 { btree_next $::c1 btree_key $::c1 } {four} do_test btree-3.11 { btree_data $::c1 } {4.00} do_test btree-3.12 { btree_next $::c1 btree_key $::c1 } {one} do_test btree-3.13 { btree_data $::c1 } {1.00} do_test btree-3.14 { btree_next $::c1 btree_key $::c1 } {six} do_test btree-3.15 { btree_data $::c1 } {6.00} do_test btree-3.16 { btree_next $::c1 btree_key $::c1 } {three} do_test btree-3.17 { btree_data $::c1 } {3.00} do_test btree-3.18 { btree_next $::c1 btree_key $::c1 } {two} do_test btree-3.19 { btree_data $::c1 } {2.00} do_test btree-3.20 { btree_next $::c1 btree_key $::c1 } {} do_test btree-3.21 { btree_data $::c1 } {} # Commit the changes, reopen and reread the data # do_test btree-3.22 { set rc [catch {btree_close_cursor $::c1} msg] lappend rc $msg } {0 {}} do_test btree-3.23 { set rc [catch {btree_commit $::b1} msg] lappend rc $msg } {0 {}} do_test btree-3.24 { file size test1.bt } {2048} do_test btree-3.25 { set rc [catch {btree_cursor $::b1 2} ::c1] if {$rc} {lappend rc $::c1} set rc } {0} do_test btree-3.26 { set rc [btree_move_to $::c1 {}] expr {$rc>0} } {1} do_test btree-3.27 { btree_key $::c1 } {five} do_test btree-3.28 { btree_data $::c1 } {5.00} do_test btree-3.29 { btree_next $::c1 btree_key $::c1 } {four} do_test btree-3.30 { btree_data $::c1 } {4.00} do_test btree-3.31 { btree_next $::c1 btree_key $::c1 } {one} do_test btree-3.32 { btree_data $::c1 } {1.00} do_test btree-3.33 { btree_next $::c1 btree_key $::c1 } {six} do_test btree-3.34 { btree_data $::c1 } {6.00} do_test btree-3.35 { btree_next $::c1 btree_key $::c1 } {three} do_test btree-3.36 { btree_data $::c1 } {3.00} do_test btree-3.37 { btree_next $::c1 btree_key $::c1 } {two} do_test btree-3.38 { btree_data $::c1 } {2.00} do_test btree-3.39 { btree_next $::c1 btree_key $::c1 } {} do_test btree-3.40 { btree_data $::c1 } {} # Now try a delete # do_test btree-4.1 { btree_begin_transaction $::b1 btree_move_to $::c1 one btree_key $::c1 } {one} do_test btree-4.2 { btree_delete $::c1 } {} do_test btree-4.3 { btree_key $::c1 } {six} do_test btree-4.4 { btree_next $::c1 btree_key $::c1 } {six} do_test btree-4.5 { btree_next $::c1 btree_key $::c1 } {three} do_test btree-4.4 { btree_move_to $::c1 {} set r {} while 1 { set key [btree_key $::c1] if {$key==""} break lappend r $key lappend r [btree_data $::c1] btree_next $::c1 } set r } {five 5.00 four 4.00 six 6.00 three 3.00 two 2.00} # Commit and make sure the delete is still there. # do_test btree-4.5 { btree_close_cursor $::c1 btree_commit $::b1 set ::c1 [btree_cursor $::b1 2] btree_move_to $::c1 {} set r {} while 1 { set key [btree_key $::c1] if {$key==""} break lappend r $key lappend r [btree_data $::c1] btree_next $::c1 } set r } {five 5.00 four 4.00 six 6.00 three 3.00 two 2.00} do_test btree-99.1 { btree_close $::b1 } {} } ;# end if( not mem: and has pager_open command ); finish_test |
Changes to test/pager.test.
︙ | ︙ | |||
19 20 21 22 23 24 25 | # drh@hwaci.com # http://www.hwaci.com/drh/ # #*********************************************************************** # This file implements regression tests for SQLite library. The # focus of this script is page cache subsystem. # | | | | 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | # drh@hwaci.com # http://www.hwaci.com/drh/ # #*********************************************************************** # This file implements regression tests for SQLite library. The # focus of this script is page cache subsystem. # # $Id: pager.test,v 1.6 2001/06/24 20:39:41 drh Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl if {$dbprefix!="memory:" && [info commands pager_open]!=""} { # Basic sanity check. Open and close a pager. # do_test pager-1.0 { catch {file delete -force ptf1.db} catch {file delete -force ptf1.db-journal} set v [catch { |
︙ | ︙ |