HBase 0.92.1 Scan 源码详细分析

从这篇文章开始终于要讨论比较正常版本的hbase了---0.92.1~~

 

Scan是hbase提供的非常重要的功能之一，我们的hbase分析系列就从这儿开始吧。

 

首先，我们有一些background的知识需要了解:

1.HBase是如何区分不同记录的，大家可以参考http://punishzhou.iteye.com/blog/1266341，讲的比较详细

2.Region，MemStore，Store，StoreFile分别的含义和如何工作的，可以参考淘宝的入门文档http://www.searchtb.com/2011/01/understanding-hbase.html

3.Scan的客户端实现可以参考http://punishzhou.iteye.com/blog/1297015

4.hbase客户端如何使用scan，这个文章实在太多了，随便搜一篇吧~

 

在这篇文章中，我们主要focus在Scan的Server端实现。

Scan的概念是扫描数据集中[startkey，stopkey)的数据，数据必须是全体有序的，根据hbase mem+storefile的结构我们大致描述下scan的步骤：

1.准备好所有的scanner，包括memstorescanner，storefilescanner

2.将scanner放入一个prorityQueue

3.开始scan，从prorityQueue中取出当前所有scanner中最小的一个数据记录

4.如果3取出的满足结果则返回，如果不满足则从prorityQueue中取next

5.如果取出的数据记录等于stopkey或者prorityQueue为空则结束

 

下面开始进入实现部分。

scan过程中会使用到诸多scanner，scanner类图如下：

 步骤1：准备Scanner：

memstore和storefile的getScanner：

return Collections.<KeyValueScanner>singletonList(
          new MemStoreScanner());

List<StoreFileScanner> scanners = new ArrayList<StoreFileScanner>(
        files.size());
    for (StoreFile file : files) {
      StoreFile.Reader r = file.createReader();
      scanners.add(r.getStoreFileScanner(cacheBlocks, usePread, isCompaction));
    }
    return scanners;

store层的getScanner：对memstore和storefile分别判断是否满足scan的条件，包括时间，是否支持bloomfilter

List<KeyValueScanner> allStoreScanners =
        this.store.getScanners(cacheBlocks, isGet, false);

    List<KeyValueScanner> scanners =
        new ArrayList<KeyValueScanner>(allStoreScanners.size());

    // include only those scan files which pass all filters
    for (KeyValueScanner kvs : allStoreScanners) {
      if (kvs instanceof StoreFileScanner) {
        if (memOnly == false
            && ((StoreFileScanner) kvs).shouldSeek(scan, columns)) {
          scanners.add(kvs);
        }
      } else {
        // kvs is a MemStoreScanner
        if (filesOnly == false && this.store.memstore.shouldSeek(scan)) {
          scanners.add(kvs);
        }
      }
    }

Store层：获取store的scanner们，seekExactly检查是否符合我们scan的column，scanner.seek调用memscanner或者storefilescanner的seek，检查我们查询的startkey是否在当前的scanner范围中，过滤掉不需要搜索的查询，其中，storefilescanner会使用bloomfilter来seek。当收集到当前store的scanner们后会构建store层的KeyValueHeap。

// pass columns = try to filter out unnecessary ScanFiles
    List<KeyValueScanner> scanners = getScanners(scan, columns);

    // Seek all scanners to the start of the Row (or if the exact matching row
    // key does not exist, then to the start of the next matching Row).
    if (matcher.isExactColumnQuery()) {
      for (KeyValueScanner scanner : scanners)
        scanner.seekExactly(matcher.getStartKey(), false);
    } else {
      for (KeyValueScanner scanner : scanners)
        scanner.seek(matcher.getStartKey());
    }

    // Combine all seeked scanners with a heap
    heap = new KeyValueHeap(scanners, store.comparator);

 region层：将store中的scanner中取出来放到scanners里，并创建RegionScanner的KeyValueHeap

for (Map.Entry<byte[], NavigableSet<byte[]>> entry :
          scan.getFamilyMap().entrySet()) {
        Store store = stores.get(entry.getKey());
        StoreScanner scanner = store.getScanner(scan, entry.getValue());
        scanners.add(scanner);
      }
      this.storeHeap = new KeyValueHeap(scanners, comparator);

 是不是已经被诸多scanner看晕了，这边先梳理下思路：

• memscanner和storefilescanner为直接数据交互的scanner，因此继承KeyValueScanner接口，每次next读取一个KeyValue对象
• storescanner管理里面的memscanner和storefilescanner，并且将所有的scanner放到一个KeyValueHeap内，KeyValueHeap会保证每次next都会取Store中满足条件的最小值
• regionscanner类似storescanner，管理所有的storescanner，并将所有的scanner放到KeyValueHeap中，作用同上

2.初始化KeyValueHeap（其实在第一部中已经做了），关键是初始化内部的PriorityQueue

this.comparator = new KVScannerComparator(comparator);
    if (!scanners.isEmpty()) {
      this.heap = new PriorityQueue<KeyValueScanner>(scanners.size(),
          this.comparator);
      for (KeyValueScanner scanner : scanners) {
        if (scanner.peek() != null) {
          this.heap.add(scanner);
        } else {
          scanner.close();
        }
      }
      this.current = heap.poll();

关于PriorityQueue可以看看http://blog.csdn.net/hudashi/article/details/6942789，内部实现了一个heap。

3.开始scan的next方法，首先，peekRow取得KeyValueHeap中当前的rowkey。这是通过current的scanner peek获得当前的rowkey，从第二部可知，KeyValueHeap刚开始时current即为heap中最小的那个

public KeyValue peek() {
    if (this.current == null) {
      return null;
    }
    return this.current.peek();
  }

4.开始取出符合当前rowkey的values
调用heap.next 循环从heap中取出相同key的不同value，直到heap取出的key不等于当前的key为止，这就表示我们已经遍历到下一个rowkey了必须停止这次next操作。

do {
            this.storeHeap.next(results, limit - results.size());
            if (limit > 0 && results.size() == limit) {
              if (this.filter != null && filter.hasFilterRow()) {
                throw new IncompatibleFilterException(
                  "Filter with filterRow(List<KeyValue>) incompatible with scan with limit!");
              }
              return true; // we are expecting more yes, but also limited to how many we can return.
            }
          } while (Bytes.equals(currentRow, nextRow = peekRow()));

heap的next方法：首先取出当前的scanner，调用next方法取出一个result塞到results里，然后peek判断这个scanner是否没数据了，如果没了就关闭，如果有就再将scanner放入heap中，再取出下一个最小的scanner

if (this.current == null) {
      return false;
    }
    InternalScanner currentAsInternal = (InternalScanner)this.current;
    boolean mayContainMoreRows = currentAsInternal.next(result, limit);
    KeyValue pee = this.current.peek();
    /*
     * By definition, any InternalScanner must return false only when it has no
     * further rows to be fetched. So, we can close a scanner if it returns
     * false. All existing implementations seem to be fine with this. It is much
     * more efficient to close scanners which are not needed than keep them in
     * the heap. This is also required for certain optimizations.
     */
    if (pee == null || !mayContainMoreRows) {
      this.current.close();
    } else {
      this.heap.add(this.current);
    }
    this.current = this.heap.poll();
    return (this.current != null);

5.对取出的results进行filter，判断是否到了stoprow，如果到了next返回false

	final boolean stopRow = isStopRow(nextRow);

          // now that we have an entire row, lets process with a filters:

          // first filter with the filterRow(List)
          if (filter != null && filter.hasFilterRow()) {
            filter.filterRow(results);
          }

          if (results.isEmpty() || filterRow()) {
            // this seems like a redundant step - we already consumed the row
            // there're no left overs.
            // the reasons for calling this method are:
            // 1. reset the filters.
            // 2. provide a hook to fast forward the row (used by subclasses)
            nextRow(currentRow);

            // This row was totally filtered out, if this is NOT the last row,
            // we should continue on.

            if (!stopRow) continue;
          }
          return !stopRow;

最后总结一下:

1.scan的实现是非常复杂的，原因主要是因为hbase在内存和硬盘中有很多颗有序树，scan时需要将多颗有序树merge成一个

2.scan.next出来的list<KeyValue>是同一个key下按照一定顺序从小到大排列的，顺序是key>column>quality>timestamp>type>maxsequenceId,然后如果是memstore，则比较memstoreTs，大的排前面，而且memstore的maxsequenceId默认是整数最大值

3.最好能指明scan的cf和quality，这样会加快速度

4.memstore的scan和storefile的scan如果有机会后面会再写文详细阐述