# 2001 September 15 # # 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 # # $Id: btree.test,v 1.38 2007/01/03 23:37:29 drh Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl ifcapable default_autovacuum { finish_test return } # 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 2000 0} ::b1] } {0} # The second element of the list returned by btree_pager_stats is the # number of pages currently checked out. We'll be checking this value # frequently during this test script, to make sure the btree library # is properly releasing the pages it checks out, and thus avoiding # page leaks. # do_test btree-1.1.1 { lindex [btree_pager_stats $::b1] 1 } {0} do_test btree-1.2 { set rc [catch {btree_open test1.bt 2000 0} ::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.4.1 { lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-1.5 { set rc [catch {btree_cursor $::b1 1 1} ::c1] if {$rc} {lappend rc $::c1} set rc } {0} do_test btree-1.6 { set rc [catch {btree_insert $::c1 100 1.00} msg] lappend rc $msg } {0 {}} do_test btree-1.7 { btree_move_to $::c1 100 btree_key $::c1 } {100} 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 } {1024} do_test btree-1.12 { lindex [btree_pager_stats $::b1] 1 } {0} # Reopen the database and attempt to read the record that we wrote. # do_test btree-2.1 { set rc [catch {btree_cursor $::b1 1 1} ::c1] if {$rc} {lappend rc $::c1} set rc } {0} do_test btree-2.2 { btree_move_to $::c1 99 } {1} do_test btree-2.3 { btree_move_to $::c1 101 } {-1} do_test btree-2.4 { btree_move_to $::c1 100 } {0} do_test btree-2.5 { btree_key $::c1 } {100} do_test btree-2.6 { btree_data $::c1 } {1.00} do_test btree-2.7 { lindex [btree_pager_stats $::b1] 1 } {1} # Do some additional inserts # do_test btree-3.1 { btree_begin_transaction $::b1 btree_insert $::c1 200 2.00 btree_move_to $::c1 200 btree_key $::c1 } {200} do_test btree-3.1.1 { lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-3.2 { btree_insert $::c1 300 3.00 btree_move_to $::c1 300 btree_key $::c1 } {300} do_test btree-3.4 { btree_insert $::c1 400 4.00 btree_move_to $::c1 400 btree_key $::c1 } {400} do_test btree-3.5 { btree_insert $::c1 500 5.00 btree_move_to $::c1 500 btree_key $::c1 } {500} do_test btree-3.6 { btree_insert $::c1 600 6.00 btree_move_to $::c1 600 btree_key $::c1 } {600} #btree_page_dump $::b1 2 do_test btree-3.7 { set rc [btree_move_to $::c1 0] expr {$rc>0} } {1} do_test btree-3.8 { btree_key $::c1 } {100} do_test btree-3.9 { btree_data $::c1 } {1.00} do_test btree-3.10 { btree_next $::c1 btree_key $::c1 } {200} do_test btree-3.11 { btree_data $::c1 } {2.00} do_test btree-3.12 { btree_next $::c1 btree_key $::c1 } {300} do_test btree-3.13 { btree_data $::c1 } {3.00} do_test btree-3.14 { btree_next $::c1 btree_key $::c1 } {400} do_test btree-3.15 { btree_data $::c1 } {4.00} do_test btree-3.16 { btree_next $::c1 btree_key $::c1 } {500} do_test btree-3.17 { btree_data $::c1 } {5.00} do_test btree-3.18 { btree_next $::c1 btree_key $::c1 } {600} do_test btree-3.19 { btree_data $::c1 } {6.00} do_test btree-3.20.1 { btree_next $::c1 btree_key $::c1 } {0} do_test btree-3.20.2 { btree_eof $::c1 } {1} # This test case used to test that one couldn't request data from an # invalid cursor. That is now an assert()ed condition. # # do_test btree-3.21 { # set rc [catch {btree_data $::c1} res] # lappend rc $res # } {1 SQLITE_INTERNAL} # 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.22.1 { lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-3.23 { set rc [catch {btree_commit $::b1} msg] lappend rc $msg } {0 {}} do_test btree-3.23.1 { lindex [btree_pager_stats $::b1] 1 } {0} do_test btree-3.24 { file size test1.bt } {1024} do_test btree-3.25 { set rc [catch {btree_cursor $::b1 1 1} ::c1] if {$rc} {lappend rc $::c1} set rc } {0} do_test btree-3.25.1 { lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-3.26 { set rc [btree_move_to $::c1 0] expr {$rc>0} } {1} do_test btree-3.27 { btree_key $::c1 } {100} do_test btree-3.28 { btree_data $::c1 } {1.00} do_test btree-3.29 { btree_next $::c1 btree_key $::c1 } {200} do_test btree-3.30 { btree_data $::c1 } {2.00} do_test btree-3.31 { btree_next $::c1 btree_key $::c1 } {300} do_test btree-3.32 { btree_data $::c1 } {3.00} do_test btree-3.33 { btree_next $::c1 btree_key $::c1 } {400} do_test btree-3.34 { btree_data $::c1 } {4.00} do_test btree-3.35 { btree_next $::c1 btree_key $::c1 } {500} do_test btree-3.36 { btree_data $::c1 } {5.00} do_test btree-3.37 { btree_next $::c1 btree_key $::c1 } {600} do_test btree-3.38 { btree_data $::c1 } {6.00} do_test btree-3.39 { btree_next $::c1 btree_key $::c1 } {0} # This test case used to test that requesting data from an invalid cursor # returned SQLITE_INTERNAL. That is now an assert()ed condition. # # do_test btree-3.40 { # set rc [catch {btree_data $::c1} res] # lappend rc $res # } {1 SQLITE_INTERNAL} do_test btree-3.41 { lindex [btree_pager_stats $::b1] 1 } {1} # Now try a delete # do_test btree-4.1 { btree_begin_transaction $::b1 btree_move_to $::c1 100 btree_key $::c1 } {100} do_test btree-4.1.1 { lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-4.2 { btree_delete $::c1 } {} do_test btree-4.3 { btree_move_to $::c1 100 btree_key $::c1 } {200} do_test btree-4.4 { btree_next $::c1 btree_key $::c1 } {300} do_test btree-4.5 { btree_next $::c1 btree_key $::c1 } {400} do_test btree-4.4 { btree_move_to $::c1 0 set r {} while 1 { set key [btree_key $::c1] if {[btree_eof $::c1]} break lappend r $key lappend r [btree_data $::c1] btree_next $::c1 } set r } {200 2.00 300 3.00 400 4.00 500 5.00 600 6.00} # Commit and make sure the delete is still there. # do_test btree-4.5 { btree_commit $::b1 btree_move_to $::c1 0 set r {} while 1 { set key [btree_key $::c1] if {[btree_eof $::c1]} break lappend r $key lappend r [btree_data $::c1] btree_next $::c1 } set r } {200 2.00 300 3.00 400 4.00 500 5.00 600 6.00} # Completely close the database and reopen it. Then check # the data again. # do_test btree-4.6 { lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-4.7 { btree_close_cursor $::c1 lindex [btree_pager_stats $::b1] 1 } {0} do_test btree-4.8 { btree_close $::b1 set ::b1 [btree_open test1.bt 2000 0] set ::c1 [btree_cursor $::b1 1 1] lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-4.9 { set r {} btree_first $::c1 while 1 { set key [btree_key $::c1] if {[btree_eof $::c1]} break lappend r $key lappend r [btree_data $::c1] btree_next $::c1 } set r } {200 2.00 300 3.00 400 4.00 500 5.00 600 6.00} # Try to read and write meta data # do_test btree-5.1 { btree_get_meta $::b1 } {0 0 0 0 0 0 0 0 0 0} do_test btree-5.2 { set rc [catch { btree_update_meta $::b1 0 1 2 3 4 5 6 7 8 9 } msg] lappend rc $msg } {1 SQLITE_ERROR} do_test btree-5.3 { btree_begin_transaction $::b1 set rc [catch { btree_update_meta $::b1 0 1 2 3 0 5 6 7 8 9 } msg] lappend rc $msg } {0 {}} do_test btree-5.4 { btree_get_meta $::b1 } {0 1 2 3 0 5 6 7 8 9} do_test btree-5.5 { btree_close_cursor $::c1 btree_rollback $::b1 btree_get_meta $::b1 } {0 0 0 0 0 0 0 0 0 0} do_test btree-5.6 { btree_begin_transaction $::b1 btree_update_meta $::b1 0 10 20 30 0 50 60 70 80 90 btree_commit $::b1 btree_get_meta $::b1 } {0 10 20 30 0 50 60 70 80 90} proc select_all {cursor} { set r {} btree_first $cursor while {![btree_eof $cursor]} { set key [btree_key $cursor] lappend r $key lappend r [btree_data $cursor] btree_next $cursor } return $r } proc select_keys {cursor} { set r {} btree_first $cursor while {![btree_eof $cursor]} { set key [btree_key $cursor] lappend r $key btree_next $cursor } return $r } # Try to create a new table in the database file # do_test btree-6.1 { set rc [catch {btree_create_table $::b1 0} msg] lappend rc $msg } {1 SQLITE_ERROR} do_test btree-6.2 { btree_begin_transaction $::b1 set ::t2 [btree_create_table $::b1 0] } {2} do_test btree-6.2.1 { lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-6.2.2 { set ::c2 [btree_cursor $::b1 $::t2 1] lindex [btree_pager_stats $::b1] 1 } {2} do_test btree-6.2.3 { btree_insert $::c2 ten 10 btree_move_to $::c2 ten btree_key $::c2 } {ten} do_test btree-6.3 { btree_commit $::b1 set ::c1 [btree_cursor $::b1 1 1] lindex [btree_pager_stats $::b1] 1 } {2} do_test btree-6.3.1 { select_all $::c1 } {200 2.00 300 3.00 400 4.00 500 5.00 600 6.00} #btree_page_dump $::b1 3 do_test btree-6.4 { select_all $::c2 } {ten 10} # Drop the new table, then create it again anew. # do_test btree-6.5 { btree_begin_transaction $::b1 } {} do_test btree-6.6 { btree_close_cursor $::c2 } {} do_test btree-6.6.1 { lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-6.7 { btree_close_cursor $::c1 btree_drop_table $::b1 $::t2 } {} do_test btree-6.7.1 { lindex [btree_get_meta $::b1] 0 } {1} do_test btree-6.8 { set ::t2 [btree_create_table $::b1 0] } {2} do_test btree-6.8.1 { lindex [btree_get_meta $::b1] 0 } {0} do_test btree-6.9 { set ::c2 [btree_cursor $::b1 $::t2 1] lindex [btree_pager_stats $::b1] 1 } {2} # This test case used to test that requesting the key from an invalid cursor # returned an empty string. But that is now an assert()ed condition. # # do_test btree-6.9.1 { # btree_move_to $::c2 {} # btree_key $::c2 # } {} # If we drop table 1 it just clears the table. Table 1 always exists. # do_test btree-6.10 { btree_close_cursor $::c2 btree_drop_table $::b1 1 set ::c2 [btree_cursor $::b1 $::t2 1] set ::c1 [btree_cursor $::b1 1 1] btree_first $::c1 btree_eof $::c1 } {1} do_test btree-6.11 { btree_commit $::b1 select_all $::c1 } {} do_test btree-6.12 { select_all $::c2 } {} do_test btree-6.13 { btree_close_cursor $::c2 lindex [btree_pager_stats $::b1] 1 } {1} # Check to see that pages defragment properly. To do this test we will # # 1. Fill the first page of table 1 with data. # 2. Delete every other entry of table 1. # 3. Insert a single entry that requires more contiguous # space than is available. # do_test btree-7.1 { btree_begin_transaction $::b1 } {} catch {unset key} catch {unset data} # Check to see that data on overflow pages work correctly. # do_test btree-8.1 { set data "*** This is a very long key " while {[string length $data]<1234} {append data $data} set ::data $data btree_insert $::c1 2020 $data } {} btree_page_dump $::b1 1 btree_page_dump $::b1 2 do_test btree-8.1.1 { lindex [btree_pager_stats $::b1] 1 } {1} #btree_pager_ref_dump $::b1 do_test btree-8.2 { btree_move_to $::c1 2020 string length [btree_data $::c1] } [string length $::data] do_test btree-8.3 { btree_data $::c1 } $::data do_test btree-8.4 { btree_delete $::c1 } {} do_test btree-8.4.1 { lindex [btree_get_meta $::b1] 0 } [expr {int(([string length $::data]-238+1019)/1020)}] do_test btree-8.4.2 { btree_integrity_check $::b1 1 2 } {} do_test btree-8.5 { set data "*** This is an even longer key " while {[string length $data]<2000} {append data $data} append data END set ::data $data btree_insert $::c1 2030 $data } {} do_test btree-8.6 { btree_move_to $::c1 2030 string length [btree_data $::c1] } [string length $::data] do_test btree-8.7 { btree_data $::c1 } $::data do_test btree-8.8 { btree_commit $::b1 btree_data $::c1 } $::data do_test btree-8.9.1 { btree_close_cursor $::c1 btree_close $::b1 set ::b1 [btree_open test1.bt 2000 0] set ::c1 [btree_cursor $::b1 1 1] btree_move_to $::c1 2030 btree_data $::c1 } $::data do_test btree-8.9.2 { btree_integrity_check $::b1 1 2 } {} do_test btree-8.10 { btree_begin_transaction $::b1 btree_delete $::c1 } {} do_test btree-8.11 { lindex [btree_get_meta $::b1] 0 } {4} # Now check out keys on overflow pages. # do_test btree-8.12.1 { set ::keyprefix "This is a long prefix to a key " while {[string length $::keyprefix]<256} {append ::keyprefix $::keyprefix} btree_close_cursor $::c1 btree_clear_table $::b1 2 lindex [btree_get_meta $::b1] 0 } {4} do_test btree-8.12.2 { btree_integrity_check $::b1 1 2 } {} do_test btree-8.12.3 { set ::c1 [btree_cursor $::b1 2 1] btree_insert $::c1 ${::keyprefix}1 1 btree_first $::c1 btree_data $::c1 } {1} do_test btree-8.13 { btree_key $::c1 } ${keyprefix}1 do_test btree-8.14 { btree_insert $::c1 ${::keyprefix}2 2 btree_insert $::c1 ${::keyprefix}3 3 btree_last $::c1 btree_key $::c1 } ${keyprefix}3 do_test btree-8.15 { btree_move_to $::c1 ${::keyprefix}2 btree_data $::c1 } {2} do_test btree-8.16 { btree_move_to $::c1 ${::keyprefix}1 btree_data $::c1 } {1} do_test btree-8.17 { btree_move_to $::c1 ${::keyprefix}3 btree_data $::c1 } {3} do_test btree-8.18 { lindex [btree_get_meta $::b1] 0 } {1} do_test btree-8.19 { btree_move_to $::c1 ${::keyprefix}2 btree_key $::c1 } ${::keyprefix}2 #btree_page_dump $::b1 2 do_test btree-8.20 { btree_delete $::c1 btree_next $::c1 btree_key $::c1 } ${::keyprefix}3 #btree_page_dump $::b1 2 do_test btree-8.21 { lindex [btree_get_meta $::b1] 0 } {2} do_test btree-8.22 { lindex [btree_pager_stats $::b1] 1 } {2} do_test btree-8.23.1 { btree_close_cursor $::c1 btree_drop_table $::b1 2 btree_integrity_check $::b1 1 } {} do_test btree-8.23.2 { btree_create_table $::b1 0 } {2} do_test btree-8.23.3 { set ::c1 [btree_cursor $::b1 2 1] lindex [btree_get_meta $::b1] 0 } {4} do_test btree-8.24 { lindex [btree_pager_stats $::b1] 1 } {2} #btree_pager_ref_dump $::b1 do_test btree-8.25 { btree_integrity_check $::b1 1 2 } {} # Check page splitting logic # do_test btree-9.1 { for {set i 1} {$i<=19} {incr i} { set key [format %03d $i] set data "*** $key *** $key *** $key *** $key ***" btree_insert $::c1 $key $data } } {} #btree_tree_dump $::b1 2 #btree_pager_ref_dump $::b1 #set pager_refinfo_enable 1 do_test btree-9.2 { btree_insert $::c1 020 {*** 020 *** 020 *** 020 *** 020 ***} select_keys $::c1 } {001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017 018 019 020} #btree_page_dump $::b1 2 #btree_pager_ref_dump $::b1 #set pager_refinfo_enable 0 # The previous "select_keys" command left the cursor pointing at the root # page. So there should only be two pages checked out. 2 (the root) and # page 1. do_test btree-9.2.1 { lindex [btree_pager_stats $::b1] 1 } {2} for {set i 1} {$i<=20} {incr i} { do_test btree-9.3.$i.1 [subst { btree_move_to $::c1 [format %03d $i] btree_key $::c1 }] [format %03d $i] do_test btree-9.3.$i.2 [subst { btree_move_to $::c1 [format %03d $i] string range \[btree_data $::c1\] 0 10 }] "*** [format %03d $i] ***" } do_test btree-9.4.1 { lindex [btree_pager_stats $::b1] 1 } {2} # Check the page joining logic. # #btree_page_dump $::b1 2 #btree_pager_ref_dump $::b1 do_test btree-9.4.2 { btree_move_to $::c1 005 btree_delete $::c1 } {} #btree_page_dump $::b1 2 for {set i 1} {$i<=19} {incr i} { if {$i==5} continue do_test btree-9.5.$i.1 [subst { btree_move_to $::c1 [format %03d $i] btree_key $::c1 }] [format %03d $i] do_test btree-9.5.$i.2 [subst { btree_move_to $::c1 [format %03d $i] string range \[btree_data $::c1\] 0 10 }] "*** [format %03d $i] ***" } #btree_pager_ref_dump $::b1 do_test btree-9.6 { btree_close_cursor $::c1 lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-9.7 { btree_integrity_check $::b1 1 2 } {} do_test btree-9.8 { btree_rollback $::b1 lindex [btree_pager_stats $::b1] 1 } {0} do_test btree-9.9 { btree_integrity_check $::b1 1 2 } {} do_test btree-9.10 { btree_close $::b1 set ::b1 [btree_open test1.bt 2000 0] btree_integrity_check $::b1 1 2 } {} # Create a tree of depth two. That is, there is a single divider entry # on the root pages and two leaf pages. Then delete the divider entry # see what happens. # do_test btree-10.1 { btree_begin_transaction $::b1 btree_clear_table $::b1 2 lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-10.2 { set ::c1 [btree_cursor $::b1 2 1] lindex [btree_pager_stats $::b1] 1 } {2} do_test btree-10.3 { for {set i 1} {$i<=30} {incr i} { set key [format %03d $i] set data "*** $key *** $key *** $key *** $key ***" btree_insert $::c1 $key $data } select_keys $::c1 } {001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030} #btree_tree_dump $::b1 2 do_test btree-10.4 { # The divider entry is 012. This is found by uncommenting the # btree_tree_dump call above and looking at the tree. If the page size # changes, this test will no longer work. btree_move_to $::c1 012 btree_delete $::c1 select_keys $::c1 } {001 002 003 004 005 006 007 008 009 010 011 013 014 015 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030} #btree_pager_ref_dump $::b1 #btree_tree_dump $::b1 2 for {set i 1} {$i<=30} {incr i} { # Check the number of unreference pages. This should be 3 in most cases, # but 2 when the cursor is pointing to the divider entry which is now 013. do_test btree-10.5.$i { btree_move_to $::c1 [format %03d $i] lindex [btree_pager_stats $::b1] 1 } [expr {$i==13?2:3}] #btree_pager_ref_dump $::b1 #btree_tree_dump $::b1 2 } # Create a tree with lots more pages # catch {unset ::data} catch {unset ::key} for {set i 31} {$i<=2000} {incr i} { do_test btree-11.1.$i.1 { set key [format %03d $i] set ::data "*** $key *** $key *** $key *** $key ***" btree_insert $::c1 $key $data btree_move_to $::c1 $key btree_key $::c1 } [format %03d $i] do_test btree-11.1.$i.2 { btree_data $::c1 } $::data set ::key [format %03d [expr {$i/2}]] if {$::key=="012"} {set ::key 013} do_test btree-11.1.$i.3 { btree_move_to $::c1 $::key btree_key $::c1 } $::key } catch {unset ::data} catch {unset ::key} # Make sure our reference count is still correct. # do_test btree-11.2 { btree_close_cursor $::c1 lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-11.3 { set ::c1 [btree_cursor $::b1 2 1] lindex [btree_pager_stats $::b1] 1 } {2} # Delete the dividers on the root page # #btree_page_dump $::b1 2 do_test btree-11.4 { btree_move_to $::c1 1667 btree_delete $::c1 btree_move_to $::c1 1667 set k [btree_key $::c1] if {$k==1666} { set k [btree_next $::c1] } btree_key $::c1 } {1668} #btree_page_dump $::b1 2 # Change the data on an intermediate node such that the node becomes overfull # and has to split. We happen to know that intermediate nodes exist on # 337, 401 and 465 by the btree_page_dumps above # catch {unset ::data} set ::data {This is going to be a very long data segment} append ::data $::data append ::data $::data do_test btree-12.1 { btree_insert $::c1 337 $::data btree_move_to $::c1 337 btree_data $::c1 } $::data do_test btree-12.2 { btree_insert $::c1 401 $::data btree_move_to $::c1 401 btree_data $::c1 } $::data do_test btree-12.3 { btree_insert $::c1 465 $::data btree_move_to $::c1 465 btree_data $::c1 } $::data do_test btree-12.4 { btree_move_to $::c1 337 btree_key $::c1 } {337} do_test btree-12.5 { btree_data $::c1 } $::data do_test btree-12.6 { btree_next $::c1 btree_key $::c1 } {338} do_test btree-12.7 { btree_move_to $::c1 464 btree_key $::c1 } {464} do_test btree-12.8 { btree_next $::c1 btree_data $::c1 } $::data do_test btree-12.9 { btree_next $::c1 btree_key $::c1 } {466} do_test btree-12.10 { btree_move_to $::c1 400 btree_key $::c1 } {400} do_test btree-12.11 { btree_next $::c1 btree_data $::c1 } $::data do_test btree-12.12 { btree_next $::c1 btree_key $::c1 } {402} # btree_commit $::b1 # btree_tree_dump $::b1 1 do_test btree-13.1 { btree_integrity_check $::b1 1 2 } {} # To Do: # # 1. Do some deletes from the 3-layer tree # 2. Commit and reopen the database # 3. Read every 15th entry and make sure it works # 4. Implement btree_sanity and put it throughout this script # do_test btree-15.98 { btree_close_cursor $::c1 lindex [btree_pager_stats $::b1] 1 } {1} do_test btree-15.99 { btree_rollback $::b1 lindex [btree_pager_stats $::b1] 1 } {0} btree_pager_ref_dump $::b1 # Miscellaneous tests. # # btree-16.1 - Check that a statement cannot be started if a transaction # is not active. # btree-16.2 - Check that it is an error to request more payload from a # btree entry than the entry contains. do_test btree-16.1 { catch {btree_begin_statement $::b1} msg set msg } SQLITE_ERROR do_test btree-16.2 { btree_begin_transaction $::b1 set ::c1 [btree_cursor $::b1 2 1] btree_insert $::c1 1 helloworld btree_close_cursor $::c1 btree_commit $::b1 } {} do_test btree-16.3 { set ::c1 [btree_cursor $::b1 2 1] btree_first $::c1 } 0 do_test btree-16.4 { catch {btree_data $::c1 [expr [btree_payload_size $::c1] + 10]} msg set msg } SQLITE_ERROR if {$tcl_platform(platform)=="unix"} { do_test btree-16.5 { btree_close $::b1 set ::origperm [file attributes test1.bt -permissions] file attributes test1.bt -permissions o-w,g-w,a-w set ::b1 [btree_open test1.bt 2000 0] catch {btree_cursor $::b1 2 1} msg file attributes test1.bt -permissions $::origperm btree_close $::b1 set ::b1 [btree_open test1.bt 2000 0] set msg } {SQLITE_READONLY} } do_test btree-16.6 { set ::c1 [btree_cursor $::b1 2 1] set ::c2 [btree_cursor $::b1 2 1] btree_begin_transaction $::b1 for {set i 0} {$i<100} {incr i} { btree_insert $::c1 $i [string repeat helloworld 10] } btree_last $::c2 btree_insert $::c1 100 [string repeat helloworld 10] } {} do_test btree-16.7 { btree_close_cursor $::c1 btree_close_cursor $::c2 btree_commit $::b1 set ::c1 [btree_cursor $::b1 2 1] catch {btree_insert $::c1 101 helloworld} msg set msg } {SQLITE_ERROR} do_test btree-16.8 { btree_first $::c1 catch {btree_delete $::c1} msg set msg } {SQLITE_ERROR} do_test btree-16.9 { btree_close_cursor $::c1 btree_begin_transaction $::b1 set ::c1 [btree_cursor $::b1 2 0] catch {btree_insert $::c1 101 helloworld} msg set msg } {SQLITE_PERM} do_test btree-16.10 { catch {btree_delete $::c1} msg set msg } {SQLITE_PERM} # As of 2006-08-16 (version 3.3.7+) a read cursor will no # longer block a write cursor from the same database # connectiin. The following three tests uses to return # the SQLITE_LOCK error, but no more. # do_test btree-16.11 { btree_close_cursor $::c1 set ::c2 [btree_cursor $::b1 2 1] set ::c1 [btree_cursor $::b1 2 0] catch {btree_insert $::c2 101 helloworld} msg set msg } {} do_test btree-16.12 { btree_first $::c2 catch {btree_delete $::c2} msg set msg } {} do_test btree-16.13 { catch {btree_clear_table $::b1 2} msg set msg } {} do_test btree-16.14 { btree_close_cursor $::c1 btree_close_cursor $::c2 btree_commit $::b1 catch {btree_clear_table $::b1 2} msg set msg } {SQLITE_ERROR} do_test btree-16.15 { catch {btree_drop_table $::b1 2} msg set msg } {SQLITE_ERROR} do_test btree-16.16 { btree_begin_transaction $::b1 set ::c1 [btree_cursor $::b1 2 0] catch {btree_drop_table $::b1 2} msg set msg } {SQLITE_LOCKED} do_test btree-99.1 { btree_close $::b1 } {} catch {unset data} catch {unset key} finish_test