hash.t

berkeleyDB,强大的嵌入式数据,多个数据库的内核

    # partial
    # check works via tied hash 

    my $lex = new LexFile $Dfile ;
    my %hash ;
    my $value ;
    ok 120, my $db = tie %hash, 'BerkeleyDB::Hash', -Filename => $Dfile,
                                      	       -Flags    => DB_CREATE ;

    # create some data
    my %data =  (
		"red"	=> "boat",
		"green"	=> "house",
		"blue"	=> "sea",
		) ;

    while (my ($k, $v) = each %data) {
	$hash{$k} = $v ;
    }


    # do a partial get
    $db->partial_set(0,2) ;
    ok 121, $hash{"red"} eq "bo" ;
    ok 122, $hash{"green"} eq "ho" ;
    ok 123, $hash{"blue"}  eq "se" ;

    # do a partial get, off end of data
    $db->partial_set(3,2) ;
    ok 124, $hash{"red"} eq "t" ;
    ok 125, $hash{"green"} eq "se" ;
    ok 126, $hash{"blue"} eq "" ;

    # switch of partial mode
    $db->partial_clear() ;
    ok 127, $hash{"red"} eq "boat" ;
    ok 128, $hash{"green"} eq "house" ;
    ok 129, $hash{"blue"} eq "sea" ;

    # now partial put
    $db->partial_set(0,2) ;
    ok 130, $hash{"red"} = "" ;
    ok 131, $hash{"green"} = "AB" ;
    ok 132, $hash{"blue"} = "XYZ" ;
    ok 133, $hash{"new"} = "KLM" ;

    $db->partial_clear() ;
    ok 134, $hash{"red"} eq "at" ;
    ok 135, $hash{"green"} eq "ABuse" ;
    ok 136, $hash{"blue"} eq "XYZa" ;
    ok 137, $hash{"new"} eq "KLM" ;

    # now partial put
    $db->partial_set(3,2) ;
    ok 138, $hash{"red"} = "PPP" ;
    ok 139, $hash{"green"} = "Q" ;
    ok 140, $hash{"blue"} = "XYZ" ;
    ok 141, $hash{"new"} = "TU" ;

    $db->partial_clear() ;
    ok 142, $hash{"red"} eq "at\0PPP" ;
    ok 143, $hash{"green"} eq "ABuQ" ;
    ok 144, $hash{"blue"} eq "XYZXYZ" ;
    ok 145, $hash{"new"} eq "KLMTU" ;
}

{
    # transaction

    my $lex = new LexFile $Dfile ;
    my %hash ;
    my $value ;

    my $home = "./fred" ;
    ok 146, my $lexD = new LexDir($home);
    ok 147, my $env = new BerkeleyDB::Env -Home => $home,@StdErrFile,
				     -Flags => DB_CREATE|DB_INIT_TXN|
					  	DB_INIT_MPOOL|DB_INIT_LOCK ;
    ok 148, my $txn = $env->txn_begin() ;
    ok 149, my $db1 = tie %hash, 'BerkeleyDB::Hash', -Filename => $Dfile,
                                      	       	-Flags     => DB_CREATE ,
					       	-Env 	   => $env,
					    	-Txn	   => $txn  ;

    
    ok 150, $txn->txn_commit() == 0 ;
    ok 151, $txn = $env->txn_begin() ;
    $db1->Txn($txn);
    # create some data
    my %data =  (
		"red"	=> "boat",
		"green"	=> "house",
		"blue"	=> "sea",
		) ;

    my $ret = 0 ;
    while (my ($k, $v) = each %data) {
        $ret += $db1->db_put($k, $v) ;
    }
    ok 152, $ret == 0 ;

    # should be able to see all the records

    ok 153, my $cursor = $db1->db_cursor() ;
    my ($k, $v) = ("", "") ;
    my $count = 0 ;
    # sequence forwards
    while ($cursor->c_get($k, $v, DB_NEXT) == 0) {
        ++ $count ;
    }
    ok 154, $count == 3 ;
    undef $cursor ;

    # now abort the transaction
    ok 155, $txn->txn_abort() == 0 ;

    # there shouldn't be any records in the database
    $count = 0 ;
    # sequence forwards
    ok 156, $cursor = $db1->db_cursor() ;
    while ($cursor->c_get($k, $v, DB_NEXT) == 0) {
        ++ $count ;
    }
    ok 157, $count == 0 ;

    undef $txn ;
    undef $cursor ;
    undef $db1 ;
    undef $env ;
    untie %hash ;
}


{
    # DB_DUP

    my $lex = new LexFile $Dfile ;
    my %hash ;
    ok 158, my $db = tie %hash, 'BerkeleyDB::Hash', -Filename => $Dfile,
				      -Property  => DB_DUP,
                                      -Flags    => DB_CREATE ;

    $hash{'Wall'} = 'Larry' ;
    $hash{'Wall'} = 'Stone' ;
    $hash{'Smith'} = 'John' ;
    $hash{'Wall'} = 'Brick' ;
    $hash{'Wall'} = 'Brick' ;
    $hash{'mouse'} = 'mickey' ;

    ok 159, keys %hash == 6 ;

    # create a cursor
    ok 160, my $cursor = $db->db_cursor() ;

    my $key = "Wall" ;
    my $value ;
    ok 161, $cursor->c_get($key, $value, DB_SET) == 0 ;
    ok 162, $key eq "Wall" && $value eq "Larry" ;
    ok 163, $cursor->c_get($key, $value, DB_NEXT) == 0 ;
    ok 164, $key eq "Wall" && $value eq "Stone" ;
    ok 165, $cursor->c_get($key, $value, DB_NEXT) == 0 ;
    ok 166, $key eq "Wall" && $value eq "Brick" ;
    ok 167, $cursor->c_get($key, $value, DB_NEXT) == 0 ;
    ok 168, $key eq "Wall" && $value eq "Brick" ;

    #my $ref = $db->db_stat() ; 
    #ok 143, $ref->{bt_flags} | DB_DUP ;

    # test DB_DUP_NEXT
    my ($k, $v) = ("Wall", "") ;
    ok 169, $cursor->c_get($k, $v, DB_SET) == 0 ;
    ok 170, $k eq "Wall" && $v eq "Larry" ;
    ok 171, $cursor->c_get($k, $v, DB_NEXT_DUP) == 0 ;
    ok 172, $k eq "Wall" && $v eq "Stone" ;
    ok 173, $cursor->c_get($k, $v, DB_NEXT_DUP) == 0 ;
    ok 174, $k eq "Wall" && $v eq "Brick" ;
    ok 175, $cursor->c_get($k, $v, DB_NEXT_DUP) == 0 ;
    ok 176, $k eq "Wall" && $v eq "Brick" ;
    ok 177, $cursor->c_get($k, $v, DB_NEXT_DUP) == DB_NOTFOUND ;
    

    undef $db ;
    undef $cursor ;
    untie %hash ;

}

{
    # DB_DUP & DupCompare
    my $lex = new LexFile $Dfile, $Dfile2;
    my ($key, $value) ;
    my (%h, %g) ;
    my @Keys   = qw( 0123 9 12 -1234 9 987654321 9 def  ) ; 
    my @Values = qw( 1    11 3   dd   x abc      2 0    ) ; 

    ok 178, tie %h, "BerkeleyDB::Hash", -Filename => $Dfile, 
				     -DupCompare   => sub { $_[0] cmp $_[1] },
				     -Property  => DB_DUP|DB_DUPSORT,
				     -Flags    => DB_CREATE ;

    ok 179, tie %g, 'BerkeleyDB::Hash', -Filename => $Dfile2, 
				     -DupCompare   => sub { $_[0] <=> $_[1] },
				     -Property  => DB_DUP|DB_DUPSORT,
				     -Flags    => DB_CREATE ;

    foreach (@Keys) {
        local $^W = 0 ;
	my $value = shift @Values ;
        $h{$_} = $value ; 
        $g{$_} = $value ;
    }

    ok 180, my $cursor = (tied %h)->db_cursor() ;
    $key = 9 ; $value = "";
    ok 181, $cursor->c_get($key, $value, DB_SET) == 0 ;
    ok 182, $key == 9 && $value eq 11 ;
    ok 183, $cursor->c_get($key, $value, DB_NEXT) == 0 ;
    ok 184, $key == 9 && $value == 2 ;
    ok 185, $cursor->c_get($key, $value, DB_NEXT) == 0 ;
    ok 186, $key == 9 && $value eq "x" ;

    $cursor = (tied %g)->db_cursor() ;
    $key = 9 ;
    ok 187, $cursor->c_get($key, $value, DB_SET) == 0 ;
    ok 188, $key == 9 && $value eq "x" ;
    ok 189, $cursor->c_get($key, $value, DB_NEXT) == 0 ;
    ok 190, $key == 9 && $value == 2 ;
    ok 191, $cursor->c_get($key, $value, DB_NEXT) == 0 ;
    ok 192, $key == 9 && $value  == 11 ;


}

{
    # get_dup etc
    my $lex = new LexFile $Dfile;
    my %hh ;

    ok 193, my $YY = tie %hh, "BerkeleyDB::Hash", -Filename => $Dfile, 
				     -DupCompare   => sub { $_[0] cmp $_[1] },
				     -Property  => DB_DUP,
				     -Flags    => DB_CREATE ;

    $hh{'Wall'} = 'Larry' ;
    $hh{'Wall'} = 'Stone' ; # Note the duplicate key
    $hh{'Wall'} = 'Brick' ; # Note the duplicate key
    $hh{'Smith'} = 'John' ;
    $hh{'mouse'} = 'mickey' ;
    
    # first work in scalar context
    ok 194, scalar $YY->get_dup('Unknown') == 0 ;
    ok 195, scalar $YY->get_dup('Smith') == 1 ;
    ok 196, scalar $YY->get_dup('Wall') == 3 ;
    
    # now in list context
    my @unknown = $YY->get_dup('Unknown') ;
    ok 197, "@unknown" eq "" ;
    
    my @smith = $YY->get_dup('Smith') ;
    ok 198, "@smith" eq "John" ;
    
    {
        my @wall = $YY->get_dup('Wall') ;
        my %wall ;
        @wall{@wall} = @wall ;
        ok 199, (@wall == 3 && $wall{'Larry'} 
			&& $wall{'Stone'} && $wall{'Brick'});
    }
    
    # hash
    my %unknown = $YY->get_dup('Unknown', 1) ;
    ok 200, keys %unknown == 0 ;
    
    my %smith = $YY->get_dup('Smith', 1) ;
    ok 201, keys %smith == 1 && $smith{'John'} ;
    
    my %wall = $YY->get_dup('Wall', 1) ;
    ok 202, keys %wall == 3 && $wall{'Larry'} == 1 && $wall{'Stone'} == 1 
    		&& $wall{'Brick'} == 1 ;
    
    undef $YY ;
    untie %hh ;

}

{
   # sub-class test

   package Another ;

   use strict ;

   open(FILE, ">SubDB.pm") or die "Cannot open SubDB.pm: $!\n" ;
   print FILE <<'EOM' ;

   package SubDB ;

   use strict ;
   use vars qw( @ISA @EXPORT) ;

   require Exporter ;
   use BerkeleyDB;
   @ISA=qw(BerkeleyDB BerkeleyDB::Hash);
   @EXPORT = @BerkeleyDB::EXPORT ;

   sub db_put { 
	my $self = shift ;
        my $key = shift ;
        my $value = shift ;
        $self->SUPER::db_put($key, $value * 3) ;
   }

   sub db_get { 
	my $self = shift ;
        $self->SUPER::db_get($_[0], $_[1]) ;
	$_[1] -= 2 ;
   }

   sub A_new_method
   {
	my $self = shift ;
        my $key = shift ;
        my $value = $self->FETCH($key) ;
	return "[[$value]]" ;
   }

   1 ;
EOM

    close FILE ;

    BEGIN { push @INC, '.'; }    
    eval 'use SubDB ; ';
    main::ok 203, $@ eq "" ;
    my %h ;
    my $X ;
    eval '
	$X = tie(%h, "SubDB", -Filename => "dbhash.tmp", 
			-Flags => DB_CREATE,
			-Mode => 0640 );
	' ;

    main::ok 204, $@ eq "" ;

    my $ret = eval '$h{"fred"} = 3 ; return $h{"fred"} ' ;
    main::ok 205, $@ eq "" ;
    main::ok 206, $ret == 7 ;

    my $value = 0;
    $ret = eval '$X->db_put("joe", 4) ; $X->db_get("joe", $value) ; return $value' ;
    main::ok 207, $@ eq "" ;
    main::ok 208, $ret == 10 ;

    $ret = eval ' DB_NEXT eq main::DB_NEXT ' ;
    main::ok 209, $@ eq ""  ;
    main::ok 210, $ret == 1 ;

    $ret = eval '$X->A_new_method("joe") ' ;
    main::ok 211, $@ eq "" ;
    main::ok 212, $ret eq "[[10]]" ;

    unlink "SubDB.pm", "dbhash.tmp" ;

}