org.apache.hadoop.hbase.coprocessor

Interface RegionObserver

All Superinterfaces:

Coprocessor

All Known Implementing Classes:

AccessController, ConstraintProcessor, ReplicationObserver, VisibilityController, WriteSinkCoprocessor

@InterfaceAudience.LimitedPrivate(value="Coprocesssor")
 @InterfaceStability.Evolving
public interface RegionObserver
extends Coprocessor

Coprocessors implement this interface to observe and mediate client actions on the region.

Since most implementations will be interested in only a subset of hooks, this class uses 'default' functions to avoid having to add unnecessary overrides. When the functions are non-empty, it's simply to satisfy the compiler by returning value of expected (non-void) type. It is done in a way that these default definitions act as no-op. So our suggestion to implementation would be to not call these 'default' methods from overrides.

Exception Handling

For all functions, exception handling is done as follows:

• Exceptions of type IOException are reported back to client.
• For any other kind of exception:
  • If the configuration CoprocessorHost.ABORT_ON_ERROR_KEY is set to true, then the server aborts.
  • Otherwise, coprocessor is removed from the server and DoNotRetryIOException is returned to the client.

For Split Related Hooks

In hbase2/AMv2, master runs splits, so the split related hooks are moved to MasterObserver.

Increment Column Value

We do not call this hook anymore.

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	RegionObserver.MutationType Mutation type for postMutationBeforeWAL hook

Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.Coprocessor

Coprocessor.State

Field Summary

Fields inherited from interface org.apache.hadoop.hbase.Coprocessor

PRIORITY_HIGHEST, PRIORITY_LOWEST, PRIORITY_SYSTEM, PRIORITY_USER, VERSION

Method Summary

Modifier and Type	Method and Description
default Result	postAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append, Result result) Called after Append
default void	postBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp) This will be called after applying a batch of Mutations on a region.
default void	postBatchMutateIndispensably(ObserverContext<RegionCoprocessorEnvironment> ctx, MiniBatchOperationInProgress<Mutation> miniBatchOp, boolean success) Called after the completion of batch put/delete and will be called even if the batch operation fails.
default boolean	postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> stagingFamilyPaths, Map<byte[],List<org.apache.hadoop.fs.Path>> finalPaths, boolean hasLoaded) Called after bulkLoadHFile.
default boolean	postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete, boolean result) Called after checkAndDelete
default boolean	postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put, boolean result) Called after checkAndPut
default void	postClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested) Called after the region is reported as closed to the master.
default void	postCloseRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx, Region.Operation operation) Called after releasing read lock in Region.closeRegionOperation().
default void	postCommitStoreFile(ObserverContext<RegionCoprocessorEnvironment> ctx, byte[] family, org.apache.hadoop.fs.Path srcPath, org.apache.hadoop.fs.Path dstPath) Called after moving bulk loaded hfile to region directory.
default void	postCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile, CompactionLifeCycleTracker tracker) Called after compaction has completed and the new store file has been moved in to place.
default void	postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, org.apache.hadoop.hbase.shaded.com.google.common.collect.ImmutableList<StoreFile> selected, CompactionLifeCycleTracker tracker) Called after the StoreFiles to compact have been selected from the available candidates.
default void	postDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability) Called after the client deletes a value.
default boolean	postExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists) Called after the client tests for existence using a Get.
default void	postFlush(ObserverContext<RegionCoprocessorEnvironment> c) Called after the memstore is flushed to disk.
default void	postFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile) Called after a Store's memstore is flushed to disk.
default void	postGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result) Called after the client performs a Get
default Result	postIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment, Result result) Called after increment
default DeleteTracker	postInstantiateDeleteTracker(ObserverContext<RegionCoprocessorEnvironment> ctx, DeleteTracker delTracker) Called after the ScanQueryMatcher creates ScanDeleteTracker.
default void	postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c) Called after the log replay on the region is over.
default Cell	postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, RegionObserver.MutationType opType, Mutation mutation, Cell oldCell, Cell newCell) Called after a new cell has been created during an increment operation, but before it is committed to the WAL or memstore.
default void	postOpen(ObserverContext<RegionCoprocessorEnvironment> c) Called after the region is reported as open to the master.
default void	postPut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability) Called after the client stores a value.
default void	postReplayWALs(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, HRegionInfo info, org.apache.hadoop.fs.Path edits) Called after replaying WALs for this region.
default void	postScannerClose(ObserverContext<RegionCoprocessorEnvironment> ctx, InternalScanner s) Called after the client closes a scanner.
default boolean	postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, Cell curRowCell, boolean hasMore) This will be called by the scan flow when the current scanned row is being filtered out by the filter.
default boolean	postScannerNext(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, List<Result> result, int limit, boolean hasNext) Called after the client asks for the next row on a scanner.
default RegionScanner	postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s) Called after the client opens a new scanner.
default void	postStartRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx, Region.Operation operation) This will be called for region operations where read lock is acquired in Region.startRegionOperation().
default StoreFileReader	postStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path p, FSDataInputStreamWrapper in, long size, CacheConfig cacheConf, Reference r, StoreFileReader reader) Deprecated. For Phoenix only, StoreFileReader is not a stable interface.
default void	postWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, HRegionInfo info, WALKey logKey, WALEdit logEdit) Called after a WALEdit replayed for this region.
default Result	preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append) Called before Append.
default Result	preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Append append) Called before Append but after acquiring rowlock.
default void	preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp) This will be called for every batch mutation operation happening at the server.
default void	preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> familyPaths) Called before bulkLoadHFile.
default boolean	preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete, boolean result) Called before checkAndDelete.
default boolean	preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete, boolean result) Called before checkAndDelete but after acquiring rowock.
default boolean	preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put, boolean result) Called before checkAndPut.
default boolean	preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put, boolean result) Called before checkAndPut but after acquiring rowlock.
default void	preClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested) Called before the region is reported as closed to the master.
default void	preCommitStoreFile(ObserverContext<RegionCoprocessorEnvironment> ctx, byte[] family, List<Pair<org.apache.hadoop.fs.Path,org.apache.hadoop.fs.Path>> pairs) Called before moving bulk loaded hfile to region directory.
default InternalScanner	preCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner, ScanType scanType, CompactionLifeCycleTracker tracker) Called prior to writing the StoreFiles selected for compaction into a new StoreFile.
default InternalScanner	preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s, CompactionLifeCycleTracker tracker, long readPoint) Called prior to writing the StoreFiles selected for compaction into a new StoreFile and prior to creating the scanner used to read the input files.
default void	preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<StoreFile> candidates, CompactionLifeCycleTracker tracker) Called prior to selecting the StoreFiles to compact from the list of available candidates.
default void	preDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability) Called before the client deletes a value.
default boolean	preExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists) Called before the client tests for existence using a Get.
default void	preFlush(ObserverContext<RegionCoprocessorEnvironment> c) Called before the memstore is flushed to disk.
default InternalScanner	preFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner) Called before a Store's memstore is flushed to disk.
default InternalScanner	preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<KeyValueScanner> scanners, InternalScanner s, long readPoint) Called before a memstore is flushed to disk and prior to creating the scanner to read from the memstore.
default void	preGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result) Called before the client performs a Get
default Result	preIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment) Called before Increment.
default Result	preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment) Called before Increment but after acquiring rowlock.
default void	preOpen(ObserverContext<RegionCoprocessorEnvironment> c) Called before the region is reported as open to the master.
default void	prePrepareTimeStampForDeleteVersion(ObserverContext<RegionCoprocessorEnvironment> c, Mutation mutation, Cell cell, byte[] byteNow, Get get) Called before the server updates the timestamp for version delete with latest timestamp.
default void	prePut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability) Called before the client stores a value.
default void	preReplayWALs(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, HRegionInfo info, org.apache.hadoop.fs.Path edits) Called before replaying WALs for this region.
default void	preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s) Called before the client closes a scanner.
default boolean	preScannerNext(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, List<Result> result, int limit, boolean hasNext) Called before the client asks for the next row on a scanner.
default RegionScanner	preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s) Called before the client opens a new scanner.
default StoreFileReader	preStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path p, FSDataInputStreamWrapper in, long size, CacheConfig cacheConf, Reference r, StoreFileReader reader) Deprecated. For Phoenix only, StoreFileReader is not a stable interface.
default KeyValueScanner	preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, Scan scan, NavigableSet<byte[]> targetCols, KeyValueScanner s, long readPt) Called before a store opens a new scanner.
default void	preWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, HRegionInfo info, WALKey logKey, WALEdit logEdit) Called before a WALEdit replayed for this region.

Methods inherited from interface org.apache.hadoop.hbase.Coprocessor

start, stop

Method Detail

preOpen

default void preOpen(ObserverContext<RegionCoprocessorEnvironment> c)
              throws IOException

Called before the region is reported as open to the master.

Parameters:

c - the environment provided by the region server

Throws:

IOException

postOpen

default void postOpen(ObserverContext<RegionCoprocessorEnvironment> c)

Called after the region is reported as open to the master.

Parameters:

c - the environment provided by the region server

postLogReplay

default void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c)

Called after the log replay on the region is over.

Parameters:

c - the environment provided by the region server

preFlushScannerOpen

default InternalScanner preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                            Store store,
                                            List<KeyValueScanner> scanners,
                                            InternalScanner s,
                                            long readPoint)
                                     throws IOException

Called before a memstore is flushed to disk and prior to creating the scanner to read from the memstore. To override or modify how a memstore is flushed, implementing classes can return a new scanner to provide the KeyValues to be stored into the new StoreFile or null to perform the default processing. Calling ObserverContext.bypass() has no effect in this hook.

Parameters:

c - the environment provided by the region server

store - the store being flushed

scanners - the scanners for the memstore that is flushed

s - the base scanner, if not null, from previous RegionObserver in the chain

readPoint - the readpoint to create scanner

Returns:

the scanner to use during the flush. null if the default implementation is to be used.

Throws:

IOException

preFlush

default void preFlush(ObserverContext<RegionCoprocessorEnvironment> c)
               throws IOException

Called before the memstore is flushed to disk.

Parameters:

c - the environment provided by the region server

Throws:

IOException

preFlush

default InternalScanner preFlush(ObserverContext<RegionCoprocessorEnvironment> c,
                                 Store store,
                                 InternalScanner scanner)
                          throws IOException

Called before a Store's memstore is flushed to disk.

Parameters:

c - the environment provided by the region server

store - the store where compaction is being requested

scanner - the scanner over existing data used in the store file

Returns:

the scanner to use during compaction. Should not be null unless the implementation is writing new store files on its own.

Throws:

IOException

postFlush

default void postFlush(ObserverContext<RegionCoprocessorEnvironment> c)
                throws IOException

Called after the memstore is flushed to disk.

Parameters:

c - the environment provided by the region server

Throws:

IOException - if an error occurred on the coprocessor

postFlush

default void postFlush(ObserverContext<RegionCoprocessorEnvironment> c,
                       Store store,
                       StoreFile resultFile)
                throws IOException

Called after a Store's memstore is flushed to disk.

Parameters:

c - the environment provided by the region server

store - the store being flushed

resultFile - the new store file written out during compaction

Throws:

IOException

preCompactSelection

default void preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
                                 Store store,
                                 List<StoreFile> candidates,
                                 CompactionLifeCycleTracker tracker)
                          throws IOException

Called prior to selecting the StoreFiles to compact from the list of available candidates. To alter the files used for compaction, you may mutate the passed in list of candidates.

Parameters:

c - the environment provided by the region server

store - the store where compaction is being requested

candidates - the store files currently available for compaction

tracker - tracker used to track the life cycle of a compaction

Throws:

IOException

postCompactSelection

default void postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
                                  Store store,
                                  org.apache.hadoop.hbase.shaded.com.google.common.collect.ImmutableList<StoreFile> selected,
                                  CompactionLifeCycleTracker tracker)

Called after the StoreFiles to compact have been selected from the available candidates.

Parameters:

c - the environment provided by the region server

store - the store being compacted

selected - the store files selected to compact

tracker - tracker used to track the life cycle of a compaction

preCompact

default InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                                   Store store,
                                   InternalScanner scanner,
                                   ScanType scanType,
                                   CompactionLifeCycleTracker tracker)
                            throws IOException

Called prior to writing the StoreFiles selected for compaction into a new StoreFile. To override or modify the compaction process, implementing classes have two options:

• Wrap the provided InternalScanner with a custom implementation that is returned from this method. The custom scanner can then inspect KeyValues from the wrapped scanner, applying its own policy to what gets written.
• Call ObserverContext.bypass() and provide a custom implementation for writing of new StoreFiles. Note: any implementations bypassing core compaction using this approach must write out new store files themselves or the existing data will no longer be available after compaction.

Parameters:

c - the environment provided by the region server

store - the store being compacted

scanner - the scanner over existing data used in the store file rewriting

scanType - type of Scan

tracker - tracker used to track the life cycle of a compaction

Returns:

the scanner to use during compaction. Should not be null unless the implementation is writing new store files on its own.

Throws:

IOException

preCompactScannerOpen

default InternalScanner preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                              Store store,
                                              List<? extends KeyValueScanner> scanners,
                                              ScanType scanType,
                                              long earliestPutTs,
                                              InternalScanner s,
                                              CompactionLifeCycleTracker tracker,
                                              long readPoint)
                                       throws IOException

Called prior to writing the StoreFiles selected for compaction into a new StoreFile and prior to creating the scanner used to read the input files. To override or modify the compaction process, implementing classes can return a new scanner to provide the KeyValues to be stored into the new StoreFile or null to perform the default processing. Calling ObserverContext.bypass() has no effect in this hook.

Parameters:

c - the environment provided by the region server

store - the store being compacted

scanners - the list of store file scanners to be read from

scanType - the ScanType indicating whether this is a major or minor compaction

earliestPutTs - timestamp of the earliest put that was found in any of the involved store files

s - the base scanner, if not null, from previous RegionObserver in the chain

tracker - used to track the life cycle of a compaction

readPoint - the readpoint to create scanner

Returns:

the scanner to use during compaction. null if the default implementation is to be used.

Throws:

IOException

postCompact

default void postCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                         Store store,
                         StoreFile resultFile,
                         CompactionLifeCycleTracker tracker)
                  throws IOException

Called after compaction has completed and the new store file has been moved in to place.

Parameters:

c - the environment provided by the region server

store - the store being compacted

resultFile - the new store file written out during compaction

tracker - used to track the life cycle of a compaction

Throws:

IOException

preClose

default void preClose(ObserverContext<RegionCoprocessorEnvironment> c,
                      boolean abortRequested)
               throws IOException

Called before the region is reported as closed to the master.

Parameters:

c - the environment provided by the region server

abortRequested - true if the region server is aborting

Throws:

IOException

postClose

default void postClose(ObserverContext<RegionCoprocessorEnvironment> c,
                       boolean abortRequested)

Called after the region is reported as closed to the master.

Parameters:

c - the environment provided by the region server

abortRequested - true if the region server is aborting

preGetOp

default void preGetOp(ObserverContext<RegionCoprocessorEnvironment> c,
                      Get get,
                      List<Cell> result)
               throws IOException

Called before the client performs a Get

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

get - the Get request

result - The result to return to the client if default processing is bypassed. Can be modified. Will not be used if default processing is not bypassed.

Throws:

IOException

postGetOp

default void postGetOp(ObserverContext<RegionCoprocessorEnvironment> c,
                       Get get,
                       List<Cell> result)
                throws IOException

Called after the client performs a Get

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'result' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

get - the Get request

result - the result to return to the client, modify as necessary

Throws:

IOException

preExists

default boolean preExists(ObserverContext<RegionCoprocessorEnvironment> c,
                          Get get,
                          boolean exists)
                   throws IOException

Called before the client tests for existence using a Get.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

get - the Get request

exists -

Returns:

the value to return to the client if bypassing default processing

Throws:

IOException

postExists

default boolean postExists(ObserverContext<RegionCoprocessorEnvironment> c,
                           Get get,
                           boolean exists)
                    throws IOException

Called after the client tests for existence using a Get.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

get - the Get request

exists - the result returned by the region server

Returns:

the result to return to the client

Throws:

IOException

prePut

default void prePut(ObserverContext<RegionCoprocessorEnvironment> c,
                    Put put,
                    WALEdit edit,
                    Durability durability)
             throws IOException

Called before the client stores a value.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

put - The Put object

edit - The WALEdit object that will be written to the wal

durability - Persistence guarantee for this Put

Throws:

IOException

postPut

default void postPut(ObserverContext<RegionCoprocessorEnvironment> c,
                     Put put,
                     WALEdit edit,
                     Durability durability)
              throws IOException

Called after the client stores a value.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

put - The Put object

edit - The WALEdit object for the wal

durability - Persistence guarantee for this Put

Throws:

IOException

preDelete

default void preDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                       Delete delete,
                       WALEdit edit,
                       Durability durability)
                throws IOException

Called before the client deletes a value.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

delete - The Delete object

edit - The WALEdit object for the wal

durability - Persistence guarantee for this Delete

Throws:

IOException

prePrepareTimeStampForDeleteVersion

default void prePrepareTimeStampForDeleteVersion(ObserverContext<RegionCoprocessorEnvironment> c,
                                                 Mutation mutation,
                                                 Cell cell,
                                                 byte[] byteNow,
                                                 Get get)
                                          throws IOException

Called before the server updates the timestamp for version delete with latest timestamp.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

mutation - - the parent mutation associated with this delete cell

cell - - The deleteColumn with latest version cell

byteNow - - timestamp bytes

get - - the get formed using the current cell's row. Note that the get does not specify the family and qualifier

Throws:

IOException

postDelete

default void postDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                        Delete delete,
                        WALEdit edit,
                        Durability durability)
                 throws IOException

Called after the client deletes a value.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

delete - The Delete object

edit - The WALEdit object for the wal

durability - Persistence guarantee for this Delete

Throws:

IOException

preBatchMutate

default void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
                            MiniBatchOperationInProgress<Mutation> miniBatchOp)
                     throws IOException

This will be called for every batch mutation operation happening at the server. This will be called after acquiring the locks on the mutating rows and after applying the proper timestamp for each Mutation at the server. The batch may contain Put/Delete. By setting OperationStatus of Mutations (MiniBatchOperationInProgress.setOperationStatus(int, OperationStatus)), RegionObserver can make Region to skip these Mutations.

Note: Do not retain references to any Cells in Mutations beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

miniBatchOp - batch of Mutations getting applied to region.

Throws:

IOException

postBatchMutate

default void postBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
                             MiniBatchOperationInProgress<Mutation> miniBatchOp)
                      throws IOException

This will be called after applying a batch of Mutations on a region. The Mutations are added to memstore and WAL. The difference of this one with postPut(ObserverContext, Put, WALEdit, Durability) and postDelete(ObserverContext, Delete, WALEdit, Durability) is this hook will be executed before the mvcc transaction completion.

Note: Do not retain references to any Cells in Mutations beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

miniBatchOp - batch of Mutations applied to region.

Throws:

IOException

postStartRegionOperation

default void postStartRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                      Region.Operation operation)
                               throws IOException

This will be called for region operations where read lock is acquired in Region.startRegionOperation().

Parameters:

ctx -

operation - The operation is about to be taken on the region

Throws:

IOException

postCloseRegionOperation

default void postCloseRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                      Region.Operation operation)
                               throws IOException

Called after releasing read lock in Region.closeRegionOperation().

Parameters:

ctx -

operation -

Throws:

IOException

postBatchMutateIndispensably

default void postBatchMutateIndispensably(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                          MiniBatchOperationInProgress<Mutation> miniBatchOp,
                                          boolean success)
                                   throws IOException

Called after the completion of batch put/delete and will be called even if the batch operation fails.

Note: Do not retain references to any Cells in Mutations beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

ctx -

miniBatchOp -

success - true if batch operation is successful otherwise false.

Throws:

IOException

preCheckAndPut

default boolean preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                               byte[] row,
                               byte[] family,
                               byte[] qualifier,
                               CompareOperator op,
                               ByteArrayComparable comparator,
                               Put put,
                               boolean result)
                        throws IOException

Called before checkAndPut.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

op - the comparison operation

comparator - the comparator

put - data to put if check succeeds

result -

Returns:

the return value to return to client if bypassing default processing

Throws:

IOException

preCheckAndPutAfterRowLock

default boolean preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                           byte[] row,
                                           byte[] family,
                                           byte[] qualifier,
                                           CompareOperator op,
                                           ByteArrayComparable comparator,
                                           Put put,
                                           boolean result)
                                    throws IOException

Called before checkAndPut but after acquiring rowlock.

Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

op - the comparison operation

comparator - the comparator

put - data to put if check succeeds

result -

Returns:

the return value to return to client if bypassing default processing

Throws:

IOException

postCheckAndPut

default boolean postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                                byte[] row,
                                byte[] family,
                                byte[] qualifier,
                                CompareOperator op,
                                ByteArrayComparable comparator,
                                Put put,
                                boolean result)
                         throws IOException

Called after checkAndPut

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

op - the comparison operation

comparator - the comparator

put - data to put if check succeeds

result - from the checkAndPut

Returns:

the possibly transformed return value to return to client

Throws:

IOException

preCheckAndDelete

default boolean preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                                  byte[] row,
                                  byte[] family,
                                  byte[] qualifier,
                                  CompareOperator op,
                                  ByteArrayComparable comparator,
                                  Delete delete,
                                  boolean result)
                           throws IOException

Called before checkAndDelete.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

op - the comparison operation

comparator - the comparator

delete - delete to commit if check succeeds

result -

Returns:

the value to return to client if bypassing default processing

Throws:

IOException

preCheckAndDeleteAfterRowLock

default boolean preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                              byte[] row,
                                              byte[] family,
                                              byte[] qualifier,
                                              CompareOperator op,
                                              ByteArrayComparable comparator,
                                              Delete delete,
                                              boolean result)
                                       throws IOException

Called before checkAndDelete but after acquiring rowock.

Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

op - the comparison operation

comparator - the comparator

delete - delete to commit if check succeeds

result -

Returns:

the value to return to client if bypassing default processing

Throws:

IOException

postCheckAndDelete

default boolean postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                                   byte[] row,
                                   byte[] family,
                                   byte[] qualifier,
                                   CompareOperator op,
                                   ByteArrayComparable comparator,
                                   Delete delete,
                                   boolean result)
                            throws IOException

Called after checkAndDelete

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

op - the comparison operation

comparator - the comparator

delete - delete to commit if check succeeds

result - from the CheckAndDelete

Returns:

the possibly transformed returned value to return to client

Throws:

IOException

preAppend

default Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                         Append append)
                  throws IOException

Called before Append.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'append' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

append - Append object

Returns:

result to return to the client if bypassing default processing

Throws:

IOException

preAppendAfterRowLock

default Result preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                     Append append)
                              throws IOException

Called before Append but after acquiring rowlock.

Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'append' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

append - Append object

Returns:

result to return to the client if bypassing default processing

Throws:

IOException

postAppend

default Result postAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                          Append append,
                          Result result)
                   throws IOException

Called after Append

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'append' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

append - Append object

result - the result returned by increment

Returns:

the result to return to the client

Throws:

IOException

preIncrement

default Result preIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                            Increment increment)
                     throws IOException

Called before Increment.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'increment' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

increment - increment object

Returns:

result to return to the client if bypassing default processing

Throws:

IOException

preIncrementAfterRowLock

default Result preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                        Increment increment)
                                 throws IOException

Called before Increment but after acquiring rowlock.

Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'increment' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

increment - increment object

Returns:

result to return to the client if bypassing default processing if an error occurred on the coprocessor

Throws:

IOException

postIncrement

default Result postIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                             Increment increment,
                             Result result)
                      throws IOException

Called after increment

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells in 'increment' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

increment - increment object

result - the result returned by increment

Returns:

the result to return to the client

Throws:

IOException

preScannerOpen

default RegionScanner preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                     Scan scan,
                                     RegionScanner s)
                              throws IOException

Called before the client opens a new scanner.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

scan - the Scan specification

s - if not null, the base scanner

Returns:

an RegionScanner instance to use instead of the base scanner if overriding default behavior, null otherwise

Throws:

IOException

preStoreScannerOpen

default KeyValueScanner preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                            Store store,
                                            Scan scan,
                                            NavigableSet<byte[]> targetCols,
                                            KeyValueScanner s,
                                            long readPt)
                                     throws IOException

Called before a store opens a new scanner. This hook is called when a "user" scanner is opened.

See preFlushScannerOpen(ObserverContext, Store, List, InternalScanner, long) and preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner, CompactionLifeCycleTracker, long) to override scanners created for flushes or compactions, resp.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors. Calling ObserverContext.bypass() has no effect in this hook.

Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

store - the store being scanned

scan - the Scan specification

targetCols - columns to be used in the scanner

s - the base scanner, if not null, from previous RegionObserver in the chain

readPt - the read point

Returns:

a KeyValueScanner instance to use or null to use the default implementation

Throws:

IOException

postScannerOpen

default RegionScanner postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                      Scan scan,
                                      RegionScanner s)
                               throws IOException

Called after the client opens a new scanner.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

scan - the Scan specification

s - if not null, the base scanner

Returns:

the scanner instance to use

Throws:

IOException

preScannerNext

default boolean preScannerNext(ObserverContext<RegionCoprocessorEnvironment> c,
                               InternalScanner s,
                               List<Result> result,
                               int limit,
                               boolean hasNext)
                        throws IOException

Called before the client asks for the next row on a scanner.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

s - the scanner

result - The result to return to the client if default processing is bypassed. Can be modified. Will not be returned if default processing is not bypassed.

limit - the maximum number of results to return

hasNext - the 'has more' indication

Returns:

'has more' indication that should be sent to client

Throws:

IOException

postScannerNext

default boolean postScannerNext(ObserverContext<RegionCoprocessorEnvironment> c,
                                InternalScanner s,
                                List<Result> result,
                                int limit,
                                boolean hasNext)
                         throws IOException

Called after the client asks for the next row on a scanner.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

s - the scanner

result - the result to return to the client, can be modified

limit - the maximum number of results to return

hasNext - the 'has more' indication

Returns:

'has more' indication that should be sent to client

Throws:

IOException

postScannerFilterRow

default boolean postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> c,
                                     InternalScanner s,
                                     Cell curRowCell,
                                     boolean hasMore)
                              throws IOException

This will be called by the scan flow when the current scanned row is being filtered out by the filter. The filter may be filtering out the row via any of the below scenarios

1. boolean filterRowKey(byte [] buffer, int offset, int length) returning true
2. boolean filterRow() returning true
3. default void filterRow(List<KeyValue> kvs) removing all the kvs from the passed List

Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.

Parameters:

c - the environment provided by the region server

s - the scanner

curRowCell - The cell in the current row which got filtered out

hasMore - the 'has more' indication

Returns:

whether more rows are available for the scanner or not

Throws:

IOException

preScannerClose

default void preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c,
                             InternalScanner s)
                      throws IOException

Called before the client closes a scanner.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

s - the scanner

Throws:

IOException

postScannerClose

default void postScannerClose(ObserverContext<RegionCoprocessorEnvironment> ctx,
                              InternalScanner s)
                       throws IOException

Called after the client closes a scanner.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

ctx - the environment provided by the region server

s - the scanner

Throws:

IOException

preReplayWALs

default void preReplayWALs(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
                           HRegionInfo info,
                           org.apache.hadoop.fs.Path edits)
                    throws IOException

Called before replaying WALs for this region. Calling ObserverContext.bypass() has no effect in this hook.

Parameters:

ctx - the environment provided by the region server

info - the RegionInfo for this region

edits - the file of recovered edits

Throws:

IOException

postReplayWALs

default void postReplayWALs(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
                            HRegionInfo info,
                            org.apache.hadoop.fs.Path edits)
                     throws IOException

Called after replaying WALs for this region.

Parameters:

ctx - the environment provided by the region server

info - the RegionInfo for this region

edits - the file of recovered edits

Throws:

IOException

preWALRestore

default void preWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
                           HRegionInfo info,
                           WALKey logKey,
                           WALEdit logEdit)
                    throws IOException

Called before a WALEdit replayed for this region.

Parameters:

ctx - the environment provided by the region server

Throws:

IOException

postWALRestore

default void postWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
                            HRegionInfo info,
                            WALKey logKey,
                            WALEdit logEdit)
                     throws IOException

Called after a WALEdit replayed for this region.

Parameters:

ctx - the environment provided by the region server

Throws:

IOException

preBulkLoadHFile

default void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                              List<Pair<byte[],String>> familyPaths)
                       throws IOException

Called before bulkLoadHFile. Users can create a StoreFile instance to access the contents of a HFile.

Parameters:

ctx - the environment provided by the region server

familyPaths - pairs of { CF, HFile path } submitted for bulk load. Adding or removing from this list will add or remove HFiles to be bulk loaded.

Throws:

IOException

preCommitStoreFile

default void preCommitStoreFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                byte[] family,
                                List<Pair<org.apache.hadoop.fs.Path,org.apache.hadoop.fs.Path>> pairs)
                         throws IOException

Called before moving bulk loaded hfile to region directory.

Parameters:

ctx - the environment provided by the region server

family - column family

pairs - List of pairs of { HFile location in staging dir, HFile path in region dir } Each pair are for the same hfile.

Throws:

IOException

postCommitStoreFile

default void postCommitStoreFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                 byte[] family,
                                 org.apache.hadoop.fs.Path srcPath,
                                 org.apache.hadoop.fs.Path dstPath)
                          throws IOException

Called after moving bulk loaded hfile to region directory.

Parameters:

ctx - the environment provided by the region server

family - column family

srcPath - Path to file before the move

dstPath - Path to file after the move

Throws:

IOException

postBulkLoadHFile

default boolean postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                  List<Pair<byte[],String>> stagingFamilyPaths,
                                  Map<byte[],List<org.apache.hadoop.fs.Path>> finalPaths,
                                  boolean hasLoaded)
                           throws IOException

Called after bulkLoadHFile.

Parameters:

ctx - the environment provided by the region server

stagingFamilyPaths - pairs of { CF, HFile path } submitted for bulk load

finalPaths - Map of CF to List of file paths for the loaded files

hasLoaded - whether the bulkLoad was successful

Returns:

the new value of hasLoaded

Throws:

IOException

preStoreFileReaderOpen

@Deprecated
default StoreFileReader preStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                                           org.apache.hadoop.fs.FileSystem fs,
                                                           org.apache.hadoop.fs.Path p,
                                                           FSDataInputStreamWrapper in,
                                                           long size,
                                                           CacheConfig cacheConf,
                                                           Reference r,
                                                           StoreFileReader reader)
                                                    throws IOException

Deprecated. For Phoenix only, StoreFileReader is not a stable interface.

Called before creation of Reader for a store file. Calling ObserverContext.bypass() has no effect in this hook.

Parameters:

ctx - the environment provided by the region server

fs - fileystem to read from

p - path to the file

in - FSDataInputStreamWrapper

size - Full size of the file

cacheConf -

r - original reference file. This will be not null only when reading a split file.

reader - the base reader, if not null, from previous RegionObserver in the chain

Returns:

a Reader instance to use instead of the base reader if overriding default behavior, null otherwise

Throws:

IOException

postStoreFileReaderOpen

@Deprecated
default StoreFileReader postStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                                            org.apache.hadoop.fs.FileSystem fs,
                                                            org.apache.hadoop.fs.Path p,
                                                            FSDataInputStreamWrapper in,
                                                            long size,
                                                            CacheConfig cacheConf,
                                                            Reference r,
                                                            StoreFileReader reader)
                                                     throws IOException

Deprecated. For Phoenix only, StoreFileReader is not a stable interface.

Called after the creation of Reader for a store file.

Parameters:

ctx - the environment provided by the region server

fs - fileystem to read from

p - path to the file

in - FSDataInputStreamWrapper

size - Full size of the file

cacheConf -

r - original reference file. This will be not null only when reading a split file.

reader - the base reader instance

Returns:

The reader to use

Throws:

IOException

postMutationBeforeWAL

default Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                   RegionObserver.MutationType opType,
                                   Mutation mutation,
                                   Cell oldCell,
                                   Cell newCell)
                            throws IOException

Called after a new cell has been created during an increment operation, but before it is committed to the WAL or memstore. Calling ObserverContext.bypass() has no effect in this hook.

Parameters:

ctx - the environment provided by the region server

opType - the operation type

mutation - the current mutation

oldCell - old cell containing previous value

newCell - the new cell containing the computed value

Returns:

the new cell, possibly changed

Throws:

IOException

postInstantiateDeleteTracker

default DeleteTracker postInstantiateDeleteTracker(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                                   DeleteTracker delTracker)
                                            throws IOException

Called after the ScanQueryMatcher creates ScanDeleteTracker. Implementing this hook would help in creating customised DeleteTracker and returning the newly created DeleteTracker

Parameters:

ctx - the environment provided by the region server

delTracker - the deleteTracker that is created by the QueryMatcher

Returns:

the Delete Tracker

Throws:

IOException