rs.fetchMoreResults().get(); } else { rs.fetchMoreResults().get(timeout, timeUnit);
rs.fetchMoreResults().get(); } else { rs.fetchMoreResults().get(timeout, timeUnit);
@Override public ListenableFuture<ResultSet> apply(ResultSet rs) throws Exception { int remainingInPage = rs.getAvailableWithoutFetching(); for (Row row : rs) { all.add(row.getInt(0)); if (--remainingInPage == 0) break; } boolean wasLastPage = rs.getExecutionInfo().getPagingState() == null; if (wasLastPage) return Futures.immediateFuture(rs); else return GuavaCompatibility.INSTANCE.transformAsync(rs.fetchMoreResults(), this); } }
@Override public ListenableFuture<ResultSet> fetchMoreResultsAsync() { return rs.fetchMoreResults(); }
@Override public ListenableFuture<ResultSet> fetchMoreResultsAsync() { return rs.fetchMoreResults(); }
@Override public ListenableFuture<Result<T>> fetchMoreResults() { return Futures.transform(rs.fetchMoreResults(), new Function<ResultSet, Result<T>>() { @Override public Result<T> apply(ResultSet rs) { return Result.this; } }); }
private void ensureFetchedNextPage(ResultSet resultSet) { if (fetchNeeded(resultSet)) { resultSet.fetchMoreResults(); } }
private void ensureFetchedNextPage(ResultSet resultSet) { if (fetchNeeded(resultSet)) { resultSet.fetchMoreResults(); } }
@Override protected ListenableFuture<ResultSet> newFuture() { return resultSet().fetchMoreResults(); }
@Override public ResultSet fetchMoreResults(Handler<AsyncResult<Void>> handler) { handleOnContext(resultSet.fetchMoreResults(), vertx.getOrCreateContext(), ar -> { if (ar.succeeded()) { handler.handle(Future.succeededFuture()); } else { handler.handle(Future.failedFuture(ar.cause())); } }); return this; }
@Override public ListenableFuture<ResultSet> fetchMoreResults() { final ResultSet delegate = _delegate; // If we've already tried to pre-fetch for this delegate and ran into frame size issues then don't try again. if (_delegateWithPrefetchFailure == delegate) { return Futures.immediateFuture(this); } // Change the returned future to contain this instance instead of the delegate ListenableFuture<ResultSet> future = Futures.transform(delegate.fetchMoreResults(), new Function<ResultSet, ResultSet>() { @Override public ResultSet apply(ResultSet ignore) { return AdaptiveResultSet.this; } }); Futures.addCallback(future, new MoreFutures.FailureCallback<ResultSet>() { @Override public void onFailure(Throwable t) { // The async pre-fetch has failed. Check if the root cause is adaptive. if (isAdaptiveException(t)) { // Future: Optimize to pre-fetch the next delegate immediately. For now simply record that // we shouldn't try to pre-fetch again for this delegate. The frame size will be adjusted // synchronously after all available rows have been consumed. _prefetchFailure = t; _delegateWithPrefetchFailure = delegate; } } }); return future; }
@Override public ListenableFuture<ResultSet> fetchMoreResults() { final ResultSet delegate = _delegate; // If we've already tried to pre-fetch for this delegate and ran into frame size issues then don't try again. if (_delegateWithPrefetchFailure == delegate) { return Futures.immediateFuture(this); } // Change the returned future to contain this instance instead of the delegate ListenableFuture<ResultSet> future = Futures.transform(delegate.fetchMoreResults(), new Function<ResultSet, ResultSet>() { @Override public ResultSet apply(ResultSet ignore) { return AdaptiveResultSet.this; } }); Futures.addCallback(future, new MoreFutures.FailureCallback<ResultSet>() { @Override public void onFailure(Throwable t) { // The async pre-fetch has failed. Check if the root cause is adaptive. if (isAdaptiveException(t)) { // Future: Optimize to pre-fetch the next delegate immediately. For now simply record that // we shouldn't try to pre-fetch again for this delegate. The frame size will be adjusted // synchronously after all available rows have been consumed. _prefetchFailure = t; _delegateWithPrefetchFailure = delegate; } } }); return future; }
private void loadMore(Context context, List<Row> loaded, Handler<AsyncResult<List<Row>>> handler) { int availableWithoutFetching = resultSet.getAvailableWithoutFetching(); List<Row> rows = new ArrayList<>(loaded.size() + availableWithoutFetching); for (int i = 0; i < availableWithoutFetching; i++) { rows.add(resultSet.one()); } if (!resultSet.isFullyFetched()) { handleOnContext(resultSet.fetchMoreResults(), context, ar -> { if (ar.succeeded()) { loadMore(context, rows, handler); } else { handler.handle(Future.failedFuture(ar.cause())); } }); } else { handler.handle(Future.succeededFuture(rows)); } }
@Override public ResultSet one(Handler<AsyncResult<Row>> handler) { if (getAvailableWithoutFetching() == 0 && !resultSet.isFullyFetched()) { handleOnContext(resultSet.fetchMoreResults(), vertx.getOrCreateContext(), ar -> { if (ar.succeeded()) { handler.handle(Future.succeededFuture(resultSet.one())); } else { handler.handle(Future.failedFuture(ar.cause())); } }); } else { handler.handle(Future.succeededFuture(resultSet.one())); } return this; }
private void fetchAndCallOneMoreTime() { if (datastaxResultSet.isFullyFetched()) { fire(); return; } handleOnContext(datastaxResultSet.fetchMoreResults(), context, ar -> { if (ar.succeeded()) { fire(); } else { if (exceptionHandler != null) { exceptionHandler.handle(ar.cause()); } if (endHandler != null) { endHandler.handle(null); } } }); }
private void requestDatabaseForMoreRecords() { // no more data to fetch? if (rs.isFullyFetched()) { terminateRegularly(); return; } synchronized (dbQueryLock) { if (runningDatabaseQuery.get() == null) { Runnable databaseRequest = new Runnable() { @Override public void run() { synchronized (dbQueryLock) { runningDatabaseQuery.set(null); } processReadRequests(); } }; runningDatabaseQuery.set(databaseRequest); ListenableFuture<Void> future = rs.fetchMoreResults(); future.addListener(databaseRequest, ctx.getTaskExecutor()); } } }
private Row nextRow() { // If we've reached the prefetch limit and there are more results to fetch then prefetch them now. if (_prefetchFuture == null && _resultSet.getAvailableWithoutFetching() <= _prefetchLimit && !_resultSet.isFullyFetched()) { _prefetchFuture = _resultSet.fetchMoreResults(); _prefetchFuture.addListener(_onPrefetchComplete, MoreExecutors.sameThreadExecutor()); } return _resultSet.one(); }
private Row nextRow() { // If we've reached the prefetch limit and there are more results to fetch then prefetch them now. if (_prefetchFuture == null && _resultSet.getAvailableWithoutFetching() <= _prefetchLimit && !_resultSet.isFullyFetched()) { _prefetchFuture = _resultSet.fetchMoreResults(); _prefetchFuture.addListener(_onPrefetchComplete, MoreExecutors.sameThreadExecutor()); } return _resultSet.one(); }
@Override public ListenableFuture<ResultSet> apply(ResultSet rs) throws Exception { int remainingInPage = rs.getAvailableWithoutFetching(); for (Row row : rs) { all.add(row.getInt(0)); if (--remainingInPage == 0) break; } boolean wasLastPage = rs.getExecutionInfo().getPagingState() == null; if (wasLastPage) return Futures.immediateFuture(rs); else return GuavaCompatibility.INSTANCE.transformAsync(rs.fetchMoreResults(), this); } }
private Flux<Row> getRows(Mono<ResultSet> nextResults) { return nextResults.flatMapMany(it -> { Flux<Row> rows = toRows(it); if (it.isFullyFetched()) { return rows; } MonoProcessor<ResultSet> processor = MonoProcessor.create(); return rows .doOnComplete(() -> fetchMore(it.fetchMoreResults(), processor)) .concatWith(getRows(processor)); }); }