Package org.apache.tinkerpop.gremlin.structure.util

Class AbstractTransaction

java.lang.Object
org.apache.tinkerpop.gremlin.structure.util.AbstractTransaction
All Implemented Interfaces:
AutoCloseable, Transaction
Direct Known Subclasses:
AbstractThreadedTransaction, AbstractThreadLocalTransaction
public abstract class AbstractTransaction extends Object implements Transaction
A simple base class for Transaction that provides some common functionality and default behavior. While providers can choose to use this class, it is generally better to extend from AbstractThreadedTransaction or AbstractThreadLocalTransaction which include default "listener" functionality. Implementers should note that this class assumes that threaded transactions are not enabled and should explicitly override createThreadedTx() to implement that functionality if required.
Author:
Stephen Mallette (http://stephen.genoprime.com)

  • Constructor Details

    • AbstractTransaction

      public AbstractTransaction(Graph graph)

  • Method Details

    • doOpen

      protected abstract void doOpen()
      Called within begin(Class) if it is determined that the transaction is not yet open given Transaction.isOpen(). Implementers should assume the transaction is not yet started and should thus open one.

    • doCommit

      protected abstract void doCommit() throws TransactionException
      Called with commit() after the Transaction.onReadWrite(Consumer) has been notified. Implementers should include their commit logic here.
      Throws:
      TransactionException

    • doRollback

      protected abstract void doRollback() throws TransactionException
      Called with rollback() after the Transaction.onReadWrite(Consumer) has been notified. Implementers should include their rollback logic here.
      Throws:
      TransactionException

    • fireOnCommit

      protected abstract void fireOnCommit()
      Called within commit() just after the internal call to doCommit(). Implementations of this method should raise Transaction.Status.COMMIT events to any listeners added via Transaction.addTransactionListener(Consumer).

    • fireOnRollback

      protected abstract void fireOnRollback()
      Called within rollback() just after the internal call to doRollback() ()}. Implementations of this method should raise Transaction.Status.ROLLBACK events to any listeners added via Transaction.addTransactionListener(Consumer).

    • doReadWrite

      protected abstract void doReadWrite()
      Called readWrite(). Implementers should run their readWrite consumer here.

    • doClose

      protected abstract void doClose()
      Called close(). Implementers should run their readWrite consumer here.

    • commit

      public void commit()
      Commits a transaction. This method may optionally throw TransactionException on error. Providers should consider wrapping their transaction exceptions in this TinkerPop exception as it will lead to better error handling with Gremlin Server and other parts of the stack.
      Specified by:
      commit in interface Transaction

    • rollback

      public void rollback()
      Rolls back a transaction. This method may optionally throw TransactionException on error. Providers should consider wrapping their transaction exceptions in this TinkerPop exception as it will lead to better error handling with Gremlin Server and other parts of the stack.
      Specified by:
      rollback in interface Transaction

    • createThreadedTx

      public <G extends Graph> G createThreadedTx()
      Creates a transaction that can be executed across multiple threads. The Graph returned from this method is not meant to represent some form of child transaction that can be committed from this object. A threaded transaction is a Graph instance that has a transaction context that enables multiple threads to collaborate on the same transaction. A standard transactional context tied to a Graph that supports transactions will typically bind a transaction to a single thread via ThreadLocal.
      Specified by:
      createThreadedTx in interface Transaction

    • begin

      public <T extends TraversalSource> T begin(Class<T> traversalSourceClass)
      Starts a transaction in the context of a particular TraversalSource instance and returns a TraversalSource bound to it. If a transaction is not already open for this Transaction, one is started; if a transaction is already open, this method is idempotent - it does not start a new transaction and does not throw, returning a source bound to the open transaction. The identity of the returned source across calls is unspecified and must not be relied upon. How the returned TraversalSource is bound to the transaction's context is up to the implementation and up to users to be aware of that meaning.

      Starts a transaction if one is not already open for this Transaction (delegating to doOpen() under an Transaction.isOpen() guard) and returns a TraversalSource bound to it. This method is idempotent with respect to the transaction: calling it while a transaction is already open does not start a new transaction and does not throw - it simply returns a traversal source bound to the open transaction. The identity of the returned source across calls is unspecified; callers must not rely on reference identity.

      Specified by:
      begin in interface Transaction

    • readWrite

      public void readWrite()
      An internal function that signals a read or a write has occurred - not meant to be called directly by end users.
      Specified by:
      readWrite in interface Transaction

    • close

      public void close()
      Closes the transaction where the default close behavior defined by {Transaction.onClose(Consumer)} will be executed.
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Transaction