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 =pod
 100 sub get_classname {
 101     my $self = shift;
 102     my ($obj) = @_;
 103 }
 104
 105 sub make_reference {
 106     my $self = shift;
 107     my ($obj, $old_key, $new_key) = @_;
 108 }
 109 =cut
 110
 111 # exists returns '', not undefined.
 112 sub key_exists {
 113     my $self = shift;
 114     my ($obj, $key) = @_;
 115
 116     my $sector = $self->load_sector( $obj->_base_offset, 'refs' )
 117         or return '';
 118
 119 #    if ( $sector->staleness != $obj->_staleness ) {
 120 #        return '';
 121 #    }
 122
 123     my $data = $sector->get_data_for({
 124 #        key_md5    => $self->_apply_digest( $key ),
 125         key        => $key,
 126         allow_head => 1,
 127     });
 128
 129     # exists() returns 1 or '' for true/false.
 130     return $data ? 1 : '';
 131 }
 132
 133 sub delete_key {
 134     my $self = shift;
 135     my ($obj, $key) = @_;
 136
 137     my $sector = $self->load_sector( $obj->_base_offset, 'refs' )
 138         or return '';
 139
 140 #    if ( $sector->staleness != $obj->_staleness ) {
 141 #        return '';
 142 #    }
 143
 144     return $sector->delete_key({
 145 #        key_md5    => $self->_apply_digest( $key ),
 146         key        => $key,
 147         allow_head => 0,
 148     });
 149 }
 150
 151 sub write_value {
 152     my $self = shift;
 153     my ($obj, $key, $value) = @_;
 154
 155     my $r = Scalar::Util::reftype( $value ) || '';
 156     {
 157         last if $r eq '';
 158         last if $r eq 'HASH';
 159         last if $r eq 'ARRAY';
 160
 161         DBM::Deep->_throw_error(
 162             "Storage of references of type '$r' is not supported."
 163         );
 164     }
 165
 166     # Load the reference entry
 167     # Determine if the row was deleted under us
 168     #
 169
 170     my $sector = $self->load_sector( $obj->_base_offset, 'refs' )
 171         or die "Cannot load sector at '@{[$obj->_base_offset]}'\n";;
 172
 173     my ($type, $class);
 174     if ( $r eq 'ARRAY' || $r eq 'HASH' ) {
 175         my $tmpvar;
 176         if ( $r eq 'ARRAY' ) {
 177             $tmpvar = tied @$value;
 178         } elsif ( $r eq 'HASH' ) {
 179             $tmpvar = tied %$value;
 180         }
 181
 182         if ( $tmpvar ) {
 183             my $is_dbm_deep = eval { local $SIG{'__DIE__'}; $tmpvar->isa( 'DBM::Deep' ); };
 184
 185             unless ( $is_dbm_deep ) {
 186                 DBM::Deep->_throw_error( "Cannot store something that is tied." );
 187             }
 188
 189             unless ( $tmpvar->_engine->storage == $self->storage ) {
 190                 DBM::Deep->_throw_error( "Cannot store values across DBM::Deep files. Please use export() instead." );
 191             }
 192
 193             # Load $tmpvar's sector
 194
 195             # First, verify if we're storing the same thing to this spot. If we
 196             # are, then this should be a no-op. -EJS, 2008-05-19
 197
 198             # See whether or not we are storing ourselves to ourself.
 199             # Write the sector as data in this reference (keyed by $key)
 200             my $value_sector = $self->load_sector( $tmpvar->_base_offset );
 201             $sector->write_data({
 202                 key     => $key,
 203                 key_md5 => $self->_apply_digest( $key ),
 204                 value   => $value_sector,
 205             });
 206             $value_sector->increment_refcount;
 207
 208             return 1;
 209         }
 210
 211         $type = substr( $r, 0, 1 );
 212         $class = 'DBM::Deep::Sector::DBI::Reference';
 213     }
 214     else {
 215         if ( tied($value) ) {
 216             DBM::Deep->_throw_error( "Cannot store something that is tied." );
 217         }
 218
 219         $class = 'DBM::Deep::Sector::DBI::Scalar';
 220         $type  = 'S';
 221     }
 222
 223     # Create this after loading the reference sector in case something bad
 224     # happens. This way, we won't allocate value sector(s) needlessly.
 225     my $value_sector = $class->new({
 226         engine => $self,
 227         data   => $value,
 228         type   => $type,
 229     });
 230
 231     $sector->write_data({
 232         key     => $key,
 233 #        key_md5 => $self->_apply_digest( $key ),
 234         value   => $value_sector,
 235     });
 236
 237     # This code is to make sure we write all the values in the $value to the
 238     # disk and to make sure all changes to $value after the assignment are
 239     # reflected on disk. This may be counter-intuitive at first, but it is
 240     # correct dwimmery.
 241     #   NOTE - simply tying $value won't perform a STORE on each value. Hence,
 242     # the copy to a temp value.
 243     if ( $r eq 'ARRAY' ) {
 244         my @temp = @$value;
 245         tie @$value, 'DBM::Deep', {
 246             base_offset => $value_sector->offset,
 247 #            staleness   => $value_sector->staleness,
 248             storage     => $self->storage,
 249             engine      => $self,
 250         };
 251         @$value = @temp;
 252         bless $value, 'DBM::Deep::Array' unless Scalar::Util::blessed( $value );
 253     }
 254     elsif ( $r eq 'HASH' ) {
 255         my %temp = %$value;
 256         tie %$value, 'DBM::Deep', {
 257             base_offset => $value_sector->offset,
 258 #            staleness   => $value_sector->staleness,
 259             storage     => $self->storage,
 260             engine      => $self,
 261         };
 262
 263         %$value = %temp;
 264         bless $value, 'DBM::Deep::Hash' unless Scalar::Util::blessed( $value );
 265     }
 266
 267     return 1;
 268 }
 269
 270 sub begin_work {
 271     my $self = shift;
 272     my ($obj) = @_;
 273 }
 274
 275 sub rollback {
 276     my $self = shift;
 277     my ($obj) = @_;
 278 }
 279
 280 sub commit {
 281     my $self = shift;
 282     my ($obj) = @_;
 283 }
 284
 285
 286 1;
 287 __END__