integers that could lead to database corruption. Now all file position
computation is done with Python longs. Thanks to Shane Hathaway for
finding this.

Fixed a bug that could cause database corruption if transaction user
names, descriptions, or extension data exceeded 64K bytes. This was
due to the faulty assumption that struct.pack caught overflows, which
it doesn't. :(

Changed to use new tpc_vote protocol. This allows errors that occur
in the last transaction step to be caught during the first phase of
two-phase commit. For example, if we run out of disk space, we now
catch the problem early enough to recover from it.

_abort.

Added some comments.

split database XML export/import into separate module at Zope
application level, since it (currently) depends on Zope-specific,
rather than ZODB-specific code.

bypasses/takes-over transaction processing.

application level, since it (currently) depends on Zope-specific,
rather than ZODB-specific code.

error messages.

FileStorage from expanding to 2 GB.

previous packs. Packs to earlier times can cause data lossage.

of the startup invalidation protocol.

called from a separate thread than the async main loop. We only want
the async main loop to close our _call (rpc) object. Instead of
closing it directly, we call closeIntensionally(), which, in return,
requests that the async main loop closes it, via the select trigger.

when a transaction is about to be written. It would be bad if we
"flipped" the cache twice during a transaction, as we would have
incomplete transaction data.  Note that this means that we could
exceed the target cache size if the data for a transaction exceeded
the target size (/2).

Changed the way that the storage is closed. Our close method may be
called from a separate thread than the async main loop. We only want
the async main loop to close our _call (rpc) object. Instead of
closing it directly, we call closeIntensionally(), which, in return,
requests that the async main loop closes it, via the select trigger.

Added seek before write in invalidate method. Without this, strange
things happen on NT and solaris. (I was probably breaking a rule of
thumb that says never to do a write() right after a read() even though
tell() would indicate I was in the right place.)

Added logic to update the cache index on an invalidate.

Added a separate call to check the cache size so that we only check
when a transaction is about to be written. It would be bad if we
"flipped" the cache twice during a transaction, as we would have
incomplete transaction data.  Note that this means that we could
exceed the target cache size if the data for a transaction exceeded
the target size (/2).

  - Serving multiple storages,

  - Serving storages other than file storages.

access.

The protocol was changed on the client, but not the server.
The client has been changed back. This part of the protocol
will go away in r0.3.

(e.g. when moving data between a DCOracleStorage and a FileStorage),
especially the method copyTransactionsFrom, as in:

  import ZODB.FileStorage, DCOracle, DCOracleStorage

  # Copy data.fs to oracle
  DCOracleStorage.Full(
    lambda : DCOracle.Connect('user/pw@sid')
    ).copyTransactionsFrom(
      ZODB.FileStorage.FileStorage('Data.fs', read_only=1)
    )

any current storages.

included unless the -L option is provided.

a transaction id to be spacified, rather than being defined
by the storage. This should *only* be used when copying data
from one type of storage to another.

from one storage to another.

than the (timestamp of the first record written after the) last pack.
Packing to a time earlier than the last pack can cause serious data
lossage.

requested disregarded the filter. That is, the arguments first and
last should be applied *after* filtering.