StoreFileScanner (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.regionserver.StoreFileScanner

All Implemented Interfaces:

KeyValueScanner
```
@InterfaceAudience.LimitedPrivate(value="Coprocessor")
public class StoreFileScanner
extends Object
implements KeyValueScanner
```
KeyValueScanner adaptor over the Reader. It also provides hooks into bloom filter things.

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`closed`
`private Cell`	`cur`
`private boolean`	`delayedReseek`
`private Cell`	`delayedSeekKV`
`private boolean`	`enforceMVCC`
`private boolean`	`hasMVCCInfo`
`private HFileScanner`	`hfs`
`private static org.apache.commons.logging.Log`	`LOG`
`private ScanQueryMatcher`	`matcher`
`private StoreFile.Reader`	`reader`
`private long`	`readPt`
`private boolean`	`realSeekDone`
`private static AtomicLong`	`seekCount`
`private boolean`	`stopSkippingKVsIfNextRow`

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

Constructor Summary

Constructors
Constructor and Description
`StoreFileScanner(StoreFile.Reader reader, HFileScanner hfs, boolean useMVCC, boolean hasMVCC, long readPt)` Implements a `KeyValueScanner` on top of the specified `HFileScanner`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`backwardSeek(Cell key)` Seek the scanner at or before the row of specified Cell, it firstly tries to seek the scanner at or after the specified Cell, return if peek KeyValue of scanner has the same row with specified Cell, otherwise seek the scanner at the first Cell of the row which is the previous row of specified KeyValue
`void`	`close()` Close the KeyValue scanner.
`void`	`enforceSeek()` Does the real seek operation in case it was skipped by seekToRowCol(KeyValue, boolean) (TODO: Whats this?).
`(package private) KeyValue.KVComparator`	`getComparator()`
`Cell`	`getNextIndexedKey()`
`(package private) StoreFile.Reader`	`getReader()`
`static List<StoreFileScanner>`	`getScannersForStoreFiles(Collection<StoreFile> files, boolean cacheBlocks, boolean usePread, boolean isCompaction, boolean useDropBehind, long readPt)` Return an array of scanners corresponding to the given set of store files.
`static List<StoreFileScanner>`	`getScannersForStoreFiles(Collection<StoreFile> files, boolean cacheBlocks, boolean usePread, boolean isCompaction, boolean canUseDrop, ScanQueryMatcher matcher, long readPt)`
`static List<StoreFileScanner>`	`getScannersForStoreFiles(Collection<StoreFile> files, boolean cacheBlocks, boolean usePread, boolean isCompaction, boolean canUseDrop, ScanQueryMatcher matcher, long readPt, boolean isPrimaryReplica)` Return an array of scanners corresponding to the given set of store files, And set the ScanQueryMatcher for each store file scanner for further optimization
`static List<StoreFileScanner>`	`getScannersForStoreFiles(Collection<StoreFile> files, boolean cacheBlocks, boolean usePread, long readPt)` Return an array of scanners corresponding to the given set of store files.
`(package private) static long`	`getSeekCount()`
`long`	`getSequenceID()` Get the sequence id associated with this KeyValueScanner.
`(package private) static void`	`instrument()`
`boolean`	`isFileScanner()`
`(package private) boolean`	`isPrimaryReplica()`
`Cell`	`next()` Return the next Cell in this scanner, iterating the scanner
`Cell`	`peek()` Look at the next Cell in this scanner, but do not iterate scanner.
`boolean`	`realSeekDone()` We optimize our store scanners by checking the most recent store file first, so we sometimes pretend we have done a seek but delay it until the store scanner bubbles up to the top of the key-value heap.
`boolean`	`requestSeek(Cell kv, boolean forward, boolean useBloom)` Pretend we have done a seek but don't do it yet, if possible.
`boolean`	`reseek(Cell key)` Reseek the scanner at or after the specified KeyValue.
`(package private) static boolean`	`reseekAtOrAfter(HFileScanner s, Cell k)`
`boolean`	`seek(Cell key)` Seek the scanner at or after the specified KeyValue.
`static boolean`	`seekAtOrAfter(HFileScanner s, Cell k)`
`boolean`	`seekToLastRow()` Seek the scanner at the first KeyValue of last row
`boolean`	`seekToPreviousRow(Cell originalKey)` Seek the scanner at the first Cell of the row which is the previous row of specified key
`protected void`	`setCurrentCell(Cell newVal)`
`void`	`setScanQueryMatcher(ScanQueryMatcher matcher)`
`boolean`	`shouldUseScanner(Scan scan, Store store, long oldestUnexpiredTS)` Allows to filter out scanners (both StoreFile and memstore) that we don't want to use based on criteria such as Bloom filters and timestamp ranges.
`protected boolean`	`skipKVsNewerThanReadpoint()`
`String`	`toString()`

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

- Field Detail
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - reader
```
private final StoreFile.Reader reader
```
  - hfs
```
private final HFileScanner hfs
```
  - cur
```
private Cell cur
```
  - closed
```
private boolean closed
```
  - realSeekDone
```
private boolean realSeekDone
```
  - delayedReseek
```
private boolean delayedReseek
```
  - delayedSeekKV
```
private Cell delayedSeekKV
```
  - enforceMVCC
```
private boolean enforceMVCC
```
  - hasMVCCInfo
```
private boolean hasMVCCInfo
```
  - stopSkippingKVsIfNextRow
```
private boolean stopSkippingKVsIfNextRow
```
  - seekCount
```
private static AtomicLong seekCount
```
  - matcher
```
private ScanQueryMatcher matcher
```
  - readPt
```
private long readPt
```
- Constructor Detail
  - StoreFileScanner
```
public StoreFileScanner(StoreFile.Reader reader,
                HFileScanner hfs,
                boolean useMVCC,
                boolean hasMVCC,
                long readPt)
```
    Implements a KeyValueScanner on top of the specified HFileScanner
    
    Parameters:
    hfs - HFile scanner
- Method Detail
  - isPrimaryReplica
```
boolean isPrimaryReplica()
```
  - getScannersForStoreFiles
```
public static List<StoreFileScanner> getScannersForStoreFiles(Collection<StoreFile> files,
                                              boolean cacheBlocks,
                                              boolean usePread,
                                              long readPt)
                                                       throws IOException
```
    Return an array of scanners corresponding to the given set of store files.
    
    Throws:
    
    IOException
  - getScannersForStoreFiles
```
public static List<StoreFileScanner> getScannersForStoreFiles(Collection<StoreFile> files,
                                              boolean cacheBlocks,
                                              boolean usePread,
                                              boolean isCompaction,
                                              boolean useDropBehind,
                                              long readPt)
                                                       throws IOException
```
    Return an array of scanners corresponding to the given set of store files.
    
    Throws:
    
    IOException
  - getScannersForStoreFiles
```
public static List<StoreFileScanner> getScannersForStoreFiles(Collection<StoreFile> files,
                                              boolean cacheBlocks,
                                              boolean usePread,
                                              boolean isCompaction,
                                              boolean canUseDrop,
                                              ScanQueryMatcher matcher,
                                              long readPt,
                                              boolean isPrimaryReplica)
                                                       throws IOException
```
    Return an array of scanners corresponding to the given set of store files, And set the ScanQueryMatcher for each store file scanner for further optimization
    
    Throws:
    
    IOException
  - getScannersForStoreFiles
```
public static List<StoreFileScanner> getScannersForStoreFiles(Collection<StoreFile> files,
                                              boolean cacheBlocks,
                                              boolean usePread,
                                              boolean isCompaction,
                                              boolean canUseDrop,
                                              ScanQueryMatcher matcher,
                                              long readPt)
                                                       throws IOException
```
    Throws:
    
    IOException
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - 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 Cell next()
          throws IOException
```
    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
    
    Throws:
    
    IOException
  - 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
  - reseek
```
public boolean reseek(Cell key)
               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:
    key - seek value (should be non-null)
    
    Returns:
    true if scanner has values left, false if end of scanner
    
    Throws:
    
    IOException
  - setCurrentCell
```
protected void setCurrentCell(Cell newVal)
                       throws IOException
```
    Throws:
    
    IOException
  - skipKVsNewerThanReadpoint
```
protected boolean skipKVsNewerThanReadpoint()
                                     throws IOException
```
    Throws:
    
    IOException
  - close
```
public void close()
```
    Description copied from interface: KeyValueScanner
    
    Close the KeyValue scanner.
    
    Specified by:
    
    close in interface KeyValueScanner
  - seekAtOrAfter
```
public static boolean seekAtOrAfter(HFileScanner s,
                    Cell k)
                             throws IOException
```
    Parameters:
    s -
    k -
    
    Returns:
    false if not found or if k is after the end.
    
    Throws:
    
    IOException
  - reseekAtOrAfter
```
static boolean reseekAtOrAfter(HFileScanner s,
                      Cell k)
                        throws IOException
```
    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
  - requestSeek
```
public boolean requestSeek(Cell kv,
                  boolean forward,
                  boolean useBloom)
                    throws IOException
```
    Pretend we have done a seek but don't do it yet, if possible. The hope is that we find requested columns in more recent files and won't have to seek in older files. Creates a fake key/value with the given row/column and the highest (most recent) possible timestamp we might get from this file. When users of such "lazy scanner" need to know the next KV precisely (e.g. when this scanner is at the top of the heap), they run enforceSeek().
    Note that this function does guarantee that the current KV of this scanner will be advanced to at least the given KV. Because of this, it does have to do a real seek in cases when the seek timestamp is older than the highest timestamp of the file, e.g. when we are trying to seek to the next row/column and use OLDEST_TIMESTAMP in the seek key.
    
    Specified by:
    
    requestSeek in interface KeyValueScanner
    
    forward - do a forward-only "reseek" instead of a random-access seek
    useBloom - whether to enable multi-column Bloom filter optimization
    
    Throws:
    
    IOException
  - getReader
```
StoreFile.Reader getReader()
```
  - getComparator
```
KeyValue.KVComparator getComparator()
```
  - realSeekDone
```
public boolean realSeekDone()
```
    Description copied from interface: KeyValueScanner
    
    We optimize our store scanners by checking the most recent store file first, so we sometimes pretend we have done a seek but delay it until the store scanner bubbles up to the top of the key-value heap. This method is then used to ensure the top store file scanner has done a seek operation.
    
    Specified by:
    
    realSeekDone in interface KeyValueScanner
  - enforceSeek
```
public void enforceSeek()
                 throws IOException
```
    Description copied from interface: KeyValueScanner
    
    Does the real seek operation in case it was skipped by seekToRowCol(KeyValue, boolean) (TODO: Whats this?). Note that this function should be never called on scanners that always do real seek operations (i.e. most of the scanners). The easiest way to achieve this is to call KeyValueScanner.realSeekDone() first.
    
    Specified by:
    
    enforceSeek in interface KeyValueScanner
    
    Throws:
    
    IOException
  - setScanQueryMatcher
```
public void setScanQueryMatcher(ScanQueryMatcher matcher)
```
  - isFileScanner
```
public boolean isFileScanner()
```
    Specified by:
    
    isFileScanner in interface KeyValueScanner
    
    Returns:
    true if this is a file scanner. Otherwise a memory scanner is assumed.
  - getSeekCount
```
static final long getSeekCount()
```
  - instrument
```
static final void instrument()
```
  - shouldUseScanner
```
public boolean shouldUseScanner(Scan scan,
                       Store store,
                       long oldestUnexpiredTS)
```
    Description copied from interface: KeyValueScanner
    
    Allows to filter out scanners (both StoreFile and memstore) that we don't want to use based on criteria such as Bloom filters and timestamp ranges.
    
    Specified by:
    
    shouldUseScanner in interface KeyValueScanner
    
    Parameters:
    scan - the scan that we are selecting scanners for
    store - the store we are performing the scan on.
    oldestUnexpiredTS - the oldest timestamp we are interested in for this query, based on TTL
    
    Returns:
    true if the scanner should be included in the query
  - seekToPreviousRow
```
public boolean seekToPreviousRow(Cell originalKey)
                          throws IOException
```
    Description copied from interface: KeyValueScanner
    
    Seek the scanner at the first Cell of the row which is the previous row of specified key
    
    Specified by:
    
    seekToPreviousRow in interface KeyValueScanner
    
    Parameters:
    originalKey - seek value
    
    Returns:
    true if the scanner at the first valid Cell of previous row, false if not existing such Cell
    
    Throws:
    
    IOException
  - seekToLastRow
```
public boolean seekToLastRow()
                      throws IOException
```
    Description copied from interface: KeyValueScanner
    
    Seek the scanner at the first KeyValue of last row
    
    Specified by:
    
    seekToLastRow in interface KeyValueScanner
    
    Returns:
    true if scanner has values left, false if the underlying data is empty
    
    Throws:
    
    IOException
  - backwardSeek
```
public boolean backwardSeek(Cell key)
                     throws IOException
```
    Description copied from interface: KeyValueScanner
    
    Seek the scanner at or before the row of specified Cell, it firstly tries to seek the scanner at or after the specified Cell, return if peek KeyValue of scanner has the same row with specified Cell, otherwise seek the scanner at the first Cell of the row which is the previous row of specified KeyValue
    
    Specified by:
    
    backwardSeek in interface KeyValueScanner
    
    Parameters:
    key - seek KeyValue
    
    Returns:
    true if the scanner is at the valid KeyValue, false if such KeyValue does not exist
    
    Throws:
    
    IOException
  - getNextIndexedKey
```
public Cell getNextIndexedKey()
```
    Specified by:
    
    getNextIndexedKey in interface KeyValueScanner
    
    Returns:
    the next key in the index (the key to seek to the next block) if known, or null otherwise

Class StoreFileScanner

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

reader

hfs

cur

closed

realSeekDone

delayedReseek

delayedSeekKV

enforceMVCC

hasMVCCInfo

stopSkippingKVsIfNextRow

seekCount

matcher

readPt

Constructor Detail

StoreFileScanner

Method Detail

isPrimaryReplica

getScannersForStoreFiles

getScannersForStoreFiles

getScannersForStoreFiles

getScannersForStoreFiles

toString

peek

next

seek

reseek

setCurrentCell

skipKVsNewerThanReadpoint

close

seekAtOrAfter

reseekAtOrAfter

getSequenceID

requestSeek

getReader

getComparator

realSeekDone

enforceSeek

setScanQueryMatcher

isFileScanner

getSeekCount

instrument

shouldUseScanner

seekToPreviousRow

seekToLastRow

backwardSeek

getNextIndexedKey