StoreScanner (Apache HBase 1.2.12 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

Direct Known Subclasses:

ReversedStoreScanner
```
@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.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

(package private) static class StoreScanner.StoreScannerCompactionRace

Nested Classes
Modifier and Type	Class and Description
`(package private) static class`	`StoreScanner.StoreScannerCompactionRace`

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`
`private long`	`kvsScanned` The number of KVs seen by the scanner.
`protected Cell`	`lastTop`
`(package private) static boolean`	`LAZY_SEEK_ENABLED_BY_DEFAULT` We don't ever expect to change this, the constant is just for clarity.
`protected static boolean`	`lazySeekEnabledGlobally` Used during unit testing to ensure that lazy seek does save seek ops
`protected ReentrantLock`	`lock`
`private static org.apache.commons.logging.Log`	`LOG`
`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
`private Cell`	`prevCell`
`private long`	`readPt`
`protected Scan`	`scan`
`private boolean`	`scanUsePread`
`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
`(package private)`	`StoreScanner(Scan scan, ScanInfo scanInfo, ScanType scanType, NavigableSet<byte[]> columns, List<KeyValueScanner> scanners)`
`(package private)`	`StoreScanner(Scan scan, ScanInfo scanInfo, ScanType scanType, NavigableSet<byte[]> columns, List<KeyValueScanner> scanners, long earliestPutTs)`
`private`	`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.
`private`	`StoreScanner(Store store, ScanInfo scanInfo, Scan scan, List<? extends KeyValueScanner> scanners, ScanType scanType, long smallestReadPoint, long earliestPutTs, byte[] dropDeletesFromRow, byte[] dropDeletesToRow)`
	`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 boolean`	`checkReseek()`
`protected void`	`checkScanOrder(Cell prevKV, Cell kv, KeyValue.KVComparator comparator)` Check whether scan as expected order
`void`	`close()` Close the KeyValue scanner.
`(package private) static void`	`enableLazySeekGlobally(boolean enable)`
`(package private) List<KeyValueScanner>`	`getAllScannersForTesting()` Used in testing.
`long`	`getEstimatedNumberOfKvsScanned()`
`Cell`	`getNextIndexedKey()`
`protected List<KeyValueScanner>`	`getScannersNoCompaction()` Get a filtered list of scanners.
`long`	`getSequenceID()` Get the sequence id associated with this KeyValueScanner.
`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.
`private ScanQueryMatcher.MatchCode`	`optimize(ScanQueryMatcher.MatchCode qcode, Cell cell)`
`private void`	`parallelSeek(List<? extends KeyValueScanner> scanners, Cell kv)` Seek storefiles in parallel to optimize IO latency as much as possible
`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.
`void`	`updateReaders()` 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
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - 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
```
  - kvsScanned
```
private long kvsScanned
```
    The number of KVs seen by the scanner. Includes explicitly skipped KVs, but not KVs skipped via seeking to next row/column. TODO: estimate them?
  - prevCell
```
private Cell prevCell
```
  - LAZY_SEEK_ENABLED_BY_DEFAULT
```
static final boolean LAZY_SEEK_ENABLED_BY_DEFAULT
```
    We don't ever expect to change this, the constant is just for clarity.
    
    See Also:
    Constant Field Values
  - 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
```
  - scanUsePread
```
private boolean scanUsePread
```
  - lock
```
protected ReentrantLock lock
```
  - readPt
```
private final long readPt
```
- 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
```
private StoreScanner(Store store,
            ScanInfo scanInfo,
            Scan scan,
            List<? extends KeyValueScanner> scanners,
            ScanType scanType,
            long smallestReadPoint,
            long earliestPutTs,
            byte[] dropDeletesFromRow,
            byte[] dropDeletesToRow)
              throws IOException
```
    Throws:
    
    IOException
  - StoreScanner
```
StoreScanner(Scan scan,
            ScanInfo scanInfo,
            ScanType scanType,
            NavigableSet<byte[]> columns,
            List<KeyValueScanner> scanners)
       throws IOException
```
    Throws:
    
    IOException
  - StoreScanner
```
StoreScanner(Scan scan,
            ScanInfo scanInfo,
            ScanType scanType,
            NavigableSet<byte[]> columns,
            List<KeyValueScanner> scanners,
            long earliestPutTs)
       throws IOException
```
    Throws:
    
    IOException
  - StoreScanner
```
private StoreScanner(Scan scan,
            ScanInfo scanInfo,
            ScanType scanType,
            NavigableSet<byte[]> columns,
            List<KeyValueScanner> scanners,
            long earliestPutTs,
            long readPt)
              throws IOException
```
    Throws:
    
    IOException
- Method Detail
  - 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.
    
    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
  - optimize
```
private ScanQueryMatcher.MatchCode optimize(ScanQueryMatcher.MatchCode qcode,
                                  Cell cell)
```
  - updateReaders
```
public void updateReaders()
                   throws IOException
```
    Description copied from interface: ChangedReadersObserver
    
    Notify observers.
    
    Specified by:
    
    updateReaders in interface ChangedReadersObserver
    
    Throws:
    
    IOException - e
  - checkReseek
```
protected boolean checkReseek()
                       throws IOException
```
    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
  - getSequenceID
```
public long getSequenceID()
```
    Description copied from interface: KeyValueScanner
    
    Get the sequence id associated with this KeyValueScanner. This is required for comparing multiple files to find out which one has the latest data. The default implementation for this would be to return 0. A file having lower sequence id will be considered to be the older one.
    
    Specified by:
    
    getSequenceID in interface KeyValueScanner
  - parallelSeek
```
private void parallelSeek(List<? extends KeyValueScanner> scanners,
                Cell kv)
                   throws IOException
```
    Seek storefiles in parallel to optimize IO latency as much as possible
    
    Parameters:
    scanners - the list KeyValueScanners to be read from
    kv - the KeyValue on which the operation is being requested
    
    Throws:
    
    IOException
  - getAllScannersForTesting
```
List<KeyValueScanner> getAllScannersForTesting()
```
    Used in testing.
    
    Returns:
    all scanners in no particular order
  - enableLazySeekGlobally
```
static void enableLazySeekGlobally(boolean enable)
```
  - 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 (the key to seek to the next block) if known, or null otherwise

Class StoreScanner

Nested Class Summary

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

LOG

store

matcher

heap

cacheBlocks

countPerRow

storeLimit

storeOffset

closing

get

explicitColumnQuery

useRowColBloom

parallelSeekEnabled

executor

scan

columns

oldestUnexpiredTS

now

minVersions

maxRowSize

cellsPerHeartbeatCheck

kvsScanned

prevCell

LAZY_SEEK_ENABLED_BY_DEFAULT

STORESCANNER_PARALLEL_SEEK_ENABLE

lazySeekEnabledGlobally

HBASE_CELLS_SCANNED_PER_HEARTBEAT_CHECK

DEFAULT_HBASE_CELLS_SCANNED_PER_HEARTBEAT_CHECK

lastTop

scanUsePread

lock

readPt

Constructor Detail

StoreScanner

StoreScanner

StoreScanner

StoreScanner

StoreScanner

StoreScanner

StoreScanner

StoreScanner

Method Detail

getScannersNoCompaction

seekScanners

resetKVHeap

selectScannersFrom

peek

next

close

seek

next

next

optimize

updateReaders

checkReseek

resetScannerStack

checkScanOrder

seekToNextRow

seekAsDirection

reseek

getSequenceID

parallelSeek

getAllScannersForTesting

enableLazySeekGlobally

getEstimatedNumberOfKvsScanned

getNextIndexedKey