Java ColumnInterpreter.divideForAvg方法代码示例

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
public static <R, S, P extends Message, Q extends Message, T extends Message>
    CompletableFuture<Double>
    avg(AsyncTable<?> table, ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) {
  CompletableFuture<Double> future = new CompletableFuture<>();
  AggregateRequest req;
  try {
    req = validateArgAndGetPB(scan, ci, false);
  } catch (IOException e) {
    future.completeExceptionally(e);
    return future;
  }
  AbstractAggregationCallback<Double> callback = new AbstractAggregationCallback<Double>(future) {

    private S sum;

    long count = 0L;

    @Override
    protected void aggregate(RegionInfo region, AggregateResponse resp) throws IOException {
      if (resp.getFirstPartCount() > 0) {
        sum = ci.add(sum, getPromotedValueFromProto(ci, resp, 0));
        count += resp.getSecondPart().asReadOnlyByteBuffer().getLong();
      }
    }

    @Override
    protected Double getFinalResult() {
      return ci.divideForAvg(sum, count);
    }
  };
  table
      .<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;
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
public static <R, S, P extends Message, Q extends Message, T extends Message>
    CompletableFuture<Double>
    std(AsyncTable<?> table, ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) {
  CompletableFuture<Double> future = new CompletableFuture<>();
  AggregateRequest req;
  try {
    req = validateArgAndGetPB(scan, ci, false);
  } catch (IOException e) {
    future.completeExceptionally(e);
    return future;
  }
  AbstractAggregationCallback<Double> callback = new AbstractAggregationCallback<Double>(future) {

    private S sum;

    private S sumSq;

    private long count;

    @Override
    protected void aggregate(RegionInfo region, AggregateResponse resp) throws IOException {
      if (resp.getFirstPartCount() > 0) {
        sum = ci.add(sum, getPromotedValueFromProto(ci, resp, 0));
        sumSq = ci.add(sumSq, getPromotedValueFromProto(ci, resp, 1));
        count += resp.getSecondPart().asReadOnlyByteBuffer().getLong();
      }
    }

    @Override
    protected Double getFinalResult() {
      double avg = ci.divideForAvg(sum, count);
      double avgSq = ci.divideForAvg(sumSq, count);
      return Math.sqrt(avgSq - avg * avg);
    }
  };
  table
      .<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;
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
private static <R, S, P extends Message, Q extends Message, T extends Message> void findMedian(
    CompletableFuture<R> future, AsyncTable<AdvancedScanResultConsumer> table,
    ColumnInterpreter<R, S, P, Q, T> ci, Scan scan, NavigableMap<byte[], S> sumByRegion) {
  double halfSum = ci.divideForAvg(sumByRegion.values().stream().reduce(ci::add).get(), 2L);
  S movingSum = null;
  byte[] startRow = null;
  for (Map.Entry<byte[], S> entry : sumByRegion.entrySet()) {
    startRow = entry.getKey();
    S newMovingSum = ci.add(movingSum, entry.getValue());
    if (ci.divideForAvg(newMovingSum, 1L) > halfSum) {
      break;
    }
    movingSum = newMovingSum;
  }
  if (startRow != null) {
    scan.withStartRow(startRow);
  }
  // we can not pass movingSum directly to an anonymous class as it is not final.
  S baseSum = movingSum;
  byte[] family = scan.getFamilies()[0];
  NavigableSet<byte[]> qualifiers = scan.getFamilyMap().get(family);
  byte[] weightQualifier = qualifiers.last();
  byte[] valueQualifier = qualifiers.first();
  table.scan(scan, new AdvancedScanResultConsumer() {

    private S sum = baseSum;

    private R value = null;

    @Override
    public void onNext(Result[] results, ScanController controller) {
      try {
        for (Result result : results) {
          Cell weightCell = result.getColumnLatestCell(family, weightQualifier);
          R weight = ci.getValue(family, weightQualifier, weightCell);
          sum = ci.add(sum, ci.castToReturnType(weight));
          if (ci.divideForAvg(sum, 1L) > halfSum) {
            if (value != null) {
              future.complete(value);
            } else {
              future.completeExceptionally(new NoSuchElementException());
            }
            controller.terminate();
            return;
          }
          Cell valueCell = result.getColumnLatestCell(family, valueQualifier);
          value = ci.getValue(family, valueQualifier, valueCell);
        }
      } catch (IOException e) {
        future.completeExceptionally(e);
        controller.terminate();
      }
    }

    @Override
    public void onError(Throwable error) {
      future.completeExceptionally(error);
    }

    @Override
    public void onComplete() {
      if (!future.isDone()) {
        // we should not reach here as the future should be completed in onNext.
        future.completeExceptionally(new NoSuchElementException());
      }
    }
  });
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
/**
 * This is the client side interface/handle for calling the average method for
 * a given cf-cq combination. It was necessary to add one more call stack as
 * its return type should be a decimal value, irrespective of what
 * columninterpreter says. So, this methods collects the necessary parameters
 * to compute the average and returs the double value.
 * @param tableName
 * @param ci
 * @param scan
 * @return <R, S>
 * @throws Throwable
 */
public <R, S, P extends Message, Q extends Message, T extends Message>
double avg(final TableName tableName,
    final ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) throws Throwable {
  Pair<S, Long> p = getAvgArgs(tableName, ci, scan);
  return ci.divideForAvg(p.getFirst(), p.getSecond());
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
/**
 * This is the client side interface/handle for calling the std method for a
 * given cf-cq combination. It was necessary to add one more call stack as its
 * return type should be a decimal value, irrespective of what
 * columninterpreter says. So, this methods collects the necessary parameters
 * to compute the std and returns the double value.
 * @param table
 * @param ci
 * @param scan
 * @return <R, S>
 * @throws Throwable
 */
public <R, S, P extends Message, Q extends Message, T extends Message> double std(
    final Table table, ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) throws Throwable {
  Pair<List<S>, Long> p = getStdArgs(table, ci, scan);
  double res = 0d;
  double avg = ci.divideForAvg(p.getFirst().get(0), p.getSecond());
  double avgOfSumSq = ci.divideForAvg(p.getFirst().get(1), p.getSecond());
  res = avgOfSumSq - (avg) * (avg); // variance
  res = Math.pow(res, 0.5);
  return res;
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
/**
 * This is the client side interface/handle for calling the std method for a
 * given cf-cq combination. It was necessary to add one more call stack as its
 * return type should be a decimal value, irrespective of what
 * columninterpreter says. So, this methods collects the necessary parameters
 * to compute the std and returns the double value.
 *
 * @param table
 * @param ci
 * @param scan
 * @return <R, S>
 * @throws Throwable
 */
public <R, S, P extends Message, Q extends Message, T extends Message> double std(
        final Table table, ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) throws Throwable {
    Pair<List<S>, Long> p = getStdArgs(table, ci, scan);
    double res = 0d;
    double avg = ci.divideForAvg(p.getFirst().get(0), p.getSecond());
    double avgOfSumSq = ci.divideForAvg(p.getFirst().get(1), p.getSecond());
    res = avgOfSumSq - (avg) * (avg); // variance
    res = Math.pow(res, 0.5);
    return res;
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
/**
 * This is the client side interface/handle for calling the std method for a
 * given cf-cq combination. It was necessary to add one more call stack as its
 * return type should be a decimal value, irrespective of what
 * columninterpreter says. So, this methods collects the necessary parameters
 * to compute the std and returns the double value.
 * @param tableName
 * @param ci
 * @param scan
 * @return <R, S>
 * @throws Throwable
 */
public <R, S> double std(final byte[] tableName, ColumnInterpreter<R, S> ci,
    Scan scan) throws Throwable {
  Pair<List<S>, Long> p = getStdArgs(tableName, ci, scan);
  double res = 0d;
  double avg = ci.divideForAvg(p.getFirst().get(0), p.getSecond());
  double avgOfSumSq = ci.divideForAvg(p.getFirst().get(1), p.getSecond());
  res = avgOfSumSq - (avg) * (avg); // variance
  res = Math.pow(res, 0.5);
  return res;
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
/**
 * This is the client side interface/handle for calling the average method for
 * a given cf-cq combination. It was necessary to add one more call stack as
 * its return type should be a decimal value, irrespective of what
 * columninterpreter says. So, this methods collects the necessary parameters
 * to compute the average and returs the double value.
 * @param tableName
 * @param ci
 * @param scan
 * @return <R, S>
 * @throws Throwable
 */
public <R, S, P extends Message, Q extends Message, T extends Message>
double avg(final TableName tableName,
    final ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) throws Throwable {
  Pair<S, Long> p = getAvgArgs(tableName, ci, scan);
  return ci.divideForAvg(p.getFirst(), p.getSecond());
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
/**
 * This is the client side interface/handle for calling the std method for a
 * given cf-cq combination. It was necessary to add one more call stack as its
 * return type should be a decimal value, irrespective of what
 * columninterpreter says. So, this methods collects the necessary parameters
 * to compute the std and returns the double value.
 * @param table
 * @param ci
 * @param scan
 * @return <R, S>
 * @throws Throwable
 */
public <R, S, P extends Message, Q extends Message, T extends Message> double std(
    final Table table, ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) throws Throwable {
  Pair<List<S>, Long> p = getStdArgs(table, ci, scan);
  double res = 0d;
  double avg = ci.divideForAvg(p.getFirst().get(0), p.getSecond());
  double avgOfSumSq = ci.divideForAvg(p.getFirst().get(1), p.getSecond());
  res = avgOfSumSq - (avg) * (avg); // variance
  res = Math.pow(res, 0.5);
  return res;
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
/**
 * This is the client side interface/handle for calling the std method for a
 * given cf-cq combination. It was necessary to add one more call stack as its
 * return type should be a decimal value, irrespective of what
 * columninterpreter says. So, this methods collects the necessary parameters
 * to compute the std and returns the double value.
 * @param table
 * @param ci
 * @param scan
 * @return <R, S>
 * @throws Throwable
 */
public <R, S, P extends Message, Q extends Message, T extends Message> double std(
    final HTable table, ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) throws Throwable {
  Pair<List<S>, Long> p = getStdArgs(table, ci, scan);
  double res = 0d;
  double avg = ci.divideForAvg(p.getFirst().get(0), p.getSecond());
  double avgOfSumSq = ci.divideForAvg(p.getFirst().get(1), p.getSecond());
  res = avgOfSumSq - (avg) * (avg); // variance
  res = Math.pow(res, 0.5);
  return res;
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
/**
 * This is the client side interface/handle for calling the average method for
 * a given cf-cq combination. It was necessary to add one more call stack as
 * its return type should be a decimal value, irrespective of what
 * columninterpreter says. So, this methods collects the necessary parameters
 * to compute the average and returs the double value.
 * @param tableName
 * @param ci
 * @param scan
 * @return <R, S>
 * @throws Throwable
 */
public <R, S, P extends Message, Q extends Message, T extends Message>
double avg(final byte[] tableName,
    final ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) throws Throwable {
  Pair<S, Long> p = getAvgArgs(tableName, ci, scan);
  return ci.divideForAvg(p.getFirst(), p.getSecond());
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
/**
 * This is the client side interface/handle for calling the std method for a
 * given cf-cq combination. It was necessary to add one more call stack as its
 * return type should be a decimal value, irrespective of what
 * columninterpreter says. So, this methods collects the necessary parameters
 * to compute the std and returns the double value.
 * @param tableName
 * @param ci
 * @param scan
 * @return <R, S>
 * @throws Throwable
 */
public <R, S, P extends Message, Q extends Message, T extends Message>
double std(final byte[] tableName, ColumnInterpreter<R, S, P, Q, T> ci,
    Scan scan) throws Throwable {
  Pair<List<S>, Long> p = getStdArgs(tableName, ci, scan);
  double res = 0d;
  double avg = ci.divideForAvg(p.getFirst().get(0), p.getSecond());
  double avgOfSumSq = ci.divideForAvg(p.getFirst().get(1), p.getSecond());
  res = avgOfSumSq - (avg) * (avg); // variance
  res = Math.pow(res, 0.5);
  return res;
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
/**
 * This is the client side interface/handle for calling the average method for
 * a given cf-cq combination. It was necessary to add one more call stack as
 * its return type should be a decimal value, irrespective of what
 * columninterpreter says. So, this methods collects the necessary parameters
 * to compute the average and returs the double value.
 *
 * @param tableName
 * @param ci
 * @param scan
 * @return <R, S>
 * @throws Throwable
 */
public <R, S, P extends Message, Q extends Message, T extends Message> double avg(final TableName tableName, final ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) throws Throwable {
    Pair<S, Long> p = getAvgArgs(tableName, ci, scan);
    return ci.divideForAvg(p.getFirst(), p.getSecond());
}
 

import org.apache.hadoop.hbase.coprocessor.ColumnInterpreter; //导入方法依赖的package包/类
/**
 * This is the client side interface/handle for calling the average method for
 * a given cf-cq combination. It was necessary to add one more call stack as
 * its return type should be a decimal value, irrespective of what
 * columninterpreter says. So, this methods collects the necessary parameters
 * to compute the average and returs the double value.
 * @param tableName
 * @param ci
 * @param scan
 * @return <R, S>
 * @throws Throwable
 */
public <R, S> double avg(final byte[] tableName,
    final ColumnInterpreter<R, S> ci, Scan scan) throws Throwable {
  Pair<S, Long> p = getAvgArgs(tableName, ci, scan);
  return ci.divideForAvg(p.getFirst(), p.getSecond());
}