Java IsolationLevel.READ_UNCOMMITTED属性代码示例

@Override public long getReadpoint(IsolationLevel isolationLevel) {
  if (isolationLevel == IsolationLevel.READ_UNCOMMITTED) {
    // This scan can read even uncommitted transactions
    return Long.MAX_VALUE;
  }
  return mvcc.getReadPoint();
}
 

public long getReadpoint(IsolationLevel isolationLevel) {
    if (isolationLevel == IsolationLevel.READ_UNCOMMITTED) {
        // This scan can read even uncommitted transactions
        return Long.MAX_VALUE;
    }
    return mvcc.memstoreReadPoint();
}
 

public long getReadpoint(IsolationLevel isolationLevel) {
  if (isolationLevel == IsolationLevel.READ_UNCOMMITTED) {
    // This scan can read even uncommitted transactions
    return Long.MAX_VALUE;
  }
  return mvcc.memstoreReadPoint();
}
 

/**
 * @return readpoint considering given IsolationLevel. Pass {@code null} for default
 */
public long getReadPoint(IsolationLevel isolationLevel) {
  if (isolationLevel != null && isolationLevel == IsolationLevel.READ_UNCOMMITTED) {
    // This scan can read even uncommitted transactions
    return Long.MAX_VALUE;
  }
  return mvcc.getReadPoint();
}
 

RegionScannerImpl(Scan scan, List<KeyValueScanner> additionalScanners, HRegion region)
    throws IOException {
  // DebugPrint.println("HRegionScanner.<init>");
  this.region = region;
  this.filter = scan.getFilter();
  this.batch = scan.getBatch();
  if (Bytes.equals(scan.getStopRow(), HConstants.EMPTY_END_ROW)) {
    this.stopRow = null;
  } else {
    this.stopRow = scan.getStopRow();
  }
  // If we are doing a get, we want to be [startRow,endRow] normally
  // it is [startRow,endRow) and if startRow=endRow we get nothing.
  this.isScan = scan.isGetScan() ? -1 : 0;

  // synchronize on scannerReadPoints so that nobody calculates
  // getSmallestReadPoint, before scannerReadPoints is updated.
  IsolationLevel isolationLevel = scan.getIsolationLevel();
  synchronized(scannerReadPoints) {
    if (isolationLevel == IsolationLevel.READ_UNCOMMITTED) {
      // This scan can read even uncommitted transactions
      this.readPt = Long.MAX_VALUE;
      MultiVersionConsistencyControl.setThreadReadPoint(this.readPt);
    } else {
      this.readPt = MultiVersionConsistencyControl.resetThreadReadPoint(mvcc);
    }
    scannerReadPoints.put(this, this.readPt);
  }

  // Here we separate all scanners into two lists - scanner that provide data required
  // by the filter to operate (scanners list) and all others (joinedScanners list).
  List<KeyValueScanner> scanners = new ArrayList<KeyValueScanner>();
  List<KeyValueScanner> joinedScanners = new ArrayList<KeyValueScanner>();
  if (additionalScanners != null) {
    scanners.addAll(additionalScanners);
  }

  for (Map.Entry<byte[], NavigableSet<byte[]>> entry :
      scan.getFamilyMap().entrySet()) {
    Store store = stores.get(entry.getKey());
    KeyValueScanner scanner = store.getScanner(scan, entry.getValue());
    if (this.filter == null || !scan.doLoadColumnFamiliesOnDemand()
      || FilterBase.isFamilyEssential(this.filter, entry.getKey())) {
      scanners.add(scanner);
    } else {
      joinedScanners.add(scanner);
    }
  }
  this.storeHeap = new KeyValueHeap(scanners, comparator);
  if (!joinedScanners.isEmpty()) {
    this.joinedHeap = new KeyValueHeap(joinedScanners, comparator);
  }
  
  // whether to use index
  byte[] tmpvalue=scan.getAttribute(IndexConstants.SCAN_WITH_INDEX);
  if(tmpvalue!=null){        
    this.useIndex = Bytes.toBoolean(tmpvalue);
  }
  tmpvalue=scan.getAttribute(IndexConstants.MAX_SCAN_SCALE);
  float maxScale=IndexConstants.DEFAULT_MAX_SCAN_SCALE;
  if(tmpvalue!=null){
    maxScale = Bytes.toFloat(tmpvalue);
  }
  if (this.useIndex) {
    indexTree = ScanPreprocess.preprocess(this.region, scan.getFilter(), maxScale);
    if (indexTree!=null) {
      useIndex = true;
      long buildStartTime = System.currentTimeMillis();
      generateCandidateRows(scan);
      this.indexReadTime = (System.currentTimeMillis() - buildStartTime) - this.indexMergeTime - this.indexSortTime;
    } else {
      useIndex = false;
      LOG.debug("skip using index");
    }
  }
}
 

RegionScannerImpl(Scan scan, List<KeyValueScanner> additionalScanners, HRegion region)
    throws IOException {

  this.region = region;
  this.maxResultSize = scan.getMaxResultSize();
  if (scan.hasFilter()) {
    this.filter = new FilterWrapper(scan.getFilter());
  } else {
    this.filter = null;
  }

  this.batch = scan.getBatch();
  if (Bytes.equals(scan.getStopRow(), HConstants.EMPTY_END_ROW) && !scan.isGetScan()) {
    this.stopRow = null;
  } else {
    this.stopRow = scan.getStopRow();
  }
  // If we are doing a get, we want to be [startRow,endRow] normally
  // it is [startRow,endRow) and if startRow=endRow we get nothing.
  this.isScan = scan.isGetScan() ? -1 : 0;

  // synchronize on scannerReadPoints so that nobody calculates
  // getSmallestReadPoint, before scannerReadPoints is updated.
  IsolationLevel isolationLevel = scan.getIsolationLevel();
  synchronized(scannerReadPoints) {
    if (isolationLevel == IsolationLevel.READ_UNCOMMITTED) {
      // This scan can read even uncommitted transactions
      this.readPt = Long.MAX_VALUE;
      MultiVersionConsistencyControl.setThreadReadPoint(this.readPt);
    } else {
      this.readPt = MultiVersionConsistencyControl.resetThreadReadPoint(mvcc);
    }
    scannerReadPoints.put(this, this.readPt);
  }

  // Here we separate all scanners into two lists - scanner that provide data required
  // by the filter to operate (scanners list) and all others (joinedScanners list).
  List<KeyValueScanner> scanners = new ArrayList<KeyValueScanner>();
  List<KeyValueScanner> joinedScanners = new ArrayList<KeyValueScanner>();
  if (additionalScanners != null) {
    scanners.addAll(additionalScanners);
  }

  for (Map.Entry<byte[], NavigableSet<byte[]>> entry :
      scan.getFamilyMap().entrySet()) {
    Store store = stores.get(entry.getKey());
    KeyValueScanner scanner = store.getScanner(scan, entry.getValue());
    if (this.filter == null || !scan.doLoadColumnFamiliesOnDemand()
      || this.filter.isFamilyEssential(entry.getKey())) {
      scanners.add(scanner);
    } else {
      joinedScanners.add(scanner);
    }
  }
  this.storeHeap = new KeyValueHeap(scanners, comparator);
  if (!joinedScanners.isEmpty()) {
    this.joinedHeap = new KeyValueHeap(joinedScanners, comparator);
  }
}
 

RegionScannerImpl(Scan scan, List<KeyValueScanner> additionalScanners, HRegion region)
    throws IOException {
  // DebugPrint.println("HRegionScanner.<init>");
  this.region = region;
  this.filter = scan.getFilter();
  this.batch = scan.getBatch();
  if (Bytes.equals(scan.getStopRow(), HConstants.EMPTY_END_ROW)) {
    this.stopRow = null;
  } else {
    this.stopRow = scan.getStopRow();
  }
  // If we are doing a get, we want to be [startRow,endRow] normally
  // it is [startRow,endRow) and if startRow=endRow we get nothing.
  this.isScan = scan.isGetScan() ? -1 : 0;

  // synchronize on scannerReadPoints so that nobody calculates
  // getSmallestReadPoint, before scannerReadPoints is updated.
  IsolationLevel isolationLevel = scan.getIsolationLevel();
  synchronized(scannerReadPoints) {
    if (isolationLevel == IsolationLevel.READ_UNCOMMITTED) {
      // This scan can read even uncommitted transactions
      this.readPt = Long.MAX_VALUE;
      MultiVersionConsistencyControl.setThreadReadPoint(this.readPt);
    } else {
      this.readPt = MultiVersionConsistencyControl.resetThreadReadPoint(mvcc);
    }
    scannerReadPoints.put(this, this.readPt);
  }

  // Here we separate all scanners into two lists - scanner that provide data required
  // by the filter to operate (scanners list) and all others (joinedScanners list).
  List<KeyValueScanner> scanners = new ArrayList<KeyValueScanner>();
  List<KeyValueScanner> joinedScanners = new ArrayList<KeyValueScanner>();
  if (additionalScanners != null) {
    scanners.addAll(additionalScanners);
  }

  for (Map.Entry<byte[], NavigableSet<byte[]>> entry :
      scan.getFamilyMap().entrySet()) {
    Store store = stores.get(entry.getKey());
    KeyValueScanner scanner = store.getScanner(scan, entry.getValue());
    if (this.filter == null || !scan.doLoadColumnFamiliesOnDemand()
      || FilterBase.isFamilyEssential(this.filter, entry.getKey())) {
      scanners.add(scanner);
    } else {
      joinedScanners.add(scanner);
    }
  }
  this.storeHeap = new KeyValueHeap(scanners, comparator);
  if (!joinedScanners.isEmpty()) {
    this.joinedHeap = new KeyValueHeap(joinedScanners, comparator);
  }
}
 

RegionScannerImpl(Scan scan, List<KeyValueScanner> additionalScanners) throws IOException {
  //DebugPrint.println("HRegionScanner.<init>");

  this.maxResultSize = scan.getMaxResultSize();
  if (scan.hasFilter()) {
    this.filter = new FilterWrapper(scan.getFilter());
  } else {
    this.filter = null;
  }

  this.batch = scan.getBatch();
  if (Bytes.equals(scan.getStopRow(), HConstants.EMPTY_END_ROW)) {
    this.stopRow = null;
  } else {
    this.stopRow = scan.getStopRow();
  }
  // If we are doing a get, we want to be [startRow,endRow] normally
  // it is [startRow,endRow) and if startRow=endRow we get nothing.
  this.isScan = scan.isGetScan() ? -1 : 0;

  // synchronize on scannerReadPoints so that nobody calculates
  // getSmallestReadPoint, before scannerReadPoints is updated.
  IsolationLevel isolationLevel = scan.getIsolationLevel();
  synchronized(scannerReadPoints) {
    if (isolationLevel == IsolationLevel.READ_UNCOMMITTED) {
      // This scan can read even uncommitted transactions
      this.readPt = Long.MAX_VALUE;
      MultiVersionConsistencyControl.setThreadReadPoint(this.readPt);
    } else {
      this.readPt = MultiVersionConsistencyControl.resetThreadReadPoint(mvcc);
    }
    scannerReadPoints.put(this, this.readPt);
  }

  // Here we separate all scanners into two lists - scanner that provide data required
  // by the filter to operate (scanners list) and all others (joinedScanners list).
  List<KeyValueScanner> scanners = new ArrayList<KeyValueScanner>();
  List<KeyValueScanner> joinedScanners = new ArrayList<KeyValueScanner>();
  if (additionalScanners != null) {
    scanners.addAll(additionalScanners);
  }

  for (Map.Entry<byte[], NavigableSet<byte[]>> entry :
      scan.getFamilyMap().entrySet()) {
    Store store = stores.get(entry.getKey());
    KeyValueScanner scanner = store.getScanner(scan, entry.getValue());
    if (this.filter == null || !scan.doLoadColumnFamiliesOnDemand()
      || this.filter.isFamilyEssential(entry.getKey())) {
      scanners.add(scanner);
    } else {
      joinedScanners.add(scanner);
    }
  }
  this.storeHeap = new KeyValueHeap(scanners, comparator);
  if (!joinedScanners.isEmpty()) {
    this.joinedHeap = new KeyValueHeap(joinedScanners, comparator);
  }
}