com.splicemachine.derby.impl.store.access

Class SpliceTransactionFactory

java.lang.Object

com.splicemachine.derby.impl.store.access.SpliceTransactionFactory

All Implemented Interfaces:

ModuleControl, ModuleSupportable

public class SpliceTransactionFactory
extends java.lang.Object
implements ModuleControl, ModuleSupportable

Field Summary

Fields

Modifier and Type	Field and Description
protected ContextService	contextFactory
protected DataValueFactory	dataValueFactory
protected FileResource	fileHandler
protected HBaseStore	hbaseStore
protected SpliceLockFactory	lockFactory
protected static java.lang.String	NESTED_READONLY_USER_CONTEXT_ID
protected StorageFactory	storageFactory
protected static java.lang.String	USER_CONTEXT_ID

Constructor Summary

Constructors

Constructor and Description
SpliceTransactionFactory()

Method Summary

Modifier and Type	Method and Description
void	boot(boolean create, java.util.Properties properties) Boot this module with the given properties.
boolean	canSupport(java.util.Properties properties) See if this implementation can support any attributes that are listed in properties.
Transaction	findUserTransaction(HBaseStore hbaseStore, ContextManager contextMgr, java.lang.String transName) Find or create a user-level transaction.
FileResource	getFileHandler()
LockFactory	getLockFactory()
java.lang.Object	getXAResourceManager()
Transaction	marshalTransaction(java.lang.String transName, TxnView txn) place a transaction which was created outside of derby (e.g.
protected SpliceTransaction	startCommonTransaction(HBaseStore hbaseStore, ContextManager contextMgr, DataValueFactory dataValueFactory, java.lang.String transName, boolean abortAll, java.lang.String contextName) Start a new transaction.
protected SpliceTransaction	startNestedTransaction(HBaseStore hbaseStore, ContextManager contextMgr, DataValueFactory dataValueFactory, java.lang.String transName, boolean abortAll, java.lang.String contextName, boolean additive, TxnView parentTxn)
Transaction	startNestedTransaction(HBaseStore hbaseStore, ContextManager contextMgr, TxnView parentTxn) Start a "nested" transaction.
Transaction	startTransaction(HBaseStore hbaseStore, ContextManager contextMgr, java.lang.String transName) Starts a new transaction with the given name.
void	stop() Stop the module.

Methods inherited from class java.lang.Object

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

Field Detail

USER_CONTEXT_ID

protected static final java.lang.String USER_CONTEXT_ID

See Also:

Constant Field Values

NESTED_READONLY_USER_CONTEXT_ID

protected static final java.lang.String NESTED_READONLY_USER_CONTEXT_ID

See Also:

Constant Field Values

lockFactory

protected SpliceLockFactory lockFactory

dataValueFactory

protected DataValueFactory dataValueFactory

contextFactory

protected ContextService contextFactory

hbaseStore

protected HBaseStore hbaseStore

storageFactory

protected StorageFactory storageFactory

fileHandler

protected FileResource fileHandler

Constructor Detail

SpliceTransactionFactory

public SpliceTransactionFactory()

Method Detail

getLockFactory

public LockFactory getLockFactory()

getXAResourceManager

public java.lang.Object getXAResourceManager()
                                      throws StandardException

Throws:

StandardException

marshalTransaction

public Transaction marshalTransaction(java.lang.String transName,
                                      TxnView txn)
                               throws StandardException

place a transaction which was created outside of derby (e.g. across a serialization boundary, or a manually-created transaction) within the context of Derby, so that derby system calls can be used.

This is relatively cheap--it creates a new object, but registers the existing transaction, rather than creating a new one.

Parameters:

transName - the name of the transaction

txn - the transaction to marshall

Returns:

a derby representation of the transaction

Throws:

StandardException - if something goes wrong (which it isn't super likely to do)

startTransaction

public Transaction startTransaction(HBaseStore hbaseStore,
                                    ContextManager contextMgr,
                                    java.lang.String transName)
                             throws StandardException

Starts a new transaction with the given name.

This will create a new top-level transaction. As such, it will likely be an expensive network operation.

Parameters:

hbaseStore - the hbase store relevant to the transaction

contextMgr - the context manager

transName - the name of the transaction

Returns:

a new transaction with the specified name and context.

Throws:

StandardException - if something goes wrong creating the transaction

startNestedTransaction

public Transaction startNestedTransaction(HBaseStore hbaseStore,
                                          ContextManager contextMgr,
                                          TxnView parentTxn)
                                   throws StandardException

Start a "nested" transaction.

Derby's nested transaction is functionally equivalent to Splice's child transaction, and this method will actually create a child transaction.

Parameters:

hbaseStore - the hbase store relevant to the transaction

contextMgr - the context manager

parentTxn - the parent transaction

Returns:

a new child transaction of the parent transaction

Throws:

StandardException - if something goes wrong

findUserTransaction

public Transaction findUserTransaction(HBaseStore hbaseStore,
                                       ContextManager contextMgr,
                                       java.lang.String transName)
                                throws StandardException

Find or create a user-level transaction.

If the current context already has a created user level transaction, then it will return the value which currently exists. Otherwise, it will create a new user-level transaction.

Because of the possibility of creating a new transaction, it may use a network call, which makes this a potentially expensive call.

Parameters:

hbaseStore - the hbase store relevant to the transaction

contextMgr - the context manager

transName - the name of the transaction

Returns:

a new user-level transaction

Throws:

StandardException - if something goes wrong

startNestedTransaction

protected final SpliceTransaction startNestedTransaction(HBaseStore hbaseStore,
                                                         ContextManager contextMgr,
                                                         DataValueFactory dataValueFactory,
                                                         java.lang.String transName,
                                                         boolean abortAll,
                                                         java.lang.String contextName,
                                                         boolean additive,
                                                         TxnView parentTxn)

startCommonTransaction

protected final SpliceTransaction startCommonTransaction(HBaseStore hbaseStore,
                                                         ContextManager contextMgr,
                                                         DataValueFactory dataValueFactory,
                                                         java.lang.String transName,
                                                         boolean abortAll,
                                                         java.lang.String contextName)

Start a new transaction.

If parentTxn==null, then this will create a new top-level transaction (e.g. a child of the ROOT_TRANSACTION). Performing this generally requires a network call, and so is expensive.

If parentTxn!=null, then this may create a "read-only child transaction"; this is in effect a copy of the parent transaction's information along with some additional logic for when elevation occur. Therefore, this way is likely very inexpensive to call this method, but it will be doubly expensive when elevateTransaction() is called (as it will require 2 network calls to elevate).

See Also:

TxnLifecycleManager.beginChildTransaction(com.splicemachine.si.api.txn.TxnView,com.splicemachine.si.api.txn.Txn.IsolationLevel,boolean,byte[])

canSupport

public boolean canSupport(java.util.Properties properties)

Description copied from interface: ModuleSupportable

See if this implementation can support any attributes that are listed in properties. This call may be made on a newly created instance before the boot() method has been called, or after the boot method has been called for a running module.

The module can check for attributes in the properties to see if it can fulfill the required behaviour. E.g. the raw store may define an attribute called RawStore.Recoverable. If a temporary raw store is required the property RawStore.recoverable=false would be added to the properties before calling bootServiceModule. If a raw store cannot support this attribute its canSupport method would return null. Also see the Monitor class's prologue to see how the identifier is used in looking up properties.
Actually a better way maybe to have properties of the form RawStore.Attributes.mandatory=recoverable,smallfootprint and RawStore.Attributes.requested=oltp,fast

Specified by:

canSupport in interface ModuleSupportable

Returns:

true if this instance can be used, false otherwise.

boot

public void boot(boolean create,
                 java.util.Properties properties)
          throws StandardException

Description copied from interface: ModuleControl

Boot this module with the given properties. Creates a module instance that can be found using the findModule() methods of Monitor. The module can only be found using one of these findModule() methods once this method has returned.

An implementation's boot method can throw StandardException. If it is thrown the module is not registered by the monitor and therefore cannot be found through a findModule(). In this case the module's stop() method is not called, thus throwing this exception must free up any resources.

When create is true the contents of the properties object will be written to the service.properties of the persistent service. Thus any code that requires an entry in service.properties must explicitly place the value in this properties set using the put method.
Typically the properties object contains one or more default properties sets, which are not written out to service.properties. These default sets are how callers modify the create process. In a JDBC connection database create the first set of defaults is a properties object that contains the attributes that were set on the jdbc:splice: URL. This attributes properties set has the second default properties set as its default. This set (which could be null) contains the properties that the user set on their DriverManager.getConnection() call, and are thus not owned by Derby code, and thus must not be modified by Derby code.

When create is false the properties object contains all the properties set in the service.properties file plus a limited number of attributes from the JDBC URL attributes or connection properties set. This avoids properties set by the user compromising the boot process. An example of a property passed in from the JDBC world is the bootPassword for encrypted databases.

Code should not hold onto the passed in properties reference after boot time as its contents may change underneath it. At least after the complete boot is completed, the links to all the default sets will be removed.

Specified by:

boot in interface ModuleControl

Throws:

StandardException - Module cannot be started.

See Also:

Monitor, ModuleFactory

stop

public void stop()

Description copied from interface: ModuleControl

Stop the module. The module may be found via a findModule() method until some time after this method returns. Therefore the factory must be prepared to reject requests to it once it has been stopped. In addition other modules may cache a reference to the module and make requests of it after it has been stopped, these requests should be rejected as well.

Specified by:

stop in interface ModuleControl

See Also:

Monitor, ModuleFactory

getFileHandler

public FileResource getFileHandler()