Debian Codegraph @

lang/perl/BerkeleyDB/t/queue.t

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