HRegion.RegionScannerImpl (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.regionserver.HRegion.RegionScannerImpl

All Implemented Interfaces:

Closeable, AutoCloseable, InternalScanner, RegionScanner

Direct Known Subclasses:

ReversedRegionScannerImpl

Enclosing class:

HRegion
```
 class HRegion.RegionScannerImpl
extends Object
implements RegionScanner
```
RegionScannerImpl is used to combine scanners from multiple Stores (aka column families).

Field Summary

Fields
Modifier and Type	Field and Description
`private ScannerContext`	`defaultScannerContext`
`private FilterWrapper`	`filter`
`private boolean`	`filterClosed`
`protected int`	`isScan`
`protected Cell`	`joinedContinuationRow` If the joined heap data gathering is interrupted due to scan limits, this will contain the row for which we are populating the values.
`(package private) KeyValueHeap`	`joinedHeap` Heap of key-values that are not essential for the provided filters and are thus read on demand, if on-demand column family loading is enabled.
`private long`	`maxResultSize`
`private long`	`readPt`
`protected HRegion`	`region`
`protected byte[]`	`stopRow`
`(package private) KeyValueHeap`	`storeHeap`

Constructor Summary

Constructors
Constructor and Description

HRegion.RegionScannerImpl(Scan scan, List<KeyValueScanner> additionalScanners, HRegion region)

Constructors
Constructor and Description
`HRegion.RegionScannerImpl(Scan scan, List<KeyValueScanner> additionalScanners, HRegion region)`

Method Summary

Methods
Modifier and Type	Method and Description
`private void`	`abortRegionServer(String msg)`
`void`	`close()` Closes the scanner and releases any resources it has allocated
`private boolean`	`filterRow()` This function is to maintain backward compatibility for 0.94 filters.
`private boolean`	`filterRowKey(byte[] row, int offset, short length)`
`int`	`getBatch()`
`long`	`getMaxResultSize()`
`long`	`getMvccReadPoint()`
`HRegionInfo`	`getRegionInfo()`
`(package private) KeyValueHeap`	`getStoreHeapForTesting()`
`private IOException`	`handleException(List<KeyValueScanner> instantiatedScanners, Throwable t)`
`private IOException`	`handleFileNotFound(FileNotFoundException fnfe)`
`protected void`	`incrementCountOfRowsFilteredMetric(ScannerContext scannerContext)`
`protected void`	`incrementCountOfRowsScannedMetric(ScannerContext scannerContext)`
`protected void`	`initializeKVHeap(List<KeyValueScanner> scanners, List<KeyValueScanner> joinedScanners, HRegion region)`
`boolean`	`isFilterDone()`
`private boolean`	`isFilterDoneInternal()`
`protected boolean`	`isStopRow(byte[] currentRow, int offset, short length)`
`private boolean`	`joinedHeapMayHaveData(byte[] currentRow, int offset, short length)`
`private boolean`	`moreCellsInRow(Cell nextKv, byte[] currentRow, int offset, short length)` Based on the nextKv in the heap, and the current row, decide whether or not there are more cells to be read in the heap.
`boolean`	`next(List<Cell> outResults)` Grab the next row's worth of values.
`boolean`	`next(List<Cell> outResults, ScannerContext scannerContext)` Grab the next row's worth of values.
`private boolean`	`nextInternal(List<Cell> results, ScannerContext scannerContext)`
`boolean`	`nextRaw(List<Cell> outResults)` Grab the next row's worth of values.
`boolean`	`nextRaw(List<Cell> outResults, ScannerContext scannerContext)` Grab the next row's worth of values.
`protected boolean`	`nextRow(ScannerContext scannerContext, byte[] currentRow, int offset, short length)`
`private boolean`	`populateFromJoinedHeap(List<Cell> results, ScannerContext scannerContext)`
`private boolean`	`populateResult(List<Cell> results, KeyValueHeap heap, ScannerContext scannerContext, byte[] currentRow, int offset, short length)` Fetches records with currentRow into results list, until next row, batchLimit (if not -1) is reached, or remainingResultSize (if not -1) is reaced
`boolean`	`reseek(byte[] row)` Do a reseek to the required row.
`protected void`	`resetFilters()` Reset both the filter and the old filter.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - storeHeap
```
KeyValueHeap storeHeap
```
  - joinedHeap
```
KeyValueHeap joinedHeap
```
    Heap of key-values that are not essential for the provided filters and are thus read on demand, if on-demand column family loading is enabled.
  - joinedContinuationRow
```
protected Cell joinedContinuationRow
```
    If the joined heap data gathering is interrupted due to scan limits, this will contain the row for which we are populating the values.
  - filterClosed
```
private boolean filterClosed
```
  - isScan
```
protected final int isScan
```
  - stopRow
```
protected final byte[] stopRow
```
  - region
```
protected final HRegion region
```
  - readPt
```
private final long readPt
```
  - maxResultSize
```
private final long maxResultSize
```
  - defaultScannerContext
```
private final ScannerContext defaultScannerContext
```
  - filter
```
private final FilterWrapper filter
```
- Constructor Detail
  - HRegion.RegionScannerImpl
```
HRegion.RegionScannerImpl(Scan scan,
                         List<KeyValueScanner> additionalScanners,
                         HRegion region)
                    throws IOException
```
    Throws:
    
    IOException
- Method Detail
  - getRegionInfo
```
public HRegionInfo getRegionInfo()
```
    Specified by:
    
    getRegionInfo in interface RegionScanner
    
    Returns:
    The RegionInfo for this scanner.
  - initializeKVHeap
```
protected void initializeKVHeap(List<KeyValueScanner> scanners,
                    List<KeyValueScanner> joinedScanners,
                    HRegion region)
                         throws IOException
```
    Throws:
    
    IOException
  - handleException
```
private IOException handleException(List<KeyValueScanner> instantiatedScanners,
                          Throwable t)
```
  - getMaxResultSize
```
public long getMaxResultSize()
```
    Specified by:
    
    getMaxResultSize in interface RegionScanner
    
    Returns:
    The preferred max buffersize. See Scan.setMaxResultSize(long)
  - getMvccReadPoint
```
public long getMvccReadPoint()
```
    Specified by:
    
    getMvccReadPoint in interface RegionScanner
    
    Returns:
    The Scanner's MVCC readPt see MultiVersionConcurrencyControl
  - getBatch
```
public int getBatch()
```
    Specified by:
    
    getBatch in interface RegionScanner
    
    Returns:
    The limit on the number of cells to retrieve on each call to next(). See Scan.setBatch(int)
  - resetFilters
```
protected void resetFilters()
                     throws IOException
```
    Reset both the filter and the old filter.
    
    Throws:
    
    IOException - in case a filter raises an I/O exception.
  - next
```
public boolean next(List<Cell> outResults)
             throws IOException
```
    Description copied from interface: InternalScanner
    
    Grab the next row's worth of values.
    
    Specified by:
    
    next in interface InternalScanner
    
    Parameters:
    outResults - return output array
    
    Returns:
    true if more rows exist after this one, false if scanner is done
    
    Throws:
    
    IOException - e
  - next
```
public boolean next(List<Cell> outResults,
           ScannerContext scannerContext)
             throws IOException
```
    Description copied from interface: InternalScanner
    
    Grab the next row's worth of values.
    
    Specified by:
    
    next in interface InternalScanner
    
    Parameters:
    outResults - return output array
    
    Returns:
    true if more rows exist after this one, false if scanner is done
    
    Throws:
    
    IOException - e
  - nextRaw
```
public boolean nextRaw(List<Cell> outResults)
                throws IOException
```
    Description copied from interface: RegionScanner
    
    Grab the next row's worth of values. This is a special internal method to be called from coprocessor hooks to avoid expensive setup. Caller must set the thread's readpoint, start and close a region operation, an synchronize on the scanner object. Caller should maintain and update metrics. See RegionScanner.nextRaw(List, ScannerContext)
    
    Specified by:
    
    nextRaw in interface RegionScanner
    
    Parameters:
    outResults - return output array
    
    Returns:
    true if more rows exist after this one, false if scanner is done
    
    Throws:
    
    IOException - e
  - nextRaw
```
public boolean nextRaw(List<Cell> outResults,
              ScannerContext scannerContext)
                throws IOException
```
    Description copied from interface: RegionScanner
    
    Grab the next row's worth of values. The ScannerContext is used to enforce and track any limits associated with this call. Any progress that exists in the ScannerContext prior to calling this method will be LOST if ScannerContext.getKeepProgress() is false. Upon returning from this method, the ScannerContext will contain information about the progress made towards the limits. This is a special internal method to be called from coprocessor hooks to avoid expensive setup. Caller must set the thread's readpoint, start and close a region operation, an synchronize on the scanner object. Example: HRegion region = ...; RegionScanner scanner = ... MultiVersionConcurrencyControl.setThreadReadPoint(scanner.getMvccReadPoint()); region.startRegionOperation(); try { synchronized(scanner) { ... boolean moreRows = scanner.nextRaw(values); ... } } finally { region.closeRegionOperation(); }
    
    Specified by:
    
    nextRaw in interface RegionScanner
    
    Parameters:
    outResults - return output array
    scannerContext - The ScannerContext instance encapsulating all limits that should be tracked during calls to this method. The progress towards these limits can be tracked within this instance.
    
    Returns:
    true if more rows exist after this one, false if scanner is done
    
    Throws:
    
    IOException - e
  - populateFromJoinedHeap
```
private boolean populateFromJoinedHeap(List<Cell> results,
                             ScannerContext scannerContext)
                                throws IOException
```
    Returns:
    true if more cells exist after this batch, false if scanner is done
    
    Throws:
    
    IOException
  - populateResult
```
private boolean populateResult(List<Cell> results,
                     KeyValueHeap heap,
                     ScannerContext scannerContext,
                     byte[] currentRow,
                     int offset,
                     short length)
                        throws IOException
```
    Fetches records with currentRow into results list, until next row, batchLimit (if not -1) is reached, or remainingResultSize (if not -1) is reaced
    
    Parameters:
    heap - KeyValueHeap to fetch data from.It must be positioned on correct row before call.
    scannerContext -
    currentRow - Byte array with key we are fetching.
    offset - offset for currentRow
    length - length for currentRow
    
    Returns:
    state of last call to KeyValueHeap.next()
    
    Throws:
    
    IOException
  - moreCellsInRow
```
private boolean moreCellsInRow(Cell nextKv,
                     byte[] currentRow,
                     int offset,
                     short length)
```
    Based on the nextKv in the heap, and the current row, decide whether or not there are more cells to be read in the heap. If the row of the nextKv in the heap matches the current row then there are more cells to be read in the row.
    
    Parameters:
    nextKv -
    currentRow -
    offset -
    length -
    
    Returns:
    true When there are more cells in the row to be read
  - isFilterDone
```
public boolean isFilterDone()
                     throws IOException
```
    Specified by:
    
    isFilterDone in interface RegionScanner
    
    Returns:
    True if a filter indicates that this scanner will return no further rows.
    
    Throws:
    
    IOException - in case of I/O failure on a filter.
  - isFilterDoneInternal
```
private boolean isFilterDoneInternal()
                              throws IOException
```
    Throws:
    
    IOException
  - nextInternal
```
private boolean nextInternal(List<Cell> results,
                   ScannerContext scannerContext)
                      throws IOException
```
    Throws:
    
    IOException
  - incrementCountOfRowsFilteredMetric
```
protected void incrementCountOfRowsFilteredMetric(ScannerContext scannerContext)
```
  - incrementCountOfRowsScannedMetric
```
protected void incrementCountOfRowsScannedMetric(ScannerContext scannerContext)
```
  - joinedHeapMayHaveData
```
private boolean joinedHeapMayHaveData(byte[] currentRow,
                            int offset,
                            short length)
                               throws IOException
```
    Parameters:
    currentRow -
    offset -
    length -
    
    Returns:
    true when the joined heap may have data for the current row
    
    Throws:
    
    IOException
  - filterRow
```
private boolean filterRow()
                   throws IOException
```
    This function is to maintain backward compatibility for 0.94 filters. HBASE-6429 combines both filterRow & filterRow(List kvs) functions. While 0.94 code or older, it may not implement hasFilterRow as HBase-6429 expects because 0.94 hasFilterRow() only returns true when filterRow(List kvs) is overridden not the filterRow(). Therefore, the filterRow() will be skipped.
    
    Throws:
    
    IOException
  - filterRowKey
```
private boolean filterRowKey(byte[] row,
                   int offset,
                   short length)
                      throws IOException
```
    Throws:
    
    IOException
  - nextRow
```
protected boolean nextRow(ScannerContext scannerContext,
              byte[] currentRow,
              int offset,
              short length)
                   throws IOException
```
    Throws:
    
    IOException
  - isStopRow
```
protected boolean isStopRow(byte[] currentRow,
                int offset,
                short length)
```
  - close
```
public void close()
```
    Description copied from interface: InternalScanner
    
    Closes the scanner and releases any resources it has allocated
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface InternalScanner
  - getStoreHeapForTesting
```
KeyValueHeap getStoreHeapForTesting()
```
  - reseek
```
public boolean reseek(byte[] row)
               throws IOException
```
    Description copied from interface: RegionScanner
    
    Do a reseek to the required row. Should not be used to seek to a key which may come before the current position. Always seeks to the beginning of a row boundary.
    
    Specified by:
    
    reseek in interface RegionScanner
    
    Throws:
    
    IOException
  - handleFileNotFound
```
private IOException handleFileNotFound(FileNotFoundException fnfe)
                                throws IOException
```
    Throws:
    
    IOException
  - abortRegionServer
```
private void abortRegionServer(String msg)
                        throws IOException
```
    Throws:
    
    IOException

Class HRegion.RegionScannerImpl

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

storeHeap

joinedHeap

joinedContinuationRow

filterClosed

isScan

stopRow

region

readPt

maxResultSize

defaultScannerContext

filter

Constructor Detail

HRegion.RegionScannerImpl

Method Detail

getRegionInfo

initializeKVHeap

handleException

getMaxResultSize

getMvccReadPoint

getBatch

resetFilters

next

next

nextRaw

nextRaw

populateFromJoinedHeap

populateResult

moreCellsInRow

isFilterDone

isFilterDoneInternal

nextInternal

incrementCountOfRowsFilteredMetric

incrementCountOfRowsScannedMetric

joinedHeapMayHaveData

filterRow

filterRowKey

nextRow

isStopRow

close

getStoreHeapForTesting

reseek

handleFileNotFound

abortRegionServer