RxStatementResult (Neo4j Java Driver 4.0.0-beta03 API)

```
public interface RxStatementResult
```
A reactive result provides a reactive way to execute query on the server and receives records back. This reactive result consists of a result key publisher, a record publisher and a result summary publisher. The reactive result is created via RxStatementRunner.run(Statement) and RxStatementRunner.run(Statement) for example. On the creation of the result, the query submitted to create this result will not be executed until one of the publishers in this class is subscribed. The records or the summary stream has to be consumed and finished (completed or errored) to ensure the resources used by this result to be freed correctly.

Since:

2.0

See Also:

Publisher, Subscriber, Subscription

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`org.reactivestreams.Publisher<ResultSummary>`	`consume()` Returns a cold publisher of result summary which arrives after all records.
`org.reactivestreams.Publisher<List<String>>`	`keys()` Returns a cold publisher of keys.
`org.reactivestreams.Publisher<Record>`	`records()` Returns a cold unicast publisher of records.

- Method Detail
  - keys
```
org.reactivestreams.Publisher<List<String>> keys()
```
    Returns a cold publisher of keys. This publisher always publishes one item - a list of keys. The list could be empty which indicates no keys in the result.
    When this publisher is subscribed, the statement is sent to the server and executed. This method does not start the record streaming nor publish statement execution result. To retrieve the execution result, either records() or consume() can be used. records() starts record streaming and reports statement execution result. consume() skips record streaming and directly reports statement execution result.
    Consuming of execution result ensures the resources (such as network connections) used by this result is freed correctly. Consuming the keys without consuming the execution result will result in resource leak. To avoid the resource leak, RxSession.close() (and/or RxTransaction.commit() and RxTransaction.rollback()) shall be invoked and subscribed to enforce the result resources created in the RxSession (and/or RxTransaction) to be freed correctly.
    This publisher can be subscribed many times. The keys published stays the same as the keys are buffered. If this publisher is subscribed after the publisher of records() or consume(), then the buffered keys will be returned.
    
    Returns:
    
    a cold publisher of keys.
  - records
```
org.reactivestreams.Publisher<Record> records()
```
    Returns a cold unicast publisher of records.
    When the record publisher is subscribed, the query statement is executed and the statement result is streamed back as a record stream followed by a result summary. This record publisher publishes all records in the result and signals the completion. However before completion or error reporting if any, a cleanup of result resources such as network connection will be carried out automatically.
    Therefore the Subscriber of this record publisher shall wait for the termination signal (complete or error) to ensure that the resources used by this result are released correctly. Then the session is ready to be used to run more statements.
    Cancelling of the record streaming will immediately terminate the propagation of new records. But it will not cancel statement execution on the server. When the execution is finished, the Subscriber will be notified with a termination signal (complete or error).
    The record publishing event by default runs in an Network IO thread, as a result no blocking operation is allowed in this thread. Otherwise network IO might be blocked by application logic.
    This publisher can only be subscribed by one Subscriber once.
    If this publisher is subscribed after keys(), then the publish of records is carried out after the arrival of keys. If this publisher is subscribed after consume(), then a ResultConsumedException will be thrown.
    
    Returns:
    
    a cold unicast publisher of records.
  - consume
```
org.reactivestreams.Publisher<ResultSummary> consume()
```
    Returns a cold publisher of result summary which arrives after all records.
    Subscribing the summary publisher results in the execution of the statement followed by the result summary being returned. The summary publisher cancels record publishing if not yet subscribed and directly streams back the summary on statement execution completion. As a result, the invocation of records() after this method, would receive an ResultConsumedException.
    If subscribed after keys(), then the result summary will be published after the statement execution without streaming any record to client. If subscribed after records(), then the result summary will be published after the statement execution and the streaming of records.
    Usually, this method shall be chained after records() to ensure that all records are processed before summary.
    This method can be subscribed multiple times. When the summary arrives, it will be buffered locally for all subsequent calls.
    
    Returns:
    
    a cold publisher of result summary which only arrives after all records.

Interface RxStatementResult

Method Summary

Method Detail

keys

records

consume