Debian Codegraph @

lang/perl/BerkeleyDB/t/btree.t

raw
1 #!./perl -w
2
3 use strict ;
4
5 use lib 't';
6 use BerkeleyDB;
7 use util ;
8 use Test::More;
9
10 plan tests => 250;
11
12 my $Dfile = "dbhash.tmp";
13 my $Dfile2 = "dbhash2.tmp";
14 my $Dfile3 = "dbhash3.tmp";
15 unlink $Dfile;
16
17 umask(0) ;
18
19
20 # Check for invalid parameters
21 {
22 # Check for invalid parameters
23 my $db ;
24 eval ' $db = new BerkeleyDB::Btree -Stupid => 3 ; ' ;
25 ok $@ =~ /unknown key value\(s\) Stupid/ ;
26
27 eval ' $db = new BerkeleyDB::Btree -Bad => 2, -Mode => 0345, -Stupid => 3; ' ;
28 ok $@ =~ /unknown key value\(s\) (Bad,? |Stupid,? ){2}/
29 or print "# $@" ;
30
31 eval ' $db = new BerkeleyDB::Btree -Env => 2 ' ;
32 ok $@ =~ /^Env not of type BerkeleyDB::Env/ ;
33
34 eval ' $db = new BerkeleyDB::Btree -Txn => "x" ' ;
35 ok $@ =~ /^Txn not of type BerkeleyDB::Txn/ ;
36
37 my $obj = bless [], "main" ;
38 eval ' $db = new BerkeleyDB::Btree -Env => $obj ' ;
39 ok $@ =~ /^Env not of type BerkeleyDB::Env/ ;
40 }
41
42 # Now check the interface to Btree
43
44 {
45 my $lex = new LexFile $Dfile ;
46
47 ok my $db = new BerkeleyDB::Btree -Filename => $Dfile,
48 -Flags => DB_CREATE ;
49
50 # Add a k/v pair
51 my $value ;
52 my $status ;
53 is $db->Env, undef;
54 ok $db->db_put("some key", "some value") == 0 ;
55 ok $db->status() == 0 ;
56 ok $db->db_get("some key", $value) == 0 ;
57 ok $value eq "some value" ;
58 ok $db->db_put("key", "value") == 0 ;
59 ok $db->db_get("key", $value) == 0 ;
60 ok $value eq "value" ;
61 ok $db->db_del("some key") == 0 ;
62 ok $db->db_get("some key", $value) == DB_NOTFOUND ;
63 ok $db->status() == DB_NOTFOUND ;
64 ok $db->status() =~ $DB_errors{'DB_NOTFOUND'}
65 or diag "Status is [" . $db->status() . "]";
66
67 ok $db->db_sync() == 0 ;
68
69 # Check NOOVERWRITE will make put fail when attempting to overwrite
70 # an existing record.
71
72 ok $db->db_put( 'key', 'x', DB_NOOVERWRITE) == DB_KEYEXIST ;
73 ok $db->status() =~ $DB_errors{'DB_KEYEXIST'} ;
74 ok $db->status() == DB_KEYEXIST ;
75
76
77 # check that the value of the key has not been changed by the
78 # previous test
79 ok $db->db_get("key", $value) == 0 ;
80 ok $value eq "value" ;
81
82 # test DB_GET_BOTH
83 my ($k, $v) = ("key", "value") ;
84 ok $db->db_get($k, $v, DB_GET_BOTH) == 0 ;
85
86 ($k, $v) = ("key", "fred") ;
87 ok $db->db_get($k, $v, DB_GET_BOTH) == DB_NOTFOUND ;
88
89 ($k, $v) = ("another", "value") ;
90 ok $db->db_get($k, $v, DB_GET_BOTH) == DB_NOTFOUND ;
91
92
93 }
94
95 {
96 # Check simple env works with a hash.
97 my $lex = new LexFile $Dfile ;
98
99 my $home = "./fred" ;
100 ok my $lexD = new LexDir($home) ;
101
102 ok my $env = new BerkeleyDB::Env -Flags => DB_CREATE|DB_INIT_MPOOL,
103 @StdErrFile, -Home => $home ;
104 ok my $db = new BerkeleyDB::Btree -Filename => $Dfile,
105 -Env => $env,
106 -Flags => DB_CREATE ;
107
108 isa_ok $db->Env, 'BerkeleyDB::Env';
109 $db->Env->errPrefix("abc");
110 is $db->Env->errPrefix("abc"), 'abc';
111 # Add a k/v pair
112 my $value ;
113 ok $db->db_put("some key", "some value") == 0 ;
114 ok $db->db_get("some key", $value) == 0 ;
115 ok $value eq "some value" ;
116 undef $db ;
117 undef $env ;
118 }
119
120
121 {
122 # cursors
123
124 my $lex = new LexFile $Dfile ;
125 my %hash ;
126 my ($k, $v) ;
127 ok my $db = new BerkeleyDB::Btree -Filename => $Dfile,
128 -Flags => DB_CREATE ;
129 #print "[$db] [$!] $BerkeleyDB::Error\n" ;
130
131 # create some data
132 my %data = (
133 "red" => 2,
134 "green" => "house",
135 "blue" => "sea",
136 ) ;
137
138 my $ret = 0 ;
139 while (($k, $v) = each %data) {
140 $ret += $db->db_put($k, $v) ;
141 }
142 ok $ret == 0 ;
143
144 # create the cursor
145 ok my $cursor = $db->db_cursor() ;
146
147 $k = $v = "" ;
148 my %copy = %data ;
149 my $extras = 0 ;
150 # sequence forwards
151 while ($cursor->c_get($k, $v, DB_NEXT) == 0) {
152 if ( $copy{$k} eq $v )
153 { delete $copy{$k} }
154 else
155 { ++ $extras }
156 }
157 ok $cursor->status() == DB_NOTFOUND ;
158 ok $cursor->status() =~ $DB_errors{'DB_NOTFOUND'};
159 ok keys %copy == 0 ;
160 ok $extras == 0 ;
161
162 # sequence backwards
163 %copy = %data ;
164 $extras = 0 ;
165 my $status ;
166 for ( $status = $cursor->c_get($k, $v, DB_LAST) ;
167 $status == 0 ;
168 $status = $cursor->c_get($k, $v, DB_PREV)) {
169 if ( $copy{$k} eq $v )
170 { delete $copy{$k} }
171 else
172 { ++ $extras }
173 }
174 ok $status == DB_NOTFOUND ;
175 ok $status =~ $DB_errors{'DB_NOTFOUND'};
176 ok $cursor->status() == $status ;
177 ok $cursor->status() eq $status ;
178 ok keys %copy == 0 ;
179 ok $extras == 0 ;
180
181 ($k, $v) = ("green", "house") ;
182 ok $cursor->c_get($k, $v, DB_GET_BOTH) == 0 ;
183
184 ($k, $v) = ("green", "door") ;
185 ok $cursor->c_get($k, $v, DB_GET_BOTH) == DB_NOTFOUND ;
186
187 ($k, $v) = ("black", "house") ;
188 ok $cursor->c_get($k, $v, DB_GET_BOTH) == DB_NOTFOUND ;
189
190 }
191
192 {
193 # Tied Hash interface
194
195 my $lex = new LexFile $Dfile ;
196 my %hash ;
197 ok tie %hash, 'BerkeleyDB::Btree', -Filename => $Dfile,
198 -Flags => DB_CREATE ;
199
200 is((tied %hash)->Env, undef);
201 # check "each" with an empty database
202 my $count = 0 ;
203 while (my ($k, $v) = each %hash) {
204 ++ $count ;
205 }
206 ok ((tied %hash)->status() == DB_NOTFOUND) ;
207 ok $count == 0 ;
208
209 # Add a k/v pair
210 my $value ;
211 $hash{"some key"} = "some value";
212 ok ((tied %hash)->status() == 0) ;
213 ok $hash{"some key"} eq "some value";
214 ok defined $hash{"some key"} ;
215 ok ((tied %hash)->status() == 0) ;
216 ok exists $hash{"some key"} ;
217 ok !defined $hash{"jimmy"} ;
218 ok ((tied %hash)->status() == DB_NOTFOUND) ;
219 ok !exists $hash{"jimmy"} ;
220 ok ((tied %hash)->status() == DB_NOTFOUND) ;
221
222 delete $hash{"some key"} ;
223 ok ((tied %hash)->status() == 0) ;
224 ok ! defined $hash{"some key"} ;
225 ok ((tied %hash)->status() == DB_NOTFOUND) ;
226 ok ! exists $hash{"some key"} ;
227 ok ((tied %hash)->status() == DB_NOTFOUND) ;
228
229 $hash{1} = 2 ;
230 $hash{10} = 20 ;
231 $hash{1000} = 2000 ;
232
233 my ($keys, $values) = (0,0);
234 $count = 0 ;
235 while (my ($k, $v) = each %hash) {
236 $keys += $k ;
237 $values += $v ;
238 ++ $count ;
239 }
240 ok $count == 3 ;
241 ok $keys == 1011 ;
242 ok $values == 2022 ;
243
244 # now clear the hash
245 %hash = () ;
246 ok keys %hash == 0 ;
247
248 untie %hash ;
249 }
250
251 {
252 # override default compare
253 my $lex = new LexFile $Dfile, $Dfile2, $Dfile3 ;
254 my $value ;
255 my (%h, %g, %k) ;
256 my @Keys = qw( 0123 12 -1234 9 987654321 def ) ;
257 ok tie %h, "BerkeleyDB::Btree", -Filename => $Dfile,
258 -Compare => sub { $_[0] <=> $_[1] },
259 -Flags => DB_CREATE ;
260
261 ok tie %g, 'BerkeleyDB::Btree', -Filename => $Dfile2,
262 -Compare => sub { $_[0] cmp $_[1] },
263 -Flags => DB_CREATE ;
264
265 ok tie %k, 'BerkeleyDB::Btree', -Filename => $Dfile3,
266 -Compare => sub { length $_[0] <=> length $_[1] },
267 -Flags => DB_CREATE ;
268
269 my @srt_1 ;
270 { local $^W = 0 ;
271 @srt_1 = sort { $a <=> $b } @Keys ;
272 }
273 my @srt_2 = sort { $a cmp $b } @Keys ;
274 my @srt_3 = sort { length $a <=> length $b } @Keys ;
275
276 foreach (@Keys) {
277 local $^W = 0 ;
278 $h{$_} = 1 ;
279 $g{$_} = 1 ;
280 $k{$_} = 1 ;
281 }
282
283 sub ArrayCompare
284 {
285 my($a, $b) = @_ ;
286
287 return 0 if @$a != @$b ;
288
289 foreach (1 .. length @$a)
290 {
291 return 0 unless $$a[$_] eq $$b[$_] ;
292 }
293
294 1 ;
295 }
296
297 ok ArrayCompare (\@srt_1, [keys %h]);
298 ok ArrayCompare (\@srt_2, [keys %g]);
299 ok ArrayCompare (\@srt_3, [keys %k]);
300
301 }
302
303 {
304 # override default compare, with duplicates, don't sort values
305 my $lex = new LexFile $Dfile, $Dfile2, $Dfile3 ;
306 my $value ;
307 my (%h, %g, %k) ;
308 my @Keys = qw( 0123 9 12 -1234 9 987654321 def ) ;
309 my @Values = qw( 1 0 3 dd x abc 0 ) ;
310 ok tie %h, "BerkeleyDB::Btree", -Filename => $Dfile,
311 -Compare => sub { $_[0] <=> $_[1] },
312 -Property => DB_DUP,
313 -Flags => DB_CREATE ;
314
315 ok tie %g, 'BerkeleyDB::Btree', -Filename => $Dfile2,
316 -Compare => sub { $_[0] cmp $_[1] },
317 -Property => DB_DUP,
318 -Flags => DB_CREATE ;
319
320 ok tie %k, 'BerkeleyDB::Btree', -Filename => $Dfile3,
321 -Compare => sub { length $_[0] <=> length $_[1] },
322 -Property => DB_DUP,
323 -Flags => DB_CREATE ;
324
325 my @srt_1 ;
326 { local $^W = 0 ;
327 @srt_1 = sort { $a <=> $b } @Keys ;
328 }
329 my @srt_2 = sort { $a cmp $b } @Keys ;
330 my @srt_3 = sort { length $a <=> length $b } @Keys ;
331
332 foreach (@Keys) {
333 local $^W = 0 ;
334 my $value = shift @Values ;
335 $h{$_} = $value ;
336 $g{$_} = $value ;
337 $k{$_} = $value ;
338 }
339
340 sub getValues
341 {
342 my $hash = shift ;
343 my $db = tied %$hash ;
344 my $cursor = $db->db_cursor() ;
345 my @values = () ;
346 my ($k, $v) = (0,0) ;
347 while ($cursor->c_get($k, $v, DB_NEXT) == 0) {
348 push @values, $v ;
349 }
350 return @values ;
351 }
352
353 ok ArrayCompare (\@srt_1, [keys %h]);
354 ok ArrayCompare (\@srt_2, [keys %g]);
355 ok ArrayCompare (\@srt_3, [keys %k]);
356 ok ArrayCompare ([qw(dd 0 0 x 3 1 abc)], [getValues \%h]);
357 ok ArrayCompare ([qw(dd 1 0 3 x abc 0)], [getValues \%g]);
358 ok ArrayCompare ([qw(0 x 3 0 1 dd abc)], [getValues \%k]);
359
360 # test DB_DUP_NEXT
361 ok my $cur = (tied %g)->db_cursor() ;
362 my ($k, $v) = (9, "") ;
363 ok $cur->c_get($k, $v, DB_SET) == 0 ;
364 ok $k == 9 && $v == 0 ;
365 ok $cur->c_get($k, $v, DB_NEXT_DUP) == 0 ;
366 ok $k == 9 && $v eq "x" ;
367 ok $cur->c_get($k, $v, DB_NEXT_DUP) == DB_NOTFOUND ;
368 }
369
370 {
371 # override default compare, with duplicates, sort values
372 my $lex = new LexFile $Dfile, $Dfile2;
373 my $value ;
374 my (%h, %g) ;
375 my @Keys = qw( 0123 9 12 -1234 9 987654321 9 def ) ;
376 my @Values = qw( 1 11 3 dd x abc 2 0 ) ;
377 ok tie %h, "BerkeleyDB::Btree", -Filename => $Dfile,
378 -Compare => sub { $_[0] <=> $_[1] },
379 -DupCompare => sub { $_[0] cmp $_[1] },
380 -Property => DB_DUP,
381 -Flags => DB_CREATE ;
382
383 ok tie %g, 'BerkeleyDB::Btree', -Filename => $Dfile2,
384 -Compare => sub { $_[0] cmp $_[1] },
385 -DupCompare => sub { $_[0] <=> $_[1] },
386 -Property => DB_DUP,
387
388
389
390 -Flags => DB_CREATE ;
391
392 my @srt_1 ;
393 { local $^W = 0 ;
394 @srt_1 = sort { $a <=> $b } @Keys ;
395 }
396 my @srt_2 = sort { $a cmp $b } @Keys ;
397
398 foreach (@Keys) {
399 local $^W = 0 ;
400 my $value = shift @Values ;
401 $h{$_} = $value ;
402 $g{$_} = $value ;
403 }
404
405 ok ArrayCompare (\@srt_1, [keys %h]);
406 ok ArrayCompare (\@srt_2, [keys %g]);
407 ok ArrayCompare ([qw(dd 1 3 x 2 11 abc 0)], [getValues \%g]);
408 ok ArrayCompare ([qw(dd 0 11 2 x 3 1 abc)], [getValues \%h]);
409
410 }
411
412 {
413 # get_dup etc
414 my $lex = new LexFile $Dfile;
415 my %hh ;
416
417 ok my $YY = tie %hh, "BerkeleyDB::Btree", -Filename => $Dfile,
418 -DupCompare => sub { $_[0] cmp $_[1] },
419 -Property => DB_DUP,
420 -Flags => DB_CREATE ;
421
422 $hh{'Wall'} = 'Larry' ;
423 $hh{'Wall'} = 'Stone' ; # Note the duplicate key
424 $hh{'Wall'} = 'Brick' ; # Note the duplicate key
425 $hh{'Smith'} = 'John' ;
426 $hh{'mouse'} = 'mickey' ;
427
428 # first work in scalar context
429 ok scalar $YY->get_dup('Unknown') == 0 ;
430 ok scalar $YY->get_dup('Smith') == 1 ;
431 ok scalar $YY->get_dup('Wall') == 3 ;
432
433 # now in list context
434 my @unknown = $YY->get_dup('Unknown') ;
435 ok "@unknown" eq "" ;
436
437 my @smith = $YY->get_dup('Smith') ;
438 ok "@smith" eq "John" ;
439
440 {
441 my @wall = $YY->get_dup('Wall') ;
442 my %wall ;
443 @wall{@wall} = @wall ;
444 ok (@wall == 3 && $wall{'Larry'} && $wall{'Stone'} && $wall{'Brick'});
445 }
446
447 # hash
448 my %unknown = $YY->get_dup('Unknown', 1) ;
449 ok keys %unknown == 0 ;
450
451 my %smith = $YY->get_dup('Smith', 1) ;
452 ok keys %smith == 1 && $smith{'John'} ;
453
454 my %wall = $YY->get_dup('Wall', 1) ;
455 ok keys %wall == 3 && $wall{'Larry'} == 1 && $wall{'Stone'} == 1
456 && $wall{'Brick'} == 1 ;
457
458 undef $YY ;
459 untie %hh ;
460
461 }
462
463 {
464 # in-memory file
465
466 my $lex = new LexFile $Dfile ;
467 my %hash ;
468 my $fd ;
469 my $value ;
470 ok my $db = tie %hash, 'BerkeleyDB::Btree' ;
471
472 ok $db->db_put("some key", "some value") == 0 ;
473 ok $db->db_get("some key", $value) == 0 ;
474 ok $value eq "some value" ;
475
476 }
477
478 {
479 # partial
480 # check works via API
481
482 my $lex = new LexFile $Dfile ;
483 my $value ;
484 ok my $db = new BerkeleyDB::Btree -Filename => $Dfile,
485 -Flags => DB_CREATE ;
486
487 # create some data
488 my %data = (
489 "red" => "boat",
490 "green" => "house",
491 "blue" => "sea",
492 ) ;
493
494 my $ret = 0 ;
495 while (my ($k, $v) = each %data) {
496 $ret += $db->db_put($k, $v) ;
497 }
498 ok $ret == 0 ;
499
500
501 # do a partial get
502 my ($pon, $off, $len) = $db->partial_set(0,2) ;
503 ok ! $pon && $off == 0 && $len == 0 ;
504 ok $db->db_get("red", $value) == 0 && $value eq "bo" ;
505 ok $db->db_get("green", $value) == 0 && $value eq "ho" ;
506 ok $db->db_get("blue", $value) == 0 && $value eq "se" ;
507
508 # do a partial get, off end of data
509 ($pon, $off, $len) = $db->partial_set(3,2) ;
510 ok $pon ;
511 ok $off == 0 ;
512 ok $len == 2 ;
513 ok $db->db_get("red", $value) == 0 && $value eq "t" ;
514 ok $db->db_get("green", $value) == 0 && $value eq "se" ;
515 ok $db->db_get("blue", $value) == 0 && $value eq "" ;
516
517 # switch of partial mode
518 ($pon, $off, $len) = $db->partial_clear() ;
519 ok $pon ;
520 ok $off == 3 ;
521 ok $len == 2 ;
522 ok $db->db_get("red", $value) == 0 && $value eq "boat" ;
523 ok $db->db_get("green", $value) == 0 && $value eq "house" ;
524 ok $db->db_get("blue", $value) == 0 && $value eq "sea" ;
525
526 # now partial put
527 $db->partial_set(0,2) ;
528 ok $db->db_put("red", "") == 0 ;
529 ok $db->db_put("green", "AB") == 0 ;
530 ok $db->db_put("blue", "XYZ") == 0 ;
531 ok $db->db_put("new", "KLM") == 0 ;
532
533 ($pon, $off, $len) = $db->partial_clear() ;
534 ok $pon ;
535 ok $off == 0 ;
536 ok $len == 2 ;
537 ok $db->db_get("red", $value) == 0 && $value eq "at" ;
538 ok $db->db_get("green", $value) == 0 && $value eq "ABuse" ;
539 ok $db->db_get("blue", $value) == 0 && $value eq "XYZa" ;
540 ok $db->db_get("new", $value) == 0 && $value eq "KLM" ;
541
542 # now partial put
543 ($pon, $off, $len) = $db->partial_set(3,2) ;
544 ok ! $pon ;
545 ok $off == 0 ;
546 ok $len == 0 ;
547 ok $db->db_put("red", "PPP") == 0 ;
548 ok $db->db_put("green", "Q") == 0 ;
549 ok $db->db_put("blue", "XYZ") == 0 ;
550 ok $db->db_put("new", "TU") == 0 ;
551
552 $db->partial_clear() ;
553 ok $db->db_get("red", $value) == 0 && $value eq "at\0PPP" ;
554 ok $db->db_get("green", $value) == 0 && $value eq "ABuQ" ;
555 ok $db->db_get("blue", $value) == 0 && $value eq "XYZXYZ" ;
556 ok $db->db_get("new", $value) == 0 && $value eq "KLMTU" ;
557 }
558
559 {
560 # partial
561 # check works via tied hash
562
563 my $lex = new LexFile $Dfile ;
564 my %hash ;
565 my $value ;
566 ok my $db = tie %hash, 'BerkeleyDB::Btree', -Filename => $Dfile,
567 -Flags => DB_CREATE ;
568
569 # create some data
570 my %data = (
571 "red" => "boat",
572 "green" => "house",
573 "blue" => "sea",
574 ) ;
575
576 while (my ($k, $v) = each %data) {
577 $hash{$k} = $v ;
578 }
579
580
581 # do a partial get
582 $db->partial_set(0,2) ;
583 ok $hash{"red"} eq "bo" ;
584 ok $hash{"green"} eq "ho" ;
585 ok $hash{"blue"} eq "se" ;
586
587 # do a partial get, off end of data
588 $db->partial_set(3,2) ;
589 ok $hash{"red"} eq "t" ;
590 ok $hash{"green"} eq "se" ;
591 ok $hash{"blue"} eq "" ;
592
593 # switch of partial mode
594 $db->partial_clear() ;
595 ok $hash{"red"} eq "boat" ;
596 ok $hash{"green"} eq "house" ;
597 ok $hash{"blue"} eq "sea" ;
598
599 # now partial put
600 $db->partial_set(0,2) ;
601 ok $hash{"red"} = "" ;
602 ok $hash{"green"} = "AB" ;
603 ok $hash{"blue"} = "XYZ" ;
604 ok $hash{"new"} = "KLM" ;
605
606 $db->partial_clear() ;
607 ok $hash{"red"} eq "at" ;
608 ok $hash{"green"} eq "ABuse" ;
609 ok $hash{"blue"} eq "XYZa" ;
610 ok $hash{"new"} eq "KLM" ;
611
612 # now partial put
613 $db->partial_set(3,2) ;
614 ok $hash{"red"} = "PPP" ;
615 ok $hash{"green"} = "Q" ;
616 ok $hash{"blue"} = "XYZ" ;
617 ok $hash{"new"} = "TU" ;
618
619 $db->partial_clear() ;
620 ok $hash{"red"} eq "at\0PPP" ;
621 ok $hash{"green"} eq "ABuQ" ;
622 ok $hash{"blue"} eq "XYZXYZ" ;
623 ok $hash{"new"} eq "KLMTU" ;
624 }
625
626 {
627 # transaction
628
629 my $lex = new LexFile $Dfile ;
630 my %hash ;
631 my $value ;
632
633 my $home = "./fred" ;
634 ok my $lexD = new LexDir($home) ;
635 ok my $env = new BerkeleyDB::Env -Home => $home, @StdErrFile,
636 -Flags => DB_CREATE|DB_INIT_TXN|
637 DB_INIT_MPOOL|DB_INIT_LOCK ;
638 ok my $txn = $env->txn_begin() ;
639 ok my $db1 = tie %hash, 'BerkeleyDB::Btree', -Filename => $Dfile,
640 -Flags => DB_CREATE ,
641 -Env => $env,
642 -Txn => $txn ;
643
644 isa_ok((tied %hash)->Env, 'BerkeleyDB::Env');
645 (tied %hash)->Env->errPrefix("abc");
646 is((tied %hash)->Env->errPrefix("abc"), 'abc');
647 ok ((my $Z = $txn->txn_commit()) == 0) ;
648 ok $txn = $env->txn_begin() ;
649 $db1->Txn($txn);
650
651 # create some data
652 my %data = (
653 "red" => "boat",
654 "green" => "house",
655 "blue" => "sea",
656 ) ;
657
658 my $ret = 0 ;
659 while (my ($k, $v) = each %data) {
660 $ret += $db1->db_put($k, $v) ;
661 }
662 ok $ret == 0 ;
663
664 # should be able to see all the records
665
666 ok my $cursor = $db1->db_cursor() ;
667 my ($k, $v) = ("", "") ;
668 my $count = 0 ;
669 # sequence forwards
670 while ($cursor->c_get($k, $v, DB_NEXT) == 0) {
671 ++ $count ;
672 }
673 ok $count == 3 ;
674 undef $cursor ;
675
676 # now abort the transaction
677 #ok $txn->txn_abort() == 0 ;
678 ok (($Z = $txn->txn_abort()) == 0) ;
679
680 # there shouldn't be any records in the database
681 $count = 0 ;
682 # sequence forwards
683 ok $cursor = $db1->db_cursor() ;
684 while ($cursor->c_get($k, $v, DB_NEXT) == 0) {
685 ++ $count ;
686 }
687 ok $count == 0 ;
688
689 undef $txn ;
690 undef $cursor ;
691 undef $db1 ;
692 undef $env ;
693 untie %hash ;
694 }
695
696 {
697 # DB_DUP
698
699 my $lex = new LexFile $Dfile ;
700 my %hash ;
701 ok my $db = tie %hash, 'BerkeleyDB::Btree', -Filename => $Dfile,
702 -Property => DB_DUP,
703 -Flags => DB_CREATE ;
704
705 $hash{'Wall'} = 'Larry' ;
706 $hash{'Wall'} = 'Stone' ;
707 $hash{'Smith'} = 'John' ;
708 $hash{'Wall'} = 'Brick' ;
709 $hash{'Wall'} = 'Brick' ;
710 $hash{'mouse'} = 'mickey' ;
711
712 ok keys %hash == 6 ;
713
714 # create a cursor
715 ok my $cursor = $db->db_cursor() ;
716
717 my $key = "Wall" ;
718 my $value ;
719 ok $cursor->c_get($key, $value, DB_SET) == 0 ;
720 ok $key eq "Wall" && $value eq "Larry" ;
721 ok $cursor->c_get($key, $value, DB_NEXT) == 0 ;
722 ok $key eq "Wall" && $value eq "Stone" ;
723 ok $cursor->c_get($key, $value, DB_NEXT) == 0 ;
724 ok $key eq "Wall" && $value eq "Brick" ;
725 ok $cursor->c_get($key, $value, DB_NEXT) == 0 ;
726 ok $key eq "Wall" && $value eq "Brick" ;
727
728 #my $ref = $db->db_stat() ;
729 #ok ($ref->{bt_flags} | DB_DUP) == DB_DUP ;
730 #print "bt_flags " . $ref->{bt_flags} . " DB_DUP " . DB_DUP ."\n";
731
732 undef $db ;
733 undef $cursor ;
734 untie %hash ;
735
736 }
737
738 {
739 # db_stat
740
741 my $lex = new LexFile $Dfile ;
742 my $recs = ($BerkeleyDB::db_version >= 3.1 ? "bt_ndata" : "bt_nrecs") ;
743 my %hash ;
744 my ($k, $v) ;
745 ok my $db = new BerkeleyDB::Btree -Filename => $Dfile,
746 -Flags => DB_CREATE,
747 -Minkey =>3 ,
748 -Pagesize => 2 **12
749 ;
750
751 my $ref = $db->db_stat() ;
752 ok $ref->{$recs} == 0;
753 ok $ref->{'bt_minkey'} == 3;
754 ok $ref->{'bt_pagesize'} == 2 ** 12;
755
756 # create some data
757 my %data = (
758 "red" => 2,
759 "green" => "house",
760 "blue" => "sea",
761 ) ;
762
763 my $ret = 0 ;
764 while (($k, $v) = each %data) {
765 $ret += $db->db_put($k, $v) ;
766 }
767 ok $ret == 0 ;
768
769 $ref = $db->db_stat() ;
770 ok $ref->{$recs} == 3;
771 }
772
773 {
774 # sub-class test
775
776 package Another ;
777
778 use strict ;
779
780 open(FILE, ">SubDB.pm") or die "Cannot open SubDB.pm: $!\n" ;
781 print FILE <<'EOM' ;
782
783 package SubDB ;
784
785 use strict ;
786 use vars qw( @ISA @EXPORT) ;
787
788 require Exporter ;
789 use BerkeleyDB;
790 @ISA=qw(BerkeleyDB BerkeleyDB::Btree );
791 @EXPORT = @BerkeleyDB::EXPORT ;
792
793 sub db_put {
794 my $self = shift ;
795 my $key = shift ;
796 my $value = shift ;
797 $self->SUPER::db_put($key, $value * 3) ;
798 }
799
800 sub db_get {
801 my $self = shift ;
802 $self->SUPER::db_get($_[0], $_[1]) ;
803 $_[1] -= 2 ;
804 }
805
806 sub A_new_method
807 {
808 my $self = shift ;
809 my $key = shift ;
810 my $value = $self->FETCH($key) ;
811 return "[[$value]]" ;
812 }
813
814 1 ;
815 EOM
816
817 close FILE ;
818
819 use Test::More;
820 BEGIN { push @INC, '.'; }
821 eval 'use SubDB ; ';
822 ok $@ eq "" ;
823 my %h ;
824 my $X ;
825 eval '
826 $X = tie(%h, "SubDB", -Filename => "dbbtree.tmp",
827 -Flags => DB_CREATE,
828 -Mode => 0640 );
829 ' ;
830
831 ok $@ eq "" && $X ;
832
833 my $ret = eval '$h{"fred"} = 3 ; return $h{"fred"} ' ;
834 ok $@ eq "" ;
835 ok $ret == 7 ;
836
837 my $value = 0;
838 $ret = eval '$X->db_put("joe", 4) ; $X->db_get("joe", $value) ; return $value' ;
839 ok $@ eq "" ;
840 ok $ret == 10 ;
841
842 $ret = eval ' DB_NEXT eq main::DB_NEXT ' ;
843 ok $@ eq "" ;
844 ok $ret == 1 ;
845
846 $ret = eval '$X->A_new_method("joe") ' ;
847 ok $@ eq "" ;
848 ok $ret eq "[[10]]" ;
849
850 undef $X;
851 untie %h;
852 unlink "SubDB.pm", "dbbtree.tmp" ;
853
854 }
855
856 {
857 # DB_RECNUM, DB_SET_RECNO & DB_GET_RECNO
858
859 my $lex = new LexFile $Dfile ;
860 my %hash ;
861 my ($k, $v) = ("", "");
862 ok my $db = new BerkeleyDB::Btree
863 -Filename => $Dfile,
864 -Flags => DB_CREATE,
865 -Property => DB_RECNUM ;
866
867
868 # create some data
869 my @data = (
870 "A zero",
871 "B one",
872 "C two",
873 "D three",
874 "E four"
875 ) ;
876
877 my $ix = 0 ;
878 my $ret = 0 ;
879 foreach (@data) {
880 $ret += $db->db_put($_, $ix) ;
881 ++ $ix ;
882 }
883 ok $ret == 0 ;
884
885 # db_get & DB_SET_RECNO
886 $k = 1 ;
887 ok $db->db_get($k, $v, DB_SET_RECNO) == 0;
888 ok $k eq "B one" && $v == 1 ;
889
890 $k = 3 ;
891 ok $db->db_get($k, $v, DB_SET_RECNO) == 0;
892 ok $k eq "D three" && $v == 3 ;
893
894 $k = 4 ;
895 ok $db->db_get($k, $v, DB_SET_RECNO) == 0;
896 ok $k eq "E four" && $v == 4 ;
897
898 $k = 0 ;
899 ok $db->db_get($k, $v, DB_SET_RECNO) == 0;
900 ok $k eq "A zero" && $v == 0 ;
901
902 # cursor & DB_SET_RECNO
903
904 # create the cursor
905 ok my $cursor = $db->db_cursor() ;
906
907 $k = 2 ;
908 ok $db->db_get($k, $v, DB_SET_RECNO) == 0;
909 ok $k eq "C two" && $v == 2 ;
910
911 $k = 0 ;
912 ok $cursor->c_get($k, $v, DB_SET_RECNO) == 0;
913 ok $k eq "A zero" && $v == 0 ;
914
915 $k = 3 ;
916 ok $db->db_get($k, $v, DB_SET_RECNO) == 0;
917 ok $k eq "D three" && $v == 3 ;
918
919 # cursor & DB_GET_RECNO
920 ok $cursor->c_get($k, $v, DB_FIRST) == 0 ;
921 ok $k eq "A zero" && $v == 0 ;
922 ok $cursor->c_get($k, $v, DB_GET_RECNO) == 0;
923 ok $v == 0 ;
924
925 ok $cursor->c_get($k, $v, DB_NEXT) == 0 ;
926 ok $k eq "B one" && $v == 1 ;
927 ok $cursor->c_get($k, $v, DB_GET_RECNO) == 0;
928 ok $v == 1 ;
929
930 ok $cursor->c_get($k, $v, DB_LAST) == 0 ;
931 ok $k eq "E four" && $v == 4 ;
932 ok $cursor->c_get($k, $v, DB_GET_RECNO) == 0;
933 ok $v == 4 ;
934
935 }
936