StoreScanner (Apache HBase 1.4.11 API)

java.lang.Object
- org.apache.hadoop.hbase.regionserver.NonLazyKeyValueScanner
- - org.apache.hadoop.hbase.regionserver.NonReversedNonLazyKeyValueScanner
  - - org.apache.hadoop.hbase.regionserver.StoreScanner

All Implemented Interfaces:

Closeable, AutoCloseable, ChangedReadersObserver, InternalScanner, KeyValueScanner
```
@InterfaceAudience.Private
public class StoreScanner
extends NonReversedNonLazyKeyValueScanner
implements KeyValueScanner, InternalScanner, ChangedReadersObserver
```
Scanner scans both the memstore and the Store. Coalesce KeyValue stream into List<KeyValue> for a single row.

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`cacheBlocks`
`protected long`	`cellsPerHeartbeatCheck`
`protected boolean`	`closing`
`protected NavigableSet<byte[]>`	`columns`
`protected long`	`countPerRow`
`static long`	`DEFAULT_HBASE_CELLS_SCANNED_PER_HEARTBEAT_CHECK` Default value of `HBASE_CELLS_SCANNED_PER_HEARTBEAT_CHECK`.
`protected ExecutorService`	`executor`
`protected boolean`	`explicitColumnQuery`
`protected boolean`	`get`
`static String`	`HBASE_CELLS_SCANNED_PER_HEARTBEAT_CHECK` The number of cells scanned in between timeout checks.
`protected KeyValueHeap`	`heap`
`protected Cell`	`lastTop`
`protected static boolean`	`lazySeekEnabledGlobally` Used during unit testing to ensure that lazy seek does save seek ops
`protected ScanQueryMatcher`	`matcher`
`protected long`	`maxRowSize`
`protected int`	`minVersions`
`protected long`	`now`
`protected long`	`oldestUnexpiredTS`
`protected boolean`	`parallelSeekEnabled` A flag that enables StoreFileScanner parallel-seeking
`protected Scan`	`scan`
`protected Store`	`store`
`protected int`	`storeLimit`
`protected int`	`storeOffset`
`static String`	`STORESCANNER_PARALLEL_SEEK_ENABLE`
`protected boolean`	`useRowColBloom`

Fields inherited from interface org.apache.hadoop.hbase.regionserver.KeyValueScanner
NO_NEXT_INDEXED_KEY

Constructor Summary

Constructors
Modifier	Constructor and Description
	`StoreScanner(Scan scan, ScanInfo scanInfo, ScanType scanType, NavigableSet<byte[]> columns, List<KeyValueScanner> scanners, long earliestPutTs, long readPt)`
	`StoreScanner(Store store, ScanInfo scanInfo, Scan scan, List<? extends KeyValueScanner> scanners, long smallestReadPoint, long earliestPutTs, byte[] dropDeletesFromRow, byte[] dropDeletesToRow)` Used for compactions that drop deletes from a limited range of rows.
	`StoreScanner(Store store, ScanInfo scanInfo, Scan scan, List<? extends KeyValueScanner> scanners, ScanType scanType, long smallestReadPoint, long earliestPutTs)` Used for compactions.
	`StoreScanner(Store store, ScanInfo scanInfo, Scan scan, NavigableSet<byte[]> columns, long readPt)` Opens a scanner across memstore, snapshot, and all StoreFiles.
`protected`	`StoreScanner(Store store, Scan scan, ScanInfo scanInfo, NavigableSet<byte[]> columns, long readPt, boolean cacheBlocks)` An internal constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`addCurrentScanners(List<? extends KeyValueScanner> scanners)`
`protected boolean`	`checkFlushed()`
`protected boolean`	`checkReseek(boolean flushed)`
`protected void`	`checkScanOrder(Cell prevKV, Cell kv, KeyValue.KVComparator comparator)` Check whether scan as expected order
`void`	`close()` Close the KeyValue scanner.
`long`	`getEstimatedNumberOfKvsScanned()`
`Cell`	`getNextIndexedKey()`
`long`	`getReadPoint()`
`long`	`getScannerOrder()` Get the order of this KeyValueScanner.
`protected List<KeyValueScanner>`	`getScannersNoCompaction()` Get a filtered list of scanners.
`KeyValue`	`next()` Return the next Cell in this scanner, iterating the scanner
`boolean`	`next(List<Cell> outResult)` Grab the next row's worth of values.
`boolean`	`next(List<Cell> outResult, ScannerContext scannerContext)` Get the next row of values from this Store.
`protected void`	`nullifyCurrentHeap()`
`Cell`	`peek()` Look at the next Cell in this scanner, but do not iterate scanner.
`boolean`	`reseek(Cell kv)` Reseek the scanner at or after the specified KeyValue.
`protected void`	`resetKVHeap(List<? extends KeyValueScanner> scanners, KeyValue.KVComparator comparator)`
`protected void`	`resetScannerStack(Cell lastTopKey)`
`boolean`	`seek(Cell key)` Seek the scanner at or after the specified KeyValue.
`protected boolean`	`seekAsDirection(Cell kv)` Do a reseek in a normal StoreScanner(scan forward)
`protected void`	`seekScanners(List<? extends KeyValueScanner> scanners, Cell seekKey, boolean isLazy, boolean isParallelSeek)` Seek the specified scanners with the given key
`protected boolean`	`seekToNextRow(Cell kv)`
`protected List<KeyValueScanner>`	`selectScannersFrom(List<? extends KeyValueScanner> allScanners)` Filters the given list of scanners using Bloom filter, time range, and TTL.
`protected boolean`	`trySkipToNextColumn(Cell cell)` See `trySkipToNextRow(Cell)`
`protected boolean`	`trySkipToNextRow(Cell cell)` See if we should actually SEEK or rather just SKIP to the next Cell (see HBASE-13109).
`void`	`updateReaders(List<StoreFile> sfs, List<KeyValueScanner> memStoreScanners)` Notify observers.

Methods inherited from class org.apache.hadoop.hbase.regionserver.NonReversedNonLazyKeyValueScanner
backwardSeek, seekToLastRow, seekToPreviousRow

Methods inherited from class org.apache.hadoop.hbase.regionserver.NonLazyKeyValueScanner
doRealSeek, enforceSeek, isFileScanner, realSeekDone, requestSeek, shouldUseScanner

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

Methods inherited from interface org.apache.hadoop.hbase.regionserver.KeyValueScanner
backwardSeek, enforceSeek, isFileScanner, realSeekDone, requestSeek, seekToLastRow, seekToPreviousRow, shouldUseScanner

- Field Detail
  - store
```
protected final Store store
```
  - matcher
```
protected ScanQueryMatcher matcher
```
  - heap
```
protected KeyValueHeap heap
```
  - cacheBlocks
```
protected boolean cacheBlocks
```
  - countPerRow
```
protected long countPerRow
```
  - storeLimit
```
protected int storeLimit
```
  - storeOffset
```
protected int storeOffset
```
  - closing
```
protected boolean closing
```
  - get
```
protected final boolean get
```
  - explicitColumnQuery
```
protected final boolean explicitColumnQuery
```
  - useRowColBloom
```
protected final boolean useRowColBloom
```
  - parallelSeekEnabled
```
protected boolean parallelSeekEnabled
```
    A flag that enables StoreFileScanner parallel-seeking
  - executor
```
protected ExecutorService executor
```
  - scan
```
protected final Scan scan
```
  - columns
```
protected final NavigableSet<byte[]> columns
```
  - oldestUnexpiredTS
```
protected final long oldestUnexpiredTS
```
  - now
```
protected final long now
```
  - minVersions
```
protected final int minVersions
```
  - maxRowSize
```
protected final long maxRowSize
```
  - cellsPerHeartbeatCheck
```
protected final long cellsPerHeartbeatCheck
```
  - STORESCANNER_PARALLEL_SEEK_ENABLE
```
public static final String STORESCANNER_PARALLEL_SEEK_ENABLE
```
    See Also:
    Constant Field Values
  - lazySeekEnabledGlobally
```
protected static boolean lazySeekEnabledGlobally
```
    Used during unit testing to ensure that lazy seek does save seek ops
  - HBASE_CELLS_SCANNED_PER_HEARTBEAT_CHECK
```
public static final String HBASE_CELLS_SCANNED_PER_HEARTBEAT_CHECK
```
    The number of cells scanned in between timeout checks. Specifying a larger value means that timeout checks will occur less frequently. Specifying a small value will lead to more frequent timeout checks.
    
    See Also:
    Constant Field Values
  - DEFAULT_HBASE_CELLS_SCANNED_PER_HEARTBEAT_CHECK
```
public static final long DEFAULT_HBASE_CELLS_SCANNED_PER_HEARTBEAT_CHECK
```
    Default value of HBASE_CELLS_SCANNED_PER_HEARTBEAT_CHECK.
    
    See Also:
    Constant Field Values
  - lastTop
```
protected Cell lastTop
```
- Constructor Detail
  - StoreScanner
```
protected StoreScanner(Store store,
            Scan scan,
            ScanInfo scanInfo,
            NavigableSet<byte[]> columns,
            long readPt,
            boolean cacheBlocks)
```
    An internal constructor.
  - StoreScanner
```
public StoreScanner(Store store,
            ScanInfo scanInfo,
            Scan scan,
            NavigableSet<byte[]> columns,
            long readPt)
             throws IOException
```
    Opens a scanner across memstore, snapshot, and all StoreFiles. Assumes we are not in a compaction.
    
    Parameters:
    store - who we scan
    scan - the spec
    columns - which columns we are scanning
    
    Throws:
    
    IOException
  - StoreScanner
```
public StoreScanner(Store store,
            ScanInfo scanInfo,
            Scan scan,
            List<? extends KeyValueScanner> scanners,
            ScanType scanType,
            long smallestReadPoint,
            long earliestPutTs)
             throws IOException
```
    Used for compactions.
    Opens a scanner across specified StoreFiles.
    
    Parameters:
    store - who we scan
    scan - the spec
    scanners - ancillary scanners
    smallestReadPoint - the readPoint that we should use for tracking versions
    
    Throws:
    
    IOException
  - StoreScanner
```
public StoreScanner(Store store,
            ScanInfo scanInfo,
            Scan scan,
            List<? extends KeyValueScanner> scanners,
            long smallestReadPoint,
            long earliestPutTs,
            byte[] dropDeletesFromRow,
            byte[] dropDeletesToRow)
             throws IOException
```
    Used for compactions that drop deletes from a limited range of rows.
    Opens a scanner across specified StoreFiles.
    
    Parameters:
    store - who we scan
    scan - the spec
    scanners - ancillary scanners
    smallestReadPoint - the readPoint that we should use for tracking versions
    dropDeletesFromRow - The inclusive left bound of the range; can be EMPTY_START_ROW.
    dropDeletesToRow - The exclusive right bound of the range; can be EMPTY_END_ROW.
    
    Throws:
    
    IOException
  - StoreScanner
```
public StoreScanner(Scan scan,
            ScanInfo scanInfo,
            ScanType scanType,
            NavigableSet<byte[]> columns,
            List<KeyValueScanner> scanners,
            long earliestPutTs,
            long readPt)
             throws IOException
```
    Throws:
    
    IOException
- Method Detail
  - addCurrentScanners
```
protected void addCurrentScanners(List<? extends KeyValueScanner> scanners)
```
  - getScannersNoCompaction
```
protected List<KeyValueScanner> getScannersNoCompaction()
                                                 throws IOException
```
    Get a filtered list of scanners. Assumes we are not in a compaction.
    
    Returns:
    list of scanners to seek
    
    Throws:
    
    IOException
  - seekScanners
```
protected void seekScanners(List<? extends KeyValueScanner> scanners,
                Cell seekKey,
                boolean isLazy,
                boolean isParallelSeek)
                     throws IOException
```
    Seek the specified scanners with the given key
    
    Parameters:
    scanners -
    seekKey -
    isLazy - true if using lazy seek
    isParallelSeek - true if using parallel seek
    
    Throws:
    
    IOException
  - resetKVHeap
```
protected void resetKVHeap(List<? extends KeyValueScanner> scanners,
               KeyValue.KVComparator comparator)
                    throws IOException
```
    Throws:
    
    IOException
  - selectScannersFrom
```
protected List<KeyValueScanner> selectScannersFrom(List<? extends KeyValueScanner> allScanners)
```
    Filters the given list of scanners using Bloom filter, time range, and TTL.
  - peek
```
public Cell peek()
```
    Description copied from interface: KeyValueScanner
    
    Look at the next Cell in this scanner, but do not iterate scanner. NOTICE: The returned cell has not been passed into ScanQueryMatcher. So it may not be what the user need.
    
    Specified by:
    
    peek in interface KeyValueScanner
    
    Returns:
    the next Cell
  - next
```
public KeyValue next()
```
    Description copied from interface: KeyValueScanner
    
    Return the next Cell in this scanner, iterating the scanner
    
    Specified by:
    
    next in interface KeyValueScanner
    
    Returns:
    the next Cell
  - close
```
public void close()
```
    Description copied from interface: KeyValueScanner
    
    Close the KeyValue scanner.
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface InternalScanner
    
    Specified by:
    
    close in interface KeyValueScanner
  - seek
```
public boolean seek(Cell key)
             throws IOException
```
    Description copied from interface: KeyValueScanner
    
    Seek the scanner at or after the specified KeyValue.
    
    Specified by:
    
    seek in interface KeyValueScanner
    
    Parameters:
    key - seek value
    
    Returns:
    true if scanner has values left, false if end of scanner
    
    Throws:
    
    IOException
  - next
```
public boolean next(List<Cell> outResult)
             throws IOException
```
    Description copied from interface: InternalScanner
    
    Grab the next row's worth of values.
    
    Specified by:
    
    next in interface InternalScanner
    
    Parameters:
    outResult - 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> outResult,
           ScannerContext scannerContext)
             throws IOException
```
    Get the next row of values from this Store.
    
    Specified by:
    
    next in interface InternalScanner
    
    Parameters:
    outResult -
    scannerContext -
    
    Returns:
    true if there are more rows, false if scanner is done
    
    Throws:
    
    IOException - e
  - trySkipToNextRow
```
protected boolean trySkipToNextRow(Cell cell)
                            throws IOException
```
    See if we should actually SEEK or rather just SKIP to the next Cell (see HBASE-13109). ScanQueryMatcher may issue SEEK hints, such as seek to next column, next row, or seek to an arbitrary seek key. This method decides whether a seek is the most efficient _actual_ way to get us to the requested cell (SEEKs are more expensive than SKIP, SKIP, SKIP inside the current, loaded block). It does this by looking at the next indexed key of the current HFile. This key is then compared with the _SEEK_ key, where a SEEK key is an artificial 'last possible key on the row' (only in here, we avoid actually creating a SEEK key; in the compare we work with the current Cell but compare as though it were a seek key; see down in matcher.compareKeyForNextRow, etc). If the compare gets us onto the next block we *_SEEK, otherwise we just SKIP to the next requested cell.
    Other notes:
    - Rows can straddle block boundaries
    - Versions of columns can straddle block boundaries (i.e. column C1 at T1 might be in a different block than column C1 at T2)
    - We want to SKIP if the chance is high that we'll find the desired Cell after a few SKIPs...
    - We want to SEEK when the chance is high that we'll be able to seek past many Cells, especially if we know we need to go to the next block.
    A good proxy (best effort) to determine whether SKIP is better than SEEK is whether we'll likely end up seeking to the next block (or past the next block) to get our next column. Example:
```
 |    BLOCK 1              |     BLOCK 2                   |
 |  r1/c1, r1/c2, r1/c3    |    r1/c4, r1/c5, r2/c1        |
                                   ^         ^
                                   |         |
                           Next Index Key   SEEK_NEXT_ROW (before r2/c1)


 |    BLOCK 1                       |     BLOCK 2                      |
 |  r1/c1/t5, r1/c1/t4, r1/c1/t3    |    r1/c1/t2, r1/c1/T1, r1/c2/T3  |
                                            ^              ^
                                            |              |
                                    Next Index Key        SEEK_NEXT_COL
 
```
    Now imagine we want columns c1 and c3 (see first diagram above), the 'Next Index Key' of r1/c4 is > r1/c3 so we should seek to get to the c1 on the next row, r2. In second case, say we only want one version of c1, after we have it, a SEEK_COL will be issued to get to c2. Looking at the 'Next Index Key', it would land us in the next block, so we should SEEK. In other scenarios where the SEEK will not land us in the next block, it is very likely better to issues a series of SKIPs.
    Parameters:
    cell - current cell
    
    Returns:
    true means skip to next row, false means not
    
    Throws:
    
    IOException
  - trySkipToNextColumn
```
protected boolean trySkipToNextColumn(Cell cell)
                               throws IOException
```
    See trySkipToNextRow(Cell)
    
    Parameters:
    cell - current cell
    
    Returns:
    true means skip to next column, false means not
    
    Throws:
    
    IOException
  - getReadPoint
```
public long getReadPoint()
```
    Specified by:
    
    getReadPoint in interface ChangedReadersObserver
    
    Returns:
    the read point of the current scan
  - updateReaders
```
public void updateReaders(List<StoreFile> sfs,
                 List<KeyValueScanner> memStoreScanners)
                   throws IOException
```
    Description copied from interface: ChangedReadersObserver
    
    Notify observers.
    
    Specified by:
    
    updateReaders in interface ChangedReadersObserver
    
    Parameters:
    sfs - The new files
    memStoreScanners - scanner of current memstore
    
    Throws:
    
    IOException - e
  - nullifyCurrentHeap
```
protected void nullifyCurrentHeap()
                           throws IOException
```
    Throws:
    
    IOException
  - checkReseek
```
protected boolean checkReseek(boolean flushed)
                       throws IOException
```
    Parameters:
    flushed - indicates if there was a flush
    
    Returns:
    true if top of heap has changed (and KeyValueHeap has to try the next KV)
    
    Throws:
    
    IOException
  - resetScannerStack
```
protected void resetScannerStack(Cell lastTopKey)
                          throws IOException
```
    Throws:
    
    IOException
  - checkScanOrder
```
protected void checkScanOrder(Cell prevKV,
                  Cell kv,
                  KeyValue.KVComparator comparator)
                       throws IOException
```
    Check whether scan as expected order
    
    Parameters:
    prevKV -
    kv -
    comparator -
    
    Throws:
    
    IOException
  - seekToNextRow
```
protected boolean seekToNextRow(Cell kv)
                         throws IOException
```
    Throws:
    
    IOException
  - seekAsDirection
```
protected boolean seekAsDirection(Cell kv)
                           throws IOException
```
    Do a reseek in a normal StoreScanner(scan forward)
    
    Parameters:
    kv -
    
    Returns:
    true if scanner has values left, false if end of scanner
    
    Throws:
    
    IOException
  - reseek
```
public boolean reseek(Cell kv)
               throws IOException
```
    Description copied from interface: KeyValueScanner
    
    Reseek the scanner at or after the specified KeyValue. This method is guaranteed to seek at or after the required key only if the key comes after the current position of the scanner. Should not be used to seek to a key which may come before the current position.
    
    Specified by:
    
    reseek in interface KeyValueScanner
    
    Parameters:
    kv - seek value (should be non-null)
    
    Returns:
    true if scanner has values left, false if end of scanner
    
    Throws:
    
    IOException
  - checkFlushed
```
protected boolean checkFlushed()
```
  - getScannerOrder
```
public long getScannerOrder()
```
    Description copied from interface: KeyValueScanner
    
    Get the order of this KeyValueScanner. This is only relevant for StoreFileScanners and MemStoreScanners (other scanners simply return 0). This is required for comparing multiple files to find out which one has the latest data. StoreFileScanners are ordered from 0 (oldest) to newest in increasing order. MemStoreScanner gets LONG.max since it always contains freshest data.
    
    Specified by:
    
    getScannerOrder in interface KeyValueScanner
    
    See Also:
    KeyValueScanner.getScannerOrder()
  - getEstimatedNumberOfKvsScanned
```
public long getEstimatedNumberOfKvsScanned()
```
    Returns:
    The estimated number of KVs seen by this scanner (includes some skipped KVs).
  - getNextIndexedKey
```
public Cell getNextIndexedKey()
```
    Specified by:
    
    getNextIndexedKey in interface KeyValueScanner
    
    Overrides:
    
    getNextIndexedKey in class NonLazyKeyValueScanner
    
    Returns:
    the next key in the index, usually the first key of next block OR a key that falls between last key of current block and first key of next block.. see HFileWriterImpl#getMidpoint, or null if not known.

Class StoreScanner

Field Summary

Fields inherited from interface org.apache.hadoop.hbase.regionserver.KeyValueScanner

Constructor Summary

Method Summary

Methods inherited from class org.apache.hadoop.hbase.regionserver.NonReversedNonLazyKeyValueScanner

Methods inherited from class org.apache.hadoop.hbase.regionserver.NonLazyKeyValueScanner

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.hadoop.hbase.regionserver.KeyValueScanner

Field Detail

store

matcher

heap

cacheBlocks

countPerRow

storeLimit

storeOffset

closing

get

explicitColumnQuery

useRowColBloom

parallelSeekEnabled

executor

scan

columns

oldestUnexpiredTS

now

minVersions

maxRowSize

cellsPerHeartbeatCheck

STORESCANNER_PARALLEL_SEEK_ENABLE

lazySeekEnabledGlobally

HBASE_CELLS_SCANNED_PER_HEARTBEAT_CHECK

DEFAULT_HBASE_CELLS_SCANNED_PER_HEARTBEAT_CHECK

lastTop

Constructor Detail

StoreScanner

StoreScanner

StoreScanner

StoreScanner

StoreScanner

Method Detail

addCurrentScanners

getScannersNoCompaction

seekScanners

resetKVHeap

selectScannersFrom

peek

next

close

seek

next

next

trySkipToNextRow

trySkipToNextColumn

getReadPoint

updateReaders

nullifyCurrentHeap

checkReseek

resetScannerStack

checkScanOrder

seekToNextRow

seekAsDirection

reseek

checkFlushed

getScannerOrder

getEstimatedNumberOfKvsScanned

getNextIndexedKey