293 lines
7.0 KiB
Plaintext
293 lines
7.0 KiB
Plaintext
# 2004 May 10
|
|
#
|
|
# 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: btree5.test,v 1.5 2004/05/14 12:17:46 drh Exp $
|
|
|
|
|
|
set testdir [file dirname $argv0]
|
|
source $testdir/tester.tcl
|
|
|
|
# Attempting to read table 1 of an empty file gives an SQLITE_EMPTY
|
|
# error.
|
|
#
|
|
do_test btree5-1.1 {
|
|
file delete -force test1.bt
|
|
file delete -force test1.bt-journal
|
|
set rc [catch {btree_open test1.bt 2000 0} ::b1]
|
|
} {0}
|
|
do_test btree5-1.2 {
|
|
set rc [catch {btree_cursor $::b1 1 0} ::c1]
|
|
} {1}
|
|
do_test btree5-1.3 {
|
|
set ::c1
|
|
} {SQLITE_EMPTY}
|
|
do_test btree5-1.4 {
|
|
set rc [catch {btree_cursor $::b1 1 1} ::c1]
|
|
} {1}
|
|
do_test btree5-1.5 {
|
|
set ::c1
|
|
} {SQLITE_EMPTY}
|
|
|
|
# Starting a transaction initializes the first page of the database
|
|
# and the error goes away.
|
|
#
|
|
do_test btree5-1.6 {
|
|
btree_begin_transaction $b1
|
|
set rc [catch {btree_cursor $b1 1 0} c1]
|
|
} {0}
|
|
do_test btree5-1.7 {
|
|
btree_first $c1
|
|
} {1}
|
|
do_test btree5-1.8 {
|
|
btree_close_cursor $c1
|
|
btree_rollback $b1
|
|
set rc [catch {btree_cursor $b1 1 0} c1]
|
|
} {1}
|
|
do_test btree5-1.9 {
|
|
set c1
|
|
} {SQLITE_EMPTY}
|
|
do_test btree5-1.10 {
|
|
btree_begin_transaction $b1
|
|
set rc [catch {btree_cursor $b1 1 0} c1]
|
|
} {0}
|
|
do_test btree5-1.11 {
|
|
btree_first $c1
|
|
} {1}
|
|
do_test btree5-1.12 {
|
|
btree_close_cursor $c1
|
|
btree_commit $b1
|
|
set rc [catch {btree_cursor $b1 1 0} c1]
|
|
} {0}
|
|
do_test btree5-1.13 {
|
|
btree_first $c1
|
|
} {1}
|
|
do_test btree5-1.14 {
|
|
btree_close_cursor $c1
|
|
btree_integrity_check $b1 1
|
|
} {}
|
|
|
|
# Insert many entries into table 1. This is designed to test the
|
|
# virtual-root logic that comes into play for page one. It is also
|
|
# a good test of INTKEY tables.
|
|
#
|
|
# Stagger the inserts. After the inserts complete, go back and do
|
|
# deletes. Stagger the deletes too. Repeat this several times.
|
|
#
|
|
|
|
# Do N inserts into table 1 using random keys between 0 and 1000000
|
|
#
|
|
proc random_inserts {N} {
|
|
global c1
|
|
while {$N>0} {
|
|
set k [expr {int(rand()*1000000)}]
|
|
if {[btree_move_to $c1 $k]==0} continue; # entry already exists
|
|
btree_insert $c1 $k data-for-$k
|
|
incr N -1
|
|
}
|
|
}
|
|
|
|
# Do N delete from table 1
|
|
#
|
|
proc random_deletes {N} {
|
|
global c1
|
|
while {$N>0} {
|
|
set k [expr {int(rand()*1000000)}]
|
|
btree_move_to $c1 $k
|
|
btree_delete $c1
|
|
incr N -1
|
|
}
|
|
}
|
|
|
|
# Make sure the table has exactly N entries. Make sure the data for
|
|
# each entry agrees with its key.
|
|
#
|
|
proc check_table {N} {
|
|
global c1
|
|
btree_first $c1
|
|
set cnt 0
|
|
while {![btree_eof $c1]} {
|
|
if {[set data [btree_data $c1]] ne "data-for-[btree_key $c1]"} {
|
|
return "wrong data for entry $cnt"
|
|
}
|
|
set n [string length $data]
|
|
set fdata1 [btree_fetch_data $c1 $n]
|
|
set fdata2 [btree_fetch_data $c1 -1]
|
|
if {$fdata1 ne "" && $fdata1 ne $data} {
|
|
return "DataFetch returned the wrong value with amt=$n"
|
|
}
|
|
if {$fdata1 ne $fdata2} {
|
|
return "DataFetch returned the wrong value when amt=-1"
|
|
}
|
|
if {$n>10} {
|
|
set fdata3 [btree_fetch_data $c1 10]
|
|
if {$fdata3 ne [string range $data 0 9]} {
|
|
return "DataFetch returned the wrong value when amt=10"
|
|
}
|
|
}
|
|
incr cnt
|
|
btree_next $c1
|
|
}
|
|
if {$cnt!=$N} {
|
|
return "wrong number of entries"
|
|
}
|
|
return {}
|
|
}
|
|
|
|
# Initialize the database
|
|
#
|
|
btree_begin_transaction $b1
|
|
set c1 [btree_cursor $b1 1 1]
|
|
set btree_trace 0
|
|
|
|
# Do the tests.
|
|
#
|
|
set cnt 0
|
|
for {set i 1} {$i<=100} {incr i} {
|
|
do_test btree5-2.$i.1 {
|
|
random_inserts 200
|
|
incr cnt 200
|
|
check_table $cnt
|
|
} {}
|
|
do_test btree5-2.$i.2 {
|
|
btree_integrity_check $b1 1
|
|
} {}
|
|
do_test btree5-2.$i.3 {
|
|
random_deletes 190
|
|
incr cnt -190
|
|
check_table $cnt
|
|
} {}
|
|
do_test btree5-2.$i.4 {
|
|
btree_integrity_check $b1 1
|
|
} {}
|
|
}
|
|
|
|
#btree_tree_dump $b1 1
|
|
btree_close_cursor $c1
|
|
btree_commit $b1
|
|
btree_begin_transaction $b1
|
|
|
|
# This procedure converts an integer into a variable-length text key.
|
|
# The conversion is reversible.
|
|
#
|
|
# The first two characters of the string are alphabetics derived from
|
|
# the least significant bits of the number. Because they are derived
|
|
# from least significant bits, the sort order of the resulting string
|
|
# is different from numeric order. After the alphabetic prefix comes
|
|
# the original number. A variable-length suffix follows. The length
|
|
# of the suffix is based on a hash of the original number.
|
|
#
|
|
proc num_to_key {n} {
|
|
global charset ncharset suffix
|
|
set c1 [string index $charset [expr {$n%$ncharset}]]
|
|
set c2 [string index $charset [expr {($n/$ncharset)%$ncharset}]]
|
|
set nsuf [expr {($n*211)%593}]
|
|
return $c1$c2-$n-[string range $suffix 0 $nsuf]
|
|
}
|
|
set charset {abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ}
|
|
set ncharset [string length $charset]
|
|
set suffix $charset$charset
|
|
while {[string length $suffix]<1000} {append suffix $suffix}
|
|
|
|
# This procedures extracts the original integer used to create
|
|
# a key by num_to_key
|
|
#
|
|
proc key_to_num {key} {
|
|
regexp {^..-([0-9]+)} $key all n
|
|
return $n
|
|
}
|
|
|
|
# Insert into table $tab keys corresponding to all values between
|
|
# $start and $end, inclusive.
|
|
#
|
|
proc insert_range {tab start end} {
|
|
for {set i $start} {$i<=$end} {incr i} {
|
|
btree_insert $tab [num_to_key $i] {}
|
|
}
|
|
}
|
|
|
|
# Delete from table $tab keys corresponding to all values between
|
|
# $start and $end, inclusive.
|
|
#
|
|
proc delete_range {tab start end} {
|
|
for {set i $start} {$i<=$end} {incr i} {
|
|
if {[btree_move_to $tab [num_to_key $i]]==0} {
|
|
btree_delete $tab
|
|
}
|
|
}
|
|
}
|
|
|
|
# Make sure table $tab contains exactly those keys corresponding
|
|
# to values between $start and $end
|
|
#
|
|
proc check_range {tab start end} {
|
|
btree_first $tab
|
|
while {![btree_eof $tab]} {
|
|
set key [btree_key $tab]
|
|
set i [key_to_num $key]
|
|
if {[num_to_key $i] ne $key} {
|
|
return "malformed key: $key"
|
|
}
|
|
set got($i) 1
|
|
btree_next $tab
|
|
}
|
|
set all [lsort -integer [array names got]]
|
|
if {[llength $all]!=$end+1-$start} {
|
|
return "table contains wrong number of values"
|
|
}
|
|
if {[lindex $all 0]!=$start} {
|
|
return "wrong starting value"
|
|
}
|
|
if {[lindex $all end]!=$end} {
|
|
return "wrong ending value"
|
|
}
|
|
return {}
|
|
}
|
|
|
|
# Create a zero-data table and test it out.
|
|
#
|
|
do_test btree5-3.1 {
|
|
set rc [catch {btree_create_table $b1 2} t2]
|
|
} {0}
|
|
do_test btree5-3.2 {
|
|
set rc [catch {btree_cursor $b1 $t2 1} c2]
|
|
} {0}
|
|
set start 1
|
|
set end 100
|
|
for {set i 1} {$i<=100} {incr i} {
|
|
do_test btree5-3.3.$i.1 {
|
|
insert_range $c2 $start $end
|
|
btree_integrity_check $b1 1 $t2
|
|
} {}
|
|
do_test btree5-3.3.$i.2 {
|
|
check_range $c2 $start $end
|
|
} {}
|
|
set nstart $start
|
|
incr nstart 89
|
|
do_test btree5-3.3.$i.3 {
|
|
delete_range $c2 $start $nstart
|
|
btree_integrity_check $b1 1 $t2
|
|
} {}
|
|
incr start 90
|
|
do_test btree5-3.3.$i.4 {
|
|
check_range $c2 $start $end
|
|
} {}
|
|
incr end 100
|
|
}
|
|
|
|
|
|
btree_close_cursor $c2
|
|
btree_commit $b1
|
|
btree_close $b1
|
|
|
|
finish_test
|