org.apache.hadoop.hbase.coprocessor

Interface RegionObserver

All Known Implementing Classes:

AccessController, ConstraintProcessor, ReplicationObserver, ScanModifyingObserver, ValueRewritingObserver, VisibilityController, WriteHeavyIncrementObserver, WriteSinkCoprocessor, ZooKeeperScanPolicyObserver

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

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

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 void	postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> stagingFamilyPaths, Map<byte[],List<org.apache.hadoop.fs.Path>> finalPaths) 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, CompactionRequest request) Called after compaction has completed and the new store file has been moved in to place.
default void	postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends StoreFile> selected, CompactionLifeCycleTracker tracker, CompactionRequest request) 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, FlushLifeCycleTracker tracker) Called after the memstore is flushed to disk.
default void	postFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile, FlushLifeCycleTracker tracker) 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) Deprecated. Since 2.0 with out any replacement and will be removed in 3.0
default void	postMemStoreCompaction(ObserverContext<RegionCoprocessorEnvironment> c, Store store) Called after the in memory compaction is finished.
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, RegionInfo 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, RegionInfo 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, CompactionRequest request) Called prior to writing the StoreFiles selected for compaction into a new StoreFile.
default void	preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, ScanType scanType, ScanOptions options, CompactionLifeCycleTracker tracker, CompactionRequest request) Called before we open store scanner for compaction.
default void	preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends 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, FlushLifeCycleTracker tracker) Called before the memstore is flushed to disk.
default InternalScanner	preFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner, FlushLifeCycleTracker tracker) Called before a Store's memstore is flushed to disk.
default void	preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, ScanOptions options, FlushLifeCycleTracker tracker) Called before we open store scanner for flush.
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	preMemStoreCompaction(ObserverContext<RegionCoprocessorEnvironment> c, Store store) Called before in memory compaction started.
default InternalScanner	preMemStoreCompactionCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner) Called before we do in memory compaction.
default void	preMemStoreCompactionCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, ScanOptions options) Called before we open store scanner for in memory compaction.
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) Deprecated. Since hbase-2.0.0. No replacement. To be removed in hbase-3.0.0 and replaced with something that doesn't expose IntefaceAudience.Private classes.
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, RegionInfo 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 void	preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan) 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 void	preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> ctx, Store store, ScanOptions options) Called before a store opens a new scanner.
default void	preWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, RegionInfo info, WALKey logKey, WALEdit logEdit) Called before a WALEdit replayed for this region.

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

preFlush

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

Called before the memstore is flushed to disk.

Parameters:

c - the environment provided by the region server

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

Throws:

IOException

preFlushScannerOpen

default void preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                 Store store,
                                 ScanOptions options,
                                 FlushLifeCycleTracker tracker)
                          throws IOException

Called before we open store scanner for flush. You can use the options to change max versions and TTL for the scanner being opened.

Parameters:

c - the environment provided by the region server

store - the store where flush is being requested

options - used to change max versions and TTL for the scanner being opened

Throws:

IOException

preFlush

default InternalScanner preFlush(ObserverContext<RegionCoprocessorEnvironment> c,
                                 Store store,
                                 InternalScanner scanner,
                                 FlushLifeCycleTracker tracker)
                          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 flush is being requested

scanner - the scanner over existing data used in the memstore

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

Returns:

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

Throws:

IOException

postFlush

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

Called after the memstore is flushed to disk.

Parameters:

c - the environment provided by the region server

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

Throws:

IOException - if an error occurred on the coprocessor

postFlush

default void postFlush(ObserverContext<RegionCoprocessorEnvironment> c,
                       Store store,
                       StoreFile resultFile,
                       FlushLifeCycleTracker tracker)
                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

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

Throws:

IOException

preMemStoreCompaction

default void preMemStoreCompaction(ObserverContext<RegionCoprocessorEnvironment> c,
                                   Store store)
                            throws IOException

Called before in memory compaction started.

Parameters:

c - the environment provided by the region server

store - the store where in memory compaction is being requested

Throws:

IOException

preMemStoreCompactionCompactScannerOpen

default void preMemStoreCompactionCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                                     Store store,
                                                     ScanOptions options)
                                              throws IOException

Called before we open store scanner for in memory compaction. You can use the options to change max versions and TTL for the scanner being opened. Notice that this method will only be called when you use eager mode. For basic mode we will not drop any cells thus we do not open a store scanner.

Parameters:

c - the environment provided by the region server

store - the store where in memory compaction is being requested

options - used to change max versions and TTL for the scanner being opened

Throws:

IOException

preMemStoreCompactionCompact

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

Called before we do in memory compaction. Notice that this method will only be called when you use eager mode. For basic mode we will not drop any cells thus there is no InternalScanner.

Parameters:

c - the environment provided by the region server

store - the store where in memory compaction is being executed

scanner - the scanner over existing data used in the memstore segments being compact

Returns:

the scanner to use during in memory compaction. Must be non-null.

Throws:

IOException

postMemStoreCompaction

default void postMemStoreCompaction(ObserverContext<RegionCoprocessorEnvironment> c,
                                    Store store)
                             throws IOException

Called after the in memory compaction is finished.

Parameters:

c - the environment provided by the region server

store - the store where in memory compaction is being executed

Throws:

IOException

preCompactSelection

default void preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
                                 Store store,
                                 List<? extends 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. If you remove all the candidates then the compaction will be canceled.

Supports Coprocessor 'bypass' -- 'bypass' is how this method indicates that it changed the passed in candidates. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.

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,
                                  List<? extends StoreFile> selected,
                                  CompactionLifeCycleTracker tracker,
                                  CompactionRequest request)

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

request - the requested compaction

preCompactScannerOpen

default void preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                   Store store,
                                   ScanType scanType,
                                   ScanOptions options,
                                   CompactionLifeCycleTracker tracker,
                                   CompactionRequest request)
                            throws IOException

Called before we open store scanner for compaction. You can use the options to change max versions and TTL for the scanner being opened.

Parameters:

c - the environment provided by the region server

store - the store being compacted

scanType - type of Scan

options - used to change max versions and TTL for the scanner being opened

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

request - the requested compaction

Throws:

IOException

preCompact

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

Called prior to writing the StoreFiles selected for compaction into a new StoreFile.

To override or modify the compaction process, implementing classes can wrap the provided InternalScanner with a custom implementation that is returned from this method. The custom scanner can then inspect Cells from the wrapped scanner, applying its own policy to what gets written.

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

request - the requested 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

postCompact

default void postCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                         Store store,
                         StoreFile resultFile,
                         CompactionLifeCycleTracker tracker,
                         CompactionRequest request)
                  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

request - the requested 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. If 'bypass' is set, we skip out on calling 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

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. If 'bypass' is set, we skip out on calling 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 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.

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. If 'bypass' is set, we skip out on calling 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.

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. If 'bypass' is set, we skip out on calling 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

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

Deprecated. Since hbase-2.0.0. No replacement. To be removed in hbase-3.0.0 and replaced with something that doesn't expose IntefaceAudience.Private classes.

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

Call CoprocessorEnvironment#bypass to skip default actions. If 'bypass' is set, we skip out on calling 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.

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. Coprocessors are discouraged from manipulating its state.

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. If 'bypass' is set, we skip out on calling 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. If 'bypass' is set, we skip out on calling 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

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. If 'bypass' is set, we skip out on calling 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. If 'bypass' is set, we skip out on calling 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

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. If 'bypass' is set, we skip out on calling 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. If 'bypass' is set, we skip out on calling 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

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. If 'bypass' is set, we skip out on calling 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. If 'bypass' is set, we skip out on calling 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

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 void preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                            Scan scan)
                     throws IOException

Called before the client opens a new scanner.

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

Throws:

IOException

postScannerOpen

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

Called after the client opens a new scanner.

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. If 'bypass' is set, we skip out on calling 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.

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. If 'bypass' is set, we skip out on calling 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.

Parameters:

ctx - the environment provided by the region server

s - the scanner

Throws:

IOException

preStoreScannerOpen

default void preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                 Store store,
                                 ScanOptions options)
                          throws IOException

Called before a store opens a new scanner.

This hook is called when a "user" scanner is opened. Use preFlushScannerOpen and preCompactScannerOpen to inject flush/compaction.

Notice that, this method is used to change the inherent max versions and TTL for a Store. For example, you can change the max versions option for a Scan object to 10 in preScannerOpen, but if the max versions config on the Store is 1, then you still can only read 1 version. You need also to inject here to change the max versions to 10 if you want to get more versions.

Parameters:

ctx - the environment provided by the region server

store - the store which we want to get scanner from

options - used to change max versions and TTL for the scanner being opened

Throws:

IOException

See Also:

preFlushScannerOpen(ObserverContext, Store, ScanOptions, FlushLifeCycleTracker), preCompactScannerOpen(ObserverContext, Store, ScanType, ScanOptions, CompactionLifeCycleTracker, CompactionRequest)

preReplayWALs

default void preReplayWALs(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
                           RegionInfo 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,
                            RegionInfo 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,
                           RegionInfo 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,
                            RegionInfo 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 void postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                               List<Pair<byte[],String>> stagingFamilyPaths,
                               Map<byte[],List<org.apache.hadoop.fs.Path>> finalPaths)
                        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 if the Map is not null, the bulkLoad was successful. Otherwise the bulk load failed. bulkload is done by the time this hook is called.

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

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

Deprecated. Since 2.0 with out any replacement and will be removed in 3.0

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

Warn: This is used by internal coprocessors. Should not be implemented by user coprocessors

Parameters:

ctx - the environment provided by the region server

delTracker - the deleteTracker that is created by the QueryMatcher

Returns:

the Delete Tracker

Throws:

IOException