-C The\sbtree.test\stest\sis\sno\sworking\swith\sintegrity_check\senabled.\s(CVS\s1330)
-D 2004-05-09T11:51:39
+C More\sbtree.c\sbug\sfixing.\s\sIt's\sgetting\scloser\sbut\sstill\snot\sthere\syet.\nMove\sobsolete\stest\sscripts\sinto\sthe\sattic.\s(CVS\s1331)
+D 2004-05-09T20:40:11
F Makefile.in ab7b0d5118e2da97bac66be8684a1034e3500f5a
F Makefile.linux-gcc b86a99c493a5bfb402d1d9178dcdc4bd4b32f906
F README f1de682fbbd94899d50aca13d387d1b3fd3be2dd
F sqlite.pc.in 30552343140c53304c2a658c080fbe810cd09ca2
F src/attach.c fa9a58234406d84eeb900517d0c0adc4b2da051a
F src/auth.c a2a46e3ed7799134cf3d2dd5ae6650115f26b653
-F src/btree.c c1251660eaefaf3b11798c8891c90f5412f7ecae
+F src/btree.c b4c04b7867ccabaa1b04d5691a1bc6d0a27e6c6b
F src/btree.h 825034a68947baf99507f04f318f417013dcd3a3
F src/btree_rb.c 47e5b5ec90846af392b5668b34648198ba459561
F src/build.c 21b6645c966970dac51bcccfa8650403a3f56210
F src/tclsqlite.c 21147148e7b57a0bb7409cff5878c60470df9acc
F src/test1.c 67a72fa1f5f6d41c838fa97f324f8dbfb4051413
F src/test2.c 8dab493c7eccd2c7bb93a8e31f7db60f14e61b7b
-F src/test3.c a97fcd77f25218cd7dc4ca1a2956d303387cc6d2
+F src/test3.c d6d9d943de0926688fed4c4f5f5b345afda1ba73
F src/test4.c 92d2a10380a65d61e5527a556f604bfde16411e8
F src/test5.c eb39aac8fed61bd930b92613cd705c145244074a
F src/tokenize.c 256a3cf0ff938cd79774d7f95173d74281912df9
F test/bigrow.test 8ab252dba108f12ad64e337b0f2ff31a807ac578
F test/bind.test 56a57043b42c4664ca705f6050e56717a8a6699a
F test/btree.test ed5781db83b6c1de02e62781d44915a9abe3450a
-F test/btree2.test 2ff77e0218e5f55ff5a85874f3e15c7859e3ac26
-F test/btree3.test e597fb59be2ac0ea69c62aaa2064e998e528b665
-F test/btree3rb.test 127efcf5cdfcc352054e7db12622b01cdd8b36ac
-F test/btree4.test fa955a3d7a8bc91d6084b7f494f9e5d1bdfb15b6
-F test/btree4rb.test ae6f0438512edcb45cf483471cd6070a765963a9
+F test/btree2.test aed860c48f873f1678a94786bc1e6eab09a0419b
+F test/btree4.test 3797b4305694c7af6828675b0f4b1424b8ca30e4
F test/capi2.test ec96e0e235d87b53cbaef3d8e3e0f8ccf32c71ca
F test/conflict.test 0911bb2f079046914a6e9c3341b36658c4e2103e
F test/copy.test f07ea8d60878da7a67416ab62f78e9706b9d3c45
F www/tclsqlite.tcl b9271d44dcf147a93c98f8ecf28c927307abd6da
F www/vdbe.tcl 9b9095d4495f37697fd1935d10e14c6015e80aa1
F www/whentouse.tcl a8335bce47cc2fddb07f19052cb0cb4d9129a8e4
-P 499569daa6a3aed6609bcb1e11a3d231e13f4f9c
-R b0518d68837036ab90f8b4f001412933
+P 9f1caa530e69aaf202debac36b6a46d707f362d7
+R 18442ae74dd8b81b683a8a5bfb177026
U drh
-Z 029dd36060965161aaa7a2d625e23da4
+Z 472c41ca52356c30cd6f2f2fdbf61b10
-9f1caa530e69aaf202debac36b6a46d707f362d7
\ No newline at end of file
+9379c7c9cf8b0770a0c8d1feb5ffdba342173589
\ No newline at end of file
** May you share freely, never taking more than you give.
**
*************************************************************************
-** $Id: btree.c,v 1.119 2004/05/09 11:51:39 drh Exp $
+** $Id: btree.c,v 1.120 2004/05/09 20:40:11 drh Exp $
**
** This file implements a external (disk-based) database using BTrees.
** For a detailed discussion of BTrees, refer to
pBt->pPage1 = 0;
pBt->readOnly = sqlite3pager_isreadonly(pBt->pPager);
pBt->pageSize = SQLITE_PAGE_SIZE; /* FIX ME - read from header */
- pBt->maxLocal = (pBt->pageSize-10)/4-12;
+
+ /* maxLocal is the maximum amount of payload to store locally for
+ ** a cell. Make sure it is small enough so that at least MN_CELLS_PER_PAGE
+ ** will fit on one page. We assume a 10-byte page header. Besides
+ ** the payload, the cell must store:
+ ** 2-byte pointer to next cell
+ ** 4-byte child pointer
+ ** 9-byte nKey value
+ ** 4-byte nData value
+ ** 4-byte overflow page pointer
+ */
+ pBt->maxLocal = (pBt->pageSize-10)/MN_CELLS_PER_PAGE - 23;
+ assert( pBt->maxLocal + 23 <= MX_CELL_SIZE );
*ppBtree = pBt;
return SQLITE_OK;
}
return rc;
}
+/*
+** The TRACE macro will print high-level status information about the
+** btree operation when the global variable sqlite3_btree_trace is
+** enabled.
+*/
+#if SQLITE_TEST
+# define TRACE(X) if( sqlite3_btree_trace ){ printf X; fflush(stdout); }
+#else
+# define TRACE(X)
+#endif
+int sqlite3_btree_trace=0; /* True to enable tracing */
+
/*
** Allocate a new page from the database file.
**
*pPgno = get4byte(&pPage1->aData[32]);
memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
*ppPage = pTrunk;
+ TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
}else{
/* Extract a leaf from the trunk */
int closest;
closest = 0;
dist = get4byte(&aData[8]) - nearby;
if( dist<0 ) dist = -dist;
- for(i=1; i<n; i++){
+ for(i=1; i<k; i++){
int d2 = get4byte(&aData[8+i*4]) - nearby;
if( d2<0 ) d2 = -d2;
if( d2<dist ) closest = i;
}else{
closest = 0;
}
- put4byte(&aData[4], n-1);
*pPgno = get4byte(&aData[8+closest*4]);
+ TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d: %d more free pages\n",
+ *pPgno, closest+1, k, pTrunk->pgno, n-1));
if( closest<k-1 ){
memcpy(&aData[8+closest*4], &aData[4+k*4], 4);
}
- put4byte(&pTrunk->aData[4], k-1);
+ put4byte(&aData[4], k-1);
rc = getPage(pBt, *pPgno, ppPage);
releasePage(pTrunk);
if( rc==SQLITE_OK ){
rc = getPage(pBt, *pPgno, ppPage);
if( rc ) return rc;
rc = sqlite3pager_write((*ppPage)->aData);
+ TRACE(("ALLOCATE: %d from end of file\n", *pPgno));
}
return rc;
}
if( rc ) return rc;
memset(pPage->aData, 0, 8);
put4byte(&pPage1->aData[32], pPage->pgno);
+ TRACE(("FREE-PAGE: %d first\n", pPage->pgno));
}else{
/* Other free pages already exist. Retrive the first trunk page
** of the freelist and find out how many leaves it has. */
put4byte(pPage->aData, pTrunk->pgno);
put4byte(&pPage->aData[4], 0);
put4byte(&pPage1->aData[32], pPage->pgno);
+ TRACE(("FREE-PAGE: %d new trunk page replacing %d\n",
+ pPage->pgno, pTrunk->pgno));
}else{
/* Add the newly freed page as a leaf on the current trunk */
rc = sqlite3pager_write(pTrunk->aData);
put4byte(&pTrunk->aData[4], k+1);
put4byte(&pTrunk->aData[8+k*4], pPage->pgno);
sqlite3pager_dont_write(pBt->pPager, pPage->pgno);
+ TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
}
releasePage(pTrunk);
}
assert( sz==cellSize(pPage, pPage->aCell[idx]) );
assert( sqlite3pager_iswriteable(pPage->aData) );
assert( pPage->aCell[idx]>=pPage->aData );
- assert( pPage->aCell[idx]<&pPage->aData[pPage->pBt->pageSize-sz] );
+ assert( pPage->aCell[idx]<=&pPage->aData[pPage->pBt->pageSize-sz] );
data = pPage->aData;
pc = Addr(pPage->aCell[idx]) - Addr(data);
assert( pc>pPage->hdrOffset && pc+sz<=pPage->pBt->pageSize );
int ofst;
assert( pTo->hdrOffset==0 );
+ assert( pFrom->isInit );
ofst = pFrom->hdrOffset;
pageSize = pFrom->pBt->pageSize;
sqliteFree(pTo->aCell);
}
}
-/*
-** For debugging...
-*/
-#if 1
-# define TRACE(X) if( pager3_refinfo_enable ) printf X
-#else
-# define TRACE(X)
-#endif
-
/*
** The following parameters determine how many adjacent pages get involved
** in a balancing operation. NN is the number of neighbors on either side
** Return without doing any work if pPage is neither overfull nor
** underfull.
*/
+ assert( pPage->isInit );
assert( sqlite3pager_iswriteable(pPage->aData) );
pBt = pPage->pBt;
if( !pPage->isOverfull && pPage->nFree<pBt->pageSize/2 && pPage->nCell>=2){
** it means this page is the root page and special rules apply.
*/
pParent = pPage->pParent;
- TRACE(("BALANCE: begin page %d\n", pPage->pgno));
if( pParent==0 ){
Pgno pgnoChild;
MemPage *pChild;
if( pPage->leaf ){
/* The table is completely empty */
relinkCellList(pPage);
- TRACE(("BALANCE: empty table\n"));
+ TRACE(("BALANCE: empty table %d\n", pPage->pgno));
}else{
/* The root page is empty but has one child. Transfer the
** information from that one child into the root page if it
- ** will fit. This reduces the depth of the BTree by one.
+ ** will fit. This reduces the depth of the tree by one.
**
** If the root page is page 1, it has less space available than
** its child (due to the 100 byte header that occurs at the beginning
TRACE(("BALANCE: child %d will not fit on page 1\n", pChild->pgno));
}
}else{
- memcpy(pPage, pChild, pBt->pageSize);
+ memcpy(pPage->aData, pChild->aData, pBt->pageSize);
pPage->isInit = 0;
pPage->pParent = 0;
rc = initPage(pPage, 0);
assert( rc==SQLITE_OK );
freePage(pChild);
- TRACE(("BALANCE: transfer child %d into root\n", pChild->pgno));
+ TRACE(("BALANCE: transfer child %d into root %d\n",
+ pChild->pgno, pPage->pgno));
}
reparentChildPages(pPage);
releasePage(pChild);
/* It is OK for the root page to be less than half full.
*/
relinkCellList(pPage);
- TRACE(("BALANCE: Root page is underfull but that is ok\n"));
+ TRACE(("BALANCE: root page %d is low - no changes\n", pPage->pgno));
return SQLITE_OK;
}
/*
pParent = pPage;
pPage = pChild;
extraUnref = pChild;
- TRACE(("BALANCE: Copy root into %d and blance\n", pPage->pgno));
+ TRACE(("BALANCE: copy root %d into %d and balance %d\n",
+ pParent->pgno, pPage->pgno, pPage->pgno));
+ }else{
+ TRACE(("BALANCE: begin page %d child of %d\n",
+ pPage->pgno, pParent->pgno));
}
rc = sqlite3pager_write(pParent->aData);
if( rc ) return rc;
reparentChildPages(pParent);
/*
- ** balance the parent page.
+ ** Balance the parent page. Note that the current page (pPage) might
+ ** have been added to the freelist is it might no longer be initialized.
+ ** But the parent page will always be initialized.
*/
- assert( pPage->isInit );
assert( pParent->isInit );
- pageIntegrity(pPage);
+ /* assert( pPage->isInit ); // No! pPage might have been added to freelist */
+ /* pageIntegrity(pPage); // No! pPage might have been added to freelist */
rc = balance(pParent);
-
/*
** Cleanup before returning.
*/
}
releasePage(pParent);
releasePage(extraUnref);
- TRACE(("BALANCE: Finished with %d\n", pPage->pgno));
+ TRACE(("BALANCE: finished with %d: old=%d new=%d cells=%d\n",
+ pPage->pgno, nOld, nNew, nCell));
return rc;
}
rc = sqlite3BtreeMoveto(pCur, pKey, nKey, &loc);
if( rc ) return rc;
pPage = pCur->pPage;
+ TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
+ pCur->pgnoRoot, nKey, nData, pPage->pgno,
+ loc==0 ? "overwrite" : "new entry"));
assert( pPage->isInit );
rc = sqlite3pager_write(pPage->aData);
if( rc ) return rc;
rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, &szNew);
if( rc ) return rc;
assert( szNew==cellSize(pPage, newCell) );
+ assert( szNew<=sizeof(newCell) );
if( loc==0 ){
int szOld;
assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
}
rc = sqlite3pager_write(leafCur.pPage->aData);
if( rc ) return rc;
+ TRACE(("DELETE: table=%d delete internal from %d replace from leaf %d\n",
+ pCur->pgnoRoot, pPage->pgno, leafCur.pPage->pgno));
dropCell(pPage, pCur->idx, cellSize(pPage, pCell));
pNext = leafCur.pPage->aCell[leafCur.idx];
szNext = cellSize(leafCur.pPage, pNext);
rc = balance(leafCur.pPage);
releaseTempCursor(&leafCur);
}else{
+ TRACE(("DELETE: table=%d delete from leaf %d\n",
+ pCur->pgnoRoot, pPage->pgno));
dropCell(pPage, pCur->idx, cellSize(pPage, pCell));
rc = balance(pPage);
}
if( freePageFlag ){
rc = freePage(pPage);
}else{
- zeroPage(pPage, pPage->aData[0]);
+ zeroPage(pPage, pPage->aData[0] | PTF_LEAF);
}
releasePage(pPage);
return rc;
char *zContext /* Context for error messages */
){
int i;
+ int expected = N;
+ int iFirst = iPage;
char zMsg[100];
while( N-- > 0 ){
unsigned char *pOvfl;
if( iPage<1 ){
- sprintf(zMsg, "%d pages missing from overflow list", N+1);
+ sprintf(zMsg, "%d of %d pages missing from overflow list starting at %d",
+ N+1, expected, iFirst);
checkAppendMsg(pCheck, zContext, zMsg);
break;
}
pageSize = pBt->pageSize;
if( iPage==0 ) return 0;
if( checkRef(pCheck, iPage, zParentContext) ) return 0;
- sprintf(zContext, "On tree page %d: ", iPage);
if( (rc = getPage(pBt, (Pgno)iPage, &pPage))!=0 ){
sprintf(zMsg, "unable to get the page. error code=%d", rc);
checkAppendMsg(pCheck, zContext, zMsg);
/* Check payload overflow pages
*/
+ sprintf(zContext, "On tree page %d cell %d: ", iPage, i);
parseCellHeader(pPage, pCell, &nData, &nKey, &nHeader);
sz = nData;
if( !pPage->intKey ) sz += nKey;
** is not included in the SQLite library. It is used for automated
** testing of the SQLite library.
**
-** $Id: test3.c,v 1.32 2004/05/09 00:40:52 drh Exp $
+** $Id: test3.c,v 1.33 2004/05/09 20:40:11 drh Exp $
*/
#include "sqliteInt.h"
#include "pager.h"
** Register commands with the TCL interpreter.
*/
int Sqlitetest3_Init(Tcl_Interp *interp){
+ extern int sqlite3_btree_trace;
static struct {
char *zName;
Tcl_CmdProc *xProc;
}
Tcl_LinkVar(interp, "pager_refinfo_enable", (char*)&pager3_refinfo_enable,
TCL_LINK_INT);
+ Tcl_LinkVar(interp, "btree_trace", (char*)&sqlite3_btree_trace,
+ TCL_LINK_INT);
return TCL_OK;
}
# This file implements regression tests for SQLite library. The
# focus of this script is btree database backend
#
-# $Id: btree2.test,v 1.11 2004/05/09 00:40:52 drh Exp $
+# $Id: btree2.test,v 1.12 2004/05/09 20:40:11 drh Exp $
set testdir [file dirname $argv0]
expr srand(1)
file delete -force test2.bt
file delete -force test2.bt-journal
- set ::b [btree_open test2.bt]
+ set ::b [btree_open test2.bt 2000 0]
btree_begin_transaction $::b
- btree_create_table $::b
-} {3}
+ btree_create_table $::b 0
+} {2}
do_test btree2-1.2 {
- btree_create_table $::b
-} {4}
+ btree_create_table $::b 0
+} {3}
do_test btree2-1.3 {
- btree_create_table $::b
-} {5}
+ btree_create_table $::b 0
+} {4}
do_test btree2-1.4 {
- btree_create_table $::b
-} {6}
+ btree_create_table $::b 0
+} {5}
do_test btree2-1.5 {
+ btree_create_table $::b 0
+} {6}
+do_test btree2-1.6 {
set ::c2 [btree_cursor $::b 2 1]
btree_insert $::c2 {one} {1}
+ btree_move_to $::c2 {one}
btree_delete $::c2
btree_close_cursor $::c2
btree_commit $::b
- btree_integrity_check $::b 2 3 4 5 6
+ btree_integrity_check $::b 1 2 3 4 5 6
} {}
# This test module works by making lots of pseudo-random changes to a
# success or an error message if something is amiss.
#
proc check_invariants {} {
- set ck [btree_integrity_check $::b 2 3 4 5 6]
+ set ck [btree_integrity_check $::b 1 2 3 4 5 6]
if {$ck!=""} {
puts "\n*** SANITY:\n$ck"
exit
#
set chngcnt 0
proc random_changes {n I K D} {
+ global chngcnt
btree_move_to $::c2 N
set N [btree_data $::c2]
btree_move_to $::c2 L
set insert [expr {rand()<=$I}]
set longkey [expr {rand()<=$K}]
set longdata [expr {rand()<=$D}]
- # incr ::chngcnt
- # if {$::chngcnt==251} {btree_tree_dump $::b 3}
- # puts "CHANGE $::chngcnt: $k $insert $longkey $longdata"
if {$longkey} {
set x [expr {rand()}]
set keylen [expr {int($x*$x*$x*$x*3000)+10}]
if {$kx==$k} {
btree_delete $::c4
}
+ # For debugging - change the "0" to "1" to integrity check after
+ # every change.
+ if 0 {
+ incr chngcnt
+ puts check----$chngcnt
+ set ck [btree_integrity_check $::b 1 2 3 4 5 6]
+ if {$ck!=""} {
+ puts "\nSANITY CHECK FAILED!\n$ck"
+ exit
+ }
+ }
if {$insert} {
btree_insert $::c3 $key $data
} else {
} elseif {[btree_move_to $::c6 $basekey]==0} {
btree_delete $::c6
}
- # set ck [btree_integrity_check $::b 2 3 4 5 6]
- # if {$ck!=""} {
- # puts "\nSANITY CHECK FAILED!\n$ck"
- # exit
- # }
- # puts "PAGE 3:"; btree_page_dump $::b 3
- # puts "PAGE 4:"; btree_page_dump $::b 4
+ # For debugging - change the "0" to "1" to integrity check after
+ # every change.
+ if 0 {
+ incr chngcnt
+ puts check----$chngcnt
+ set ck [btree_integrity_check $::b 1 2 3 4 5 6]
+ if {$ck!=""} {
+ puts "\nSANITY CHECK FAILED!\n$ck"
+ exit
+ }
+ }
}
}
do_test btree2-$testno.7 {
btree_close $::b
} {}
-after 100
+
# For each database size, run various changes tests.
#
set num2 1
set testid btree2-$testno.8.$num2
set hash [md5file test2.bt]
do_test $testid.0 {
- set ::b [btree_open test2.bt]
+ set ::b [btree_open test2.bt 2000 0]
set ::c2 [btree_cursor $::b 2 1]
set ::c3 [btree_cursor $::b 3 1]
set ::c4 [btree_cursor $::b 4 1]
btree_begin_transaction $::b
lindex [btree_pager_stats $::b] 1
} $cnt
- # exec cp test2.bt test2.bt.bu1
do_test $testid.2 [subst {
random_changes $n $I $K $D
}] {}
btree_rollback $::b
md5file test2.bt
} $hash
- # exec cp test2.bt test2.bt.bu2
btree_begin_transaction $::b
set ::c2 [btree_cursor $::b 2 1]
set ::c3 [btree_cursor $::b 3 1]
set ::c4 [btree_cursor $::b 4 1]
set ::c5 [btree_cursor $::b 5 1]
set ::c6 [btree_cursor $::b 6 1]
+#if {$testid=="btree2-3.8.4"} {set btree_trace 1}
do_test $testid.5 [subst {
random_changes $n $I $K $D
}] {}
} {0}
do_test $testid.9 {
btree_close $::b
- set ::b [btree_open test2.bt]
+ set ::b [btree_open test2.bt 2000 0]
set ::c2 [btree_cursor $::b 2 1]
set ::c3 [btree_cursor $::b 3 1]
set ::c4 [btree_cursor $::b 4 1]
incr num2
}
incr testno
- set ::b [btree_open test2.bt]
+ set ::b [btree_open test2.bt 2000 0]
}
# Testing is complete. Shut everything down.
+++ /dev/null
-# 2001 November 22
-#
-# The author disclaims copyright to this source code. In place of
-# a legal notice, here is a blessing:
-#
-# May you do good and not evil.
-# May you find forgiveness for yourself and forgive others.
-# May you share freely, never taking more than you give.
-#
-#***********************************************************************
-# This file implements regression tests for SQLite library. The
-# focus of this script is btree database backend
-#
-# In particular, this file tests a small part of the Delete logic
-# for the BTree backend. When a row is deleted from a table, the
-# cursor is suppose to be left pointing at either the previous or
-# next entry in that table. If the cursor is left pointing at the
-# next entry, then the next Next operation is ignored. So the
-# sequence of operations (Delete, Next) should always leave the
-# cursor pointing at the first entry past the one that was deleted.
-# This test is designed to verify that behavior.
-#
-# $Id: btree3.test,v 1.2 2002/12/04 13:40:27 drh Exp $
-
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-
-if {[info commands btree_open]!=""} {
-
-# Open a test database.
-#
-file delete -force test1.bt
-file delete -force test1.bt-journal
-set b1 [btree_open test1.bt]
-btree_begin_transaction $::b1
-
-# Insert a few one records
-#
-set data {abcdefghijklmnopqrstuvwxyz0123456789}
-append data $data
-append data $data
-append data $data
-append data $data
-for {set k 2} {$k<=10} {incr k} {
- for {set j 1} {$j<=$k} {incr j} {
- set jkey [format %02d $j]
- btree_clear_table $::b1 2
- set ::c1 [btree_cursor $::b1 2 1]
- for {set i 1} {$i<=$k} {incr i} {
- set key [format %02d $i]
- do_test btree3-$k.$j.1.$i {
- btree_insert $::c1 $::key $::data
- } {}
- # btree_tree_dump $::b1 2
- }
- do_test btree3-$k.$j.2 {
- btree_move_to $::c1 $::jkey
- btree_key $::c1
- } $::jkey
- do_test btree3-$k.$j.3 {
- btree_delete $::c1
- } {}
- if {$j<$k} {
- do_test btree3-$k.$j.4 {
- btree_next $::c1
- btree_key $::c1
- } [format %02d [expr $j+1]]
- }
- if {$j>1} {
- do_test btree3-$k.$j.5 {
- btree_prev $::c1
- btree_key $::c1
- } [format %02d [expr $j-1]]
- }
- btree_close_cursor $::c1
- }
-}
-
-btree_rollback $::b1
-btree_pager_ref_dump $::b1
-btree_close $::b1
-
-} ;# end if( not mem: and has pager_open command );
-
-finish_test
+++ /dev/null
-# 2001 November 22
-#
-# The author disclaims copyright to this source code. In place of
-# a legal notice, here is a blessing:
-#
-# May you do good and not evil.
-# May you find forgiveness for yourself and forgive others.
-# May you share freely, never taking more than you give.
-#
-#***********************************************************************
-# This file implements regression tests for SQLite library. The
-# focus of this script is btree database backend
-#
-# In particular, this file tests a small part of the Delete logic
-# for the BTree backend. When a row is deleted from a table, the
-# cursor is suppose to be left pointing at either the previous or
-# next entry in that table. If the cursor is left pointing at the
-# next entry, then the next Next operation is ignored. So the
-# sequence of operations (Delete, Next) should always leave the
-# cursor pointing at the first entry past the one that was deleted.
-# This test is designed to verify that behavior.
-#
-# $Id: btree3rb.test,v 1.1 2003/04/20 23:45:23 drh Exp $
-
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-
-if {[info commands btree_open]!=""} {
-
-# Open a test database.
-#
-set b1 [btree_open :memory:]
-btree_begin_transaction $::b1
-
-# Insert a few one records
-#
-set data {abcdefghijklmnopqrstuvwxyz0123456789}
-append data $data
-append data $data
-append data $data
-append data $data
-for {set k 2} {$k<=20} {incr k} {
- for {set j 1} {$j<=$k} {incr j} {
- set jkey [format %02d $j]
- btree_clear_table $::b1 2
- set ::c1 [btree_cursor $::b1 2 1]
- for {set i 1} {$i<=$k} {incr i} {
- set key [format %02d $i]
- do_test btree3rb-$k.$j.1.$i {
- btree_insert $::c1 $::key $::data
- } {}
- # btree_tree_dump $::b1 2
- }
- do_test btree3rb-$k.$j.2 {
- btree_move_to $::c1 $::jkey
- btree_key $::c1
- } $::jkey
- do_test btree3rb-$k.$j.3 {
- btree_delete $::c1
- } {}
- if {$j<$k} {
- do_test btree3rb-$k.$j.4 {
- btree_next $::c1
- btree_key $::c1
- } [format %02d [expr $j+1]]
- }
- if {$j>1} {
- do_test btree3rb-$k.$j.5 {
- btree_prev $::c1
- btree_key $::c1
- } [format %02d [expr $j-1]]
- }
- btree_close_cursor $::c1
- }
-}
-
-btree_rollback $::b1
-#btree_pager_ref_dump $::b1
-btree_close $::b1
-
-} ;# end if( not mem: and has pager_open command );
-
-finish_test
# sqliteBtreePrevious() procedures and making sure they are able
# to step through an entire table from either direction.
#
-# $Id: btree4.test,v 1.1 2002/12/04 13:40:27 drh Exp $
+# $Id: btree4.test,v 1.2 2004/05/09 20:40:12 drh Exp $
set testdir [file dirname $argv0]
#
file delete -force test1.bt
file delete -force test1.bt-journal
-set b1 [btree_open test1.bt]
-btree_begin_transaction $::b1
+set b1 [btree_open test1.bt 2000 0]
+btree_begin_transaction $b1
+do_test btree4-0.1 {
+ btree_create_table $b1 0
+} 2
set data {abcdefghijklmnopqrstuvwxyz0123456789}
append data $data
+++ /dev/null
-# 2002 December 03
-#
-# The author disclaims copyright to this source code. In place of
-# a legal notice, here is a blessing:
-#
-# May you do good and not evil.
-# May you find forgiveness for yourself and forgive others.
-# May you share freely, never taking more than you give.
-#
-#***********************************************************************
-# This file implements regression tests for SQLite library. The
-# focus of this script is btree database backend
-#
-# This file focuses on testing the sqliteBtreeNext() and
-# sqliteBtreePrevious() procedures and making sure they are able
-# to step through an entire table from either direction.
-#
-# $Id: btree4rb.test,v 1.1 2003/04/20 23:45:23 drh Exp $
-
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-
-if {[info commands btree_open]!=""} {
-
-# Open a test database.
-#
-set b1 [btree_open :memory:]
-btree_begin_transaction $::b1
-
-set data {abcdefghijklmnopqrstuvwxyz0123456789}
-append data $data
-append data $data
-append data $data
-append data $data
-
-foreach N {10 100 1000} {
- btree_clear_table $::b1 2
- set ::c1 [btree_cursor $::b1 2 1]
- do_test btree4rb-$N.1 {
- for {set i 1} {$i<=$N} {incr i} {
- btree_insert $::c1 [format k-%05d $i] $::data-$i
- }
- btree_first $::c1
- btree_key $::c1
- } {k-00001}
- do_test btree4rb-$N.2 {
- btree_data $::c1
- } $::data-1
- for {set i 2} {$i<=$N} {incr i} {
- do_test btree-$N.3.$i.1 {
- btree_next $::c1
- } 0
- do_test btree-$N.3.$i.2 {
- btree_key $::c1
- } [format k-%05d $i]
- do_test btree-$N.3.$i.3 {
- btree_data $::c1
- } $::data-$i
- }
- do_test btree4rb-$N.4 {
- btree_next $::c1
- } 1
- do_test btree4rb-$N.5 {
- btree_last $::c1
- } 0
- do_test btree4rb-$N.6 {
- btree_key $::c1
- } [format k-%05d $N]
- do_test btree4rb-$N.7 {
- btree_data $::c1
- } $::data-$N
- for {set i [expr {$N-1}]} {$i>=1} {incr i -1} {
- do_test btree4rb-$N.8.$i.1 {
- btree_prev $::c1
- } 0
- do_test btree4rb-$N.8.$i.2 {
- btree_key $::c1
- } [format k-%05d $i]
- do_test btree4rb-$N.8.$i.3 {
- btree_data $::c1
- } $::data-$i
- }
- do_test btree4rb-$N.9 {
- btree_prev $::c1
- } 1
- btree_close_cursor $::c1
-}
-
-btree_rollback $::b1
-btree_close $::b1
-
-} ;# end if( not mem: and has pager_open command );
-
-finish_test
projects / thirdparty / sqlite.git / commitdiff
