ExplicitColumnTracker (Apache HBase 1.2.12 API)

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

All Implemented Interfaces:

ColumnTracker
```
@InterfaceAudience.Private
public class ExplicitColumnTracker
extends Object
implements ColumnTracker
```
This class is used for the tracking and enforcement of columns and numbers of versions during the course of a Get or Scan operation, when explicit column qualifiers have been asked for in the query. With a little magic (see ScanQueryMatcher), we can use this matcher for both scans and gets. The main difference is 'next' and 'done' collapse for the scan case (since we see all columns in order), and we only reset between rows.
This class is utilized by ScanQueryMatcher mainly through two methods:
- checkColumn(byte[], int, int, byte) is called when a Put satisfies all other conditions of the query.
- getNextRowOrNextColumn(byte[], int, int) is called whenever ScanQueryMatcher believes that the current column should be skipped (by timestamp, filter etc.)
These two methods returns a ScanQueryMatcher.MatchCode to define what action should be taken.
This class is NOT thread-safe as queries are never multi-threaded

Field Summary

Fields
Modifier and Type	Field and Description
`private ColumnCount`	`column`
`private ColumnCount[]`	`columns` Contains the list of columns that the ExplicitColumnTracker is tracking.
`private int`	`index`
`private long`	`latestTSOfCurrentColumn` Keeps track of the latest timestamp included for current column.
`private int`	`maxVersions`
`private int`	`minVersions`
`private long`	`oldestStamp`

Constructor Summary

Constructors
Constructor and Description
`ExplicitColumnTracker(NavigableSet<byte[]> columns, int minVersions, int maxVersions, long oldestUnexpiredTS)` Default constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`ScanQueryMatcher.MatchCode`	`checkColumn(byte[] bytes, int offset, int length, byte type)` Checks if the column is present in the list of requested columns by returning the match code instance.
`ScanQueryMatcher.MatchCode`	`checkVersions(byte[] bytes, int offset, int length, long timestamp, byte type, boolean ignoreCount)` Keeps track of the number of versions for the columns asked for.
`boolean`	`done()` Done when there are no more columns to match against.
`void`	`doneWithColumn(byte[] bytes, int offset, int length)` This method is used to inform the column tracker that we are done with this column.
`ColumnCount`	`getColumnHint()` Used by matcher and scan/get to get a hint of the next column to seek to after checkColumn() returns SKIP.
`ScanQueryMatcher.MatchCode`	`getNextRowOrNextColumn(byte[] bytes, int offset, int qualLength)` Retrieve the MatchCode for the next row or column
`boolean`	`isDone(long timestamp)` Give the tracker a chance to declare it's done based on only the timestamp to allow an early out.
`private boolean`	`isExpired(long timestamp)`
`void`	`reset()` Resets the Matcher
`private void`	`resetTS()`
`private boolean`	`sameAsPreviousTS(long timestamp)`
`private void`	`setTS(long timestamp)`

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

- Field Detail
  - maxVersions
```
private final int maxVersions
```
  - minVersions
```
private final int minVersions
```
  - columns
```
private final ColumnCount[] columns
```
    Contains the list of columns that the ExplicitColumnTracker is tracking. Each ColumnCount instance also tracks how many versions of the requested column have been returned.
  - index
```
private int index
```
  - column
```
private ColumnCount column
```
  - latestTSOfCurrentColumn
```
private long latestTSOfCurrentColumn
```
    Keeps track of the latest timestamp included for current column. Used to eliminate duplicates.
  - oldestStamp
```
private long oldestStamp
```
- Constructor Detail
  - ExplicitColumnTracker
```
public ExplicitColumnTracker(NavigableSet<byte[]> columns,
                     int minVersions,
                     int maxVersions,
                     long oldestUnexpiredTS)
```
    Default constructor.
    
    Parameters:
    columns - columns specified user in query
    minVersions - minimum number of versions to keep
    maxVersions - maximum versions to return per column
    oldestUnexpiredTS - the oldest timestamp we are interested in, based on TTL
- Method Detail
  - done
```
public boolean done()
```
    Done when there are no more columns to match against.
    
    Specified by:
    
    done in interface ColumnTracker
    
    Returns:
    true when done.
  - getColumnHint
```
public ColumnCount getColumnHint()
```
    Description copied from interface: ColumnTracker
    
    Used by matcher and scan/get to get a hint of the next column to seek to after checkColumn() returns SKIP. Returns the next interesting column we want, or NULL there is none (wildcard scanner). Implementations aren't required to return anything useful unless the most recent call was to checkColumn() and the return code was SKIP. This is pretty implementation detail-y, but optimizations are like that.
    
    Specified by:
    
    getColumnHint in interface ColumnTracker
    
    Returns:
    null, or a ColumnCount that we should seek to
  - checkColumn
```
public ScanQueryMatcher.MatchCode checkColumn(byte[] bytes,
                                     int offset,
                                     int length,
                                     byte type)
```
    Checks if the column is present in the list of requested columns by returning the match code instance. It does not check against the number of versions for the columns asked for. To do the version check, one has to call ColumnTracker.checkVersions(byte[], int, int, long, byte, boolean) method based on the return type (INCLUDE) of this method. The values that can be returned by this method are ScanQueryMatcher.MatchCode.INCLUDE, ScanQueryMatcher.MatchCode.SEEK_NEXT_COL and ScanQueryMatcher.MatchCode.SEEK_NEXT_ROW.
    
    Specified by:
    
    checkColumn in interface ColumnTracker
    
    type - The type of the KeyValue
    
    Returns:
    The match code instance.
  - checkVersions
```
public ScanQueryMatcher.MatchCode checkVersions(byte[] bytes,
                                       int offset,
                                       int length,
                                       long timestamp,
                                       byte type,
                                       boolean ignoreCount)
                                         throws IOException
```
    Description copied from interface: ColumnTracker
    
    Keeps track of the number of versions for the columns asked for. It assumes that the user has already checked if the keyvalue needs to be included by calling the ColumnTracker.checkColumn(byte[], int, int, byte) method. The enum values returned by this method are ScanQueryMatcher.MatchCode.SKIP, ScanQueryMatcher.MatchCode.INCLUDE, ScanQueryMatcher.MatchCode.INCLUDE_AND_SEEK_NEXT_COL and ScanQueryMatcher.MatchCode.INCLUDE_AND_SEEK_NEXT_ROW. Implementations which include all the columns could just return ScanQueryMatcher.MatchCode.INCLUDE in the ColumnTracker.checkColumn(byte[], int, int, byte) method and perform all the operations in this checkVersions method.
    
    Specified by:
    
    checkVersions in interface ColumnTracker
    
    timestamp - The timeToLive to enforce.
    type - the type of the key value (Put/Delete)
    ignoreCount - indicates if the KV needs to be excluded while counting (used during compactions. We only count KV's that are older than all the scanners' read points.)
    
    Returns:
    the scan query matcher match code instance
    
    Throws:
    
    IOException - in case there is an internal consistency problem caused by a data corruption.
  - reset
```
public void reset()
```
    Description copied from interface: ColumnTracker
    
    Resets the Matcher
    
    Specified by:
    
    reset in interface ColumnTracker
  - resetTS
```
private void resetTS()
```
  - setTS
```
private void setTS(long timestamp)
```
  - sameAsPreviousTS
```
private boolean sameAsPreviousTS(long timestamp)
```
  - isExpired
```
private boolean isExpired(long timestamp)
```
  - doneWithColumn
```
public void doneWithColumn(byte[] bytes,
                  int offset,
                  int length)
```
    This method is used to inform the column tracker that we are done with this column. We may get this information from external filters or timestamp range and we then need to indicate this information to tracker. It is required only in case of ExplicitColumnTracker.
    
    Parameters:
    bytes -
    offset -
    length -
  - getNextRowOrNextColumn
```
public ScanQueryMatcher.MatchCode getNextRowOrNextColumn(byte[] bytes,
                                                int offset,
                                                int qualLength)
```
    Description copied from interface: ColumnTracker
    
    Retrieve the MatchCode for the next row or column
    
    Specified by:
    
    getNextRowOrNextColumn in interface ColumnTracker
  - isDone
```
public boolean isDone(long timestamp)
```
    Description copied from interface: ColumnTracker
    
    Give the tracker a chance to declare it's done based on only the timestamp to allow an early out.
    
    Specified by:
    
    isDone in interface ColumnTracker
    
    Returns:
    true to early out based on timestamp.

Class ExplicitColumnTracker

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

maxVersions

minVersions

columns

index

column

latestTSOfCurrentColumn

oldestStamp

Constructor Detail

ExplicitColumnTracker

Method Detail

done

getColumnHint

checkColumn

checkVersions

reset

resetTS

setTS

sameAsPreviousTS

isExpired

doneWithColumn

getNextRowOrNextColumn

isDone