Versioning and persistence

[Chris Bitmead uid]

>I believe the standard way versioning is dealt with in OODBs is at the segment
>level (a segment being a collection of objects that are treated together for
>various purposes -- typically a segment is stored in a single disk file).

Those ODBMSs that use the named root scheme aren't really designed to
have thousands of names. Usually you have between 1 and several. They
are just meant to be a starting point from which you can start
navigating.

>To explain this I need to introduce the concept of named roots.  It's very
>simple: one can register any object as a named root of a given segment by
>supplying the name (a string).  Later, one can open the segment and access any
>of these roots by name.  This is the only well-defined way to get one's hands
>on an object within the segment if one doesn't already have a pointer into it.
>
>Now back to versioning.  Most code simply manipulates objects with no concern
>for versioning.  However, one can open a specific version of a segment and
>retrieve one of its named roots.  Once this is done, the object is like any
>other object.  At least as long as one is accessing only a single version of
>any segment at a time, everything works straightforwardly.
>
>Accessing more than one version of a given segment at a time gets a little
>weird because different versions of an object are not EQ.  I'm not sure how
>much of a problem this is in practice.

What is most weird is what should happen when a old version segment
starts accessing another segment, and vice versa.