org.apache.hadoop.hbase.regionserver.ScannerContext Java Examples

@Override
public InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e, Store store,
    InternalScanner scanner, ScanType scanType, CompactionLifeCycleTracker tracker,
    CompactionRequest request) {
  return new InternalScanner() {

    @Override
    public boolean next(List<Cell> results, ScannerContext scannerContext) throws IOException {
      List<Cell> internalResults = new ArrayList<>();
      boolean hasMore;
      do {
        hasMore = scanner.next(internalResults, scannerContext);
        if (!internalResults.isEmpty()) {
          long row = Bytes.toLong(CellUtil.cloneValue(internalResults.get(0)));
          if (row % 2 == 0) {
            // return this row
            break;
          }
          // clear and continue
          internalResults.clear();
        }
      } while (hasMore);

      if (!internalResults.isEmpty()) {
        results.addAll(internalResults);
      }
      return hasMore;
    }

    @Override
    public void close() throws IOException {
      scanner.close();
    }
  };
}
 

public void reset(final ScannerContext instance) {
  if (!exception) {
    try {
      clearProgress.invoke(instance);

      setScannerState.invoke(instance, NextState.MORE_VALUES);
    } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
      LOGGER.warn("Unable to invoke reset of scanner context", e);
      exception = true;
    }
  }
}
 

public NextState getScannerState(final ScannerContext instance) {
  if (!exception) {
    try {
      return (NextState) scannerState.get(instance);
    } catch (final Exception e) {
      LOGGER.warn("Unable to check partial result of scanner context", e);
      exception = true;
    }
  }
  return NextState.MORE_VALUES;
}
 

public ReflectionParams() {
  try {
    scannerState = ScannerContext.class.getDeclaredField("scannerState");
    scannerState.setAccessible(true);
    clearProgress = ScannerContext.class.getDeclaredMethod("clearProgress");
    clearProgress.setAccessible(true);
    setScannerState =
        ScannerContext.class.getDeclaredMethod("setScannerState", NextState.class);
    setScannerState.setAccessible(true);
  } catch (final Exception e) {
    LOGGER.warn("Unable to get accessible methods for ScannerContextRowScanner", e);
    exception = true;
  }
}
 

public ScannerContextRowScanner(
    final InternalScanner scanner,
    final List<Cell> cells,
    final ScannerContext scannerContext,
    final Scan scan) {
  this.scanner = scanner;
  this.cells = cells;
  this.scannerContext = scannerContext;
  this.scan = scan;
}
 

@Override
public boolean next(final List<Cell> rowCells, final ScannerContext scannerContext)
    throws IOException {
  final boolean retVal = delegate.next(rowCells, scannerContext);
  if (!internalNextRow(rowCells, scannerContext)) {
    return false;
  }
  return retVal;
}
 

@Override
public boolean nextRaw(final List<Cell> rowCells, final ScannerContext scannerContext)
    throws IOException {
  final boolean retVal = ((RegionScanner) delegate).nextRaw(rowCells, scannerContext);
  if (!internalNextRow(rowCells, scannerContext)) {
    return false;
  }
  return retVal;
}
 

@Override
public boolean nextRaw(List<Cell> result, ScannerContext scannerContext) throws IOException {
    overrideDelegate();
    boolean res = super.nextRaw(result);
    ScannerContextUtil.incrementSizeProgress(scannerContext, result);
    ScannerContextUtil.updateTimeProgress(scannerContext);
    return res;
}
 

@Override
public boolean next(List<Cell> result, ScannerContext scannerContext) throws IOException {
    overrideDelegate();
    boolean res = super.next(result);
    ScannerContextUtil.incrementSizeProgress(scannerContext, result);
    ScannerContextUtil.updateTimeProgress(scannerContext);
    return res;
}
 

@Override
public boolean next(List<Cell> result, ScannerContext scannerContext)
    throws IOException {
  if (kvs.isEmpty()) {
    return false;
  }
  result.add(kvs.remove(0));
  return !kvs.isEmpty();
}
 

public boolean next(List<Cell> cells, ScannerContext scannerContext) throws IOException {
    return false;
}
 

public boolean nextRaw(List<Cell> cells, ScannerContext scannerContext) throws IOException {
    return false;
}
 

@Override
public boolean next(List<Cell> result, ScannerContext scannerContext) throws IOException {
    return next(result);
}
 

@Override
public boolean next(List<Cell> result, ScannerContext scannerContext) throws IOException {
    return delegate.nextRaw(result, scannerContext);
}
 

@Override
public boolean nextRaw(List<Cell> result, ScannerContext scannerContext) throws IOException {
    return delegate.nextRaw(result, scannerContext);
}
 

@Override
public boolean next(List<Cell> result, ScannerContext scannerContext) throws IOException {
    return next(result);
}
 

@Override
public boolean next(List<Cell> result, ScannerContext scannerContext) throws IOException {
    return false;
}
 

@Override
public boolean nextRaw(List<Cell> result, ScannerContext scannerContext) throws IOException {
    return nextInternal(result);
}
 

@Override
public boolean next(List<Cell> result, ScannerContext scannerContext) throws IOException {
    return nextInternal(result);
}
 

protected boolean internalNextRow(final List<Cell> rowCells, final ScannerContext scannerContext)
    throws IOException {
  return internalNextRow(new ScannerContextRowScanner(delegate, rowCells, scannerContext, scan));
}
 

@Override
public boolean nextRaw(List<Cell> result, ScannerContext scannerContext) throws IOException {
    return next(result);
}
 

@Override
public boolean next(List<Cell> result, ScannerContext scannerContext) throws IOException {
    return next(result);
}
 

@Override
public boolean next(List<Cell> result, ScannerContext scannerContext) throws IOException {
  return delegate.next(result, scannerContext);
}
 

@Override
public boolean next(List<Cell> cells, ScannerContext scannerContext) throws IOException {
    return false;
}
 

@Override
public boolean next(List<Cell> result, ScannerContext scannerContext) throws IOException {
    return next(result);
}
 

@Override
public boolean next(List<Cell> result, ScannerContext scannerContext) throws IOException {
    throw new IOException("Next with scannerContext should not be called in Phoenix environment");
}
 

@Override
public boolean nextRaw(List<Cell> result, ScannerContext scannerContext)
        throws IOException {
    throw new IOException("Next with scannerContext should not be called in Phoenix environment");
}
 

@Override
public boolean nextRaw(List<Cell> result, ScannerContext scannerContext) throws IOException {
    throw new IOException("NextRaw with scannerContext should not be called in Phoenix environment");
}
 

@Override
public boolean next(List<Cell> result, ScannerContext scannerContext) throws IOException {
    throw new IOException("Next with scannerContext should not be called in Phoenix environment");
}
 

@Override
public boolean nextRaw(List<Cell> result, ScannerContext scannerContext) throws IOException {
    throw new IOException("NextRaw with scannerContext should not be called in Phoenix environment");
}