Module org.neo4j.driver
Package org.neo4j.driver.reactive

Interface RxSession

All Superinterfaces:
BaseSession, RxQueryRunner
All Known Implementing Classes:
InternalRxSession
@Deprecated public interface RxSession extends BaseSession, RxQueryRunner
Deprecated.
superseded by ReactiveSession and ReactiveSession
A reactive session is the same as Session except it provides a reactive API.
Since:
4.0
See Also:

  • Method Details

    • beginTransaction

      default org.reactivestreams.Publisher<RxTransaction> beginTransaction()
      Deprecated.
      Begin a new unmanaged transaction. At most one transaction may exist in a session at any point in time. To maintain multiple concurrent transactions, use multiple concurrent sessions.

      It by default is executed in a Network IO thread, as a result no blocking operation is allowed in this thread.

      Returns:
      a new RxTransaction

    • beginTransaction

      org.reactivestreams.Publisher<RxTransaction> beginTransaction(TransactionConfig config)
      Deprecated.
      Begin a new unmanaged transaction with the specified configuration. At most one transaction may exist in a session at any point in time. To maintain multiple concurrent transactions, use multiple concurrent sessions.

      It by default is executed in a Network IO thread, as a result no blocking operation is allowed in this thread.

      Parameters:
      config - configuration for the new transaction.
      Returns:
      a new RxTransaction

    • readTransaction

      <T> org.reactivestreams.Publisher<T> readTransaction(RxTransactionWork<? extends org.reactivestreams.Publisher<T>> work)
      Deprecated.
      Execute given unit of reactive work in a read reactive transaction.

      Transaction will automatically be committed unless given unit of work fails or transaction commit fails. It will also not be committed if explicitly rolled back via RxTransaction.rollback().

      Returned publisher and given RxTransactionWork is completed/executed by an IO thread which should never block. Otherwise IO operations on this and potentially other network connections might deadlock. Please do not chain blocking operations like CompletableFuture.get() on the returned publisher and do not use them inside the RxTransactionWork.

      Type Parameters:
      T - the return type of the given unit of work.
      Parameters:
      work - the RxTransactionWork to be applied to a new read transaction. Operation executed by the given work must NOT include any blocking operation.
      Returns:
      a publisher completed with the same result as returned by the given unit of work. publisher can be completed exceptionally if given work or commit fails.

    • readTransaction

      <T> org.reactivestreams.Publisher<T> readTransaction(RxTransactionWork<? extends org.reactivestreams.Publisher<T>> work, TransactionConfig config)
      Deprecated.
      Execute given unit of reactive work in a read reactive transaction with the specified configuration.

      Transaction will automatically be committed unless given unit of work fails or transaction commit fails. It will also not be committed if explicitly rolled back via RxTransaction.rollback().

      Returned publisher and given RxTransactionWork is completed/executed by an IO thread which should never block. Otherwise IO operations on this and potentially other network connections might deadlock. Please do not chain blocking operations like CompletableFuture.get() on the returned publisher and do not use them inside the RxTransactionWork.

      Type Parameters:
      T - the return type of the given unit of work.
      Parameters:
      work - the RxTransactionWork to be applied to a new read transaction. Operation executed by the given work must NOT include any blocking operation.
      config - the transaction configuration.
      Returns:
      a publisher completed with the same result as returned by the given unit of work. publisher can be completed exceptionally if given work or commit fails.

    • writeTransaction

      <T> org.reactivestreams.Publisher<T> writeTransaction(RxTransactionWork<? extends org.reactivestreams.Publisher<T>> work)
      Deprecated.
      Execute given unit of reactive work in a write reactive transaction.

      Transaction will automatically be committed unless given unit of work fails or transaction commit fails. It will also not be committed if explicitly rolled back via RxTransaction.rollback().

      Returned publisher and given RxTransactionWork is completed/executed by an IO thread which should never block. Otherwise IO operations on this and potentially other network connections might deadlock. Please do not chain blocking operations like CompletableFuture.get() on the returned publisher and do not use them inside the RxTransactionWork.

      Type Parameters:
      T - the return type of the given unit of work.
      Parameters:
      work - the RxTransactionWork to be applied to a new read transaction. Operation executed by the given work must NOT include any blocking operation.
      Returns:
      a publisher completed with the same result as returned by the given unit of work. publisher can be completed exceptionally if given work or commit fails.

    • writeTransaction

      <T> org.reactivestreams.Publisher<T> writeTransaction(RxTransactionWork<? extends org.reactivestreams.Publisher<T>> work, TransactionConfig config)
      Deprecated.
      Execute given unit of reactive work in a write reactive transaction with the specified configuration.

      Transaction will automatically be committed unless given unit of work fails or transaction commit fails. It will also not be committed if explicitly rolled back via RxTransaction.rollback().

      Returned publisher and given RxTransactionWork is completed/executed by an IO thread which should never block. Otherwise IO operations on this and potentially other network connections might deadlock. Please do not chain blocking operations like CompletableFuture.get() on the returned publisher and do not use them inside the RxTransactionWork.

      Type Parameters:
      T - the return type of the given unit of work.
      Parameters:
      work - the RxTransactionWork to be applied to a new read transaction. Operation executed by the given work must NOT include any blocking operation.
      config - the transaction configuration.
      Returns:
      a publisher completed with the same result as returned by the given unit of work. publisher can be completed exceptionally if given work or commit fails.

    • run

      RxResult run(String query, TransactionConfig config)
      Deprecated.
      Run a query with parameters in an auto-commit transaction with specified TransactionConfig and return a reactive result stream. The query is not executed when the reactive result is returned. Instead, the publishers in the result will actually start the execution of the query.
      Parameters:
      query - text of a Neo4j query.
      config - configuration for the new transaction.
      Returns:
      a reactive result.

    • run

      RxResult run(String query, Map<String,Object> parameters, TransactionConfig config)
      Deprecated.
      Run a query with parameters in an auto-commit transaction with specified TransactionConfig and return a reactive result stream. The query is not executed when the reactive result is returned. Instead, the publishers in the result will actually start the execution of the query.

      This method takes a set of parameters that will be injected into the query by Neo4j. Using parameters is highly encouraged, it helps avoid dangerous cypher injection attacks and improves database performance as Neo4j can re-use query plans more often.

      This version of run takes a Map of parameters. The values in the map must be values that can be converted to Neo4j types. See Values.parameters(Object...) for a list of allowed types.

      Example

       
 Map<String, Object> metadata = new HashMap<>();
 metadata.put("type", "update name");

 TransactionConfig config = TransactionConfig.builder()
                 .withTimeout(Duration.ofSeconds(3))
                 .withMetadata(metadata)
                 .build();

 Map<String, Object> parameters = new HashMap<>();
 parameters.put("myNameParam", "Bob");

 RxResult result = rxSession.run("MATCH (n) WHERE n.name = $myNameParam RETURN (n)", parameters, config);
      Parameters:
      query - text of a Neo4j query.
      parameters - input data for the query.
      config - configuration for the new transaction.
      Returns:
      a reactive result.

    • run

      RxResult run(Query query, TransactionConfig config)
      Deprecated.
      Run a query in an auto-commit transaction with specified configuration and return a reactive result stream. The query is not executed when the reactive result is returned. Instead, the publishers in the result will actually start the execution of the query.

      Example

       
 Map<String, Object> metadata = new HashMap<>();
 metadata.put("type", "update name");

 TransactionConfig config = TransactionConfig.builder()
                 .withTimeout(Duration.ofSeconds(3))
                 .withMetadata(metadata)
                 .build();

 Query query = new Query("MATCH (n) WHERE n.name = $myNameParam RETURN n.age");
 RxResult result = rxSession.run(query.withParameters(Values.parameters("myNameParam", "Bob")));
      Parameters:
      query - a Neo4j query.
      config - configuration for the new transaction.
      Returns:
      a reactive result.

    • lastBookmark

      Bookmark lastBookmark()
      Deprecated.
      Return the last bookmark of this session.

      When no new bookmark is received, the initial bookmarks are returned as a composite Bookmark containing all initial bookmarks. This may happen when no work has been done using the session. If no initial bookmarks have been provided, an empty Bookmark is returned.

      Returns:
      the last bookmark.

    • close

      <T> org.reactivestreams.Publisher<T> close()
      Deprecated.
      Signal that you are done using this session. In the default driver usage, closing and accessing sessions is very low cost.

      This operation is not needed if 1) all results created in the session have been fully consumed and 2) all transactions opened by this session have been either committed or rolled back.

      This method is a fallback if you failed to fulfill the two requirements above. This publisher is completed when all outstanding queries in the session have completed, meaning any writes you performed are guaranteed to be durably stored. It might be completed exceptionally when there are unconsumed errors from previous queries or transactions.

      Type Parameters:
      T - makes it easier to be chained.
      Returns:
      an empty publisher that represents the reactive close.