Java Code Examples for org.apache.hadoop.hbase.client.Scan.isGetScan()

The following are Jave code examples for showing how to use isGetScan() of the org.apache.hadoop.hbase.client.Scan class. You can vote up the examples you like. Your votes will be used in our system to get more good examples.
Example 1
Project: ditb   File: StoreFile.java   Source Code and License Vote up 5 votes
/**
 * 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;
  }
}
 
Example 2
Project: ditb   File: StoreScanner.java   Source Code and License Vote up 5 votes
/**
 * An internal constructor.
 */
protected StoreScanner(Store store, Scan scan, final ScanInfo scanInfo,
    final NavigableSet<byte[]> columns, long readPt, boolean cacheBlocks) {
  this.readPt = readPt;
  this.store = store;
  this.cacheBlocks = cacheBlocks;
  get = scan.isGetScan();
  int numCol = columns == null ? 0 : columns.size();
  explicitColumnQuery = numCol > 0;
  this.scan = scan;
  this.columns = columns;
  this.now = EnvironmentEdgeManager.currentTime();
  this.oldestUnexpiredTS = now - scanInfo.getTtl();
  this.minVersions = scanInfo.getMinVersions();

  // We look up row-column Bloom filters for multi-column queries as part of
  // the seek operation. However, we also look the row-column Bloom filter
  // for multi-row (non-"get") scans because this is not done in
  // StoreFile.passesBloomFilter(Scan, SortedSet<byte[]>).
  this.useRowColBloom = numCol > 1 || (!get && numCol == 1);

  this.maxRowSize = scanInfo.getTableMaxRowSize();
  this.scanUsePread = scan.isSmall() ? true : scanInfo.isUsePread();
  this.cellsPerHeartbeatCheck = scanInfo.getCellsPerTimeoutCheck();
  // Parallel seeking is on if the config allows and more there is more than one store file.
  if (this.store != null && this.store.getStorefilesCount() > 1) {
    RegionServerServices rsService = ((HStore) store).getHRegion().getRegionServerServices();
    if (rsService != null && scanInfo.isParallelSeekEnabled()) {
      this.parallelSeekEnabled = true;
      this.executor = rsService.getExecutorService();
    }
  }
}
 
Example 3
Project: ditb   File: StoreIndexScanner.java   Source Code and License Vote up 4 votes
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();
}
 
Example 4
Project: ditb   File: TestSeekOptimizations.java   Source Code and License Vote up 4 votes
private void testScan(final int[] columnArr, final boolean lazySeekEnabled,
    final int startRow, final int endRow, int maxVersions)
    throws IOException {
  StoreScanner.enableLazySeekGlobally(lazySeekEnabled);
  final Scan scan = new Scan();
  final Set<String> qualSet = new HashSet<String>();
  for (int iColumn : columnArr) {
    String qualStr = getQualStr(iColumn);
    scan.addColumn(FAMILY_BYTES, Bytes.toBytes(qualStr));
    qualSet.add(qualStr);
  }
  scan.setMaxVersions(maxVersions);
  scan.setStartRow(rowBytes(startRow));

  // Adjust for the fact that for multi-row queries the end row is exclusive.
  {
    final byte[] scannerStopRow =
        rowBytes(endRow + (startRow != endRow ? 1 : 0));
    scan.setStopRow(scannerStopRow);
  }

  final long initialSeekCount = StoreFileScanner.getSeekCount();
  final InternalScanner scanner = region.getScanner(scan);
  final List<Cell> results = new ArrayList<Cell>();
  final List<Cell> actualKVs = new ArrayList<Cell>();

  // Such a clumsy do-while loop appears to be the official way to use an
  // internalScanner. scanner.next() return value refers to the _next_
  // result, not to the one already returned in results.
  boolean hasNext;
  do {
    hasNext = scanner.next(results);
    actualKVs.addAll(results);
    results.clear();
  } while (hasNext);

  List<Cell> filteredKVs = filterExpectedResults(qualSet,
      rowBytes(startRow), rowBytes(endRow), maxVersions);
  final String rowRestrictionStr =
      (startRow == -1 && endRow == -1) ? "all rows" : (
          startRow == endRow ? ("row=" + startRow) : ("startRow="
          + startRow + ", " + "endRow=" + endRow));
  final String columnRestrictionStr =
      columnArr.length == 0 ? "all columns"
          : ("columns=" + Arrays.toString(columnArr));
  final String testDesc =
      "Bloom=" + bloomType + ", compr=" + comprAlgo + ", "
          + (scan.isGetScan() ? "Get" : "Scan") + ": "
          + columnRestrictionStr + ", " + rowRestrictionStr
          + ", maxVersions=" + maxVersions + ", lazySeek=" + lazySeekEnabled;
  long seekCount = StoreFileScanner.getSeekCount() - initialSeekCount;
  if (VERBOSE) {
    System.err.println("Seek count: " + seekCount + ", KVs returned: "
      + actualKVs.size() + ". " + testDesc +
      (lazySeekEnabled ? "\n" : ""));
  }
  if (lazySeekEnabled) {
    totalSeekLazy += seekCount;
  } else {
    totalSeekDiligent += seekCount;
  }
  assertKVListsEqual(testDesc, filteredKVs, actualKVs);
}