(Following extracted from an email from David Brown. SJG)

There is not much in the way of instructions.  All environment proxys
should inherit from this class.  No reference should be made directly
to the BdbConditions (or any other BdbDomain) in user code.  Before
fetching data from the database (BdbDatabase::fetch calls), the
startTransaction() function should be called in the faultHandler
method of the proxy.  For efficiency reasons, startTransaction()
should only be called if data are really going to be fetched, so tests
on transient validity should be made before calling it.
startTransaction() can be safely called multiple times in
faultHandler.  Once all database operations are complete (including
access to fetched data), endTransaction() should be called.  This
function may be safely called even if startTransaction() was never
called, but it can be called at most once.  Consequently, it's a good
idea to make endTransaction() the last line in faultHandler before
return.

Using this class, transaction management can be handled either outside
the class (preferable for efficiency) or inside the proxy, should
there be no active transaction when startTransaction() is called.
Optimal efficiency can be achieved if some module (event input?)
starts a read transaction at the begining of the event, then holds it
through all the proxy faults, ending it only after all the proxys have
faulted.  Otherwise, each proxy will start and end its own transaction
(which is what they're doing now, since most don't inherit from
BdbCondProxyBase anyways).  My guess is that standardizing this should
result in a speedup in database access on the first event.