lib/DBM/Deep/Engine/DBI.pm

   1 package DBM::Deep::Engine::DBI;
   2
   3 use 5.006_000;
   4
   5 use strict;
   6 use warnings FATAL => 'all';
   7
   8 use base 'DBM::Deep::Engine';
   9
  10 use DBM::Deep::Sector::DBI ();
  11 use DBM::Deep::Storage::DBI ();
  12
  13 sub sector_type { 'DBM::Deep::Sector::DBI' }
  14 sub iterator_class { 'DBM::Deep::Iterator::DBI' }
  15
  16 sub new {
  17     my $class = shift;
  18     my ($args) = @_;
  19
  20     $args->{storage} = DBM::Deep::Storage::DBI->new( $args )
  21         unless exists $args->{storage};
  22
  23     my $self = bless {
  24         storage => undef,
  25     }, $class;
  26
  27     # Grab the parameters we want to use
  28     foreach my $param ( keys %$self ) {
  29         next unless exists $args->{$param};
  30         $self->{$param} = $args->{$param};
  31     }
  32
  33     return $self;
  34 }
  35
  36 sub setup {
  37     my $self = shift;
  38     my ($obj) = @_;
  39
  40     # Default the id to 1. This means that we will be creating a row if there
  41     # isn't one. The assumption is that the row_id=1 cannot never be deleted. I
  42     # don't know if this is a good assumption.
  43     $obj->{base_offset} ||= 1;
  44
  45     my ($rows) = $self->storage->read_from(
  46         refs => $obj->_base_offset,
  47         qw( ref_type ),
  48     );
  49
  50     # We don't have a row yet.
  51     unless ( @$rows ) {
  52         $self->storage->write_to(
  53             refs => $obj->_base_offset,
  54             ref_type => $obj->_type,
  55         );
  56     }
  57
  58     my $sector = DBM::Deep::Sector::DBI::Reference->new({
  59         engine => $self,
  60         offset => $obj->_base_offset,
  61     });
  62 }
  63
  64 sub read_value {
  65     my $self = shift;
  66     my ($obj, $key) = @_;
  67
  68     my $sector = $self->load_sector( $obj->_base_offset, 'refs' )
  69         or return;
  70
  71 #    if ( $sector->staleness != $obj->_staleness ) {
  72 #        return;
  73 #    }
  74
  75 #    my $key_md5 = $self->_apply_digest( $key );
  76
  77     my $value_sector = $sector->get_data_for({
  78         key => $key,
  79 #        key_md5    => $key_md5,
  80         allow_head => 1,
  81     });
  82
  83     unless ( $value_sector ) {
  84         $value_sector = DBM::Deep::Sector::DBI::Scalar->new({
  85             engine => $self,
  86             data   => undef,
  87         });
  88
  89         $sector->write_data({
  90 #            key_md5 => $key_md5,
  91             key     => $key,
  92             value   => $value_sector,
  93         });
  94     }
  95
  96     return $value_sector->data;
  97 }
  98
  99 sub get_classname {
 100     my $self = shift;
 101     my ($obj) = @_;
 102
 103     return;
 104 }
 105
 106 =pod
 107 sub make_reference {
 108     my $self = shift;
 109     my ($obj, $old_key, $new_key) = @_;
 110 }
 111 =cut
 112
 113 # exists returns '', not undefined.
 114 sub key_exists {
 115     my $self = shift;
 116     my ($obj, $key) = @_;
 117
 118     my $sector = $self->load_sector( $obj->_base_offset, 'refs' )
 119         or return '';
 120
 121 #    if ( $sector->staleness != $obj->_staleness ) {
 122 #        return '';
 123 #    }
 124
 125     my $data = $sector->get_data_for({
 126 #        key_md5    => $self->_apply_digest( $key ),
 127         key        => $key,
 128         allow_head => 1,
 129     });
 130
 131     # exists() returns 1 or '' for true/false.
 132     return $data ? 1 : '';
 133 }
 134
 135 sub delete_key {
 136     my $self = shift;
 137     my ($obj, $key) = @_;
 138
 139     my $sector = $self->load_sector( $obj->_base_offset, 'refs' )
 140         or return '';
 141
 142 #    if ( $sector->staleness != $obj->_staleness ) {
 143 #        return '';
 144 #    }
 145
 146     return $sector->delete_key({
 147 #        key_md5    => $self->_apply_digest( $key ),
 148         key        => $key,
 149         allow_head => 0,
 150     });
 151 }
 152
 153 sub write_value {
 154     my $self = shift;
 155     my ($obj, $key, $value) = @_;
 156
 157     my $r = Scalar::Util::reftype( $value ) || '';
 158     {
 159         last if $r eq '';
 160         last if $r eq 'HASH';
 161         last if $r eq 'ARRAY';
 162
 163         DBM::Deep->_throw_error(
 164             "Storage of references of type '$r' is not supported."
 165         );
 166     }
 167
 168     # Load the reference entry
 169     # Determine if the row was deleted under us
 170     #
 171
 172     my $sector = $self->load_sector( $obj->_base_offset, 'refs' )
 173         or die "Cannot load sector at '@{[$obj->_base_offset]}'\n";;
 174
 175     my ($type, $class);
 176     if ( $r eq 'ARRAY' || $r eq 'HASH' ) {
 177         my $tmpvar;
 178         if ( $r eq 'ARRAY' ) {
 179             $tmpvar = tied @$value;
 180         } elsif ( $r eq 'HASH' ) {
 181             $tmpvar = tied %$value;
 182         }
 183
 184         if ( $tmpvar ) {
 185             my $is_dbm_deep = eval { local $SIG{'__DIE__'}; $tmpvar->isa( 'DBM::Deep' ); };
 186
 187             unless ( $is_dbm_deep ) {
 188                 DBM::Deep->_throw_error( "Cannot store something that is tied." );
 189             }
 190
 191             unless ( $tmpvar->_engine->storage == $self->storage ) {
 192                 DBM::Deep->_throw_error( "Cannot store values across DBM::Deep files. Please use export() instead." );
 193             }
 194
 195             # Load $tmpvar's sector
 196
 197             # First, verify if we're storing the same thing to this spot. If we
 198             # are, then this should be a no-op. -EJS, 2008-05-19
 199
 200             # See whether or not we are storing ourselves to ourself.
 201             # Write the sector as data in this reference (keyed by $key)
 202             my $value_sector = $self->load_sector( $tmpvar->_base_offset );
 203             $sector->write_data({
 204                 key     => $key,
 205                 key_md5 => $self->_apply_digest( $key ),
 206                 value   => $value_sector,
 207             });
 208             $value_sector->increment_refcount;
 209
 210             return 1;
 211         }
 212
 213         $type = substr( $r, 0, 1 );
 214         $class = 'DBM::Deep::Sector::DBI::Reference';
 215     }
 216     else {
 217         if ( tied($value) ) {
 218             DBM::Deep->_throw_error( "Cannot store something that is tied." );
 219         }
 220
 221         $class = 'DBM::Deep::Sector::DBI::Scalar';
 222         $type  = 'S';
 223     }
 224
 225     # Create this after loading the reference sector in case something bad
 226     # happens. This way, we won't allocate value sector(s) needlessly.
 227     my $value_sector = $class->new({
 228         engine => $self,
 229         data   => $value,
 230         type   => $type,
 231     });
 232
 233     $sector->write_data({
 234         key     => $key,
 235 #        key_md5 => $self->_apply_digest( $key ),
 236         value   => $value_sector,
 237     });
 238
 239     # This code is to make sure we write all the values in the $value to the
 240     # disk and to make sure all changes to $value after the assignment are
 241     # reflected on disk. This may be counter-intuitive at first, but it is
 242     # correct dwimmery.
 243     #   NOTE - simply tying $value won't perform a STORE on each value. Hence,
 244     # the copy to a temp value.
 245     if ( $r eq 'ARRAY' ) {
 246         my @temp = @$value;
 247         tie @$value, 'DBM::Deep', {
 248             base_offset => $value_sector->offset,
 249 #            staleness   => $value_sector->staleness,
 250             storage     => $self->storage,
 251             engine      => $self,
 252         };
 253         @$value = @temp;
 254         bless $value, 'DBM::Deep::Array' unless Scalar::Util::blessed( $value );
 255     }
 256     elsif ( $r eq 'HASH' ) {
 257         my %temp = %$value;
 258         tie %$value, 'DBM::Deep', {
 259             base_offset => $value_sector->offset,
 260 #            staleness   => $value_sector->staleness,
 261             storage     => $self->storage,
 262             engine      => $self,
 263         };
 264
 265         %$value = %temp;
 266         bless $value, 'DBM::Deep::Hash' unless Scalar::Util::blessed( $value );
 267     }
 268
 269     return 1;
 270 }
 271
 272 sub begin_work {
 273     my $self = shift;
 274     my ($obj) = @_;
 275 }
 276
 277 sub rollback {
 278     my $self = shift;
 279     my ($obj) = @_;
 280 }
 281
 282 sub commit {
 283     my $self = shift;
 284     my ($obj) = @_;
 285 }
 286
 287
 288 1;
 289 __END__