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
|
# See the file LICENSE for redistribution information.
#
# Copyright (c) 1996, 1997, 1998
# Sleepycat Software. All rights reserved.
#
# @(#)test038.tcl 10.3 (Sleepycat) 10/29/98
#
# DB Test 38 {access method}
# Use the first 10,000 entries from the dictionary.
# Insert each with self as key and "ndups" duplicates
# For the data field, prepend the letters of the alphabet
# in a random order so that we force the duplicate sorting
# code to do something.
# By setting ndups large, we can make this an off-page test
# After all are entered; test the DB_GET_BOTH functionality
# first by retrieving each dup in the file explicitly. Then
# remove each duplicate and try DB_GET_BOTH again.
proc test038 { method {nentries 10000} {ndups 5} {tnum 38} args } {
global alphabet
srand 1234
set omethod $method
set method [convert_method $method]
set args [convert_args $method $args]
# Get global declarations since tcl doesn't support
# any useful equivalent to #defines!
source ./include.tcl
# Create the database and open the dictionary
set testfile test0$tnum.db
set t1 $testdir/t1
set t2 $testdir/t2
set t3 $testdir/t3
cleanup $testdir
set args [add_to_args [expr $DB_DUP | $DB_DUPSORT] $args]
puts "Test0$tnum: $method ($args) $nentries small sorted dup key/data pairs"
if { [string compare $method DB_RECNO] == 0 || \
[is_rbtree $omethod] == 1 } {
puts "Test0$tnum skipping for method $omethod"
return
}
set db [eval [concat dbopen $testfile \
[expr $DB_CREATE | $DB_TRUNCATE] 0644 $method $args]]
error_check_good dbopen [is_valid_db $db] TRUE
set did [open $dict]
set check_db [dbopen checkdb.db [expr $DB_CREATE | $DB_TRUNCATE] \
0644 DB_HASH]
error_check_good dbopen:check_db [is_valid_db $check_db] TRUE
set flags 0
set txn 0
set count 0
# Here is the loop where we put and get each key/data pair
puts "\tTest0$tnum.a: Put/get loop"
set dbc [$db cursor $txn]
error_check_good cursor_open [is_valid_widget $dbc $db.cursor] TRUE
while { [gets $did str] != -1 && $count < $nentries } {
set dups ""
for { set i 1 } { $i <= $ndups } { incr i } {
set pref [string index $alphabet [random_int 0 25]]
set pref $pref[string index $alphabet [random_int 0 25]]
while { [string first $pref $dups] != -1 } {
set pref [string toupper $pref]
if { [string first $pref $dups] != -1 } {
set pref [string index $alphabet \
[random_int 0 25]]
set pref $pref[string index $alphabet \
[random_int 0 25]]
}
}
if { [string length $dups] == 0 } {
set dups $pref
} else {
set dups "$dups $pref"
}
set datastr $pref:$str
set ret [$db put $txn $str $datastr $flags]
error_check_good put $ret 0
}
set ret [$check_db put $txn $str $dups $flags]
error_check_good checkdb_put $ret 0
# Now retrieve all the keys matching this key
set x 0
set lastdup ""
for {set ret [$dbc get $str $DB_SET]} \
{[string length $ret] != 0} \
{set ret [$dbc get 0 $DB_NEXT_DUP] } {
set k [lindex $ret 0]
if { [string compare $k $str] != 0 } {
break
}
set datastr [lindex $ret 1]
if {[string length $datastr] == 0} {
break
}
if {[string compare $lastdup $datastr] > 0} {
error_check_good sorted_dups($lastdup,$datastr)\
0 1
}
incr x
set lastdup $datastr
}
error_check_good "Test0$tnum:ndups:$str" $x $ndups
incr count
}
error_check_good cursor_close [$dbc close] 0
close $did
# Now check the duplicates, then delete then recheck
puts "\tTest0$tnum.b: Checking and Deleting duplicates"
set dbc [$db cursor $txn]
error_check_good cursor_open [is_valid_widget $dbc $db.cursor] TRUE
set check_c [$check_db cursor $txn]
error_check_good cursor_open \
[is_valid_widget $check_c $check_db.cursor] TRUE
for {set ndx 0} {$ndx < $ndups} {incr ndx} {
for {set ret [$check_c get $str $DB_FIRST]} \
{[string length $ret] != 0} \
{set ret [$check_c get 0 $DB_NEXT] } {
set k [lindex $ret 0]
set d [lindex $ret 1]
error_check_bad key_check:$k [string length $k] 0
error_check_bad data_check:$d [string length $d] 0
set nn [expr $ndx * 3]
set pref [string range $d $nn [expr $nn + 1]]
set data $pref:$k
set ret [$dbc bget $k $data $DB_GET_BOTH]
error_check_good get_both_key:$k [lindex $ret 0] $k
error_check_good get_both_data:$k [lindex $ret 1] $data
set ret [$dbc del 0]
error_check_good del $ret 0
set ret [$db bget $txn $k $data $DB_GET_BOTH]
set expected "Key $k not found."
error_check_good error_case:$k $ret $expected
if {$ndx != 0} {
set n [expr ($ndx - 1) * 3]
set pref [string range $d $n [expr $n + 1]]
set data $pref:$k
set ret [$db bget $txn $k $data $DB_GET_BOTH]
set expected "Key $k not found."
error_check_good error_case:$k $ret $expected
}
}
}
error_check_good check_c:close [$check_c close] 0
error_check_good check_db:close [$check_db close] 0
error_check_good dbc_close [$dbc close] 0
error_check_good db_close [$db close] 0
}
|
