RegionObserver (Apache HBase 2.5.0 API)

All Known Implementing Classes:

AccessController, ConstraintProcessor, ExampleRegionObserverWithMetrics.ExampleRegionObserver, MetaTableMetrics.ExampleRegionObserverMeta, 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

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

Method Summary

All Methods Instance Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`default Result`	`postAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append, Result result)` Deprecated. since 2.5.0 and will be removed in 4.0.0. Use `postAppend(ObserverContext, Append, Result, WALEdit)` instead.
`default Result`	`postAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append, Result result, WALEdit edit)` Called after Append
`default List<Pair<Cell,Cell>>`	`postAppendBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)` Called after a list of new cells has been created during an append operation, but before they are committed to the WAL or memstore.
`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/increment/append 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)` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `postCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult)` instead.
`default boolean`	`postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, Filter filter, Delete delete, boolean result)` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `postCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult)` instead.
`default CheckAndMutateResult`	`postCheckAndMutate(ObserverContext<RegionCoprocessorEnvironment> c, CheckAndMutate checkAndMutate, CheckAndMutateResult result)` Called after checkAndMutate
`default boolean`	`postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put, boolean result)` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `postCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult)` instead.
`default boolean`	`postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, Filter filter, Put put, boolean result)` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `postCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult)` instead.
`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 `StoreFile`s to compact have been selected from the available candidates.
`default void`	`postDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit)` Called after the client deletes a value.
`default void`	`postDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)` Deprecated. since 2.5.0 and will be removed in 4.0.0. Use `postDelete(ObserverContext, Delete, WALEdit)` instead.
`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)` Deprecated. since 2.5.0 and will be removed in 4.0.0. Use `postIncrement(ObserverContext, Increment, Result, WALEdit)` instead.
`default Result`	`postIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment, Result result, WALEdit edit)` Called after increment
`default List<Pair<Cell,Cell>>`	`postIncrementBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)` Called after a list of new cells has been created during an increment operation, but before they are committed to the WAL or memstore.
`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)` Deprecated. since 2.2.0 and will be removedin 4.0.0. Use `postIncrementBeforeWAL(ObserverContext, Mutation, List)` or `postAppendBeforeWAL(ObserverContext, Mutation, List)` instead.
`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)` Called after the client stores a value.
`default void`	`postPut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)` Deprecated. since 2.5.0 and will be removed in 4.0.0. Use `postPut(ObserverContext, Put, WALEdit)` instead.
`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)` Deprecated. since 2.5.0 and will be removed in 4.0.0. Use `preAppend(ObserverContext, Append, WALEdit)` instead.
`default Result`	`preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append, WALEdit edit)` Called before Append.
`default Result`	`preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Append append)` Deprecated. since 2.5.0 and will be removed in 4.0.0. Use `preBatchMutate(ObserverContext, MiniBatchOperationInProgress)` instead.
`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)` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `preCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult)` instead.
`default boolean`	`preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, Filter filter, Delete delete, boolean result)` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `preCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult)` instead.
`default boolean`	`preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete, boolean result)` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `preCheckAndMutateAfterRowLock(ObserverContext, CheckAndMutate,CheckAndMutateResult)` instead.
`default boolean`	`preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, Filter filter, Delete delete, boolean result)` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `preCheckAndMutateAfterRowLock(ObserverContext, CheckAndMutate,CheckAndMutateResult)` instead.
`default CheckAndMutateResult`	`preCheckAndMutate(ObserverContext<RegionCoprocessorEnvironment> c, CheckAndMutate checkAndMutate, CheckAndMutateResult result)` Called before checkAndMutate
`default CheckAndMutateResult`	`preCheckAndMutateAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, CheckAndMutate checkAndMutate, CheckAndMutateResult result)` Called before checkAndDelete but after acquiring rowlock.
`default boolean`	`preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put, boolean result)` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `preCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult)` instead.
`default boolean`	`preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, Filter filter, Put put, boolean result)` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `preCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult)` instead.
`default boolean`	`preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put, boolean result)` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `preCheckAndMutateAfterRowLock(ObserverContext, CheckAndMutate,CheckAndMutateResult)` instead.
`default boolean`	`preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, Filter filter, Put put, boolean result)` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `preCheckAndMutateAfterRowLock(ObserverContext, CheckAndMutate,CheckAndMutateResult)` instead.
`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 `StoreFile`s 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)` Called before the client deletes a value.
`default void`	`preDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)` Deprecated. since 2.5.0 and will be removed in 4.0.0. Use `preDelete(ObserverContext, Delete, WALEdit)` instead.
`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)` Deprecated. since 2.5.0 and will be removed in 4.0.0. Use `preIncrement(ObserverContext, Increment, WALEdit)` instead.
`default Result`	`preIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment, WALEdit edit)` Called before Increment.
`default Result`	`preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)` Deprecated. since 2.5.0 and will be removed in 4.0.0. Use `preBatchMutate(ObserverContext, MiniBatchOperationInProgress)` instead.
`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)` Called before the client stores a value.
`default void`	`prePut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)` Deprecated. since 2.5.0 and will be removed in 4.0.0. Use `prePut(ObserverContext, Put, WALEdit)` instead.
`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`	`preWALAppend(ObserverContext<RegionCoprocessorEnvironment> ctx, WALKey key, WALEdit edit)` Called just before the WAL Entry is appended to the WAL.
`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
```
@Deprecated
default void prePut(ObserverContext<RegionCoprocessorEnvironment> c,
                                Put put,
                                WALEdit edit,
                                Durability durability)
                         throws IOException
```
    Deprecated. since 2.5.0 and will be removed in 4.0.0. Use prePut(ObserverContext, Put, WALEdit) instead.
    
    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
  - prePut
```
default void prePut(ObserverContext<RegionCoprocessorEnvironment> c,
                    Put put,
                    WALEdit edit)
             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
    
    Throws:
    
    IOException
  - postPut
```
@Deprecated
default void postPut(ObserverContext<RegionCoprocessorEnvironment> c,
                                 Put put,
                                 WALEdit edit,
                                 Durability durability)
                          throws IOException
```
    Deprecated. since 2.5.0 and will be removed in 4.0.0. Use postPut(ObserverContext, Put, WALEdit) instead.
    
    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
  - postPut
```
default void postPut(ObserverContext<RegionCoprocessorEnvironment> c,
                     Put put,
                     WALEdit edit)
              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
    
    Throws:
    
    IOException
  - preDelete
```
@Deprecated
default void preDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                                   Delete delete,
                                   WALEdit edit,
                                   Durability durability)
                            throws IOException
```
    Deprecated. since 2.5.0 and will be removed in 4.0.0. Use preDelete(ObserverContext, Delete, WALEdit) instead.
    
    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
  - preDelete
```
default void preDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                       Delete delete,
                       WALEdit edit)
                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
    
    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
```
@Deprecated
default void postDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                                    Delete delete,
                                    WALEdit edit,
                                    Durability durability)
                             throws IOException
```
    Deprecated. since 2.5.0 and will be removed in 4.0.0. Use postDelete(ObserverContext, Delete, WALEdit) instead.
    
    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
  - postDelete
```
default void postDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                        Delete delete,
                        WALEdit edit)
                 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
    
    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/Increment/Append. 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) and postDelete(ObserverContext, Delete, WALEdit) and postIncrement(ObserverContext, Increment, Result, WALEdit) and postAppend(ObserverContext, Append, Result, WALEdit) 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(). n * @param 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(). nn
    
    Throws:
    
    IOException
  - postBatchMutateIndispensably
```
default void postBatchMutateIndispensably(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                          MiniBatchOperationInProgress<Mutation> miniBatchOp,
                                          boolean success)
                                   throws IOException
```
    Called after the completion of batch put/delete/increment/append 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. nn * @param success true if batch operation is successful otherwise false.
    
    Throws:
    
    IOException
  - preCheckAndPut
```
@Deprecated
default boolean preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                                           byte[] row,
                                           byte[] family,
                                           byte[] qualifier,
                                           CompareOperator op,
                                           ByteArrayComparable comparator,
                                           Put put,
                                           boolean result)
                                    throws IOException
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use preCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult) instead.
    
    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 - the default value of the result
    
    Returns:
    
    the return value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - preCheckAndPut
```
@Deprecated
default boolean preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                                           byte[] row,
                                           Filter filter,
                                           Put put,
                                           boolean result)
                                    throws IOException
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use preCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult) instead.
    
    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
    
    filter - filter
    
    put - data to put if check succeeds
    
    result - the default value of the result
    
    Returns:
    
    the return value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - preCheckAndPutAfterRowLock
```
@Deprecated
default boolean preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                                       byte[] row,
                                                       byte[] family,
                                                       byte[] qualifier,
                                                       CompareOperator op,
                                                       ByteArrayComparable comparator,
                                                       Put put,
                                                       boolean result)
                                                throws IOException
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use preCheckAndMutateAfterRowLock(ObserverContext, CheckAndMutate,CheckAndMutateResult) instead.
    
    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 - the default value of the result
    
    Returns:
    
    the return value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - preCheckAndPutAfterRowLock
```
@Deprecated
default boolean preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                                       byte[] row,
                                                       Filter filter,
                                                       Put put,
                                                       boolean result)
                                                throws IOException
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use preCheckAndMutateAfterRowLock(ObserverContext, CheckAndMutate,CheckAndMutateResult) instead.
    
    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
    
    filter - filter
    
    put - data to put if check succeeds
    
    result - the default value of the result
    
    Returns:
    
    the return value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - postCheckAndPut
```
@Deprecated
default boolean postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                                            byte[] row,
                                            byte[] family,
                                            byte[] qualifier,
                                            CompareOperator op,
                                            ByteArrayComparable comparator,
                                            Put put,
                                            boolean result)
                                     throws IOException
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use postCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult) instead.
    
    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
  - postCheckAndPut
```
@Deprecated
default boolean postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                                            byte[] row,
                                            Filter filter,
                                            Put put,
                                            boolean result)
                                     throws IOException
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use postCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult) instead.
    
    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
    
    filter - filter
    
    put - data to put if check succeeds
    
    result - from the checkAndPut
    
    Returns:
    
    the possibly transformed return value to return to client
    
    Throws:
    
    IOException
  - preCheckAndDelete
```
@Deprecated
default boolean preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                                              byte[] row,
                                              byte[] family,
                                              byte[] qualifier,
                                              CompareOperator op,
                                              ByteArrayComparable comparator,
                                              Delete delete,
                                              boolean result)
                                       throws IOException
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use preCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult) instead.
    
    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 - the default value of the result
    
    Returns:
    
    the value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - preCheckAndDelete
```
@Deprecated
default boolean preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                                              byte[] row,
                                              Filter filter,
                                              Delete delete,
                                              boolean result)
                                       throws IOException
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use preCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult) instead.
    
    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
    
    filter - column family
    
    delete - delete to commit if check succeeds
    
    result - the default value of the result
    
    Returns:
    
    the value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - preCheckAndDeleteAfterRowLock
```
@Deprecated
default boolean preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                                          byte[] row,
                                                          byte[] family,
                                                          byte[] qualifier,
                                                          CompareOperator op,
                                                          ByteArrayComparable comparator,
                                                          Delete delete,
                                                          boolean result)
                                                   throws IOException
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use preCheckAndMutateAfterRowLock(ObserverContext, CheckAndMutate,CheckAndMutateResult) instead.
    
    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 - the default value of the result
    
    Returns:
    
    the value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - preCheckAndDeleteAfterRowLock
```
@Deprecated
default boolean preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                                          byte[] row,
                                                          Filter filter,
                                                          Delete delete,
                                                          boolean result)
                                                   throws IOException
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use preCheckAndMutateAfterRowLock(ObserverContext, CheckAndMutate,CheckAndMutateResult) instead.
    
    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
    
    filter - filter
    
    delete - delete to commit if check succeeds
    
    result - the default value of the result
    
    Returns:
    
    the value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - postCheckAndDelete
```
@Deprecated
default boolean postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                                               byte[] row,
                                               byte[] family,
                                               byte[] qualifier,
                                               CompareOperator op,
                                               ByteArrayComparable comparator,
                                               Delete delete,
                                               boolean result)
                                        throws IOException
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use postCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult) instead.
    
    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
  - postCheckAndDelete
```
@Deprecated
default boolean postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                                               byte[] row,
                                               Filter filter,
                                               Delete delete,
                                               boolean result)
                                        throws IOException
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use postCheckAndMutate(ObserverContext, CheckAndMutate, CheckAndMutateResult) instead.
    
    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
    
    filter - filter
    
    delete - delete to commit if check succeeds
    
    result - from the CheckAndDelete
    
    Returns:
    
    the possibly transformed returned value to return to client
    
    Throws:
    
    IOException
  - preCheckAndMutate
```
default CheckAndMutateResult preCheckAndMutate(ObserverContext<RegionCoprocessorEnvironment> c,
                                               CheckAndMutate checkAndMutate,
                                               CheckAndMutateResult result)
                                        throws IOException
```
    Called before checkAndMutate
    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 actions 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
    
    checkAndMutate - the CheckAndMutate object
    
    result - the default value of the result
    
    Returns:
    
    the return value to return to client if bypassing default processing
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - preCheckAndMutateAfterRowLock
```
default CheckAndMutateResult preCheckAndMutateAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                                           CheckAndMutate checkAndMutate,
                                                           CheckAndMutateResult result)
                                                    throws IOException
```
    Called before checkAndDelete 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 actions 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
    
    checkAndMutate - the CheckAndMutate object
    
    result - the default value of the result
    
    Returns:
    
    the value to return to client if bypassing default processing
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - postCheckAndMutate
```
default CheckAndMutateResult postCheckAndMutate(ObserverContext<RegionCoprocessorEnvironment> c,
                                                CheckAndMutate checkAndMutate,
                                                CheckAndMutateResult result)
                                         throws IOException
```
    Called after checkAndMutate
    Note: Do not retain references to any Cells in actions 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
    
    checkAndMutate - the CheckAndMutate object
    
    result - from the checkAndMutate
    
    Returns:
    
    the possibly transformed returned value to return to client
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - preAppend
```
@Deprecated
default Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                                     Append append)
                              throws IOException
```
    Deprecated. since 2.5.0 and will be removed in 4.0.0. Use preAppend(ObserverContext, Append, WALEdit) instead.
    
    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
  - preAppend
```
default Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                         Append append,
                         WALEdit edit)
                  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
    
    edit - The WALEdit object that will be written to the wal
    
    Returns:
    
    result to return to the client if bypassing default processing
    
    Throws:
    
    IOException
  - preAppendAfterRowLock
```
@Deprecated
default Result preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                                 Append append)
                                          throws IOException
```
    Deprecated. since 2.5.0 and will be removed in 4.0.0. Use preBatchMutate(ObserverContext, MiniBatchOperationInProgress) instead.
    
    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
```
@Deprecated
default Result postAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                                      Append append,
                                      Result result)
                               throws IOException
```
    Deprecated. since 2.5.0 and will be removed in 4.0.0. Use postAppend(ObserverContext, Append, Result, WALEdit) instead.
    
    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
  - postAppend
```
default Result postAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                          Append append,
                          Result result,
                          WALEdit edit)
                   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
    
    edit - The WALEdit object for the wal
    
    Returns:
    
    the result to return to the client
    
    Throws:
    
    IOException
  - preIncrement
```
@Deprecated
default Result preIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                                        Increment increment)
                                 throws IOException
```
    Deprecated. since 2.5.0 and will be removed in 4.0.0. Use preIncrement(ObserverContext, Increment, WALEdit) instead.
    
    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
  - preIncrement
```
default Result preIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                            Increment increment,
                            WALEdit edit)
                     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
    
    edit - The WALEdit object that will be written to the wal
    
    Returns:
    
    result to return to the client if bypassing default processing
    
    Throws:
    
    IOException
  - preIncrementAfterRowLock
```
@Deprecated
default Result preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                                    Increment increment)
                                             throws IOException
```
    Deprecated. since 2.5.0 and will be removed in 4.0.0. Use preBatchMutate(ObserverContext, MiniBatchOperationInProgress) instead.
    
    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
    
    Throws:
    
    IOException
  - postIncrement
```
@Deprecated
default Result postIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                                         Increment increment,
                                         Result result)
                                  throws IOException
```
    Deprecated. since 2.5.0 and will be removed in 4.0.0. Use postIncrement(ObserverContext, Increment, Result, WALEdit) instead.
    
    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
  - postIncrement
```
default Result postIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                             Increment increment,
                             Result result,
                             WALEdit edit)
                      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
    
    edit - The WALEdit object for the wal
    
    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 n * @param 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 n * @param 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
```
@Deprecated
default Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                               RegionObserver.MutationType opType,
                                               Mutation mutation,
                                               Cell oldCell,
                                               Cell newCell)
                                        throws IOException
```
    Deprecated. since 2.2.0 and will be removedin 4.0.0. Use postIncrementBeforeWAL(ObserverContext, Mutation, List) or postAppendBeforeWAL(ObserverContext, Mutation, List) instead.
    
    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
    
    See Also:
    
    postIncrementBeforeWAL(ObserverContext, Mutation, List), postAppendBeforeWAL(ObserverContext, Mutation, List), HBASE-21643
  - postIncrementBeforeWAL
```
default List<Pair<Cell,Cell>> postIncrementBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                                     Mutation mutation,
                                                     List<Pair<Cell,Cell>> cellPairs)
                                              throws IOException
```
    Called after a list of new cells has been created during an increment operation, but before they are committed to the WAL or memstore.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    mutation - the current mutation
    
    cellPairs - a list of cell pair. The first cell is old cell which may be null. And the second cell is the new cell.
    
    Returns:
    
    a list of cell pair, possibly changed.
    
    Throws:
    
    IOException
  - postAppendBeforeWAL
```
default List<Pair<Cell,Cell>> postAppendBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                                  Mutation mutation,
                                                  List<Pair<Cell,Cell>> cellPairs)
                                           throws IOException
```
    Called after a list of new cells has been created during an append operation, but before they are committed to the WAL or memstore.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    mutation - the current mutation
    
    cellPairs - a list of cell pair. The first cell is old cell which may be null. And the second cell is the new cell.
    
    Returns:
    
    a list of cell pair, 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
  - preWALAppend
```
default void preWALAppend(ObserverContext<RegionCoprocessorEnvironment> ctx,
                          WALKey key,
                          WALEdit edit)
                   throws IOException
```
    Called just before the WAL Entry is appended to the WAL. Implementing this hook allows coprocessors to add extended attributes to the WALKey that then get persisted to the WAL, and are available to replication endpoints to use in processing WAL Entries.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    key - the WALKey associated with a particular append to a WAL
    
    Throws:
    
    IOException

Interface RegionObserver

Exception Handling

For Split Related Hooks

Increment Column Value

Nested Class Summary

Method Summary

Method Detail

preOpen

postOpen

preFlush

preFlushScannerOpen

preFlush

postFlush

postFlush

preMemStoreCompaction

preMemStoreCompactionCompactScannerOpen

preMemStoreCompactionCompact

postMemStoreCompaction

preCompactSelection

postCompactSelection

preCompactScannerOpen

preCompact

postCompact

preClose

postClose

preGetOp

postGetOp

preExists

postExists

prePut

prePut

postPut

postPut

preDelete

preDelete

prePrepareTimeStampForDeleteVersion

postDelete

postDelete

preBatchMutate

postBatchMutate

postStartRegionOperation

postCloseRegionOperation

postBatchMutateIndispensably

preCheckAndPut

preCheckAndPut

preCheckAndPutAfterRowLock

preCheckAndPutAfterRowLock

postCheckAndPut

postCheckAndPut

preCheckAndDelete

preCheckAndDelete

preCheckAndDeleteAfterRowLock

preCheckAndDeleteAfterRowLock

postCheckAndDelete

postCheckAndDelete

preCheckAndMutate

preCheckAndMutateAfterRowLock

postCheckAndMutate

preAppend

preAppend

preAppendAfterRowLock

postAppend

postAppend

preIncrement

preIncrement

preIncrementAfterRowLock

postIncrement

postIncrement

preScannerOpen

postScannerOpen

preScannerNext

postScannerNext

postScannerFilterRow

preScannerClose

postScannerClose

preStoreScannerOpen

preReplayWALs

postReplayWALs

preWALRestore

postWALRestore