com.goldencode.p2j.persist

Class TxWrapper.WorkArea

java.lang.Object

com.goldencode.p2j.persist.TxWrapper.WorkArea

All Implemented Interfaces:

Commitable, Resettable, Scopeable

Enclosing class:

TxWrapper

private static class TxWrapper.WorkArea
extends java.lang.Object
implements Commitable, Resettable, Scopeable

Manages transaction-related state where buffers are involved. State and methods are extracted from BufferManager, and these require scope notification and management for each important block.

Field Summary

Fields

Modifier and Type	Field and Description
private java.util.Map<Database,MutableInteger>	activeDatabases Counter of in-use buffers for each database.
private TxWrapper.AggresiveFlushWrapper	aggressiveFlusher The singleton of TxWrapper.AggresiveFlushWrapper for this instance.
private java.util.BitSet	aggressiveFlushScopes The scopes which require an TxWrapper.AggresiveFlushWrapper to be registered as commitable.
private BufferManager	bm The buffer manager instance.
private ConnectionManager	connMgr Connection manager
private TailScopedDictionary<RecordBuffer,java.lang.Boolean>	dirtyBuffers The buffers touched via a Create, Update, Copy or Delete operation, in each scope.
private java.util.BitSet	emptyDirtyScopes Bitset with a flag indicating which scope was not yet loaded, for dirtyBuffers.
private java.util.BitSet	emptyLoadedScopes Bitset with a flag indicating which scope was not yet loaded, for loadedBuffers.
private java.util.Map<FastFindCache,java.util.Set<java.lang.Long>>	ffCacheChanges FastFindCache instances which need to have the specified DMOs invalidated.
private java.util.Map<Database,TxWrapper>	inactiveTxWrappers Transaction wrappers not yet activated
private ScopedDictionary<RecordBuffer,java.lang.Boolean>	loadedBuffers Scoped dictionary which key set contains all buffers into which a new record was loaded (or the old record was reloaded) into corresponding scopes.
private ProcedureManager.ProcedureHelper	pm Helper to use the ProcedureManager without any context local lookups.
private int	scopeDepth The real scope depth counter, as loadedBuffers and dirtyBuffers push scopes only when they are used.
private long	scopeTransitions Counter of the number of scope transitions (push or pop)
private long	transactionCount Counter of the number of application-level transactions
private int	transactionDepth Block depth at which full application transaction began, or -1 if not in a transaction
private TransactionManager.TransactionHelper	txHelper Transaction helper
private java.util.Map<Database,TxWrapper>	txWrapperMap Database to transaction wrapper instance map
private UniqueTracker.Context	uniqueTrackerCtx Context-local access to unique constraint tracker
private Finalizable	xactFin Transaction finalizable to manage transaction state locally (avoid context-local calls)

Constructor Summary

Constructors

Constructor and Description
WorkArea() Initialize this instance.

Method Summary

Modifier and Type	Method and Description
void	beginTx(boolean inTx, boolean fullTx, boolean aggresiveFlush, int blockDepth) Executes logic to explicitly begin a transaction.
private void	checkDirtyScopes() Check the emptyDirtyScopes and ensure that the entire dirtyBuffers scope stack is populated.
private void	checkLoadedScopes() Check the emptyLoadedScopes and ensure that the entire loadedBuffers scope stack is populated.
void	commit(boolean transaction) A full transaction or sub-transaction is committing.
private TxWrapper	createTxWrapper(Database database) Create an inactive transaction wrapper for the given database.
void	deregisterDynamicBuffer(RecordBuffer buffer) Deregister the given, dynamic record buffer by removing it from the buffer manager's tracking.
void	endTx(boolean inTx, boolean fullTx) Executes logic to explicitly end a transaction.
void	endTxPost() Executes logic required after a full transaction has ended.
ScopeId	getScopeId() Get the ScopeId for the instance.
long	getScopeTransitions() Get the number of block scope transitions made.
long	getTransactionCount() Get the current counter value of application-leve transactions which have been opened.
private void	invalidateFastFindCache() Invalidate all DMOs with ffCacheChanges.
boolean	isImportantBlockTransition() Indicate whether the current block is "important" from the standpoint of transitioning into or out of its scope.
boolean	isTransaction() Check whether the current block is within an application-level transaction.
void	maybeActivateTxWrapper(Database database) Given a database which has one or more buffers with an open scope operating within an application level transaction, possibly activate the transaction wrapper associated with that database.
void	notifyRecordWasLoaded(RecordBuffer recordBuffer) Notify the buffer manager that a new record was loaded (or the old record was reloaded) into the specified record buffer.
void	registerDirtyBuffer(RecordBuffer recordBuffer) Register this buffer as 'dirty' in the current scope.
void	resetState(boolean clearOnly) Releases the buffers into which a new record was loaded (or the old record was reloaded) into the current or deeper scopes, or only clears the list of buffers pending to be released.
void	rollback(boolean transaction) A full transaction or sub-transaction is rolling back.
void	scopeDeleted() Provides a notification that an external scope is about to be deleted.
void	scopeFinished() Provides a notification that a scope is about to be exited.
void	scopeStart(BlockDefinition block) Provides a notification that a new scope is about to be entered.
void	trackDatabase(RecordBuffer buffer, boolean add) Track the buffer's database.
void	validate(boolean transaction, boolean aggressiveFlush) A block is exiting or iterating normally within a transaction.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

txWrapperMap

private final java.util.Map<Database,TxWrapper> txWrapperMap

Database to transaction wrapper instance map

txHelper

private final TransactionManager.TransactionHelper txHelper

Transaction helper

pm

private final ProcedureManager.ProcedureHelper pm

Helper to use the ProcedureManager without any context local lookups.

bm

private BufferManager bm

The buffer manager instance.

connMgr

private final ConnectionManager connMgr

Connection manager

inactiveTxWrappers

private final java.util.Map<Database,TxWrapper> inactiveTxWrappers

Transaction wrappers not yet activated

xactFin

private final Finalizable xactFin

Transaction finalizable to manage transaction state locally (avoid context-local calls)

uniqueTrackerCtx

private final UniqueTracker.Context uniqueTrackerCtx

Context-local access to unique constraint tracker

scopeDepth

private int scopeDepth

The real scope depth counter, as loadedBuffers and dirtyBuffers push scopes only when they are used.

emptyLoadedScopes

private java.util.BitSet emptyLoadedScopes

Bitset with a flag indicating which scope was not yet loaded, for loadedBuffers.

emptyDirtyScopes

private java.util.BitSet emptyDirtyScopes

Bitset with a flag indicating which scope was not yet loaded, for dirtyBuffers.

scopeTransitions

private long scopeTransitions

Counter of the number of scope transitions (push or pop)

transactionDepth

private int transactionDepth

Block depth at which full application transaction began, or -1 if not in a transaction

transactionCount

private long transactionCount

Counter of the number of application-level transactions

activeDatabases

private final java.util.Map<Database,MutableInteger> activeDatabases

Counter of in-use buffers for each database.

loadedBuffers

private final ScopedDictionary<RecordBuffer,java.lang.Boolean> loadedBuffers

Scoped dictionary which key set contains all buffers into which a new record was loaded (or the old record was reloaded) into corresponding scopes. Value set doesn't contain any useful information and is used as a temporary data storage during copying from one scope level to another.

dirtyBuffers

private final TailScopedDictionary<RecordBuffer,java.lang.Boolean> dirtyBuffers

The buffers touched via a Create, Update, Copy or Delete operation, in each scope. If the full transaction block is not committed or rolled back, then the buffers will be merged in the previous scope.

aggressiveFlushScopes

private final java.util.BitSet aggressiveFlushScopes

The scopes which require an TxWrapper.AggresiveFlushWrapper to be registered as commitable.

aggressiveFlusher

private final TxWrapper.AggresiveFlushWrapper aggressiveFlusher

The singleton of TxWrapper.AggresiveFlushWrapper for this instance.

ffCacheChanges

private final java.util.Map<FastFindCache,java.util.Set<java.lang.Long>> ffCacheChanges

FastFindCache instances which need to have the specified DMOs invalidated.

Constructor Detail

WorkArea

public WorkArea()

Initialize this instance.

Method Detail

commit

public void commit(boolean transaction)

A full transaction or sub-transaction is committing. Notify all dirty buffers in the current scope.

Specified by:

commit in interface Commitable

Parameters:

transaction - true if full transaction; false if sub-transaction.

rollback

public void rollback(boolean transaction)

A full transaction or sub-transaction is rolling back. Notify all dirty buffers in the current scope.

Specified by:

rollback in interface Commitable

Parameters:

transaction - true if full transaction; false if sub-transaction.

validate

public void validate(boolean transaction,
                     boolean aggressiveFlush)

A block is exiting or iterating normally within a transaction. Notify all dirty buffers in the current scope.

Specified by:

validate in interface Commitable

Parameters:

transaction - true if full transaction; false if sub-transaction.

aggressiveFlush - true if transaction manager is in aggressive subtransaction flush mode, indicating that any transient buffers should be validated and flushed, regardless of other state.

registerDirtyBuffer

public void registerDirtyBuffer(RecordBuffer recordBuffer)

Register this buffer as 'dirty' in the current scope.

This registration doesn't mean that at the time of commit(boolean), rollback(boolean), or validate(boolean, boolean) the buffer's record is still 'dirty' - this is used to limit the set of buffers receiving such notifications, to avoid iterating over all BufferManager.openBuffers.

Parameters:

recordBuffer - The record buffer.

deregisterDynamicBuffer

public void deregisterDynamicBuffer(RecordBuffer buffer)

Deregister the given, dynamic record buffer by removing it from the buffer manager's tracking.

Parameters:

buffer - Dynamic record buffer to be removed.

notifyRecordWasLoaded

public void notifyRecordWasLoaded(RecordBuffer recordBuffer)

Notify the buffer manager that a new record was loaded (or the old record was reloaded) into the specified record buffer.

Parameters:

recordBuffer - The record buffer in which a record was loaded (or the old record was reloaded).

getScopeTransitions

public long getScopeTransitions()

Get the number of block scope transitions made. This is meant to be a semaphore of sorts, to allow a caller to determine whether this value has changed since some previous point when it was last retrieved. Since it is only meant to detect that the current block has changed over time, we do not protect against overflow.

Returns:

The current unique block ID.

trackDatabase

public void trackDatabase(RecordBuffer buffer,
                          boolean add)

Track the buffer's database. This will increment the activeDatabases counter when a new buffer is activated, and decrement it when it exists its scope.

Parameters:

buffer - The buffer to track.

add - Flag indicating if the buffer is opening or closing the scope.

Throws:

java.lang.IllegalStateException - If we are removing an active buffer and there is no entry for it in activeDatabases.

maybeActivateTxWrapper

public void maybeActivateTxWrapper(Database database)

Given a database which has one or more buffers with an open scope operating within an application level transaction, possibly activate the transaction wrapper associated with that database. Activation entails starting a database-level transaction and activating a savepoint manager for that transaction.

If the transaction wrapper for the given database already is active, do nothing.

Parameters:

database - Database with at least one buffer with an open scope.

isTransaction

public boolean isTransaction()

Check whether the current block is within an application-level transaction.

Returns:

true if we are in a transaction, else false.

getTransactionCount

public long getTransactionCount()

Get the current counter value of application-leve transactions which have been opened.

Returns:

Transaction count.

createTxWrapper

private TxWrapper createTxWrapper(Database database)

Create an inactive transaction wrapper for the given database. It will be activated the first time an open buffer scope is detected or when a new buffer scope is opened, at which time a database-level transaction will be opened.

Parameters:

database - Database for which this transaction wrapper is created.

Returns:

Transaction wrapper object.

beginTx

public void beginTx(boolean inTx,
                    boolean fullTx,
                    boolean aggresiveFlush,
                    int blockDepth)

Executes logic to explicitly begin a transaction.

Parameters:

inTx - Flag indicating if we are in a transaction.

fullTx - Flag indicating if we are in a full transaction.

aggresiveFlush - Flag indicating if the block isn't a transaction but it still needs to aggressively flush.

blockDepth - The current block depth (all blocks tracked by the TransactionManager).

endTx

public void endTx(boolean inTx,
                  boolean fullTx)

Executes logic to explicitly end a transaction.

Parameters:

inTx - Flag indicating if we are in a transaction.

fullTx - Flag indicating if we are in a full transaction.

endTxPost

public void endTxPost()

Executes logic required after a full transaction has ended.

isImportantBlockTransition

public boolean isImportantBlockTransition()

Indicate whether the current block is "important" from the standpoint of transitioning into or out of its scope. A block is considered "important" in this sense if it is either completely outside of an application transaction, or if it is within a transaction AND has transaction block properties (i.e., is not a NO_TRANSACTION block).

This notion of importance is used to determine whether the various scoped data structures managed by this class need to add or delete a scope when transitioning into or out of the block, respectively, and whether we need to perform processing (e.g., copying/moving data between scopes) associated with such transitions.

Returns:

true if the block is considered "important" by the above criteria, else false.

resetState

public void resetState(boolean clearOnly)

Releases the buffers into which a new record was loaded (or the old record was reloaded) into the current or deeper scopes, or only clears the list of buffers pending to be released.

Specified by:

resetState in interface Resettable

Parameters:

clearOnly - If true then clear the list of buffers pending to be released, otherwise perform release of these buffers and clear the list after that.

scopeStart

public void scopeStart(BlockDefinition block)

Provides a notification that a new scope is about to be entered.

Specified by:

scopeStart in interface Scopeable

Parameters:

block - The explicit block definition which required this notification.

scopeFinished

public void scopeFinished()

Provides a notification that a scope is about to be exited.

Specified by:

scopeFinished in interface Scopeable

scopeDeleted

public void scopeDeleted()

Provides a notification that an external scope is about to be deleted.

Specified by:

scopeDeleted in interface Scopeable

getScopeId

public ScopeId getScopeId()

Get the ScopeId for the instance.

Specified by:

getScopeId in interface Scopeable

Returns:

The scope ID, or null for cases when the scope notification is not done via BlockDefinition.scopeList.

checkLoadedScopes

private void checkLoadedScopes()

Check the emptyLoadedScopes and ensure that the entire loadedBuffers scope stack is populated.

checkDirtyScopes

private void checkDirtyScopes()

Check the emptyDirtyScopes and ensure that the entire dirtyBuffers scope stack is populated.

invalidateFastFindCache

private void invalidateFastFindCache()

Invalidate all DMOs with ffCacheChanges.