How to use

nullToEmpty

method

in

org.apache.hadoop.hbase.client.coprocessor.AsyncAggregationClient

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMedian(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getSum(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getStd(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

public static <R, S, P extends Message, Q extends Message, T extends Message>
  CompletableFuture<Long> rowCount(AsyncTable<?> table, ColumnInterpreter<R, S, P, Q, T> ci,
    Scan scan) {
 CompletableFuture<Long> future = new CompletableFuture<>();
 AggregateRequest req;
 try {
  req = validateArgAndGetPB(scan, ci, true);
 } catch (IOException e) {
  future.completeExceptionally(e);
  return future;
 }
 AbstractAggregationCallback<Long> callback = new AbstractAggregationCallback<Long>(future) {
  private long count;
  @Override
  protected void aggregate(RegionInfo region, AggregateResponse resp) throws IOException {
   count += resp.getFirstPart(0).asReadOnlyByteBuffer().getLong();
  }
  @Override
  protected Long getFinalResult() {
   return count;
  }
 };
 table
   .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
    (stub, controller, rpcCallback) -> stub.getRowNum(controller, req, rpcCallback), callback)
   .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
   .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
 return future;
}

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMin(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMax(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getAvg(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMedian(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMedian(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMax(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

public static <R, S, P extends Message, Q extends Message, T extends Message>
  CompletableFuture<Long> rowCount(AsyncTable<?> table, ColumnInterpreter<R, S, P, Q, T> ci,
    Scan scan) {
 CompletableFuture<Long> future = new CompletableFuture<>();
 AggregateRequest req;
 try {
  req = validateArgAndGetPB(scan, ci, true);
 } catch (IOException e) {
  future.completeExceptionally(e);
  return future;
 }
 AbstractAggregationCallback<Long> callback = new AbstractAggregationCallback<Long>(future) {
  private long count;
  @Override
  protected void aggregate(RegionInfo region, AggregateResponse resp) throws IOException {
   count += resp.getFirstPart(0).asReadOnlyByteBuffer().getLong();
  }
  @Override
  protected Long getFinalResult() {
   return count;
  }
 };
 table
   .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
    (stub, controller, rpcCallback) -> stub.getRowNum(controller, req, rpcCallback), callback)
   .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
   .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
 return future;
}

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getSum(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

public static <R, S, P extends Message, Q extends Message, T extends Message>
  CompletableFuture<Long>
  rowCount(AsyncTable<?> table, ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) {
 CompletableFuture<Long> future = new CompletableFuture<>();
 AggregateRequest req;
 try {
  req = validateArgAndGetPB(scan, ci, true);
 } catch (IOException e) {
  future.completeExceptionally(e);
  return future;
 }
 AbstractAggregationCallback<Long> callback = new AbstractAggregationCallback<Long>(future) {
  private long count;
  @Override
  protected void aggregate(RegionInfo region, AggregateResponse resp) throws IOException {
   count += resp.getFirstPart(0).asReadOnlyByteBuffer().getLong();
  }
  @Override
  protected Long getFinalResult() {
   return count;
  }
 };
 table
   .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
    (stub, controller, rpcCallback) -> stub.getRowNum(controller, req, rpcCallback), callback)
   .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
   .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
 return future;
}

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMin(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getSum(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getAvg(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMax(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMin(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getAvg(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getStd(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;