Java Scan.getStartRow方法代碼示例

import org.apache.hadoop.hbase.client.Scan; //導入方法依賴的package包/類
/**
 * Checks whether the given scan passes the Bloom filter (if present). Only checks Bloom filters
 * for single-row or single-row-column scans. Bloom filter checking for multi-gets is
 * implemented as part of the store scanner system (see {@link StoreFileScanner#seekExactly})
 * and uses the lower-level API
 * {@link #passesGeneralBloomFilter(byte[], int, int, byte[], int, int)}.
 *
 * @param scan    the scan specification. Used to determine the row, and to check whether this is a
 *                single-row ("get") scan.
 * @param columns the set of columns. Only used for row-column Bloom filters.
 * @return true if the scan with the given column set passes the Bloom filter, or if the Bloom
 * filter is not applicable for the scan. False if the Bloom filter is applicable and
 * the scan fails it.
 */
boolean passesBloomFilter(Scan scan, final SortedSet<byte[]> columns) {
  // Multi-column non-get scans will use Bloom filters through the
  // lower-level API function that this function calls.
  if (!scan.isGetScan()) {
    return true;
  }

  byte[] row = scan.getStartRow();
  switch (this.bloomFilterType) {
  case ROW:
    return passesGeneralBloomFilter(row, 0, row.length, null, 0, 0);

  case ROWCOL:
    if (columns != null && columns.size() == 1) {
      byte[] column = columns.first();
      return passesGeneralBloomFilter(row, 0, row.length, column, 0, column.length);
    }

    // For multi-column queries the Bloom filter is checked from the
    // seekExact operation.
    return true;

  default:
    return true;
  }
}
 

import org.apache.hadoop.hbase.client.Scan; //導入方法依賴的package包/類
public SingleScanner(Scan scan, byte[][] resultColumns, Table table) throws IOException {
  this.scan = scan;
  this.resultColumns = resultColumns;
  this.indexTable = table;
  this.currentStartKey = scan.getStartRow();
  this.scanning = true;
  this.finished = false;
  scan.setCacheBlocks(false);
  this.resultScanner = table.getScanner(scan);
  LOG.debug("scan caching:" + scan.getCaching());
}
 

import org.apache.hadoop.hbase.client.Scan; //導入方法依賴的package包/類
public StoreIndexScanner(Store store, List<KeyValueScanner> scanners, KVComparator comparator,
    IndexKVComparator indexComparator, Range range, Scan scan, Set<ByteArray> joinSet,
    boolean isAND) throws IOException {
  // winter scanner is always 1? in my test it is 1 indeed
  this.store = store;
  this.joinSet = joinSet;
  this.isAND = isAND;
  this.memstoreScanner = scanners;
  this.comparator = comparator;
  this.indexComparator = indexComparator;
  this.range = range;
  this.isGet = scan.isGetScan();
  this.cacheBlocks = scan.getCacheBlocks();
  if (isAND) {
    this.isEmptySet = this.joinSet.isEmpty();
    this.indexSet = new HashSet<ByteArray>(10000);
  }
  this.startRow = scan.getStartRow();
  this.startKV = KeyValue.createFirstOnRow(startRow);
  this.stopRow =
      Bytes.compareTo(scan.getStopRow(), HConstants.EMPTY_BYTE_ARRAY) == 0 ? null : scan
          .getStopRow();
  this.stopKV =
      Bytes.compareTo(scan.getStopRow(), HConstants.EMPTY_BYTE_ARRAY) == 0 ? null : KeyValue
          .createLastOnRow(scan.getStopRow());
  this.stopRowCmpValue = scan.isGetScan() ? -1 : 0;

  if (range.getStartValue() != null) {
    switch (range.getStartType()) {
    case EQUAL:
      startIKV =
          IndexKeyValue.createFirstOnQualifier(range.getQualifier(), range.getStartValue());
      stopIKV = startIKV;
      stopIKVCmpValue = -1;
      break;
    case GREATER_OR_EQUAL:
      startIKV =
          IndexKeyValue.createFirstOnQualifier(range.getQualifier(), range.getStartValue());
      stopIKV = null;
      stopIKVCmpValue = 0;
      break;
    case GREATER:
      startIKV = IndexKeyValue.createLastOnQualifier(range.getQualifier(), range.getStartValue());
      stopIKV = null;
      stopIKVCmpValue = 0;
      break;
    default:
      throw new IOException("Invalid Range:" + range);
    }
  } else {
    startIKV = IndexKeyValue.createFirstOnQualifier(range.getQualifier());
    stopIKV = null;
  }

  if (range.getStopValue() != null) {
    switch (range.getStopType()) {
    case LESS:
      stopIKV = IndexKeyValue.createFirstOnQualifier(range.getQualifier(), range.getStopValue());
      stopIKVCmpValue = 0;
      break;
    case LESS_OR_EQUAL:
      stopIKV = IndexKeyValue.createFirstOnQualifier(range.getQualifier(), range.getStopValue());
      stopIKVCmpValue = -1;
      break;
    default:
      throw new IOException("Invalid Range:" + range);
    }
  }
  this.needToRefresh = false;
  getScanners();
}