From: rkinyon@cpan.org Date: Sun, 15 Jun 2008 18:34:14 +0000 (+0000) Subject: Optimization: First broke out all the classes that were in Engine.pm so that I can... X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=065b45be4e413444714f0b35aa9653e10753118b;p=dbsrgits%2FDBM-Deep.git Optimization: First broke out all the classes that were in Engine.pm so that I can better see what's going on. Later, I'll create a dist action that merges all the files into one. git-svn-id: http://svn.ali.as/cpan/trunk/DBM-Deep@3574 88f4d9cd-8a04-0410-9d60-8f63309c3137 --- diff --git a/lib/DBM/Deep.pm b/lib/DBM/Deep.pm index e4a21fa..ace79c5 100644 --- a/lib/DBM/Deep.pm +++ b/lib/DBM/Deep.pm @@ -3,7 +3,7 @@ package DBM::Deep; use 5.006_000; use strict; -use warnings; +use warnings FATAL => 'all'; our $VERSION = q(1.0013); diff --git a/lib/DBM/Deep/Array.pm b/lib/DBM/Deep/Array.pm index 38c5186..73babc5 100644 --- a/lib/DBM/Deep/Array.pm +++ b/lib/DBM/Deep/Array.pm @@ -3,9 +3,7 @@ package DBM::Deep::Array; use 5.006_000; use strict; -use warnings; - -our $VERSION = q(1.0013); +use warnings FATAL => 'all'; # This is to allow DBM::Deep::Array to handle negative indices on # its own. Otherwise, Perl would intercept the call to negative diff --git a/lib/DBM/Deep/Engine.pm b/lib/DBM/Deep/Engine.pm index fa04b4f..fd7e78e 100644 --- a/lib/DBM/Deep/Engine.pm +++ b/lib/DBM/Deep/Engine.pm @@ -3,9 +3,14 @@ package DBM::Deep::Engine; use 5.006_000; use strict; -use warnings; +use warnings FATAL => 'all'; -our $VERSION = q(1.0013); +use DBM::Deep::Engine::Sector::BucketList; +use DBM::Deep::Engine::Sector::Index; +use DBM::Deep::Engine::Sector::Null; +use DBM::Deep::Engine::Sector::Reference; +use DBM::Deep::Engine::Sector::Scalar; +use DBM::Deep::Iterator; # Never import symbols into our namespace. We are a class, not a library. # -RobK, 2008-05-27 @@ -31,7 +36,7 @@ sub SIG_BLIST () { 'B' } sub SIG_FREE () { 'F' } sub SIG_SIZE () { 1 } -my $STALE_SIZE = 2; +our $STALE_SIZE = 2; # Please refer to the pack() documentation for further information my %StP = ( @@ -40,6 +45,7 @@ my %StP = ( 4 => 'N', # Unsigned long in "network" (big-endian) order 8 => 'Q', # Usigned quad (no order specified, presumably machine-dependent) ); +sub StP { $StP{$_[1]} } ################################################################################ @@ -1004,1322 +1010,5 @@ sub _dump_file { return $return; } -################################################################################ - -package DBM::Deep::Iterator; - -sub new { - my $class = shift; - my ($args) = @_; - - my $self = bless { - breadcrumbs => [], - engine => $args->{engine}, - base_offset => $args->{base_offset}, - }, $class; - - Scalar::Util::weaken( $self->{engine} ); - - return $self; -} - -sub reset { $_[0]{breadcrumbs} = [] } - -sub get_sector_iterator { - my $self = shift; - my ($loc) = @_; - - my $sector = $self->{engine}->_load_sector( $loc ) - or return; - - if ( $sector->isa( 'DBM::Deep::Engine::Sector::Index' ) ) { - return DBM::Deep::Iterator::Index->new({ - iterator => $self, - sector => $sector, - }); - } - elsif ( $sector->isa( 'DBM::Deep::Engine::Sector::BucketList' ) ) { - return DBM::Deep::Iterator::BucketList->new({ - iterator => $self, - sector => $sector, - }); - } - - DBM::Deep->_throw_error( "get_sector_iterator(): Why did $loc make a $sector?" ); -} - -sub get_next_key { - my $self = shift; - my ($obj) = @_; - - my $crumbs = $self->{breadcrumbs}; - my $e = $self->{engine}; - - unless ( @$crumbs ) { - # This will be a Reference sector - my $sector = $e->_load_sector( $self->{base_offset} ) - # If no sector is found, thist must have been deleted from under us. - or return; - - if ( $sector->staleness != $obj->_staleness ) { - return; - } - - my $loc = $sector->get_blist_loc - or return; - - push @$crumbs, $self->get_sector_iterator( $loc ); - } - - FIND_NEXT_KEY: { - # We're at the end. - unless ( @$crumbs ) { - $self->reset; - return; - } - - my $iterator = $crumbs->[-1]; - - # This level is done. - if ( $iterator->at_end ) { - pop @$crumbs; - redo FIND_NEXT_KEY; - } - - if ( $iterator->isa( 'DBM::Deep::Iterator::Index' ) ) { - # If we don't have any more, it will be caught at the - # prior check. - if ( my $next = $iterator->get_next_iterator ) { - push @$crumbs, $next; - } - redo FIND_NEXT_KEY; - } - - unless ( $iterator->isa( 'DBM::Deep::Iterator::BucketList' ) ) { - DBM::Deep->_throw_error( - "Should have a bucketlist iterator here - instead have $iterator" - ); - } - - # At this point, we have a BucketList iterator - my $key = $iterator->get_next_key; - if ( defined $key ) { - return $key; - } - #XXX else { $iterator->set_to_end() } ? - - # We hit the end of the bucketlist iterator, so redo - redo FIND_NEXT_KEY; - } - - DBM::Deep->_throw_error( "get_next_key(): How did we get here?" ); -} - -package DBM::Deep::Iterator::Index; - -sub new { - my $self = bless $_[1] => $_[0]; - $self->{curr_index} = 0; - return $self; -} - -sub at_end { - my $self = shift; - return $self->{curr_index} >= $self->{iterator}{engine}->hash_chars; -} - -sub get_next_iterator { - my $self = shift; - - my $loc; - while ( !$loc ) { - return if $self->at_end; - $loc = $self->{sector}->get_entry( $self->{curr_index}++ ); - } - - return $self->{iterator}->get_sector_iterator( $loc ); -} - -package DBM::Deep::Iterator::BucketList; - -sub new { - my $self = bless $_[1] => $_[0]; - $self->{curr_index} = 0; - return $self; -} - -sub at_end { - my $self = shift; - return $self->{curr_index} >= $self->{iterator}{engine}->max_buckets; -} - -sub get_next_key { - my $self = shift; - - return if $self->at_end; - - my $idx = $self->{curr_index}++; - - my $data_loc = $self->{sector}->get_data_location_for({ - allow_head => 1, - idx => $idx, - }) or return; - - #XXX Do we want to add corruption checks here? - return $self->{sector}->get_key_for( $idx )->data; -} - -package DBM::Deep::Engine::Sector; - -sub new { - my $self = bless $_[1], $_[0]; - Scalar::Util::weaken( $self->{engine} ); - $self->_init; - return $self; -} - -#sub _init {} -#sub clone { DBM::Deep->_throw_error( "Must be implemented in the child class" ); } - -sub engine { $_[0]{engine} } -sub offset { $_[0]{offset} } -sub type { $_[0]{type} } - -sub base_size { - my $self = shift; - return $self->engine->SIG_SIZE + $STALE_SIZE; -} - -sub free { - my $self = shift; - - my $e = $self->engine; - - $e->storage->print_at( $self->offset, $e->SIG_FREE ); - # Skip staleness counter - $e->storage->print_at( $self->offset + $self->base_size, - chr(0) x ($self->size - $self->base_size), - ); - - my $free_meth = $self->free_meth; - $e->$free_meth( $self->offset, $self->size ); - - return; -} - -package DBM::Deep::Engine::Sector::Data; - -our @ISA = qw( DBM::Deep::Engine::Sector ); - -# This is in bytes -sub size { $_[0]{engine}->data_sector_size } -sub free_meth { return '_add_free_data_sector' } - -sub clone { - my $self = shift; - return ref($self)->new({ - engine => $self->engine, - type => $self->type, - data => $self->data, - }); -} - -package DBM::Deep::Engine::Sector::Scalar; - -our @ISA = qw( DBM::Deep::Engine::Sector::Data ); - -sub free { - my $self = shift; - - my $chain_loc = $self->chain_loc; - - $self->SUPER::free(); - - if ( $chain_loc ) { - $self->engine->_load_sector( $chain_loc )->free; - } - - return; -} - -sub type { $_[0]{engine}->SIG_DATA } -sub _init { - my $self = shift; - - my $engine = $self->engine; - - unless ( $self->offset ) { - my $data_section = $self->size - $self->base_size - $engine->byte_size - 1; - - $self->{offset} = $engine->_request_data_sector( $self->size ); - - my $data = delete $self->{data}; - my $dlen = length $data; - my $continue = 1; - my $curr_offset = $self->offset; - while ( $continue ) { - - my $next_offset = 0; - - my ($leftover, $this_len, $chunk); - if ( $dlen > $data_section ) { - $leftover = 0; - $this_len = $data_section; - $chunk = substr( $data, 0, $this_len ); - - $dlen -= $data_section; - $next_offset = $engine->_request_data_sector( $self->size ); - $data = substr( $data, $this_len ); - } - else { - $leftover = $data_section - $dlen; - $this_len = $dlen; - $chunk = $data; - - $continue = 0; - } - - $engine->storage->print_at( $curr_offset, $self->type ); # Sector type - # Skip staleness - $engine->storage->print_at( $curr_offset + $self->base_size, - pack( $StP{$engine->byte_size}, $next_offset ), # Chain loc - pack( $StP{1}, $this_len ), # Data length - $chunk, # Data to be stored in this sector - chr(0) x $leftover, # Zero-fill the rest - ); - - $curr_offset = $next_offset; - } - - return; - } -} - -sub data_length { - my $self = shift; - - my $buffer = $self->engine->storage->read_at( - $self->offset + $self->base_size + $self->engine->byte_size, 1 - ); - - return unpack( $StP{1}, $buffer ); -} - -sub chain_loc { - my $self = shift; - return unpack( - $StP{$self->engine->byte_size}, - $self->engine->storage->read_at( - $self->offset + $self->base_size, - $self->engine->byte_size, - ), - ); -} - -sub data { - my $self = shift; -# my ($args) = @_; -# $args ||= {}; - - my $data; - while ( 1 ) { - my $chain_loc = $self->chain_loc; - - $data .= $self->engine->storage->read_at( - $self->offset + $self->base_size + $self->engine->byte_size + 1, $self->data_length, - ); - - last unless $chain_loc; - - $self = $self->engine->_load_sector( $chain_loc ); - } - - return $data; -} - -package DBM::Deep::Engine::Sector::Null; - -our @ISA = qw( DBM::Deep::Engine::Sector::Data ); - -sub type { $_[0]{engine}->SIG_NULL } -sub data_length { 0 } -sub data { return } - -sub _init { - my $self = shift; - - my $engine = $self->engine; - - unless ( $self->offset ) { - my $leftover = $self->size - $self->base_size - 1 * $engine->byte_size - 1; - - $self->{offset} = $engine->_request_data_sector( $self->size ); - $engine->storage->print_at( $self->offset, $self->type ); # Sector type - # Skip staleness counter - $engine->storage->print_at( $self->offset + $self->base_size, - pack( $StP{$engine->byte_size}, 0 ), # Chain loc - pack( $StP{1}, $self->data_length ), # Data length - chr(0) x $leftover, # Zero-fill the rest - ); - - return; - } -} - -package DBM::Deep::Engine::Sector::Reference; - -our @ISA = qw( DBM::Deep::Engine::Sector::Data ); - -sub _init { - my $self = shift; - - my $e = $self->engine; - - unless ( $self->offset ) { - my $classname = Scalar::Util::blessed( delete $self->{data} ); - my $leftover = $self->size - $self->base_size - 3 * $e->byte_size; - - my $class_offset = 0; - if ( defined $classname ) { - my $class_sector = DBM::Deep::Engine::Sector::Scalar->new({ - engine => $e, - data => $classname, - }); - $class_offset = $class_sector->offset; - } - - $self->{offset} = $e->_request_data_sector( $self->size ); - $e->storage->print_at( $self->offset, $self->type ); # Sector type - # Skip staleness counter - $e->storage->print_at( $self->offset + $self->base_size, - pack( $StP{$e->byte_size}, 0 ), # Index/BList loc - pack( $StP{$e->byte_size}, $class_offset ), # Classname loc - pack( $StP{$e->byte_size}, 1 ), # Initial refcount - chr(0) x $leftover, # Zero-fill the rest - ); - } - else { - $self->{type} = $e->storage->read_at( $self->offset, 1 ); - } - - $self->{staleness} = unpack( - $StP{$STALE_SIZE}, - $e->storage->read_at( $self->offset + $e->SIG_SIZE, $STALE_SIZE ), - ); - - return; -} - -sub staleness { $_[0]{staleness} } - -sub get_data_location_for { - my $self = shift; - my ($args) = @_; - - # Assume that the head is not allowed unless otherwise specified. - $args->{allow_head} = 0 unless exists $args->{allow_head}; - - # Assume we don't create a new blist location unless otherwise specified. - $args->{create} = 0 unless exists $args->{create}; - - my $blist = $self->get_bucket_list({ - key_md5 => $args->{key_md5}, - key => $args->{key}, - create => $args->{create}, - }); - return unless $blist && $blist->{found}; - - # At this point, $blist knows where the md5 is. What it -doesn't- know yet - # is whether or not this transaction has this key. That's part of the next - # function call. - my $location = $blist->get_data_location_for({ - allow_head => $args->{allow_head}, - }) or return; - - return $location; -} - -sub get_data_for { - my $self = shift; - my ($args) = @_; - - my $location = $self->get_data_location_for( $args ) - or return; - - return $self->engine->_load_sector( $location ); -} - -sub write_data { - my $self = shift; - my ($args) = @_; - - my $blist = $self->get_bucket_list({ - key_md5 => $args->{key_md5}, - key => $args->{key}, - create => 1, - }) or DBM::Deep->_throw_error( "How did write_data fail (no blist)?!" ); - - # Handle any transactional bookkeeping. - if ( $self->engine->trans_id ) { - if ( ! $blist->has_md5 ) { - $blist->mark_deleted({ - trans_id => 0, - }); - } - } - else { - my @trans_ids = $self->engine->get_running_txn_ids; - if ( $blist->has_md5 ) { - if ( @trans_ids ) { - my $old_value = $blist->get_data_for; - foreach my $other_trans_id ( @trans_ids ) { - next if $blist->get_data_location_for({ - trans_id => $other_trans_id, - allow_head => 0, - }); - $blist->write_md5({ - trans_id => $other_trans_id, - key => $args->{key}, - key_md5 => $args->{key_md5}, - value => $old_value->clone, - }); - } - } - } - else { - if ( @trans_ids ) { - foreach my $other_trans_id ( @trans_ids ) { - #XXX This doesn't seem to possible to ever happen . . . - next if $blist->get_data_location_for({ trans_id => $other_trans_id, allow_head => 0 }); - $blist->mark_deleted({ - trans_id => $other_trans_id, - }); - } - } - } - } - - #XXX Is this safe to do transactionally? - # Free the place we're about to write to. - if ( $blist->get_data_location_for({ allow_head => 0 }) ) { - $blist->get_data_for({ allow_head => 0 })->free; - } - - $blist->write_md5({ - key => $args->{key}, - key_md5 => $args->{key_md5}, - value => $args->{value}, - }); -} - -sub delete_key { - my $self = shift; - my ($args) = @_; - - # XXX What should happen if this fails? - my $blist = $self->get_bucket_list({ - key_md5 => $args->{key_md5}, - }) or DBM::Deep->_throw_error( "How did delete_key fail (no blist)?!" ); - - # Save the location so that we can free the data - my $location = $blist->get_data_location_for({ - allow_head => 0, - }); - my $old_value = $location && $self->engine->_load_sector( $location ); - - my @trans_ids = $self->engine->get_running_txn_ids; - - # If we're the HEAD and there are running txns, then we need to clone this value to the other - # transactions to preserve Isolation. - if ( $self->engine->trans_id == 0 ) { - if ( @trans_ids ) { - foreach my $other_trans_id ( @trans_ids ) { - next if $blist->get_data_location_for({ trans_id => $other_trans_id, allow_head => 0 }); - $blist->write_md5({ - trans_id => $other_trans_id, - key => $args->{key}, - key_md5 => $args->{key_md5}, - value => $old_value->clone, - }); - } - } - } - - my $data; - if ( @trans_ids ) { - $blist->mark_deleted( $args ); - - if ( $old_value ) { - $data = $old_value->data({ export => 1 }); - $old_value->free; - } - } - else { - $data = $blist->delete_md5( $args ); - } - - return $data; -} - -sub get_blist_loc { - my $self = shift; - - my $e = $self->engine; - my $blist_loc = $e->storage->read_at( $self->offset + $self->base_size, $e->byte_size ); - return unpack( $StP{$e->byte_size}, $blist_loc ); -} - -sub get_bucket_list { - my $self = shift; - my ($args) = @_; - $args ||= {}; - - # XXX Add in check here for recycling? - - my $engine = $self->engine; - - my $blist_loc = $self->get_blist_loc; - - # There's no index or blist yet - unless ( $blist_loc ) { - return unless $args->{create}; - - my $blist = DBM::Deep::Engine::Sector::BucketList->new({ - engine => $engine, - key_md5 => $args->{key_md5}, - }); - - $engine->storage->print_at( $self->offset + $self->base_size, - pack( $StP{$engine->byte_size}, $blist->offset ), - ); - - return $blist; - } - - my $sector = $engine->_load_sector( $blist_loc ) - or DBM::Deep->_throw_error( "Cannot read sector at $blist_loc in get_bucket_list()" ); - my $i = 0; - my $last_sector = undef; - while ( $sector->isa( 'DBM::Deep::Engine::Sector::Index' ) ) { - $blist_loc = $sector->get_entry( ord( substr( $args->{key_md5}, $i++, 1 ) ) ); - $last_sector = $sector; - if ( $blist_loc ) { - $sector = $engine->_load_sector( $blist_loc ) - or DBM::Deep->_throw_error( "Cannot read sector at $blist_loc in get_bucket_list()" ); - } - else { - $sector = undef; - last; - } - } - - # This means we went through the Index sector(s) and found an empty slot - unless ( $sector ) { - return unless $args->{create}; - - DBM::Deep->_throw_error( "No last_sector when attempting to build a new entry" ) - unless $last_sector; - - my $blist = DBM::Deep::Engine::Sector::BucketList->new({ - engine => $engine, - key_md5 => $args->{key_md5}, - }); - - $last_sector->set_entry( ord( substr( $args->{key_md5}, $i - 1, 1 ) ) => $blist->offset ); - - return $blist; - } - - $sector->find_md5( $args->{key_md5} ); - - # See whether or not we need to reindex the bucketlist - # Yes, the double-braces are there for a reason. if() doesn't create a redo-able block, - # so we have to create a bare block within the if() for redo-purposes. Patch and idea - # submitted by sprout@cpan.org. -RobK, 2008-01-09 - if ( !$sector->has_md5 && $args->{create} && $sector->{idx} == -1 ) {{ - my $redo; - - my $new_index = DBM::Deep::Engine::Sector::Index->new({ - engine => $engine, - }); - - my %blist_cache; - #XXX q.v. the comments for this function. - foreach my $entry ( $sector->chopped_up ) { - my ($spot, $md5) = @{$entry}; - my $idx = ord( substr( $md5, $i, 1 ) ); - - # XXX This is inefficient - my $blist = $blist_cache{$idx} - ||= DBM::Deep::Engine::Sector::BucketList->new({ - engine => $engine, - }); - - $new_index->set_entry( $idx => $blist->offset ); - - my $new_spot = $blist->write_at_next_open( $md5 ); - $engine->reindex_entry( $spot => $new_spot ); - } - - # Handle the new item separately. - { - my $idx = ord( substr( $args->{key_md5}, $i, 1 ) ); - - # If all the previous blist's items have been thrown into one - # blist and the new item belongs in there too, we need - # another index. - if ( keys %blist_cache == 1 and each %blist_cache == $idx ) { - ++$i, ++$redo; - } else { - my $blist = $blist_cache{$idx} - ||= DBM::Deep::Engine::Sector::BucketList->new({ - engine => $engine, - }); - - $new_index->set_entry( $idx => $blist->offset ); - - #XXX THIS IS HACKY! - $blist->find_md5( $args->{key_md5} ); - $blist->write_md5({ - key => $args->{key}, - key_md5 => $args->{key_md5}, - value => DBM::Deep::Engine::Sector::Null->new({ - engine => $engine, - data => undef, - }), - }); - } -# my $blist = $blist_cache{$idx} -# ||= DBM::Deep::Engine::Sector::BucketList->new({ -# engine => $engine, -# }); -# -# $new_index->set_entry( $idx => $blist->offset ); -# -# #XXX THIS IS HACKY! -# $blist->find_md5( $args->{key_md5} ); -# $blist->write_md5({ -# key => $args->{key}, -# key_md5 => $args->{key_md5}, -# value => DBM::Deep::Engine::Sector::Null->new({ -# engine => $engine, -# data => undef, -# }), -# }); - } - - if ( $last_sector ) { - $last_sector->set_entry( - ord( substr( $args->{key_md5}, $i - 1, 1 ) ), - $new_index->offset, - ); - } else { - $engine->storage->print_at( $self->offset + $self->base_size, - pack( $StP{$engine->byte_size}, $new_index->offset ), - ); - } - - $sector->clear; - $sector->free; - - if ( $redo ) { - (undef, $sector) = %blist_cache; - $last_sector = $new_index; - redo; - } - - $sector = $blist_cache{ ord( substr( $args->{key_md5}, $i, 1 ) ) }; - $sector->find_md5( $args->{key_md5} ); - }} - - return $sector; -} - -sub get_class_offset { - my $self = shift; - - my $e = $self->engine; - return unpack( - $StP{$e->byte_size}, - $e->storage->read_at( - $self->offset + $self->base_size + 1 * $e->byte_size, $e->byte_size, - ), - ); -} - -sub get_classname { - my $self = shift; - - my $class_offset = $self->get_class_offset; - - return unless $class_offset; - - return $self->engine->_load_sector( $class_offset )->data; -} - -sub data { - my $self = shift; - my ($args) = @_; - $args ||= {}; - - my $obj; - unless ( $obj = $self->engine->cache->{ $self->offset } ) { - $obj = DBM::Deep->new({ - type => $self->type, - base_offset => $self->offset, - staleness => $self->staleness, - storage => $self->engine->storage, - engine => $self->engine, - }); - - if ( $self->engine->storage->{autobless} ) { - my $classname = $self->get_classname; - if ( defined $classname ) { - bless $obj, $classname; - } - } - - $self->engine->cache->{$self->offset} = $obj; - } - - # We're not exporting, so just return. - unless ( $args->{export} ) { - return $obj; - } - - # We shouldn't export if this is still referred to. - if ( $self->get_refcount > 1 ) { - return $obj; - } - - return $obj->export; -} - -sub free { - my $self = shift; - - # We're not ready to be removed yet. - if ( $self->decrement_refcount > 0 ) { - return; - } - - # Rebless the object into DBM::Deep::Null. - eval { %{ $self->engine->cache->{ $self->offset } } = (); }; - eval { @{ $self->engine->cache->{ $self->offset } } = (); }; - bless $self->engine->cache->{ $self->offset }, 'DBM::Deep::Null'; - delete $self->engine->cache->{ $self->offset }; - - my $blist_loc = $self->get_blist_loc; - $self->engine->_load_sector( $blist_loc )->free if $blist_loc; - - my $class_loc = $self->get_class_offset; - $self->engine->_load_sector( $class_loc )->free if $class_loc; - - $self->SUPER::free(); -} - -sub increment_refcount { - my $self = shift; - - my $refcount = $self->get_refcount; - - $refcount++; - - $self->write_refcount( $refcount ); - - return $refcount; -} - -sub decrement_refcount { - my $self = shift; - - my $refcount = $self->get_refcount; - - $refcount--; - - $self->write_refcount( $refcount ); - - return $refcount; -} - -sub get_refcount { - my $self = shift; - - my $e = $self->engine; - return unpack( - $StP{$e->byte_size}, - $e->storage->read_at( - $self->offset + $self->base_size + 2 * $e->byte_size, $e->byte_size, - ), - ); -} - -sub write_refcount { - my $self = shift; - my ($num) = @_; - - my $e = $self->engine; - $e->storage->print_at( - $self->offset + $self->base_size + 2 * $e->byte_size, - pack( $StP{$e->byte_size}, $num ), - ); -} - -package DBM::Deep::Engine::Sector::BucketList; - -our @ISA = qw( DBM::Deep::Engine::Sector ); - -sub _init { - my $self = shift; - - my $engine = $self->engine; - - unless ( $self->offset ) { - my $leftover = $self->size - $self->base_size; - - $self->{offset} = $engine->_request_blist_sector( $self->size ); - $engine->storage->print_at( $self->offset, $engine->SIG_BLIST ); # Sector type - # Skip staleness counter - $engine->storage->print_at( $self->offset + $self->base_size, - chr(0) x $leftover, # Zero-fill the data - ); - } - - if ( $self->{key_md5} ) { - $self->find_md5; - } - - return $self; -} - -sub clear { - my $self = shift; - $self->engine->storage->print_at( $self->offset + $self->base_size, - chr(0) x ($self->size - $self->base_size), # Zero-fill the data - ); -} - -sub size { - my $self = shift; - unless ( $self->{size} ) { - my $e = $self->engine; - # Base + numbuckets * bucketsize - $self->{size} = $self->base_size + $e->max_buckets * $self->bucket_size; - } - return $self->{size}; -} - -sub free_meth { return '_add_free_blist_sector' } - -sub free { - my $self = shift; - - my $e = $self->engine; - foreach my $bucket ( $self->chopped_up ) { - my $rest = $bucket->[-1]; - - # Delete the keysector - my $l = unpack( $StP{$e->byte_size}, substr( $rest, $e->hash_size, $e->byte_size ) ); - my $s = $e->_load_sector( $l ); $s->free if $s; - - # Delete the HEAD sector - $l = unpack( $StP{$e->byte_size}, - substr( $rest, - $e->hash_size + $e->byte_size, - $e->byte_size, - ), - ); - $s = $e->_load_sector( $l ); $s->free if $s; - - foreach my $txn ( 0 .. $e->num_txns - 2 ) { - my $l = unpack( $StP{$e->byte_size}, - substr( $rest, - $e->hash_size + 2 * $e->byte_size + $txn * ($e->byte_size + $STALE_SIZE), - $e->byte_size, - ), - ); - my $s = $e->_load_sector( $l ); $s->free if $s; - } - } - - $self->SUPER::free(); -} - -sub bucket_size { - my $self = shift; - unless ( $self->{bucket_size} ) { - my $e = $self->engine; - # Key + head (location) + transactions (location + staleness-counter) - my $location_size = $e->byte_size + $e->byte_size + ($e->num_txns - 1) * ($e->byte_size + $STALE_SIZE); - $self->{bucket_size} = $e->hash_size + $location_size; - } - return $self->{bucket_size}; -} - -# XXX This is such a poor hack. I need to rethink this code. -sub chopped_up { - my $self = shift; - - my $e = $self->engine; - - my @buckets; - foreach my $idx ( 0 .. $e->max_buckets - 1 ) { - my $spot = $self->offset + $self->base_size + $idx * $self->bucket_size; - my $md5 = $e->storage->read_at( $spot, $e->hash_size ); - - #XXX If we're chopping, why would we ever have the blank_md5? - last if $md5 eq $e->blank_md5; - - my $rest = $e->storage->read_at( undef, $self->bucket_size - $e->hash_size ); - push @buckets, [ $spot, $md5 . $rest ]; - } - - return @buckets; -} - -sub write_at_next_open { - my $self = shift; - my ($entry) = @_; - - #XXX This is such a hack! - $self->{_next_open} = 0 unless exists $self->{_next_open}; - - my $spot = $self->offset + $self->base_size + $self->{_next_open}++ * $self->bucket_size; - $self->engine->storage->print_at( $spot, $entry ); - - return $spot; -} - -sub has_md5 { - my $self = shift; - unless ( exists $self->{found} ) { - $self->find_md5; - } - return $self->{found}; -} - -sub find_md5 { - my $self = shift; - - $self->{found} = undef; - $self->{idx} = -1; - - if ( @_ ) { - $self->{key_md5} = shift; - } - - # If we don't have an MD5, then what are we supposed to do? - unless ( exists $self->{key_md5} ) { - DBM::Deep->_throw_error( "Cannot find_md5 without a key_md5 set" ); - } - - my $e = $self->engine; - foreach my $idx ( 0 .. $e->max_buckets - 1 ) { - my $potential = $e->storage->read_at( - $self->offset + $self->base_size + $idx * $self->bucket_size, $e->hash_size, - ); - - if ( $potential eq $e->blank_md5 ) { - $self->{idx} = $idx; - return; - } - - if ( $potential eq $self->{key_md5} ) { - $self->{found} = 1; - $self->{idx} = $idx; - return; - } - } - - return; -} - -sub write_md5 { - my $self = shift; - my ($args) = @_; - - DBM::Deep->_throw_error( "write_md5: no key" ) unless exists $args->{key}; - DBM::Deep->_throw_error( "write_md5: no key_md5" ) unless exists $args->{key_md5}; - DBM::Deep->_throw_error( "write_md5: no value" ) unless exists $args->{value}; - - my $engine = $self->engine; - - $args->{trans_id} = $engine->trans_id unless exists $args->{trans_id}; - - my $spot = $self->offset + $self->base_size + $self->{idx} * $self->bucket_size; - $engine->add_entry( $args->{trans_id}, $spot ); - - unless ($self->{found}) { - my $key_sector = DBM::Deep::Engine::Sector::Scalar->new({ - engine => $engine, - data => $args->{key}, - }); - - $engine->storage->print_at( $spot, - $args->{key_md5}, - pack( $StP{$engine->byte_size}, $key_sector->offset ), - ); - } - - my $loc = $spot - + $engine->hash_size - + $engine->byte_size; - - if ( $args->{trans_id} ) { - $loc += $engine->byte_size + ($args->{trans_id} - 1) * ( $engine->byte_size + $STALE_SIZE ); - - $engine->storage->print_at( $loc, - pack( $StP{$engine->byte_size}, $args->{value}->offset ), - pack( $StP{$STALE_SIZE}, $engine->get_txn_staleness_counter( $args->{trans_id} ) ), - ); - } - else { - $engine->storage->print_at( $loc, - pack( $StP{$engine->byte_size}, $args->{value}->offset ), - ); - } -} - -sub mark_deleted { - my $self = shift; - my ($args) = @_; - $args ||= {}; - - my $engine = $self->engine; - - $args->{trans_id} = $engine->trans_id unless exists $args->{trans_id}; - - my $spot = $self->offset + $self->base_size + $self->{idx} * $self->bucket_size; - $engine->add_entry( $args->{trans_id}, $spot ); - - my $loc = $spot - + $engine->hash_size - + $engine->byte_size; - - if ( $args->{trans_id} ) { - $loc += $engine->byte_size + ($args->{trans_id} - 1) * ( $engine->byte_size + $STALE_SIZE ); - - $engine->storage->print_at( $loc, - pack( $StP{$engine->byte_size}, 1 ), # 1 is the marker for deleted - pack( $StP{$STALE_SIZE}, $engine->get_txn_staleness_counter( $args->{trans_id} ) ), - ); - } - else { - $engine->storage->print_at( $loc, - pack( $StP{$engine->byte_size}, 1 ), # 1 is the marker for deleted - ); - } - -} - -sub delete_md5 { - my $self = shift; - my ($args) = @_; - - my $engine = $self->engine; - return undef unless $self->{found}; - - # Save the location so that we can free the data - my $location = $self->get_data_location_for({ - allow_head => 0, - }); - my $key_sector = $self->get_key_for; - - my $spot = $self->offset + $self->base_size + $self->{idx} * $self->bucket_size; - $engine->storage->print_at( $spot, - $engine->storage->read_at( - $spot + $self->bucket_size, - $self->bucket_size * ( $engine->max_buckets - $self->{idx} - 1 ), - ), - chr(0) x $self->bucket_size, - ); - - $key_sector->free; - - my $data_sector = $self->engine->_load_sector( $location ); - my $data = $data_sector->data({ export => 1 }); - $data_sector->free; - - return $data; -} - -sub get_data_location_for { - my $self = shift; - my ($args) = @_; - $args ||= {}; - - $args->{allow_head} = 0 unless exists $args->{allow_head}; - $args->{trans_id} = $self->engine->trans_id unless exists $args->{trans_id}; - $args->{idx} = $self->{idx} unless exists $args->{idx}; - - my $e = $self->engine; - - my $spot = $self->offset + $self->base_size - + $args->{idx} * $self->bucket_size - + $e->hash_size - + $e->byte_size; - - if ( $args->{trans_id} ) { - $spot += $e->byte_size + ($args->{trans_id} - 1) * ( $e->byte_size + $STALE_SIZE ); - } - - my $buffer = $e->storage->read_at( - $spot, - $e->byte_size + $STALE_SIZE, - ); - my ($loc, $staleness) = unpack( $StP{$e->byte_size} . ' ' . $StP{$STALE_SIZE}, $buffer ); - - # XXX Merge the two if-clauses below - if ( $args->{trans_id} ) { - # We have found an entry that is old, so get rid of it - if ( $staleness != (my $s = $e->get_txn_staleness_counter( $args->{trans_id} ) ) ) { - $e->storage->print_at( - $spot, - pack( $StP{$e->byte_size} . ' ' . $StP{$STALE_SIZE}, (0) x 2 ), - ); - $loc = 0; - } - } - - # If we're in a transaction and we never wrote to this location, try the - # HEAD instead. - if ( $args->{trans_id} && !$loc && $args->{allow_head} ) { - return $self->get_data_location_for({ - trans_id => 0, - allow_head => 1, - idx => $args->{idx}, - }); - } - - return $loc <= 1 ? 0 : $loc; -} - -sub get_data_for { - my $self = shift; - my ($args) = @_; - $args ||= {}; - - return unless $self->{found}; - my $location = $self->get_data_location_for({ - allow_head => $args->{allow_head}, - }); - return $self->engine->_load_sector( $location ); -} - -sub get_key_for { - my $self = shift; - my ($idx) = @_; - $idx = $self->{idx} unless defined $idx; - - if ( $idx >= $self->engine->max_buckets ) { - DBM::Deep->_throw_error( "get_key_for(): Attempting to retrieve $idx" ); - } - - my $location = $self->engine->storage->read_at( - $self->offset + $self->base_size + $idx * $self->bucket_size + $self->engine->hash_size, - $self->engine->byte_size, - ); - $location = unpack( $StP{$self->engine->byte_size}, $location ); - DBM::Deep->_throw_error( "get_key_for: No location?" ) unless $location; - - return $self->engine->_load_sector( $location ); -} - -package DBM::Deep::Engine::Sector::Index; - -our @ISA = qw( DBM::Deep::Engine::Sector ); - -sub _init { - my $self = shift; - - my $engine = $self->engine; - - unless ( $self->offset ) { - my $leftover = $self->size - $self->base_size; - - $self->{offset} = $engine->_request_index_sector( $self->size ); - $engine->storage->print_at( $self->offset, $engine->SIG_INDEX ); # Sector type - # Skip staleness counter - $engine->storage->print_at( $self->offset + $self->base_size, - chr(0) x $leftover, # Zero-fill the rest - ); - } - - return $self; -} - -#XXX Change here -sub size { - my $self = shift; - unless ( $self->{size} ) { - my $e = $self->engine; - $self->{size} = $self->base_size + $e->byte_size * $e->hash_chars; - } - return $self->{size}; -} - -sub free_meth { return '_add_free_index_sector' } - -sub free { - my $self = shift; - my $e = $self->engine; - - for my $i ( 0 .. $e->hash_chars - 1 ) { - my $l = $self->get_entry( $i ) or next; - $e->_load_sector( $l )->free; - } - - $self->SUPER::free(); -} - -sub _loc_for { - my $self = shift; - my ($idx) = @_; - return $self->offset + $self->base_size + $idx * $self->engine->byte_size; -} - -sub get_entry { - my $self = shift; - my ($idx) = @_; - - my $e = $self->engine; - - DBM::Deep->_throw_error( "get_entry: Out of range ($idx)" ) - if $idx < 0 || $idx >= $e->hash_chars; - - return unpack( - $StP{$e->byte_size}, - $e->storage->read_at( $self->_loc_for( $idx ), $e->byte_size ), - ); -} - -sub set_entry { - my $self = shift; - my ($idx, $loc) = @_; - - my $e = $self->engine; - - DBM::Deep->_throw_error( "set_entry: Out of range ($idx)" ) - if $idx < 0 || $idx >= $e->hash_chars; - - $self->engine->storage->print_at( - $self->_loc_for( $idx ), - pack( $StP{$e->byte_size}, $loc ), - ); -} - -# This was copied from MARCEL's Class::Null. However, I couldn't use it because -# I need an undef value, not an implementation of the Null Class pattern. -package DBM::Deep::Null; - -use overload - 'bool' => sub { undef }, - '""' => sub { undef }, - '0+' => sub { undef }, - fallback => 1, - nomethod => 'AUTOLOAD'; - -sub AUTOLOAD { return; } - 1; __END__ diff --git a/lib/DBM/Deep/Engine/Sector.pm b/lib/DBM/Deep/Engine/Sector.pm new file mode 100644 index 0000000..be079d0 --- /dev/null +++ b/lib/DBM/Deep/Engine/Sector.pm @@ -0,0 +1,48 @@ +package DBM::Deep::Engine::Sector; + +use 5.006; + +use strict; +use warnings FATAL => 'all'; + +use Scalar::Util (); + +sub new { + my $self = bless $_[1], $_[0]; + Scalar::Util::weaken( $self->{engine} ); + $self->_init; + return $self; +} + +#sub _init {} +#sub clone { DBM::Deep->_throw_error( "Must be implemented in the child class" ); } + +sub engine { $_[0]{engine} } +sub offset { $_[0]{offset} } +sub type { $_[0]{type} } + +sub base_size { + my $self = shift; + no warnings 'once'; + return $self->engine->SIG_SIZE + $DBM::Deep::Engine::STALE_SIZE; +} + +sub free { + my $self = shift; + + my $e = $self->engine; + + $e->storage->print_at( $self->offset, $e->SIG_FREE ); + # Skip staleness counter + $e->storage->print_at( $self->offset + $self->base_size, + chr(0) x ($self->size - $self->base_size), + ); + + my $free_meth = $self->free_meth; + $e->$free_meth( $self->offset, $self->size ); + + return; +} + +1; +__END__ diff --git a/lib/DBM/Deep/Engine/Sector/BucketList.pm b/lib/DBM/Deep/Engine/Sector/BucketList.pm new file mode 100644 index 0000000..a083172 --- /dev/null +++ b/lib/DBM/Deep/Engine/Sector/BucketList.pm @@ -0,0 +1,369 @@ +#TODO: Convert this to a string +package DBM::Deep::Engine::Sector::BucketList; + +use 5.006; + +use strict; +use warnings FATAL => 'all'; + +use DBM::Deep::Engine::Sector; +our @ISA = qw( DBM::Deep::Engine::Sector ); + +sub _init { + my $self = shift; + + my $engine = $self->engine; + + unless ( $self->offset ) { + my $leftover = $self->size - $self->base_size; + + $self->{offset} = $engine->_request_blist_sector( $self->size ); + $engine->storage->print_at( $self->offset, $engine->SIG_BLIST ); # Sector type + # Skip staleness counter + $engine->storage->print_at( $self->offset + $self->base_size, + chr(0) x $leftover, # Zero-fill the data + ); + } + + if ( $self->{key_md5} ) { + $self->find_md5; + } + + return $self; +} + +sub clear { + my $self = shift; + $self->engine->storage->print_at( $self->offset + $self->base_size, + chr(0) x ($self->size - $self->base_size), # Zero-fill the data + ); +} + +sub size { + my $self = shift; + unless ( $self->{size} ) { + my $e = $self->engine; + # Base + numbuckets * bucketsize + $self->{size} = $self->base_size + $e->max_buckets * $self->bucket_size; + } + return $self->{size}; +} + +sub free_meth { return '_add_free_blist_sector' } + +sub free { + my $self = shift; + + my $e = $self->engine; + foreach my $bucket ( $self->chopped_up ) { + my $rest = $bucket->[-1]; + + # Delete the keysector + my $l = unpack( $e->StP($e->byte_size), substr( $rest, $e->hash_size, $e->byte_size ) ); + my $s = $e->_load_sector( $l ); $s->free if $s; + + # Delete the HEAD sector + $l = unpack( $e->StP($e->byte_size), + substr( $rest, + $e->hash_size + $e->byte_size, + $e->byte_size, + ), + ); + $s = $e->_load_sector( $l ); $s->free if $s; + + foreach my $txn ( 0 .. $e->num_txns - 2 ) { + my $l = unpack( $e->StP($e->byte_size), + substr( $rest, + $e->hash_size + 2 * $e->byte_size + $txn * ($e->byte_size + $DBM::Deep::Engine::STALE_SIZE), + $e->byte_size, + ), + ); + my $s = $e->_load_sector( $l ); $s->free if $s; + } + } + + $self->SUPER::free(); +} + +sub bucket_size { + my $self = shift; + unless ( $self->{bucket_size} ) { + my $e = $self->engine; + # Key + head (location) + transactions (location + staleness-counter) + my $location_size = $e->byte_size + $e->byte_size + ($e->num_txns - 1) * ($e->byte_size + $DBM::Deep::Engine::STALE_SIZE); + $self->{bucket_size} = $e->hash_size + $location_size; + } + return $self->{bucket_size}; +} + +# XXX This is such a poor hack. I need to rethink this code. +sub chopped_up { + my $self = shift; + + my $e = $self->engine; + + my @buckets; + foreach my $idx ( 0 .. $e->max_buckets - 1 ) { + my $spot = $self->offset + $self->base_size + $idx * $self->bucket_size; + my $md5 = $e->storage->read_at( $spot, $e->hash_size ); + + #XXX If we're chopping, why would we ever have the blank_md5? + last if $md5 eq $e->blank_md5; + + my $rest = $e->storage->read_at( undef, $self->bucket_size - $e->hash_size ); + push @buckets, [ $spot, $md5 . $rest ]; + } + + return @buckets; +} + +sub write_at_next_open { + my $self = shift; + my ($entry) = @_; + + #XXX This is such a hack! + $self->{_next_open} = 0 unless exists $self->{_next_open}; + + my $spot = $self->offset + $self->base_size + $self->{_next_open}++ * $self->bucket_size; + $self->engine->storage->print_at( $spot, $entry ); + + return $spot; +} + +sub has_md5 { + my $self = shift; + unless ( exists $self->{found} ) { + $self->find_md5; + } + return $self->{found}; +} + +sub find_md5 { + my $self = shift; + + $self->{found} = undef; + $self->{idx} = -1; + + if ( @_ ) { + $self->{key_md5} = shift; + } + + # If we don't have an MD5, then what are we supposed to do? + unless ( exists $self->{key_md5} ) { + DBM::Deep->_throw_error( "Cannot find_md5 without a key_md5 set" ); + } + + my $e = $self->engine; + foreach my $idx ( 0 .. $e->max_buckets - 1 ) { + my $potential = $e->storage->read_at( + $self->offset + $self->base_size + $idx * $self->bucket_size, $e->hash_size, + ); + + if ( $potential eq $e->blank_md5 ) { + $self->{idx} = $idx; + return; + } + + if ( $potential eq $self->{key_md5} ) { + $self->{found} = 1; + $self->{idx} = $idx; + return; + } + } + + return; +} + +sub write_md5 { + my $self = shift; + my ($args) = @_; + + DBM::Deep->_throw_error( "write_md5: no key" ) unless exists $args->{key}; + DBM::Deep->_throw_error( "write_md5: no key_md5" ) unless exists $args->{key_md5}; + DBM::Deep->_throw_error( "write_md5: no value" ) unless exists $args->{value}; + + my $engine = $self->engine; + + $args->{trans_id} = $engine->trans_id unless exists $args->{trans_id}; + + my $spot = $self->offset + $self->base_size + $self->{idx} * $self->bucket_size; + $engine->add_entry( $args->{trans_id}, $spot ); + + unless ($self->{found}) { + my $key_sector = DBM::Deep::Engine::Sector::Scalar->new({ + engine => $engine, + data => $args->{key}, + }); + + $engine->storage->print_at( $spot, + $args->{key_md5}, + pack( $engine->StP($engine->byte_size), $key_sector->offset ), + ); + } + + my $loc = $spot + + $engine->hash_size + + $engine->byte_size; + + if ( $args->{trans_id} ) { + $loc += $engine->byte_size + ($args->{trans_id} - 1) * ( $engine->byte_size + $DBM::Deep::Engine::STALE_SIZE ); + + $engine->storage->print_at( $loc, + pack( $engine->StP($engine->byte_size), $args->{value}->offset ), + pack( $engine->StP($DBM::Deep::Engine::STALE_SIZE), $engine->get_txn_staleness_counter( $args->{trans_id} ) ), + ); + } + else { + $engine->storage->print_at( $loc, + pack( $engine->StP($engine->byte_size), $args->{value}->offset ), + ); + } +} + +sub mark_deleted { + my $self = shift; + my ($args) = @_; + $args ||= {}; + + my $engine = $self->engine; + + $args->{trans_id} = $engine->trans_id unless exists $args->{trans_id}; + + my $spot = $self->offset + $self->base_size + $self->{idx} * $self->bucket_size; + $engine->add_entry( $args->{trans_id}, $spot ); + + my $loc = $spot + + $engine->hash_size + + $engine->byte_size; + + if ( $args->{trans_id} ) { + $loc += $engine->byte_size + ($args->{trans_id} - 1) * ( $engine->byte_size + $DBM::Deep::Engine::STALE_SIZE ); + + $engine->storage->print_at( $loc, + pack( $engine->StP($engine->byte_size), 1 ), # 1 is the marker for deleted + pack( $engine->StP($DBM::Deep::Engine::STALE_SIZE), $engine->get_txn_staleness_counter( $args->{trans_id} ) ), + ); + } + else { + $engine->storage->print_at( $loc, + pack( $engine->StP($engine->byte_size), 1 ), # 1 is the marker for deleted + ); + } + +} + +sub delete_md5 { + my $self = shift; + my ($args) = @_; + + my $engine = $self->engine; + return undef unless $self->{found}; + + # Save the location so that we can free the data + my $location = $self->get_data_location_for({ + allow_head => 0, + }); + my $key_sector = $self->get_key_for; + + my $spot = $self->offset + $self->base_size + $self->{idx} * $self->bucket_size; + $engine->storage->print_at( $spot, + $engine->storage->read_at( + $spot + $self->bucket_size, + $self->bucket_size * ( $engine->max_buckets - $self->{idx} - 1 ), + ), + chr(0) x $self->bucket_size, + ); + + $key_sector->free; + + my $data_sector = $self->engine->_load_sector( $location ); + my $data = $data_sector->data({ export => 1 }); + $data_sector->free; + + return $data; +} + +sub get_data_location_for { + my $self = shift; + my ($args) = @_; + $args ||= {}; + + $args->{allow_head} = 0 unless exists $args->{allow_head}; + $args->{trans_id} = $self->engine->trans_id unless exists $args->{trans_id}; + $args->{idx} = $self->{idx} unless exists $args->{idx}; + + my $e = $self->engine; + + my $spot = $self->offset + $self->base_size + + $args->{idx} * $self->bucket_size + + $e->hash_size + + $e->byte_size; + + if ( $args->{trans_id} ) { + $spot += $e->byte_size + ($args->{trans_id} - 1) * ( $e->byte_size + $DBM::Deep::Engine::STALE_SIZE ); + } + + my $buffer = $e->storage->read_at( + $spot, + $e->byte_size + $DBM::Deep::Engine::STALE_SIZE, + ); + my ($loc, $staleness) = unpack( $e->StP($e->byte_size) . ' ' . $e->StP($DBM::Deep::Engine::STALE_SIZE), $buffer ); + + # XXX Merge the two if-clauses below + if ( $args->{trans_id} ) { + # We have found an entry that is old, so get rid of it + if ( $staleness != (my $s = $e->get_txn_staleness_counter( $args->{trans_id} ) ) ) { + $e->storage->print_at( + $spot, + pack( $e->StP($e->byte_size) . ' ' . $e->StP($DBM::Deep::Engine::STALE_SIZE), (0) x 2 ), + ); + $loc = 0; + } + } + + # If we're in a transaction and we never wrote to this location, try the + # HEAD instead. + if ( $args->{trans_id} && !$loc && $args->{allow_head} ) { + return $self->get_data_location_for({ + trans_id => 0, + allow_head => 1, + idx => $args->{idx}, + }); + } + + return $loc <= 1 ? 0 : $loc; +} + +sub get_data_for { + my $self = shift; + my ($args) = @_; + $args ||= {}; + + return unless $self->{found}; + my $location = $self->get_data_location_for({ + allow_head => $args->{allow_head}, + }); + return $self->engine->_load_sector( $location ); +} + +sub get_key_for { + my $self = shift; + my ($idx) = @_; + $idx = $self->{idx} unless defined $idx; + + if ( $idx >= $self->engine->max_buckets ) { + DBM::Deep->_throw_error( "get_key_for(): Attempting to retrieve $idx" ); + } + + my $location = $self->engine->storage->read_at( + $self->offset + $self->base_size + $idx * $self->bucket_size + $self->engine->hash_size, + $self->engine->byte_size, + ); + $location = unpack( $self->engine->StP($self->engine->byte_size), $location ); + DBM::Deep->_throw_error( "get_key_for: No location?" ) unless $location; + + return $self->engine->_load_sector( $location ); +} + +1; +__END__ diff --git a/lib/DBM/Deep/Engine/Sector/Data.pm b/lib/DBM/Deep/Engine/Sector/Data.pm new file mode 100644 index 0000000..d39fac6 --- /dev/null +++ b/lib/DBM/Deep/Engine/Sector/Data.pm @@ -0,0 +1,27 @@ +package DBM::Deep::Engine::Sector::Data; + +use 5.006; + +use strict; +use warnings FATAL => 'all'; + +our $VERSION = '0.01'; + +use DBM::Deep::Engine::Sector; +our @ISA = qw( DBM::Deep::Engine::Sector ); + +# This is in bytes +sub size { $_[0]{engine}->data_sector_size } +sub free_meth { return '_add_free_data_sector' } + +sub clone { + my $self = shift; + return ref($self)->new({ + engine => $self->engine, + type => $self->type, + data => $self->data, + }); +} + +1; +__END__ diff --git a/lib/DBM/Deep/Engine/Sector/Index.pm b/lib/DBM/Deep/Engine/Sector/Index.pm new file mode 100644 index 0000000..8278f9a --- /dev/null +++ b/lib/DBM/Deep/Engine/Sector/Index.pm @@ -0,0 +1,92 @@ +#TODO: Convert this to a string +package DBM::Deep::Engine::Sector::Index; + +use 5.006; + +use strict; +use warnings FATAL => 'all'; + +use DBM::Deep::Engine::Sector; +our @ISA = qw( DBM::Deep::Engine::Sector ); + +sub _init { + my $self = shift; + + my $engine = $self->engine; + + unless ( $self->offset ) { + my $leftover = $self->size - $self->base_size; + + $self->{offset} = $engine->_request_index_sector( $self->size ); + $engine->storage->print_at( $self->offset, $engine->SIG_INDEX ); # Sector type + # Skip staleness counter + $engine->storage->print_at( $self->offset + $self->base_size, + chr(0) x $leftover, # Zero-fill the rest + ); + } + + return $self; +} + +#XXX Change here +sub size { + my $self = shift; + unless ( $self->{size} ) { + my $e = $self->engine; + $self->{size} = $self->base_size + $e->byte_size * $e->hash_chars; + } + return $self->{size}; +} + +sub free_meth { return '_add_free_index_sector' } + +sub free { + my $self = shift; + my $e = $self->engine; + + for my $i ( 0 .. $e->hash_chars - 1 ) { + my $l = $self->get_entry( $i ) or next; + $e->_load_sector( $l )->free; + } + + $self->SUPER::free(); +} + +sub _loc_for { + my $self = shift; + my ($idx) = @_; + return $self->offset + $self->base_size + $idx * $self->engine->byte_size; +} + +sub get_entry { + my $self = shift; + my ($idx) = @_; + + my $e = $self->engine; + + DBM::Deep->_throw_error( "get_entry: Out of range ($idx)" ) + if $idx < 0 || $idx >= $e->hash_chars; + + return unpack( + $e->StP($e->byte_size), + $e->storage->read_at( $self->_loc_for( $idx ), $e->byte_size ), + ); +} + +sub set_entry { + my $self = shift; + my ($idx, $loc) = @_; + + my $e = $self->engine; + + DBM::Deep->_throw_error( "set_entry: Out of range ($idx)" ) + if $idx < 0 || $idx >= $e->hash_chars; + + $self->engine->storage->print_at( + $self->_loc_for( $idx ), + pack( $e->StP($e->byte_size), $loc ), + ); +} + +1; +__END__ diff --git a/lib/DBM/Deep/Engine/Sector/Null.pm b/lib/DBM/Deep/Engine/Sector/Null.pm new file mode 100644 index 0000000..c97f0f5 --- /dev/null +++ b/lib/DBM/Deep/Engine/Sector/Null.pm @@ -0,0 +1,38 @@ +package DBM::Deep::Engine::Sector::Null; + +use 5.006; + +use strict; +use warnings FATAL => 'all'; + +use DBM::Deep::Engine::Sector::Data; +our @ISA = qw( DBM::Deep::Engine::Sector::Data ); + +sub type { $_[0]{engine}->SIG_NULL } +sub data_length { 0 } +sub data { return } + +sub _init { + my $self = shift; + + my $engine = $self->engine; + + unless ( $self->offset ) { + $self->{offset} = $engine->_request_data_sector( $self->size ); + + my $string = chr(0) x $self->size; + + substr( $string, 0, 1, $self->type ); + substr( $string, $self->base_size, $engine->byte_size + 1, + pack( $engine->StP($engine->byte_size), 0 ) # Chain loc + . pack( $engine->StP(1), $self->data_length ), # Data length + ); + + $engine->storage->print_at( $self->offset, $string ); + + return; + } +} + +1; +__END__ diff --git a/lib/DBM/Deep/Engine/Sector/Reference.pm b/lib/DBM/Deep/Engine/Sector/Reference.pm new file mode 100644 index 0000000..b0b749d --- /dev/null +++ b/lib/DBM/Deep/Engine/Sector/Reference.pm @@ -0,0 +1,514 @@ +#TODO: Convert this to a string +package DBM::Deep::Engine::Sector::Reference; + +use 5.006; + +use strict; +use warnings FATAL => 'all'; + +use Scalar::Util (); + +use DBM::Deep::Null; + +use DBM::Deep::Engine::Sector::Data; +our @ISA = qw( DBM::Deep::Engine::Sector::Data ); + +sub _init { + my $self = shift; + + my $e = $self->engine; + + unless ( $self->offset ) { + my $classname = Scalar::Util::blessed( delete $self->{data} ); + my $leftover = $self->size - $self->base_size - 3 * $e->byte_size; + + my $class_offset = 0; + if ( defined $classname ) { + my $class_sector = DBM::Deep::Engine::Sector::Scalar->new({ + engine => $e, + data => $classname, + }); + $class_offset = $class_sector->offset; + } + + $self->{offset} = $e->_request_data_sector( $self->size ); + $e->storage->print_at( $self->offset, $self->type ); # Sector type + # Skip staleness counter + $e->storage->print_at( $self->offset + $self->base_size, + pack( $e->StP($e->byte_size), 0 ), # Index/BList loc + pack( $e->StP($e->byte_size), $class_offset ), # Classname loc + pack( $e->StP($e->byte_size), 1 ), # Initial refcount + chr(0) x $leftover, # Zero-fill the rest + ); + } + else { + $self->{type} = $e->storage->read_at( $self->offset, 1 ); + } + + $self->{staleness} = unpack( + $e->StP($DBM::Deep::Engine::STALE_SIZE), + $e->storage->read_at( $self->offset + $e->SIG_SIZE, $DBM::Deep::Engine::STALE_SIZE ), + ); + + return; +} + +sub staleness { $_[0]{staleness} } + +sub get_data_location_for { + my $self = shift; + my ($args) = @_; + + # Assume that the head is not allowed unless otherwise specified. + $args->{allow_head} = 0 unless exists $args->{allow_head}; + + # Assume we don't create a new blist location unless otherwise specified. + $args->{create} = 0 unless exists $args->{create}; + + my $blist = $self->get_bucket_list({ + key_md5 => $args->{key_md5}, + key => $args->{key}, + create => $args->{create}, + }); + return unless $blist && $blist->{found}; + + # At this point, $blist knows where the md5 is. What it -doesn't- know yet + # is whether or not this transaction has this key. That's part of the next + # function call. + my $location = $blist->get_data_location_for({ + allow_head => $args->{allow_head}, + }) or return; + + return $location; +} + +sub get_data_for { + my $self = shift; + my ($args) = @_; + + my $location = $self->get_data_location_for( $args ) + or return; + + return $self->engine->_load_sector( $location ); +} + +sub write_data { + my $self = shift; + my ($args) = @_; + + my $blist = $self->get_bucket_list({ + key_md5 => $args->{key_md5}, + key => $args->{key}, + create => 1, + }) or DBM::Deep->_throw_error( "How did write_data fail (no blist)?!" ); + + # Handle any transactional bookkeeping. + if ( $self->engine->trans_id ) { + if ( ! $blist->has_md5 ) { + $blist->mark_deleted({ + trans_id => 0, + }); + } + } + else { + my @trans_ids = $self->engine->get_running_txn_ids; + if ( $blist->has_md5 ) { + if ( @trans_ids ) { + my $old_value = $blist->get_data_for; + foreach my $other_trans_id ( @trans_ids ) { + next if $blist->get_data_location_for({ + trans_id => $other_trans_id, + allow_head => 0, + }); + $blist->write_md5({ + trans_id => $other_trans_id, + key => $args->{key}, + key_md5 => $args->{key_md5}, + value => $old_value->clone, + }); + } + } + } + else { + if ( @trans_ids ) { + foreach my $other_trans_id ( @trans_ids ) { + #XXX This doesn't seem to possible to ever happen . . . + next if $blist->get_data_location_for({ trans_id => $other_trans_id, allow_head => 0 }); + $blist->mark_deleted({ + trans_id => $other_trans_id, + }); + } + } + } + } + + #XXX Is this safe to do transactionally? + # Free the place we're about to write to. + if ( $blist->get_data_location_for({ allow_head => 0 }) ) { + $blist->get_data_for({ allow_head => 0 })->free; + } + + $blist->write_md5({ + key => $args->{key}, + key_md5 => $args->{key_md5}, + value => $args->{value}, + }); +} + +sub delete_key { + my $self = shift; + my ($args) = @_; + + # XXX What should happen if this fails? + my $blist = $self->get_bucket_list({ + key_md5 => $args->{key_md5}, + }) or DBM::Deep->_throw_error( "How did delete_key fail (no blist)?!" ); + + # Save the location so that we can free the data + my $location = $blist->get_data_location_for({ + allow_head => 0, + }); + my $old_value = $location && $self->engine->_load_sector( $location ); + + my @trans_ids = $self->engine->get_running_txn_ids; + + # If we're the HEAD and there are running txns, then we need to clone this value to the other + # transactions to preserve Isolation. + if ( $self->engine->trans_id == 0 ) { + if ( @trans_ids ) { + foreach my $other_trans_id ( @trans_ids ) { + next if $blist->get_data_location_for({ trans_id => $other_trans_id, allow_head => 0 }); + $blist->write_md5({ + trans_id => $other_trans_id, + key => $args->{key}, + key_md5 => $args->{key_md5}, + value => $old_value->clone, + }); + } + } + } + + my $data; + if ( @trans_ids ) { + $blist->mark_deleted( $args ); + + if ( $old_value ) { + $data = $old_value->data({ export => 1 }); + $old_value->free; + } + } + else { + $data = $blist->delete_md5( $args ); + } + + return $data; +} + +sub get_blist_loc { + my $self = shift; + + my $e = $self->engine; + my $blist_loc = $e->storage->read_at( $self->offset + $self->base_size, $e->byte_size ); + return unpack( $e->StP($e->byte_size), $blist_loc ); +} + +sub get_bucket_list { + my $self = shift; + my ($args) = @_; + $args ||= {}; + + # XXX Add in check here for recycling? + + my $engine = $self->engine; + + my $blist_loc = $self->get_blist_loc; + + # There's no index or blist yet + unless ( $blist_loc ) { + return unless $args->{create}; + + my $blist = DBM::Deep::Engine::Sector::BucketList->new({ + engine => $engine, + key_md5 => $args->{key_md5}, + }); + + $engine->storage->print_at( $self->offset + $self->base_size, + pack( $engine->StP($engine->byte_size), $blist->offset ), + ); + + return $blist; + } + + my $sector = $engine->_load_sector( $blist_loc ) + or DBM::Deep->_throw_error( "Cannot read sector at $blist_loc in get_bucket_list()" ); + my $i = 0; + my $last_sector = undef; + while ( $sector->isa( 'DBM::Deep::Engine::Sector::Index' ) ) { + $blist_loc = $sector->get_entry( ord( substr( $args->{key_md5}, $i++, 1 ) ) ); + $last_sector = $sector; + if ( $blist_loc ) { + $sector = $engine->_load_sector( $blist_loc ) + or DBM::Deep->_throw_error( "Cannot read sector at $blist_loc in get_bucket_list()" ); + } + else { + $sector = undef; + last; + } + } + + # This means we went through the Index sector(s) and found an empty slot + unless ( $sector ) { + return unless $args->{create}; + + DBM::Deep->_throw_error( "No last_sector when attempting to build a new entry" ) + unless $last_sector; + + my $blist = DBM::Deep::Engine::Sector::BucketList->new({ + engine => $engine, + key_md5 => $args->{key_md5}, + }); + + $last_sector->set_entry( ord( substr( $args->{key_md5}, $i - 1, 1 ) ) => $blist->offset ); + + return $blist; + } + + $sector->find_md5( $args->{key_md5} ); + + # See whether or not we need to reindex the bucketlist + # Yes, the double-braces are there for a reason. if() doesn't create a redo-able block, + # so we have to create a bare block within the if() for redo-purposes. Patch and idea + # submitted by sprout@cpan.org. -RobK, 2008-01-09 + if ( !$sector->has_md5 && $args->{create} && $sector->{idx} == -1 ) {{ + my $redo; + + my $new_index = DBM::Deep::Engine::Sector::Index->new({ + engine => $engine, + }); + + my %blist_cache; + #XXX q.v. the comments for this function. + foreach my $entry ( $sector->chopped_up ) { + my ($spot, $md5) = @{$entry}; + my $idx = ord( substr( $md5, $i, 1 ) ); + + # XXX This is inefficient + my $blist = $blist_cache{$idx} + ||= DBM::Deep::Engine::Sector::BucketList->new({ + engine => $engine, + }); + + $new_index->set_entry( $idx => $blist->offset ); + + my $new_spot = $blist->write_at_next_open( $md5 ); + $engine->reindex_entry( $spot => $new_spot ); + } + + # Handle the new item separately. + { + my $idx = ord( substr( $args->{key_md5}, $i, 1 ) ); + + # If all the previous blist's items have been thrown into one + # blist and the new item belongs in there too, we need + # another index. + if ( keys %blist_cache == 1 and each %blist_cache == $idx ) { + ++$i, ++$redo; + } else { + my $blist = $blist_cache{$idx} + ||= DBM::Deep::Engine::Sector::BucketList->new({ + engine => $engine, + }); + + $new_index->set_entry( $idx => $blist->offset ); + + #XXX THIS IS HACKY! + $blist->find_md5( $args->{key_md5} ); + $blist->write_md5({ + key => $args->{key}, + key_md5 => $args->{key_md5}, + value => DBM::Deep::Engine::Sector::Null->new({ + engine => $engine, + data => undef, + }), + }); + } +# my $blist = $blist_cache{$idx} +# ||= DBM::Deep::Engine::Sector::BucketList->new({ +# engine => $engine, +# }); +# +# $new_index->set_entry( $idx => $blist->offset ); +# +# #XXX THIS IS HACKY! +# $blist->find_md5( $args->{key_md5} ); +# $blist->write_md5({ +# key => $args->{key}, +# key_md5 => $args->{key_md5}, +# value => DBM::Deep::Engine::Sector::Null->new({ +# engine => $engine, +# data => undef, +# }), +# }); + } + + if ( $last_sector ) { + $last_sector->set_entry( + ord( substr( $args->{key_md5}, $i - 1, 1 ) ), + $new_index->offset, + ); + } else { + $engine->storage->print_at( $self->offset + $self->base_size, + pack( $engine->StP($engine->byte_size), $new_index->offset ), + ); + } + + $sector->clear; + $sector->free; + + if ( $redo ) { + (undef, $sector) = %blist_cache; + $last_sector = $new_index; + redo; + } + + $sector = $blist_cache{ ord( substr( $args->{key_md5}, $i, 1 ) ) }; + $sector->find_md5( $args->{key_md5} ); + }} + + return $sector; +} + +sub get_class_offset { + my $self = shift; + + my $e = $self->engine; + return unpack( + $e->StP($e->byte_size), + $e->storage->read_at( + $self->offset + $self->base_size + 1 * $e->byte_size, $e->byte_size, + ), + ); +} + +sub get_classname { + my $self = shift; + + my $class_offset = $self->get_class_offset; + + return unless $class_offset; + + return $self->engine->_load_sector( $class_offset )->data; +} + +sub data { + my $self = shift; + my ($args) = @_; + $args ||= {}; + + my $obj; + unless ( $obj = $self->engine->cache->{ $self->offset } ) { + $obj = DBM::Deep->new({ + type => $self->type, + base_offset => $self->offset, + staleness => $self->staleness, + storage => $self->engine->storage, + engine => $self->engine, + }); + + if ( $self->engine->storage->{autobless} ) { + my $classname = $self->get_classname; + if ( defined $classname ) { + bless $obj, $classname; + } + } + + $self->engine->cache->{$self->offset} = $obj; + } + + # We're not exporting, so just return. + unless ( $args->{export} ) { + return $obj; + } + + # We shouldn't export if this is still referred to. + if ( $self->get_refcount > 1 ) { + return $obj; + } + + return $obj->export; +} + +sub free { + my $self = shift; + + # We're not ready to be removed yet. + if ( $self->decrement_refcount > 0 ) { + return; + } + + # Rebless the object into DBM::Deep::Null. + eval { %{ $self->engine->cache->{ $self->offset } } = (); }; + eval { @{ $self->engine->cache->{ $self->offset } } = (); }; + bless $self->engine->cache->{ $self->offset }, 'DBM::Deep::Null'; + delete $self->engine->cache->{ $self->offset }; + + my $blist_loc = $self->get_blist_loc; + $self->engine->_load_sector( $blist_loc )->free if $blist_loc; + + my $class_loc = $self->get_class_offset; + $self->engine->_load_sector( $class_loc )->free if $class_loc; + + $self->SUPER::free(); +} + +sub increment_refcount { + my $self = shift; + + my $refcount = $self->get_refcount; + + $refcount++; + + $self->write_refcount( $refcount ); + + return $refcount; +} + +sub decrement_refcount { + my $self = shift; + + my $refcount = $self->get_refcount; + + $refcount--; + + $self->write_refcount( $refcount ); + + return $refcount; +} + +sub get_refcount { + my $self = shift; + + my $e = $self->engine; + return unpack( + $e->StP($e->byte_size), + $e->storage->read_at( + $self->offset + $self->base_size + 2 * $e->byte_size, $e->byte_size, + ), + ); +} + +sub write_refcount { + my $self = shift; + my ($num) = @_; + + my $e = $self->engine; + $e->storage->print_at( + $self->offset + $self->base_size + 2 * $e->byte_size, + pack( $e->StP($e->byte_size), $num ), + ); +} + + +1; +__END__ + diff --git a/lib/DBM/Deep/Engine/Sector/Scalar.pm b/lib/DBM/Deep/Engine/Sector/Scalar.pm new file mode 100644 index 0000000..a28e88b --- /dev/null +++ b/lib/DBM/Deep/Engine/Sector/Scalar.pm @@ -0,0 +1,124 @@ +#TODO: Convert this to a string +package DBM::Deep::Engine::Sector::Scalar; + +use 5.006; + +use strict; +use warnings FATAL => 'all'; + +our $VERSION = '0.01'; + +use DBM::Deep::Engine::Sector::Data; +our @ISA = qw( DBM::Deep::Engine::Sector::Data ); + +sub free { + my $self = shift; + + my $chain_loc = $self->chain_loc; + + $self->SUPER::free(); + + if ( $chain_loc ) { + $self->engine->_load_sector( $chain_loc )->free; + } + + return; +} + +sub type { $_[0]{engine}->SIG_DATA } +sub _init { + my $self = shift; + + my $engine = $self->engine; + + unless ( $self->offset ) { + my $data_section = $self->size - $self->base_size - $engine->byte_size - 1; + + $self->{offset} = $engine->_request_data_sector( $self->size ); + + my $data = delete $self->{data}; + my $dlen = length $data; + my $continue = 1; + my $curr_offset = $self->offset; + while ( $continue ) { + + my $next_offset = 0; + + my ($leftover, $this_len, $chunk); + if ( $dlen > $data_section ) { + $leftover = 0; + $this_len = $data_section; + $chunk = substr( $data, 0, $this_len ); + + $dlen -= $data_section; + $next_offset = $engine->_request_data_sector( $self->size ); + $data = substr( $data, $this_len ); + } + else { + $leftover = $data_section - $dlen; + $this_len = $dlen; + $chunk = $data; + + $continue = 0; + } + + $engine->storage->print_at( $curr_offset, $self->type ); # Sector type + # Skip staleness + $engine->storage->print_at( $curr_offset + $self->base_size, + pack( $engine->StP($engine->byte_size), $next_offset ), # Chain loc + pack( $engine->StP(1), $this_len ), # Data length + $chunk, # Data to be stored in this sector + chr(0) x $leftover, # Zero-fill the rest + ); + + $curr_offset = $next_offset; + } + + return; + } +} + +sub data_length { + my $self = shift; + + my $buffer = $self->engine->storage->read_at( + $self->offset + $self->base_size + $self->engine->byte_size, 1 + ); + + return unpack( $self->engine->StP(1), $buffer ); +} + +sub chain_loc { + my $self = shift; + return unpack( + $self->engine->StP($self->engine->byte_size), + $self->engine->storage->read_at( + $self->offset + $self->base_size, + $self->engine->byte_size, + ), + ); +} + +sub data { + my $self = shift; +# my ($args) = @_; +# $args ||= {}; + + my $data; + while ( 1 ) { + my $chain_loc = $self->chain_loc; + + $data .= $self->engine->storage->read_at( + $self->offset + $self->base_size + $self->engine->byte_size + 1, $self->data_length, + ); + + last unless $chain_loc; + + $self = $self->engine->_load_sector( $chain_loc ); + } + + return $data; +} + +1; +__END__ diff --git a/lib/DBM/Deep/File.pm b/lib/DBM/Deep/File.pm index 13342d8..0a3096f 100644 --- a/lib/DBM/Deep/File.pm +++ b/lib/DBM/Deep/File.pm @@ -3,9 +3,7 @@ package DBM::Deep::File; use 5.006_000; use strict; -use warnings; - -our $VERSION = q(1.0013); +use warnings FATAL => 'all'; use Fcntl qw( :DEFAULT :flock :seek ); diff --git a/lib/DBM/Deep/Hash.pm b/lib/DBM/Deep/Hash.pm index 6db4e21..43fd26a 100644 --- a/lib/DBM/Deep/Hash.pm +++ b/lib/DBM/Deep/Hash.pm @@ -3,9 +3,7 @@ package DBM::Deep::Hash; use 5.006_000; use strict; -use warnings; - -our $VERSION = q(1.0013); +use warnings FATAL => 'all'; use base 'DBM::Deep'; diff --git a/lib/DBM/Deep/Iterator.pm b/lib/DBM/Deep/Iterator.pm new file mode 100644 index 0000000..1c9bd5f --- /dev/null +++ b/lib/DBM/Deep/Iterator.pm @@ -0,0 +1,121 @@ +package DBM::Deep::Iterator; + +use 5.006; + +use strict; +use warnings FATAL => 'all'; + +use Scalar::Util (); + +use DBM::Deep::Iterator::Index; +use DBM::Deep::Iterator::BucketList; + +sub new { + my $class = shift; + my ($args) = @_; + + my $self = bless { + breadcrumbs => [], + engine => $args->{engine}, + base_offset => $args->{base_offset}, + }, $class; + + Scalar::Util::weaken( $self->{engine} ); + + return $self; +} + +sub reset { $_[0]{breadcrumbs} = [] } + +sub get_sector_iterator { + my $self = shift; + my ($loc) = @_; + + my $sector = $self->{engine}->_load_sector( $loc ) + or return; + + if ( $sector->isa( 'DBM::Deep::Engine::Sector::Index' ) ) { + return DBM::Deep::Iterator::Index->new({ + iterator => $self, + sector => $sector, + }); + } + elsif ( $sector->isa( 'DBM::Deep::Engine::Sector::BucketList' ) ) { + return DBM::Deep::Iterator::BucketList->new({ + iterator => $self, + sector => $sector, + }); + } + + DBM::Deep->_throw_error( "get_sector_iterator(): Why did $loc make a $sector?" ); +} + +sub get_next_key { + my $self = shift; + my ($obj) = @_; + + my $crumbs = $self->{breadcrumbs}; + my $e = $self->{engine}; + + unless ( @$crumbs ) { + # This will be a Reference sector + my $sector = $e->_load_sector( $self->{base_offset} ) + # If no sector is found, thist must have been deleted from under us. + or return; + + if ( $sector->staleness != $obj->_staleness ) { + return; + } + + my $loc = $sector->get_blist_loc + or return; + + push @$crumbs, $self->get_sector_iterator( $loc ); + } + + FIND_NEXT_KEY: { + # We're at the end. + unless ( @$crumbs ) { + $self->reset; + return; + } + + my $iterator = $crumbs->[-1]; + + # This level is done. + if ( $iterator->at_end ) { + pop @$crumbs; + redo FIND_NEXT_KEY; + } + + if ( $iterator->isa( 'DBM::Deep::Iterator::Index' ) ) { + # If we don't have any more, it will be caught at the + # prior check. + if ( my $next = $iterator->get_next_iterator ) { + push @$crumbs, $next; + } + redo FIND_NEXT_KEY; + } + + unless ( $iterator->isa( 'DBM::Deep::Iterator::BucketList' ) ) { + DBM::Deep->_throw_error( + "Should have a bucketlist iterator here - instead have $iterator" + ); + } + + # At this point, we have a BucketList iterator + my $key = $iterator->get_next_key; + if ( defined $key ) { + return $key; + } + #XXX else { $iterator->set_to_end() } ? + + # We hit the end of the bucketlist iterator, so redo + redo FIND_NEXT_KEY; + } + + DBM::Deep->_throw_error( "get_next_key(): How did we get here?" ); +} + +1; +__END__ diff --git a/lib/DBM/Deep/Iterator/BucketList.pm b/lib/DBM/Deep/Iterator/BucketList.pm new file mode 100644 index 0000000..3f57868 --- /dev/null +++ b/lib/DBM/Deep/Iterator/BucketList.pm @@ -0,0 +1,36 @@ +package DBM::Deep::Iterator::BucketList; + +use 5.006; + +use strict; +use warnings FATAL => 'all'; + +sub new { + my $self = bless $_[1] => $_[0]; + $self->{curr_index} = 0; + return $self; +} + +sub at_end { + my $self = shift; + return $self->{curr_index} >= $self->{iterator}{engine}->max_buckets; +} + +sub get_next_key { + my $self = shift; + + return if $self->at_end; + + my $idx = $self->{curr_index}++; + + my $data_loc = $self->{sector}->get_data_location_for({ + allow_head => 1, + idx => $idx, + }) or return; + + #XXX Do we want to add corruption checks here? + return $self->{sector}->get_key_for( $idx )->data; +} + +1; +__END__ diff --git a/lib/DBM/Deep/Iterator/Index.pm b/lib/DBM/Deep/Iterator/Index.pm new file mode 100644 index 0000000..2052fa5 --- /dev/null +++ b/lib/DBM/Deep/Iterator/Index.pm @@ -0,0 +1,32 @@ +package DBM::Deep::Iterator::Index; + +use 5.006; + +use strict; +use warnings FATAL => 'all'; + +sub new { + my $self = bless $_[1] => $_[0]; + $self->{curr_index} = 0; + return $self; +} + +sub at_end { + my $self = shift; + return $self->{curr_index} >= $self->{iterator}{engine}->hash_chars; +} + +sub get_next_iterator { + my $self = shift; + + my $loc; + while ( !$loc ) { + return if $self->at_end; + $loc = $self->{sector}->get_entry( $self->{curr_index}++ ); + } + + return $self->{iterator}->get_sector_iterator( $loc ); +} + +1; +__END__ diff --git a/lib/DBM/Deep/Null.pm b/lib/DBM/Deep/Null.pm new file mode 100644 index 0000000..35f1c83 --- /dev/null +++ b/lib/DBM/Deep/Null.pm @@ -0,0 +1,20 @@ +# This was copied from MARCEL's Class::Null. However, I couldn't use it because +# I need an undef value, not an implementation of the Null Class pattern. +package DBM::Deep::Null; + +use 5.006; + +use strict; +use warnings FATAL => 'all'; + +use overload + 'bool' => sub { undef }, + '""' => sub { undef }, + '0+' => sub { undef }, + fallback => 1, + nomethod => 'AUTOLOAD'; + +sub AUTOLOAD { return; } + +1; +__END__