1 package DBM::Deep::Engine;
6 use warnings FATAL => 'all';
7 no warnings 'recursion';
9 use DBM::Deep::Iterator ();
12 # * Every method in here assumes that the storage has been appropriately
13 # safeguarded. This can be anything from flock() to some sort of manual
14 # mutex. But, it's the caller's responsability to make sure that this has
17 sub SIG_HASH () { 'H' }
18 sub SIG_ARRAY () { 'A' }
26 This is an internal-use-only object for L<DBM::Deep>. It mediates the low-level
27 mapping between the L<DBM::Deep> objects and the storage medium.
29 The purpose of this documentation is to provide low-level documentation for
30 developers. It is B<not> intended to be used by the general public. This
31 documentation and what it documents can and will change without notice.
35 The engine exposes an API to the DBM::Deep objects (DBM::Deep, DBM::Deep::Array,
36 and DBM::Deep::Hash) for their use to access the actual stored values. This API
47 =item * make_reference
67 =item * lock_exclusive
75 They are explained in their own sections below. These methods, in turn, may
76 provide some bounds-checking, but primarily act to instantiate objects in the
77 Engine::Sector::* hierarchy and dispatch to them.
81 Transactions in DBM::Deep are implemented using a variant of MVCC. This attempts
82 to keep the amount of actual work done against the file low while stil providing
83 Atomicity, Consistency, and Isolation. Durability, unfortunately, cannot be done
88 If another process uses a transaction slot and writes stuff to it, then
89 terminates, the data that process wrote it still within the file. In order to
90 address this, there is also a transaction staleness counter associated within
91 every write. Each time a transaction is started, that process increments that
92 transaction's staleness counter. If, when it reads a value, the staleness
93 counters aren't identical, DBM::Deep will consider the value on disk to be stale
98 The fourth leg of ACID is Durability, the guarantee that when a commit returns,
99 the data will be there the next time you read from it. This should be regardless
100 of any crashes or powerdowns in between the commit and subsequent read.
101 DBM::Deep does provide that guarantee; once the commit returns, all of the data
102 has been transferred from the transaction shadow to the HEAD. The issue arises
103 with partial commits - a commit that is interrupted in some fashion. In keeping
104 with DBM::Deep's "tradition" of very light error-checking and non-existent
105 error-handling, there is no way to recover from a partial commit. (This is
106 probably a failure in Consistency as well as Durability.)
108 Other DBMSes use transaction logs (a separate file, generally) to achieve
109 Durability. As DBM::Deep is a single-file, we would have to do something
110 similar to what SQLite and BDB do in terms of committing using synchonized
111 writes. To do this, we would have to use a much higher RAM footprint and some
112 serious programming that make my head hurts just to think about it.
118 =head2 read_value( $obj, $key )
120 This takes an object that provides _base_offset() and a string. It returns the
121 value stored in the corresponding Sector::Value's data section.
125 sub read_value { die "read_value must be implemented in a child class" }
127 =head2 get_classname( $obj )
129 This takes an object that provides _base_offset() and returns the classname (if
130 any) associated with it.
132 It delegates to Sector::Reference::get_classname() for the heavy lifting.
134 It performs a staleness check.
138 sub get_classname { die "get_classname must be implemented in a child class" }
140 =head2 make_reference( $obj, $old_key, $new_key )
142 This takes an object that provides _base_offset() and two strings. The
143 strings correspond to the old key and new key, respectively. This operation
144 is equivalent to (given C<< $db->{foo} = []; >>) C<< $db->{bar} = $db->{foo} >>.
146 This returns nothing.
150 sub make_reference { die "make_reference must be implemented in a child class" }
152 =head2 key_exists( $obj, $key )
154 This takes an object that provides _base_offset() and a string for
155 the key to be checked. This returns 1 for true and "" for false.
159 sub key_exists { die "key_exists must be implemented in a child class" }
161 =head2 delete_key( $obj, $key )
163 This takes an object that provides _base_offset() and a string for
164 the key to be deleted. This returns the result of the Sector::Reference
169 sub delete_key { die "delete_key must be implemented in a child class" }
171 =head2 write_value( $obj, $key, $value )
173 This takes an object that provides _base_offset(), a string for the
174 key, and a value. This value can be anything storable within L<DBM::Deep>.
176 This returns 1 upon success.
180 sub write_value { die "write_value must be implemented in a child class" }
184 This takes an object that provides _base_offset(). It will do everything needed
185 in order to properly initialize all values for necessary functioning. If this is
186 called upon an already initialized object, this will also reset the inode.
192 sub setup { die "setup must be implemented in a child class" }
194 =head2 begin_work( $obj )
196 This takes an object that provides _base_offset(). It will set up all necessary
197 bookkeeping in order to run all work within a transaction.
199 If $obj is already within a transaction, an error wiill be thrown. If there are
200 no more available transactions, an error will be thrown.
206 sub begin_work { die "begin_work must be implemented in a child class" }
208 =head2 rollback( $obj )
210 This takes an object that provides _base_offset(). It will revert all
211 actions taken within the running transaction.
213 If $obj is not within a transaction, an error will be thrown.
219 sub rollback { die "rollback must be implemented in a child class" }
221 =head2 commit( $obj )
223 This takes an object that provides _base_offset(). It will apply all
224 actions taken within the transaction to the HEAD.
226 If $obj is not within a transaction, an error will be thrown.
232 sub commit { die "commit must be implemented in a child class" }
234 =head2 get_next_key( $obj, $prev_key )
236 This takes an object that provides _base_offset() and an optional string
237 representing the prior key returned via a prior invocation of this method.
239 This method delegates to C<< DBM::Deep::Iterator->get_next_key() >>.
243 # XXX Add staleness here
246 my ($obj, $prev_key) = @_;
248 # XXX Need to add logic about resetting the iterator if any key in the
249 # reference has changed
250 unless ( defined $prev_key ) {
251 eval "use " . $self->iterator_class; die $@ if $@;
252 $obj->{iterator} = $self->iterator_class->new({
253 base_offset => $obj->_base_offset,
258 return $obj->{iterator}->get_next_key( $obj );
261 =head2 lock_exclusive()
263 This takes an object that provides _base_offset(). It will guarantee that
264 the storage has taken precautions to be safe for a write.
266 This returns nothing.
273 return $self->storage->lock_exclusive( $obj );
278 This takes an object that provides _base_offset(). It will guarantee that
279 the storage has taken precautions to be safe for a read.
281 This returns nothing.
288 return $self->storage->lock_shared( $obj );
293 This takes an object that provides _base_offset(). It will guarantee that
294 the storage has released the most recently-taken lock.
296 This returns nothing.
304 my $rv = $self->storage->unlock( $obj );
311 =head1 INTERNAL METHODS
313 The following methods are internal-use-only to DBM::Deep::Engine and its
320 This takes no arguments. It will do everything necessary to flush all things to
321 disk. This is usually called during unlock() and setup().
323 This returns nothing.
330 # Why do we need to have the storage flush? Shouldn't autoflush take care of
331 # things? -RobK, 2008-06-26
332 $self->storage->flush;
337 =head2 load_sector( $loc )
339 This takes an id/location/offset and loads the sector based on the engine's
344 sub load_sector { $_[0]->sector_type->load( @_ ) }
348 This takes an object that provides _base_offset() and deletes all its
349 elements, returning nothing.
353 sub clear { die "clear must be implemented in a child class" }
355 =head2 cache / clear_cache
357 This is the cache of loaded Reference sectors.
361 sub cache { $_[0]{cache} ||= {} }
362 sub clear_cache { %{$_[0]->cache} = () }
364 =head2 supports( $option )
366 This returns a boolean depending on if this instance of DBM::Dep supports
367 that feature. C<$option> can be one of:
377 Any other value will return false.
381 sub supports { die "supports must be implemented in a child class" }
385 The following are readonly attributes.
393 =item * iterator_class
399 sub storage { $_[0]{storage} }
401 sub sector_type { die "sector_type must be implemented in a child class" }
402 sub iterator_class { die "iterator_class must be implemented in a child class" }
404 # This code is to make sure we write all the values in the $value to the
405 # disk and to make sure all changes to $value after the assignment are
406 # reflected on disk. This may be counter-intuitive at first, but it is
408 # NOTE - simply tying $value won't perform a STORE on each value. Hence,
409 # the copy to a temp value.
412 my ($value, $value_sector) = @_;
413 my $r = Scalar::Util::reftype( $value ) || '';
415 if ( $r eq 'ARRAY' ) {
417 tie @$value, 'DBM::Deep', {
418 base_offset => $value_sector->offset,
419 staleness => $value_sector->staleness,
420 storage => $self->storage,
424 bless $value, 'DBM::Deep::Array' unless Scalar::Util::blessed( $value );
426 elsif ( $r eq 'HASH' ) {
428 tie %$value, 'DBM::Deep', {
429 base_offset => $value_sector->offset,
430 staleness => $value_sector->staleness,
431 storage => $self->storage,
435 bless $value, 'DBM::Deep::Hash' unless Scalar::Util::blessed( $value );