public class Result<T> extends Object implements PagingIterable<Result<T>,T>
| Modifier and Type | Method and Description |
|---|---|
List<T> |
all()
Returns all the remaining rows in this result set as a list.
|
ListenableFuture<Result<T>> |
fetchMoreResults()
Force fetching the next page of results for this result set, if any.
|
List<ExecutionInfo> |
getAllExecutionInfo()
Return the execution information for all queries made to retrieve this result set.
|
int |
getAvailableWithoutFetching()
The number of rows that can be retrieved from this result set without blocking to fetch.
|
ExecutionInfo |
getExecutionInfo()
Returns information on the execution of the last query made for this result set.
|
boolean |
isExhausted()
Returns whether this result set has more results.
|
boolean |
isFullyFetched()
Whether all results from this result set have been fetched from the database.
|
Iterator<T> |
iterator()
Returns an iterator over the rows contained in this result set.
|
T |
one()
Returns the next result from this result set.
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitforEach, spliteratorpublic boolean isExhausted()
PagingIterableisExhausted in interface PagingIterable<Result<T>,T>public T one()
PagingIterableone in interface PagingIterable<Result<T>,T>public List<T> all()
PagingIterableNote that, contrary to PagingIterable.iterator() or successive calls to PagingIterable.one(), this
method forces fetching the full content of the result set at once, holding it all in memory in
particular. It is thus recommended to prefer iterations through PagingIterable.iterator() when
possible, especially if the result set can be big.
all in interface PagingIterable<Result<T>,T>public Iterator<T> iterator()
PagingIterableThe Iterator.next() method is equivalent to calling PagingIterable.one(). So this iterator
will consume results from this result set and after a full iteration, the result set will be
empty.
The returned iterator does not support the Iterator.remove() method.
public ExecutionInfo getExecutionInfo()
PagingIterableNote that in most cases, a result set is fetched with only one query, but large result sets
can be paged and thus be retrieved by multiple queries. In that case this method return the
ExecutionInfo for the last query performed. To retrieve the information for all
queries, use PagingIterable.getAllExecutionInfo().
The returned object includes basic information such as the queried hosts, but also the Cassandra query trace if tracing was enabled for the query.
getExecutionInfo in interface PagingIterable<Result<T>,T>public List<ExecutionInfo> getAllExecutionInfo()
PagingIterableUnless the result set is large enough to get paged underneath, the returned list will be
singleton. If paging has been used however, the returned list contains the ExecutionInfo objects for all the queries done to obtain this result set (at the time of the
call) in the order those queries were made.
getAllExecutionInfo in interface PagingIterable<Result<T>,T>public ListenableFuture<Result<T>> fetchMoreResults()
PagingIterableThis method is entirely optional. It will be called automatically while the result set is
consumed (through PagingIterable.one(), PagingIterable.all() or iteration) when needed (i.e. when getAvailableWithoutFetching() == 0 and isFullyFetched() == false).
You can however call this method manually to force the fetching of the next page of results. This can allow to prefetch results before they are strictly needed. For instance, if you want to prefetch the next page of results as soon as there is less than 100 rows readily available in this result set, you can do:
ResultSet rs = session.execute(...);
Iterator<Row> iter = rs.iterator();
while (iter.hasNext()) {
if (rs.getAvailableWithoutFetching() == 100 && !rs.isFullyFetched())
rs.fetchMoreResults();
Row row = iter.next()
... process the row ...
}
This method is not blocking, so in the example above, the call to fetchMoreResults will
not block the processing of the 100 currently available rows (but iter.hasNext() will
block once those rows have been processed until the fetch query returns, if it hasn't yet).
Only one page of results (for a given result set) can be fetched at any given time. If this method is called twice and the query triggered by the first call has not returned yet when the second one is performed, then the 2nd call will simply return a future on the currently in progress query.
fetchMoreResults in interface PagingIterable<Result<T>,T>isFullyFetched() == true), then the returned future will
return immediately but not particular error will be thrown (you should thus call PagingIterable.isFullyFetched() to know if calling this method can be of any use}).public boolean isFullyFetched()
PagingIterableNote that if isFullyFetched(), then PagingIterable.getAvailableWithoutFetching() will return
how many rows remain in the result set before exhaustion. But please note that isFullyFetched() never guarantees that the result set is exhausted (you should call PagingIterable.isExhausted() to verify it).
isFullyFetched in interface PagingIterable<Result<T>,T>public int getAvailableWithoutFetching()
PagingIterablegetAvailableWithoutFetching in interface PagingIterable<Result<T>,T>PagingIterable.isFullyFetched(),
this is the total number of rows remaining in this result set (after which the result set
will be exhausted).Copyright © 2012–2020. All rights reserved.