Storable - persistency for perl data structures

NAME

SYNOPSIS

        use Storable;
        store \%table, 'file';
        $hashref = retrieve('file');

The Storable package brings you persistency for your perl data structures containing SCALAR, ARRAY, HASH or REF objects, i.e. anything that can be convenientely stored to disk and retrieved at a later time.

It can be used in the regular procedural way by calling store with a reference to the object to store, and providing a file name. The routine returns undef for I/O problems or other internal error, a true value otherwise. Serious errors are propagated as a die exception.

To retrieve data stored to disk, you use retrieve with a file name, and the objects stored into that file are recreated into memory for you, and a reference to the root object is returned. In case an I/O error occurred while reading, undef is returned instead. Other serious errors are propagated via die.

Since storage is performed recursively, you might want to stuff references to objects that share a lot of common data into a single array or hash table, and then store that object. That way, when you retrieve back the whole thing, the objects will continue to share what they originally shared.

At the cost of a slight header overhead, you may store to an already opened file descriptor using the store_fd routine, and retrieve from a file via retrieve_fd. Those names aren't imported by default, so you will have to do that explicitely if you need those routines. The file descriptor name you supply must be fully qualified.

You can also store data in network order to allow easy sharing across multiple platforms, or when storing on a socket known to be remotely connected. The routines to call have an initial n prefix for network, as in nstore and nstore_fd. At retrieval time, your data will be correctly restored so you don't have to know whether you're restoring from native or network ordered data.

When using retrieve_fd, objects are retrieved in sequence, one object (i.e. one recursive tree) per associated store_fd.

If you're more from the object-oriented camp, you can inherit from Storable and directly store your objects by invoking store as a method. The fact that the root of the to-be-stored tree is a blessed reference (i.e. an object) is special-cased so that the retrieve does not provide a reference to that object but rather the blessed object reference itself. (Otherwise, you'd get a reference to that blessed object).

MEMORY STORE

The Storable engine can also store data into a Perl scalar instead, to later retrieve them. This is mainly used to freeze a complex structure in some safe compact memory place (where it can possibly be sent to another process via some IPC, since freezing the structure also serializes it in effect). Later on, and maybe somewhere else, you can thaw the Perl scalar out and recreate the original complex structure in memory.

Surprisingly, the routines to be called are named freeze and thaw. If you wish to send out the frozen scalar to another machine, use nfreeze instead to get a portable image.

Note that freezing an object structure and immediately thawing it actually achieves a deep cloning of that structure. Storable provides you with a dclone interface which does not create that intermediary scalar but instead freezes the structure in some internal memory space and then immediatly thaws it out.

SPEED

The heart of Storable is written in C for decent speed. Extra low-level optimization have been made when manipulating perl internals, to sacrifice encapsulation for the benefit of a greater speed.

Storage is usually faster than retrieval since the latter has to allocate the objects from memory and perform the relevant I/Os, whilst the former mainly performs I/Os.

On my HP 9000/712 machine running HPUX 9.03 and with perl 5.004, I can store 0.8 Mbyte/s and I can retrieve at 0.72 Mbytes/s, approximatively (CPU + system time). This was measured with Benchmark and the Magic: The Gathering database from Tom Christiansen (1.9 Mbytes).

EXAMPLES

Here are some code samples showing a possible usage of Storable:

        use Storable qw(store retrieve freeze thaw dclone);

        %color = ('Blue' => 0.1, 'Red' => 0.8, 'Black' => 0, 'White' => 1);

        store(\%color, '/tmp/colors') or die "Can't store %a in /tmp/colors!\n";

        $colref = retrieve('/tmp/colors');
        die "Unable to retrieve from /tmp/colors!\n" unless defined $colref;
        printf "Blue is still %lf\n", $colref->{'Blue'};

        $colref2 = dclone(\%color);

        $str = freeze(\%color);
        printf "Serialization of %%color is %d bytes long.\n", length($str);
        $colref3 = thaw($str);

which prints (on my machine):

        Blue is still 0.100000
        Serialization of %color is 102 bytes long.

WARNING

If you're using references as keys within your hash tables, you're bound to disapointment when retrieving your data. Indeed, Perl stringifies references used as hash table keys. If you later wish to access the items via another reference stringification (i.e. using the same reference that was used for the key originally to record the value into the hash table), it will work because both references stringify to the same string.

It won't work across a store and retrieve operations however, because the addresses in the retrieved objects, which are part of the stringified references, will probably differ from the original addresses. The topology of your structure is preserved, but not hidden semantics like those.

BUGS

You can't store GLOB, CODE, FORMLINE, etc... If you can define semantics for those operations, feel free to enhance Storable so that it can deal with those.

The store functions will croak if they run into such references unless you set $Storable::forgive_me to some TRUE value. In this case, the fatal message is turned in a warning and some meaningless string is stored instead.

Due to the aforementionned optimizations, Storable is at the mercy of perl's internal redesign or structure changes. If that bothers you, you can try convincing Larry that what is used in Storable should be documented and consistently kept in future revisions. As I said, you may try.

AUTHOR

Raphael Manfredi <Raphael_Manfredi@grenoble.hp.com>