Java Compactor.CellSink方法代码示例

import org.apache.hadoop.hbase.regionserver.compactions.Compactor; //导入方法依赖的package包/类
/**
 * Performs memstore flush, writing data from scanner into sink.
 *
 * @param scanner           Scanner to get data from.
 * @param sink              Sink to write data to. Could be StoreFile.Writer.
 * @param smallestReadPoint Smallest read point used for the flush.
 */
protected void performFlush(InternalScanner scanner, Compactor.CellSink sink,
    long smallestReadPoint) throws IOException {
  int compactionKVMax =
      conf.getInt(HConstants.COMPACTION_KV_MAX, HConstants.COMPACTION_KV_MAX_DEFAULT);

  ScannerContext scannerContext =
      ScannerContext.newBuilder().setBatchLimit(compactionKVMax).build();

  List<Cell> kvs = new ArrayList<Cell>();
  boolean hasMore;
  do {
    hasMore = scanner.next(kvs, scannerContext);
    if (!kvs.isEmpty()) {
      for (Cell c : kvs) {
        // If we know that this KV is going to be included always, then let us
        // set its memstoreTS to 0. This will help us save space when writing
        // to
        // disk.
        sink.append(c);
      }
      kvs.clear();
    }
  } while (hasMore);
}
 

import org.apache.hadoop.hbase.regionserver.compactions.Compactor; //导入方法依赖的package包/类
/**
 * Performs memstore flush, writing data from scanner into sink.
 * @param scanner Scanner to get data from.
 * @param sink Sink to write data to. Could be StoreFile.Writer.
 * @param smallestReadPoint Smallest read point used for the flush.
 */
protected void performFlush(InternalScanner scanner,
    Compactor.CellSink sink, long smallestReadPoint) throws IOException {
  int compactionKVMax =
    conf.getInt(HConstants.COMPACTION_KV_MAX, HConstants.COMPACTION_KV_MAX_DEFAULT);
  List<Cell> kvs = new ArrayList<Cell>();
  boolean hasMore;
  do {
    hasMore = scanner.next(kvs, compactionKVMax);
    if (!kvs.isEmpty()) {
      for (Cell c : kvs) {
        // If we know that this KV is going to be included always, then let us
        // set its memstoreTS to 0. This will help us save space when writing to
        // disk.
        sink.append(c);
      }
      kvs.clear();
    }
  } while (hasMore);
}
 

import org.apache.hadoop.hbase.regionserver.compactions.Compactor; //导入方法依赖的package包/类
/**
 * Performs memstore flush, writing data from scanner into sink.
 * @param scanner Scanner to get data from.
 * @param sink Sink to write data to. Could be StoreFile.Writer.
 * @param smallestReadPoint Smallest read point used for the flush.
 * @return Bytes flushed.
 */
protected long performFlush(InternalScanner scanner,
    Compactor.CellSink sink, long smallestReadPoint) throws IOException {
  int compactionKVMax =
    conf.getInt(HConstants.COMPACTION_KV_MAX, HConstants.COMPACTION_KV_MAX_DEFAULT);
  List<Cell> kvs = new ArrayList<Cell>();
  boolean hasMore;
  long flushed = 0;
  do {
    hasMore = scanner.next(kvs, compactionKVMax);
    if (!kvs.isEmpty()) {
      for (Cell c : kvs) {
        // If we know that this KV is going to be included always, then let us
        // set its memstoreTS to 0. This will help us save space when writing to
        // disk.
        KeyValue kv = KeyValueUtil.ensureKeyValue(c);
        if (kv.getMvccVersion() <= smallestReadPoint) {
          // let us not change the original KV. It could be in the memstore
          // changing its memstoreTS could affect other threads/scanners.
          kv = kv.shallowCopy();
          kv.setMvccVersion(0);
        }
        sink.append(kv);
        flushed += MemStore.heapSizeChange(kv, true);
      }
      kvs.clear();
    }
  } while (hasMore);
  return flushed;
}
 

import org.apache.hadoop.hbase.regionserver.compactions.Compactor; //导入方法依赖的package包/类
/**
   * Performs memstore flush, writing data from scanner into sink.
   * @param scanner Scanner to get data from.
   * @param sink Sink to write data to. Could be StoreFile.Writer.
   * @param smallestReadPoint Smallest read point used for the flush.
   * @return Bytes flushed.
s   */
  protected long performFlush(InternalScanner scanner,
      Compactor.CellSink sink, long smallestReadPoint) throws IOException {
    int compactionKVMax =
      conf.getInt(HConstants.COMPACTION_KV_MAX, HConstants.COMPACTION_KV_MAX_DEFAULT);
    List<Cell> kvs = new ArrayList<Cell>();
    boolean hasMore;
    long flushed = 0;
    do {
      hasMore = scanner.next(kvs, compactionKVMax);
      if (!kvs.isEmpty()) {
        for (Cell c : kvs) {
          // If we know that this KV is going to be included always, then let us
          // set its memstoreTS to 0. This will help us save space when writing to
          // disk.
          KeyValue kv = KeyValueUtil.ensureKeyValue(c);
          if (kv.getMvccVersion() <= smallestReadPoint) {
            // let us not change the original KV. It could be in the memstore
            // changing its memstoreTS could affect other threads/scanners.
            kv = kv.shallowCopy();
            kv.setMvccVersion(0);
          }
          sink.append(kv);
          flushed += MemStore.heapSizeChange(kv, true);
        }
        kvs.clear();
      }
    } while (hasMore);
    return flushed;
  }
 

import org.apache.hadoop.hbase.regionserver.compactions.Compactor; //导入方法依赖的package包/类
/**
 * Performs memstore flush, writing data from scanner into sink.
 * @param scanner Scanner to get data from.
 * @param sink Sink to write data to. Could be StoreFile.Writer.
 * @param smallestReadPoint Smallest read point used for the flush.
 */
protected void performFlush(InternalScanner scanner,
    Compactor.CellSink sink, long smallestReadPoint) throws IOException {
  int compactionKVMax =
    conf.getInt(HConstants.COMPACTION_KV_MAX, HConstants.COMPACTION_KV_MAX_DEFAULT);
  List<Cell> kvs = new ArrayList<Cell>();

  // Shen Li: init nextSplitRow
  splitKeyIndex = 0;
  nextSplitRow = store.getRegionInfo().getSplitKey(splitKeyIndex);

  boolean hasMore;
  do {
    hasMore = scanner.next(kvs, compactionKVMax);
    if (!kvs.isEmpty()) {
      for (Cell c : kvs) {
        // If we know that this KV is going to be included always, then let us
        // set its memstoreTS to 0. This will help us save space when writing to
        // disk.
        KeyValue kv = KeyValueUtil.ensureKeyValue(c);
        if (kv.getMvccVersion() <= smallestReadPoint) {
          // let us not change the original KV. It could be in the memstore
          // changing its memstoreTS could affect other threads/scanners.
          kv = kv.shallowCopy();
          kv.setMvccVersion(0);
        }
        // Shen Li: TODO check split boundary. use Store, if exceed boundary,
        // call Store to seal block and reset replica group
        //
        // sink is a instance of StoreFile.Writer which has a
        // HFile.Writer as a member variable
        //
        // HFile.Writer has a FSDataOutputStream member variable
        // which can do seal, and set replica group operations.
        //
        if (shouldSeal(kv)) {
          // the sealCurBlock will flush buffer before seal block
          sink.sealCurBlock();
          sink.setReplicaGroups(getReplicaNamespace(), 
                                getReplicaGroups());
        }
        sink.append(kv);
      }
      kvs.clear();
    }
  } while (hasMore);
}
 

import org.apache.hadoop.hbase.regionserver.compactions.Compactor; //导入方法依赖的package包/类
/**
 * Performs memstore flush, writing data from scanner into sink.
 *
 * @param scanner           Scanner to get data from.
 * @param sink              Sink to write data to. Could be StoreFile.Writer.
 * @param smallestReadPoint Smallest read point used for the flush.
 */
@Override
protected void performFlush(InternalScanner scanner, Compactor.CellSink sink, long smallestReadPoint) throws IOException {
    super.performFlush(scanner, sink, smallestReadPoint);
}