org.apache.tinkerpop.gremlin.driver.remote

## Class DriverRemoteTransaction

- java.lang.Object
- - org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteTransaction

- All Implemented Interfaces:
    AutoCloseable, RemoteConnection, Transaction

      public class DriverRemoteTransaction
      extends Object
      implements Transaction, RemoteConnection

  A remote `Transaction` implementation that is implemented with the Java driver. It is also a proxy for a `RemoteConnection` that is bound to a session.

  For users, starting a transaction with `Transaction.begin()` will produce a `TraversalSource` that can be used across multiple threads sending the bytecode based requests to a remote session. It is worth noting that the session will process these requests in a serial fashion and not in parallel. Calling `commit()` or `rollback()` will also close the session and no additional traversal can be executed on the `TraversalSource`. A fresh call to `Transaction.begin()` will be required to open a fresh session to work with. The default behavior of `close()` is to commit the transaction.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.structure.Transaction

      `Transaction.CLOSE_BEHAVIOR, Transaction.Exceptions, Transaction.READ_WRITE_BEHAVIOR, Transaction.Status`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Consumer<Transaction>` | `closeConsumer`

    - ### Fields inherited from interface org.apache.tinkerpop.gremlin.structure.Transaction

      `NO_OP`

    - ### Fields inherited from interface org.apache.tinkerpop.gremlin.process.remote.RemoteConnection

      `GREMLIN_REMOTE, GREMLIN_REMOTE_CONNECTION_CLASS`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `DriverRemoteTransaction(DriverRemoteConnection sessionBasedConnection)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addTransactionListener(Consumer<Transaction.Status> listener)` There is no support for remote transaction listeners.
    `<T extends TraversalSource> T` | `begin(Class<T> traversalSourceClass)` Starts a transaction in the context of a particular `TraversalSource` instance.
    `void` | `clearTransactionListeners()` There is no support for remote transaction listeners.
    `void` | `close()` The default close behavior for this `Transaction` implementation is to `commit()`.
    `void` | `commit()` Commits a transaction.
    `boolean` | `isOpen()` Determines if a transaction is currently open.
    `Transaction` | `onClose(Consumer<Transaction> consumer)` Describes what happens to a transaction on a call to `Graph.close()`.
    `Transaction` | `onReadWrite(Consumer<Transaction> consumer)` This `Transaction` implementation is not auto-managed and therefore this method is not supported.
    `void` | `open()` By virtue of creating a `DriverRemoteTransaction`, the transaction is considered open.
    `void` | `readWrite()` This `Transaction` implementation is not auto-managed and therefore this method is not supported.
    `void` | `removeTransactionListener(Consumer<Transaction.Status> listener)` There is no support for remote transaction listeners.
    `void` | `rollback()` Rolls back a transaction.
    `<E> CompletableFuture<RemoteTraversal<?,E>>` | `submitAsync(Bytecode bytecode)` Submits `Traversal` `Bytecode` to a server and returns a promise of a `RemoteTraversal`.
    `Transaction` | `tx()` It is not possible to have child transactions, therefore this method always returns `Transaction.NO_OP`.

    - ### Methods inherited from class java.lang.Object

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

    - ### Methods inherited from interface org.apache.tinkerpop.gremlin.structure.Transaction

      `begin, createThreadedTx`

    - ### Methods inherited from interface org.apache.tinkerpop.gremlin.process.remote.RemoteConnection

      `from`

- - ### Field Detail

    - #### closeConsumer

          protected Consumer<Transaction> closeConsumer

  - ### Constructor Detail

    - #### DriverRemoteTransaction

          public DriverRemoteTransaction(DriverRemoteConnection sessionBasedConnection)

  - ### Method Detail

    - #### begin

          public <T extends TraversalSource> T begin(Class<T> traversalSourceClass)

      Description copied from interface: `Transaction`
      Starts a transaction in the context of a particular `TraversalSource` instance. It is up to the `Transaction` implementation to decide what this means and up to users to be aware of that meaning.
      Specified by:
        `begin` in interface `Transaction`

    - #### open

          public void open()

      By virtue of creating a `DriverRemoteTransaction`, the transaction is considered open. There is no need to call this method. Calling it when the transaction is closed will result in exception.
      Specified by:
        `open` in interface `Transaction`

    - #### commit

          public void commit()

      Description copied from interface: `Transaction`
      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()

      Description copied from interface: `Transaction`
      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`

    - #### isOpen

          public boolean isOpen()

      Description copied from interface: `Transaction`
      Determines if a transaction is currently open.
      Specified by:
        `isOpen` in interface `Transaction`

    - #### close

          public void close()

      The default close behavior for this `Transaction` implementation is to `commit()`.
      Specified by:
        `close` in interface `AutoCloseable`
      Specified by:
        `close` in interface `Transaction`

    - #### readWrite

          public void readWrite()

      This `Transaction` implementation is not auto-managed and therefore this method is not supported.
      Specified by:
        `readWrite` in interface `Transaction`

    - #### onReadWrite

          public Transaction onReadWrite(Consumer<Transaction> consumer)

      This `Transaction` implementation is not auto-managed and therefore this method is not supported.
      Specified by:
        `onReadWrite` in interface `Transaction`

    - #### onClose

          public Transaction onClose(Consumer<Transaction> consumer)

      Description copied from interface: `Transaction`
      Describes what happens to a transaction on a call to `Graph.close()`. This value can be set using standard behavior defined in `Transaction.CLOSE_BEHAVIOR` or a mapper `Consumer` function.
      Specified by:
        `onClose` in interface `Transaction`

    - #### addTransactionListener

          public void addTransactionListener(Consumer<Transaction.Status> listener)

      There is no support for remote transaction listeners.
      Specified by:
        `addTransactionListener` in interface `Transaction`

    - #### removeTransactionListener

          public void removeTransactionListener(Consumer<Transaction.Status> listener)

      There is no support for remote transaction listeners.
      Specified by:
        `removeTransactionListener` in interface `Transaction`

    - #### clearTransactionListeners

          public void clearTransactionListeners()

      There is no support for remote transaction listeners.
      Specified by:
        `clearTransactionListeners` in interface `Transaction`

    - #### tx

          public Transaction tx()

      It is not possible to have child transactions, therefore this method always returns `Transaction.NO_OP`.
      Specified by:
        `tx` in interface `RemoteConnection`

    - #### submitAsync

          public <E> CompletableFuture<RemoteTraversal<?,E>> submitAsync(Bytecode bytecode)
                                                                  throws RemoteConnectionException

      Description copied from interface: `RemoteConnection`
      Submits `Traversal` `Bytecode` to a server and returns a promise of a `RemoteTraversal`. The `RemoteTraversal` is an abstraction over two types of results that can be returned as part of the response from the server: the results of the `Traversal` itself and the side-effects that it produced.
      Specified by:
        `submitAsync` in interface `RemoteConnection`
      Throws:
        `RemoteConnectionException`

Copyright © 2013–2021 Apache Software Foundation. All rights reserved.