RegionObserver (Apache HBase 3.0.0-SNAPSHOT API)

All Superinterfaces:

Coprocessor

All Known Implementing Classes:

AccessController, BackupObserver, ConstraintProcessor, ExampleRegionObserverWithMetrics, ReplicationObserver, VisibilityController, WriteSinkCoprocessor, ZooKeeperScanPolicyObserver
```
@InterfaceAudience.LimitedPrivate(value="Coprocesssor")
 @InterfaceStability.Evolving
public interface RegionObserver
extends Coprocessor
```
Coprocessors implement this interface to observe and mediate client actions on the region. Since most implementations will be interested in only a subset of hooks, this class uses 'default' functions to avoid having to add unnecessary overrides. When the functions are non-empty, it's simply to satisfy the compiler by returning value of expected (non-void) type. It is done in a way that these default definitions act as no-op. So our suggestion to implementation would be to not call these 'default' methods from overrides.

Exception Handling
For all functions, exception handling is done as follows:
- Exceptions of type IOException are reported back to client.
- For any other kind of exception:
  - If the configuration CoprocessorHost.ABORT_ON_ERROR_KEY is set to true, then the server aborts.
  - Otherwise, coprocessor is removed from the server and DoNotRetryIOException is returned to the client.

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class RegionObserver.MutationType
Mutation type for postMutationBeforeWAL hook
- Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.Coprocessor
  Coprocessor.State

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

Field Summary
- Fields inherited from interface org.apache.hadoop.hbase.Coprocessor
  PRIORITY_HIGHEST, PRIORITY_LOWEST, PRIORITY_SYSTEM, PRIORITY_USER, VERSION

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)` Called after Append
`default void`	`postBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)` This will be called after applying a batch of Mutations on a region.
`default void`	`postBatchMutateIndispensably(ObserverContext<RegionCoprocessorEnvironment> ctx, MiniBatchOperationInProgress<Mutation> miniBatchOp, boolean success)` Called after the completion of batch put/delete and will be called even if the batch operation fails.
`default boolean`	`postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> stagingFamilyPaths, boolean hasLoaded)` Deprecated. Use `postBulkLoadHFile(ObserverContext, List, Map, boolean)`
`default boolean`	`postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> stagingFamilyPaths, Map<byte[],List<org.apache.hadoop.fs.Path>> finalPaths, boolean hasLoaded)` Called after bulkLoadHFile.
`default boolean`	`postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)` Called after checkAndDelete
`default boolean`	`postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)` Called after checkAndPut
`default void`	`postClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested)` Called after the region is reported as closed to the master.
`default void`	`postCloseRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx, Region.Operation operation)` Called after releasing read lock in `Region.closeRegionOperation()`.
`default void`	`postCommitStoreFile(ObserverContext<RegionCoprocessorEnvironment> ctx, byte[] family, org.apache.hadoop.fs.Path srcPath, org.apache.hadoop.fs.Path dstPath)` Called after moving bulk loaded hfile to region directory.
`default void`	`postCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile)` Deprecated. Use `postCompact(ObserverContext, Store, StoreFile, CompactionRequest)` instead
`default void`	`postCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile, 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, com.google.common.collect.ImmutableList<StoreFile> selected)` Deprecated. use `postCompactSelection(ObserverContext, Store, ImmutableList, CompactionRequest)` instead.
`default void`	`postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, com.google.common.collect.ImmutableList<StoreFile> selected, CompactionRequest request)` Called after the `StoreFile`s to compact have been selected from the available candidates.
`default void`	`postCompleteSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)` Deprecated. No longer called in hbase2/AMv2 given the master runs splits now; implement `MasterObserver.postCompletedSplitRegionAction(ObserverContext, HRegionInfo, HRegionInfo)` instead.
`default void`	`postDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)` Called after the client deletes a value.
`default boolean`	`postExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists)` Called after the client tests for existence using a Get.
`default void`	`postFlush(ObserverContext<RegionCoprocessorEnvironment> c)` Deprecated. use `preFlush(ObserverContext, Store, InternalScanner)` instead.
`default void`	`postFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile)` Called after a Store's memstore is flushed to disk.
`default void`	`postGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result)` Called after the client performs a Get
`default Result`	`postIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment, Result result)` Called after increment
`default long`	`postIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, long amount, boolean writeToWAL, long result)` Deprecated. This hook is no longer called by the RegionServer
`default DeleteTracker`	`postInstantiateDeleteTracker(ObserverContext<RegionCoprocessorEnvironment> ctx, DeleteTracker delTracker)` Called after the ScanQueryMatcher creates ScanDeleteTracker.
`default void`	`postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c)` Called after the log replay on the region is over.
`default Cell`	`postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, RegionObserver.MutationType opType, Mutation mutation, Cell oldCell, Cell newCell)` Called after a new cell has been created during an increment operation, but before it is committed to the WAL or memstore.
`default void`	`postOpen(ObserverContext<RegionCoprocessorEnvironment> c)` Called after the region is reported as open to the master.
`default void`	`postPut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)` Called after the client stores a value.
`default void`	`postReplayWALs(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, HRegionInfo info, org.apache.hadoop.fs.Path edits)` Called after replaying WALs for this region.
`default void`	`postRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)` Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
`default void`	`postScannerClose(ObserverContext<RegionCoprocessorEnvironment> ctx, InternalScanner s)` Called after the client closes a scanner.
`default boolean`	`postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, byte[] currentRow, int offset, short length, boolean hasMore)` Deprecated. As of release 2.0.0, this will be removed in HBase 3.0.0. Instead use `postScannerFilterRow(ObserverContext, InternalScanner, Cell, boolean)`
`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`	`postSplit(ObserverContext<RegionCoprocessorEnvironment> c, Region l, Region r)` Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
`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)` Called after the creation of Reader for a store file.
`default void`	`postWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, HRegionInfo info, WALKey logKey, WALEdit logEdit)` Called after a `WALEdit` replayed for this region.
`default Result`	`preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append)` Called before Append.
`default Result`	`preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Append append)` Called before Append but after acquiring rowlock.
`default void`	`preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)` This will be called for every batch mutation operation happening at the server.
`default void`	`preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> familyPaths)` Called before bulkLoadHFile.
`default boolean`	`preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)` Called before checkAndDelete.
`default boolean`	`preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)` Called before checkAndDelete but after acquiring rowock.
`default boolean`	`preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)` Called before checkAndPut.
`default boolean`	`preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)` Called before checkAndPut but after acquiring rowlock.
`default void`	`preClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested)` Called before the region is reported as closed to the master.
`default void`	`preCommitStoreFile(ObserverContext<RegionCoprocessorEnvironment> ctx, byte[] family, List<Pair<org.apache.hadoop.fs.Path,org.apache.hadoop.fs.Path>> pairs)` Called before moving bulk loaded hfile to region directory.
`default InternalScanner`	`preCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner, ScanType scanType)` Deprecated. use `preCompact(ObserverContext, Store, InternalScanner, ScanType, CompactionRequest)` instead
`default InternalScanner`	`preCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner, ScanType scanType, CompactionRequest request)` Called prior to writing the `StoreFile`s selected for compaction into a new `StoreFile`.
`default InternalScanner`	`preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s)` Deprecated. Use `preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner, CompactionRequest, long)` instead.
`default InternalScanner`	`preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s, CompactionRequest request)` Deprecated. Use `preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner, CompactionRequest, long)` instead.
`default InternalScanner`	`preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s, CompactionRequest request, long readPoint)` Called prior to writing the `StoreFile`s selected for compaction into a new `StoreFile` and prior to creating the scanner used to read the input files.
`default void`	`preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<StoreFile> candidates)` Deprecated. Use `preCompactSelection(ObserverContext, Store, List, CompactionRequest)` instead
`default void`	`preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<StoreFile> candidates, CompactionRequest request)` Called prior to selecting the `StoreFiles` to compact from the list of available candidates.
`default void`	`preDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)` Called before the client deletes a value.
`default boolean`	`preExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists)` Called before the client tests for existence using a Get.
`default void`	`preFlush(ObserverContext<RegionCoprocessorEnvironment> c)` Deprecated. use `preFlush(ObserverContext, Store, InternalScanner)` instead
`default InternalScanner`	`preFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner)` Called before a Store's memstore is flushed to disk.
`default InternalScanner`	`preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, KeyValueScanner scanner, InternalScanner s, long readPoint)` Maintain backward compatibility.
`default InternalScanner`	`preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<KeyValueScanner> scanners, InternalScanner s)` Deprecated. Use `preFlushScannerOpen(ObserverContext, Store, List, InternalScanner, long)`
`default InternalScanner`	`preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<KeyValueScanner> scanners, InternalScanner s, long readPoint)` Called before a memstore is flushed to disk and prior to creating the scanner to read from the memstore.
`default void`	`preGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result)` Called before the client performs a Get
`default Result`	`preIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)` Called before Increment.
`default Result`	`preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)` Called before Increment but after acquiring rowlock.
`default long`	`preIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, long amount, boolean writeToWAL)` Deprecated. This hook is no longer called by the RegionServer
`default void`	`preOpen(ObserverContext<RegionCoprocessorEnvironment> c)` Called before the region is reported as open to the master.
`default void`	`prePrepareTimeStampForDeleteVersion(ObserverContext<RegionCoprocessorEnvironment> c, Mutation mutation, Cell cell, byte[] byteNow, Get get)` Called before the server updates the timestamp for version delete with latest timestamp.
`default void`	`prePut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)` Called before the client stores a value.
`default void`	`preReplayWALs(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, HRegionInfo info, org.apache.hadoop.fs.Path edits)` Called before replaying WALs for this region.
`default void`	`preRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)` Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
`default void`	`preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)` Called before the client closes a scanner.
`default boolean`	`preScannerNext(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, List<Result> result, int limit, boolean hasNext)` Called before the client asks for the next row on a scanner.
`default RegionScanner`	`preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s)` Called before the client opens a new scanner.
`default void`	`preSplit(ObserverContext<RegionCoprocessorEnvironment> c)` Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
`default void`	`preSplit(ObserverContext<RegionCoprocessorEnvironment> c, byte[] splitRow)` Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
`default void`	`preSplitAfterPONR(ObserverContext<RegionCoprocessorEnvironment> ctx)` Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
`default void`	`preSplitBeforePONR(ObserverContext<RegionCoprocessorEnvironment> ctx, byte[] splitKey, List<Mutation> metaEntries)` Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
`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)` Called before creation of Reader for a store file.
`default KeyValueScanner`	`preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, Scan scan, NavigableSet<byte[]> targetCols, KeyValueScanner s)` Deprecated. use `preStoreScannerOpen(ObserverContext, Store, Scan, NavigableSet, KeyValueScanner, long)` instead
`default KeyValueScanner`	`preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, Scan scan, NavigableSet<byte[]> targetCols, KeyValueScanner s, long readPt)` Called before a store opens a new scanner.
`default void`	`preWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, HRegionInfo info, WALKey logKey, WALEdit logEdit)` Called before a `WALEdit` replayed for this region.

Methods inherited from interface org.apache.hadoop.hbase.Coprocessor
start, stop

- Method Detail
  - preOpen
```
default void preOpen(ObserverContext<RegionCoprocessorEnvironment> c)
              throws IOException
```
    Called before the region is reported as open to the master.
    
    Parameters:
    
    c - the environment provided by the region server
    
    Throws:
    
    IOException
  - postOpen
```
default void postOpen(ObserverContext<RegionCoprocessorEnvironment> c)
```
    Called after the region is reported as open to the master.
    
    Parameters:
    
    c - the environment provided by the region server
  - postLogReplay
```
default void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c)
```
    Called after the log replay on the region is over.
    
    Parameters:
    
    c - the environment provided by the region server
  - preFlushScannerOpen
```
@Deprecated
default InternalScanner preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                                        Store store,
                                                        List<KeyValueScanner> scanners,
                                                        InternalScanner s)
                                                 throws IOException
```
    Deprecated. Use preFlushScannerOpen(ObserverContext, Store, List, InternalScanner, long)
    
    Called before a memstore is flushed to disk and prior to creating the scanner to read from the memstore. To override or modify how a memstore is flushed, implementing classes can return a new scanner to provide the KeyValues to be stored into the new StoreFile or null to perform the default processing. Calling ObserverContext.bypass() has no effect in this hook.
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being flushed
    
    scanners - the scanners for the memstore that is flushed
    
    s - the base scanner, if not null, from previous RegionObserver in the chain
    
    Returns:
    
    the scanner to use during the flush. null if the default implementation is to be used.
    
    Throws:
    
    IOException
  - preFlushScannerOpen
```
default InternalScanner preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                            Store store,
                                            List<KeyValueScanner> scanners,
                                            InternalScanner s,
                                            long readPoint)
                                     throws IOException
```
    Called before a memstore is flushed to disk and prior to creating the scanner to read from the memstore. To override or modify how a memstore is flushed, implementing classes can return a new scanner to provide the KeyValues to be stored into the new StoreFile or null to perform the default processing. Calling ObserverContext.bypass() has no effect in this hook.
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being flushed
    
    scanners - the scanners for the memstore that is flushed
    
    s - the base scanner, if not null, from previous RegionObserver in the chain
    
    readPoint - the readpoint to create scanner
    
    Returns:
    
    the scanner to use during the flush. null if the default implementation is to be used.
    
    Throws:
    
    IOException
  - preFlushScannerOpen
```
default InternalScanner preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                            Store store,
                                            KeyValueScanner scanner,
                                            InternalScanner s,
                                            long readPoint)
                                     throws IOException
```
    Maintain backward compatibility.
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being flushed
    
    scanner - the scanner for the memstore that is flushed
    
    s - the base scanner, if not null, from previous RegionObserver in the chain
    
    readPoint - the readpoint to create scanner
    
    Returns:
    
    the scanner to use during the flush. null if the default implementation is to be used.
    
    Throws:
    
    IOException
  - preFlush
```
@Deprecated
default void preFlush(ObserverContext<RegionCoprocessorEnvironment> c)
                           throws IOException
```
    Deprecated. use preFlush(ObserverContext, Store, InternalScanner) instead
    
    Called before the memstore is flushed to disk.
    
    Parameters:
    
    c - the environment provided by the region server
    
    Throws:
    
    IOException
  - preFlush
```
default InternalScanner preFlush(ObserverContext<RegionCoprocessorEnvironment> c,
                                 Store store,
                                 InternalScanner scanner)
                          throws IOException
```
    Called before a Store's memstore is flushed to disk.
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store where compaction is being requested
    
    scanner - the scanner over existing data used in the store file
    
    Returns:
    
    the scanner to use during compaction. Should not be null unless the implementation is writing new store files on its own.
    
    Throws:
    
    IOException
  - postFlush
```
@Deprecated
default void postFlush(ObserverContext<RegionCoprocessorEnvironment> c)
                            throws IOException
```
    Deprecated. use preFlush(ObserverContext, Store, InternalScanner) instead.
    
    Called after the memstore is flushed to disk.
    
    Parameters:
    
    c - the environment provided by the region server
    
    Throws:
    
    IOException
  - postFlush
```
default void postFlush(ObserverContext<RegionCoprocessorEnvironment> c,
                       Store store,
                       StoreFile resultFile)
                throws IOException
```
    Called after a Store's memstore is flushed to disk.
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being flushed
    
    resultFile - the new store file written out during compaction
    
    Throws:
    
    IOException
  - preCompactSelection
```
default void preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
                                 Store store,
                                 List<StoreFile> candidates,
                                 CompactionRequest request)
                          throws IOException
```
    Called prior to selecting the StoreFiles to compact from the list of available candidates. To alter the files used for compaction, you may mutate the passed in list of candidates.
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store where compaction is being requested
    
    candidates - the store files currently available for compaction
    
    request - custom compaction request
    
    Throws:
    
    IOException
  - preCompactSelection
```
@Deprecated
default void preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
                                             Store store,
                                             List<StoreFile> candidates)
                                      throws IOException
```
    Deprecated. Use preCompactSelection(ObserverContext, Store, List, CompactionRequest) instead
    
    Called prior to selecting the StoreFiles to compact from the list of available candidates. To alter the files used for compaction, you may mutate the passed in list of candidates.
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store where compaction is being requested
    
    candidates - the store files currently available for compaction
    
    Throws:
    
    IOException
  - postCompactSelection
```
default void postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
                                  Store store,
                                  com.google.common.collect.ImmutableList<StoreFile> selected,
                                  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
    
    request - custom compaction request
  - postCompactSelection
```
@Deprecated
default void postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
                                              Store store,
                                              com.google.common.collect.ImmutableList<StoreFile> selected)
```
    Deprecated. use postCompactSelection(ObserverContext, Store, ImmutableList, CompactionRequest) instead.
    
    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
  - preCompact
```
default InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                                   Store store,
                                   InternalScanner scanner,
                                   ScanType scanType,
                                   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 have two options:
    - Wrap the provided InternalScanner with a custom implementation that is returned from this method. The custom scanner can then inspect KeyValues from the wrapped scanner, applying its own policy to what gets written.
    - Call ObserverContext.bypass() and provide a custom implementation for writing of new StoreFiles. Note: any implementations bypassing core compaction using this approach must write out new store files themselves or the existing data will no longer be available after compaction.
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being compacted
    
    scanner - the scanner over existing data used in the store file rewriting
    
    scanType - type of Scan
    
    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
  - preCompact
```
@Deprecated
default InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                                               Store store,
                                               InternalScanner scanner,
                                               ScanType scanType)
                                        throws IOException
```
    Deprecated. use preCompact(ObserverContext, Store, InternalScanner, ScanType, CompactionRequest) instead
    Called prior to writing the StoreFiles selected for compaction into a new StoreFile. To override or modify the compaction process, implementing classes have two options:
    - Wrap the provided InternalScanner with a custom implementation that is returned from this method. The custom scanner can then inspect KeyValues from the wrapped scanner, applying its own policy to what gets written.
    - Call ObserverContext.bypass() and provide a custom implementation for writing of new StoreFiles. Note: any implementations bypassing core compaction using this approach must write out new store files themselves or the existing data will no longer be available after compaction.
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being compacted
    
    scanner - the scanner over existing data used in the store file rewriting
    
    scanType - type of Scan
    
    Returns:
    
    the scanner to use during compaction. Should not be null unless the implementation is writing new store files on its own.
    
    Throws:
    
    IOException
  - preCompactScannerOpen
```
@Deprecated
default InternalScanner preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                                          Store store,
                                                          List<? extends KeyValueScanner> scanners,
                                                          ScanType scanType,
                                                          long earliestPutTs,
                                                          InternalScanner s,
                                                          CompactionRequest request)
                                                   throws IOException
```
    Deprecated. Use preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner, CompactionRequest, long) instead.
    
    Called prior to writing the StoreFiles selected for compaction into a new StoreFile and prior to creating the scanner used to read the input files. To override or modify the compaction process, implementing classes can return a new scanner to provide the KeyValues to be stored into the new StoreFile or null to perform the default processing. Calling ObserverContext.bypass() has no effect in this hook.
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being compacted
    
    scanners - the list StoreFileScanners to be read from
    
    scanType - the ScanType indicating whether this is a major or minor compaction
    
    earliestPutTs - timestamp of the earliest put that was found in any of the involved store files
    
    s - the base scanner, if not null, from previous RegionObserver in the chain
    
    request - the requested compaction
    
    Returns:
    
    the scanner to use during compaction. null if the default implementation is to be used.
    
    Throws:
    
    IOException
  - preCompactScannerOpen
```
default InternalScanner preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                              Store store,
                                              List<? extends KeyValueScanner> scanners,
                                              ScanType scanType,
                                              long earliestPutTs,
                                              InternalScanner s,
                                              CompactionRequest request,
                                              long readPoint)
                                       throws IOException
```
    Called prior to writing the StoreFiles selected for compaction into a new StoreFile and prior to creating the scanner used to read the input files. To override or modify the compaction process, implementing classes can return a new scanner to provide the KeyValues to be stored into the new StoreFile or null to perform the default processing. Calling ObserverContext.bypass() has no effect in this hook.
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being compacted
    
    scanners - the list StoreFileScanners to be read from
    
    scanType - the ScanType indicating whether this is a major or minor compaction
    
    earliestPutTs - timestamp of the earliest put that was found in any of the involved store files
    
    s - the base scanner, if not null, from previous RegionObserver in the chain
    
    request - compaction request
    
    readPoint - the readpoint to create scanner
    
    Returns:
    
    the scanner to use during compaction. null if the default implementation is to be used.
    
    Throws:
    
    IOException
  - preCompactScannerOpen
```
@Deprecated
default InternalScanner preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                                          Store store,
                                                          List<? extends KeyValueScanner> scanners,
                                                          ScanType scanType,
                                                          long earliestPutTs,
                                                          InternalScanner s)
                                                   throws IOException
```
    Deprecated. Use preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner, CompactionRequest, long) instead.
    
    Called prior to writing the StoreFiles selected for compaction into a new StoreFile and prior to creating the scanner used to read the input files. To override or modify the compaction process, implementing classes can return a new scanner to provide the KeyValues to be stored into the new StoreFile or null to perform the default processing. Calling ObserverContext.bypass() has no effect in this hook.
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being compacted
    
    scanners - the list StoreFileScanners to be read from
    
    scanType - the ScanType indicating whether this is a major or minor compaction
    
    earliestPutTs - timestamp of the earliest put that was found in any of the involved store files
    
    s - the base scanner, if not null, from previous RegionObserver in the chain
    
    Returns:
    
    the scanner to use during compaction. null if the default implementation is to be used.
    
    Throws:
    
    IOException
  - postCompact
```
default void postCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                         Store store,
                         StoreFile resultFile,
                         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
    
    request - the requested compaction
    
    Throws:
    
    IOException
  - postCompact
```
@Deprecated
default void postCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                                     Store store,
                                     StoreFile resultFile)
                              throws IOException
```
    Deprecated. Use postCompact(ObserverContext, Store, StoreFile, CompactionRequest) instead
    
    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
    
    Throws:
    
    IOException
  - preSplit
```
@Deprecated
default void preSplit(ObserverContext<RegionCoprocessorEnvironment> c)
                           throws IOException
```
    Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
    
    Called before the region is split.
    
    Parameters:
    
    c - the environment provided by the region server (e.getRegion() returns the parent region)
    
    Throws:
    
    IOException
    
    See Also:
    
    MasterObserver
  - preSplit
```
@Deprecated
default void preSplit(ObserverContext<RegionCoprocessorEnvironment> c,
                                  byte[] splitRow)
                           throws IOException
```
    Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
    
    Called before the region is split.
    
    Parameters:
    
    c - the environment provided by the region server (e.getRegion() returns the parent region) Note: the logic moves to Master; it is unused in RS
    
    Throws:
    
    IOException
    
    See Also:
    
    MasterObserver
  - postSplit
```
@Deprecated
default void postSplit(ObserverContext<RegionCoprocessorEnvironment> c,
                                   Region l,
                                   Region r)
                            throws IOException
```
    Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
    
    Called after the region is split.
    
    Parameters:
    
    c - the environment provided by the region server (e.getRegion() returns the parent region)
    
    l - the left daughter region
    
    r - the right daughter region
    
    Throws:
    
    IOException
    
    See Also:
    
    MasterObserver
  - preSplitBeforePONR
```
@Deprecated
default void preSplitBeforePONR(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                            byte[] splitKey,
                                            List<Mutation> metaEntries)
                                     throws IOException
```
    Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
    
    This will be called before PONR step as part of split transaction. Calling ObserverContext.bypass() rollback the split
    
    Parameters:
    
    ctx -
    
    splitKey -
    
    metaEntries - Note: the logic moves to Master; it is unused in RS
    
    Throws:
    
    IOException
    
    See Also:
    
    MasterObserver
  - preSplitAfterPONR
```
@Deprecated
default void preSplitAfterPONR(ObserverContext<RegionCoprocessorEnvironment> ctx)
                                    throws IOException
```
    Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
    
    This will be called after PONR step as part of split transaction Calling ObserverContext.bypass() has no effect in this hook.
    
    Parameters:
    
    ctx - Note: the logic moves to Master; it is unused in RS
    
    Throws:
    
    IOException
    
    See Also:
    
    MasterObserver
  - preRollBackSplit
```
@Deprecated
default void preRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
                                   throws IOException
```
    Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
    
    This will be called before the roll back of the split region is completed
    
    Parameters:
    
    ctx - Note: the logic moves to Master; it is unused in RS
    
    Throws:
    
    IOException
    
    See Also:
    
    MasterObserver
  - postRollBackSplit
```
@Deprecated
default void postRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
                                    throws IOException
```
    Deprecated. No longer called in hbase2/AMv2 given the master runs splits now;
    
    This will be called after the roll back of the split region is completed
    
    Parameters:
    
    ctx - Note: the logic moves to Master; it is unused in RS
    
    Throws:
    
    IOException
    
    See Also:
    
    MasterObserver
  - postCompleteSplit
```
@Deprecated
default void postCompleteSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
                                    throws IOException
```
    Deprecated. No longer called in hbase2/AMv2 given the master runs splits now; implement MasterObserver.postCompletedSplitRegionAction(ObserverContext, HRegionInfo, HRegionInfo) instead.
    
    Called after any split request is processed. This will be called irrespective of success or failure of the split.
    
    Parameters:
    
    ctx -
    
    Throws:
    
    IOException
  - preClose
```
default void preClose(ObserverContext<RegionCoprocessorEnvironment> c,
                      boolean abortRequested)
               throws IOException
```
    Called before the region is reported as closed to the master.
    
    Parameters:
    
    c - the environment provided by the region server
    
    abortRequested - true if the region server is aborting
    
    Throws:
    
    IOException
  - postClose
```
default void postClose(ObserverContext<RegionCoprocessorEnvironment> c,
                       boolean abortRequested)
```
    Called after the region is reported as closed to the master.
    
    Parameters:
    
    c - the environment provided by the region server
    
    abortRequested - true if the region server is aborting
  - preGetOp
```
default void preGetOp(ObserverContext<RegionCoprocessorEnvironment> c,
                      Get get,
                      List<Cell> result)
               throws IOException
```
    Called before the client performs a Get
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Parameters:
    
    c - the environment provided by the region server
    
    get - the Get request
    
    result - The result to return to the client if default processing is bypassed. Can be modified. Will not be used if default processing is not bypassed.
    
    Throws:
    
    IOException
  - postGetOp
```
default void postGetOp(ObserverContext<RegionCoprocessorEnvironment> c,
                       Get get,
                       List<Cell> result)
                throws IOException
```
    Called after the client performs a Get
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'result' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    get - the Get request
    
    result - the result to return to the client, modify as necessary
    
    Throws:
    
    IOException
  - preExists
```
default boolean preExists(ObserverContext<RegionCoprocessorEnvironment> c,
                          Get get,
                          boolean exists)
                   throws IOException
```
    Called before the client tests for existence using a Get.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Parameters:
    
    c - the environment provided by the region server
    
    get - the Get request
    
    exists -
    
    Returns:
    
    the value to return to the client if bypassing default processing
    
    Throws:
    
    IOException
  - postExists
```
default boolean postExists(ObserverContext<RegionCoprocessorEnvironment> c,
                           Get get,
                           boolean exists)
                    throws IOException
```
    Called after the client tests for existence using a Get.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Parameters:
    
    c - the environment provided by the region server
    
    get - the Get request
    
    exists - the result returned by the region server
    
    Returns:
    
    the result to return to the client
    
    Throws:
    
    IOException
  - prePut
```
default void prePut(ObserverContext<RegionCoprocessorEnvironment> c,
                    Put put,
                    WALEdit edit,
                    Durability durability)
             throws IOException
```
    Called before the client stores a value.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    put - The Put object
    
    edit - The WALEdit object that will be written to the wal
    
    durability - Persistence guarantee for this Put
    
    Throws:
    
    IOException
  - postPut
```
default void postPut(ObserverContext<RegionCoprocessorEnvironment> c,
                     Put put,
                     WALEdit edit,
                     Durability durability)
              throws IOException
```
    Called after the client stores a value.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    put - The Put object
    
    edit - The WALEdit object for the wal
    
    durability - Persistence guarantee for this Put
    
    Throws:
    
    IOException
  - preDelete
```
default void preDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                       Delete delete,
                       WALEdit edit,
                       Durability durability)
                throws IOException
```
    Called before the client deletes a value.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    delete - The Delete object
    
    edit - The WALEdit object for the wal
    
    durability - Persistence guarantee for this Delete
    
    Throws:
    
    IOException
  - prePrepareTimeStampForDeleteVersion
```
default void prePrepareTimeStampForDeleteVersion(ObserverContext<RegionCoprocessorEnvironment> c,
                                                 Mutation mutation,
                                                 Cell cell,
                                                 byte[] byteNow,
                                                 Get get)
                                          throws IOException
```
    Called before the server updates the timestamp for version delete with latest timestamp.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Parameters:
    
    c - the environment provided by the region server
    
    mutation - - the parent mutation associated with this delete cell
    
    cell - - The deleteColumn with latest version cell
    
    byteNow - - timestamp bytes
    
    get - - the get formed using the current cell's row. Note that the get does not specify the family and qualifier
    
    Throws:
    
    IOException
  - postDelete
```
default void postDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                        Delete delete,
                        WALEdit edit,
                        Durability durability)
                 throws IOException
```
    Called after the client deletes a value.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    delete - The Delete object
    
    edit - The WALEdit object for the wal
    
    durability - Persistence guarantee for this Delete
    
    Throws:
    
    IOException
  - preBatchMutate
```
default void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
                            MiniBatchOperationInProgress<Mutation> miniBatchOp)
                     throws IOException
```
    This will be called for every batch mutation operation happening at the server. This will be called after acquiring the locks on the mutating rows and after applying the proper timestamp for each Mutation at the server. The batch may contain Put/Delete. By setting OperationStatus of Mutations (MiniBatchOperationInProgress.setOperationStatus(int, OperationStatus)), RegionObserver can make Region to skip these Mutations.
    Note: Do not retain references to any Cells in Mutations beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    miniBatchOp - batch of Mutations getting applied to region.
    
    Throws:
    
    IOException
  - postBatchMutate
```
default void postBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
                             MiniBatchOperationInProgress<Mutation> miniBatchOp)
                      throws IOException
```
    This will be called after applying a batch of Mutations on a region. The Mutations are added to memstore and WAL. The difference of this one with postPut(ObserverContext, Put, WALEdit, Durability) and postDelete(ObserverContext, Delete, WALEdit, Durability) is this hook will be executed before the mvcc transaction completion.
    Note: Do not retain references to any Cells in Mutations beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    miniBatchOp - batch of Mutations applied to region.
    
    Throws:
    
    IOException
  - postStartRegionOperation
```
default void postStartRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                      Region.Operation operation)
                               throws IOException
```
    This will be called for region operations where read lock is acquired in Region.startRegionOperation().
    
    Parameters:
    
    ctx -
    
    operation - The operation is about to be taken on the region
    
    Throws:
    
    IOException
  - postCloseRegionOperation
```
default void postCloseRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                      Region.Operation operation)
                               throws IOException
```
    Called after releasing read lock in Region.closeRegionOperation().
    
    Parameters:
    
    ctx -
    
    operation -
    
    Throws:
    
    IOException
  - postBatchMutateIndispensably
```
default void postBatchMutateIndispensably(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                          MiniBatchOperationInProgress<Mutation> miniBatchOp,
                                          boolean success)
                                   throws IOException
```
    Called after the completion of batch put/delete and will be called even if the batch operation fails.
    Note: Do not retain references to any Cells in Mutations beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    ctx -
    
    miniBatchOp -
    
    success - true if batch operation is successful otherwise false.
    
    Throws:
    
    IOException
  - preCheckAndPut
```
default boolean preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                               byte[] row,
                               byte[] family,
                               byte[] qualifier,
                               CompareFilter.CompareOp compareOp,
                               ByteArrayComparable comparator,
                               Put put,
                               boolean result)
                        throws IOException
```
    Called before checkAndPut.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    compareOp - the comparison operation
    
    comparator - the comparator
    
    put - data to put if check succeeds
    
    result -
    
    Returns:
    
    the return value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - preCheckAndPutAfterRowLock
```
default boolean preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                           byte[] row,
                                           byte[] family,
                                           byte[] qualifier,
                                           CompareFilter.CompareOp compareOp,
                                           ByteArrayComparable comparator,
                                           Put put,
                                           boolean result)
                                    throws IOException
```
    Called before checkAndPut but after acquiring rowlock.
    Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    compareOp - the comparison operation
    
    comparator - the comparator
    
    put - data to put if check succeeds
    
    result -
    
    Returns:
    
    the return value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - postCheckAndPut
```
default boolean postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                                byte[] row,
                                byte[] family,
                                byte[] qualifier,
                                CompareFilter.CompareOp compareOp,
                                ByteArrayComparable comparator,
                                Put put,
                                boolean result)
                         throws IOException
```
    Called after checkAndPut
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    compareOp - the comparison operation
    
    comparator - the comparator
    
    put - data to put if check succeeds
    
    result - from the checkAndPut
    
    Returns:
    
    the possibly transformed return value to return to client
    
    Throws:
    
    IOException
  - preCheckAndDelete
```
default boolean preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                                  byte[] row,
                                  byte[] family,
                                  byte[] qualifier,
                                  CompareFilter.CompareOp compareOp,
                                  ByteArrayComparable comparator,
                                  Delete delete,
                                  boolean result)
                           throws IOException
```
    Called before checkAndDelete.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    compareOp - the comparison operation
    
    comparator - the comparator
    
    delete - delete to commit if check succeeds
    
    result -
    
    Returns:
    
    the value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - preCheckAndDeleteAfterRowLock
```
default boolean preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                              byte[] row,
                                              byte[] family,
                                              byte[] qualifier,
                                              CompareFilter.CompareOp compareOp,
                                              ByteArrayComparable comparator,
                                              Delete delete,
                                              boolean result)
                                       throws IOException
```
    Called before checkAndDelete but after acquiring rowock.
    Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    compareOp - the comparison operation
    
    comparator - the comparator
    
    delete - delete to commit if check succeeds
    
    result -
    
    Returns:
    
    the value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - postCheckAndDelete
```
default boolean postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                                   byte[] row,
                                   byte[] family,
                                   byte[] qualifier,
                                   CompareFilter.CompareOp compareOp,
                                   ByteArrayComparable comparator,
                                   Delete delete,
                                   boolean result)
                            throws IOException
```
    Called after checkAndDelete
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    compareOp - 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
  - preIncrementColumnValue
```
@Deprecated
default long preIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> c,
                                                 byte[] row,
                                                 byte[] family,
                                                 byte[] qualifier,
                                                 long amount,
                                                 boolean writeToWAL)
                                          throws IOException
```
    Deprecated. This hook is no longer called by the RegionServer
    
    Called before incrementColumnValue
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Parameters:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    amount - long amount to increment
    
    writeToWAL - true if the change should be written to the WAL
    
    Returns:
    
    value to return to the client if bypassing default processing
    
    Throws:
    
    IOException
  - postIncrementColumnValue
```
@Deprecated
default long postIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> c,
                                                  byte[] row,
                                                  byte[] family,
                                                  byte[] qualifier,
                                                  long amount,
                                                  boolean writeToWAL,
                                                  long result)
                                           throws IOException
```
    Deprecated. This hook is no longer called by the RegionServer
    
    Called after incrementColumnValue
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Parameters:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    amount - long amount to increment
    
    writeToWAL - true if the change should be written to the WAL
    
    result - the result returned by incrementColumnValue
    
    Returns:
    
    the result to return to the client
    
    Throws:
    
    IOException
  - preAppend
```
default Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                         Append append)
                  throws IOException
```
    Called before Append.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'append' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    append - Append object
    
    Returns:
    
    result to return to the client if bypassing default processing
    
    Throws:
    
    IOException
  - preAppendAfterRowLock
```
default Result preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                     Append append)
                              throws IOException
```
    Called before Append but after acquiring rowlock.
    Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'append' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    append - Append object
    
    Returns:
    
    result to return to the client if bypassing default processing
    
    Throws:
    
    IOException
  - postAppend
```
default Result postAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                          Append append,
                          Result result)
                   throws IOException
```
    Called after Append
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'append' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    append - Append object
    
    result - the result returned by increment
    
    Returns:
    
    the result to return to the client
    
    Throws:
    
    IOException
  - preIncrement
```
default Result preIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                            Increment increment)
                     throws IOException
```
    Called before Increment.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'increment' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    increment - increment object
    
    Returns:
    
    result to return to the client if bypassing default processing
    
    Throws:
    
    IOException
  - preIncrementAfterRowLock
```
default Result preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                        Increment increment)
                                 throws IOException
```
    Called before Increment but after acquiring rowlock.
    Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'increment' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    increment - increment object
    
    Returns:
    
    result to return to the client if bypassing default processing if an error occurred on the coprocessor
    
    Throws:
    
    IOException
  - postIncrement
```
default Result postIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                             Increment increment,
                             Result result)
                      throws IOException
```
    Called after increment
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'increment' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    increment - increment object
    
    result - the result returned by increment
    
    Returns:
    
    the result to return to the client
    
    Throws:
    
    IOException
  - preScannerOpen
```
default RegionScanner preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                     Scan scan,
                                     RegionScanner s)
                              throws IOException
```
    Called before the client opens a new scanner.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    scan - the Scan specification
    
    s - if not null, the base scanner
    
    Returns:
    
    an RegionScanner instance to use instead of the base scanner if overriding default behavior, null otherwise
    
    Throws:
    
    IOException
  - preStoreScannerOpen
```
@Deprecated
default KeyValueScanner preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                                        Store store,
                                                        Scan scan,
                                                        NavigableSet<byte[]> targetCols,
                                                        KeyValueScanner s)
                                                 throws IOException
```
    Deprecated. use preStoreScannerOpen(ObserverContext, Store, Scan, NavigableSet, KeyValueScanner, long) instead
    
    Called before a store opens a new scanner. This hook is called when a "user" scanner is opened.
    See preFlushScannerOpen(ObserverContext, Store, List, InternalScanner, long) and preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner, CompactionRequest, long) to override scanners created for flushes or compactions, resp.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors. Calling ObserverContext.bypass() has no effect in this hook.
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being scanned
    
    scan - the Scan specification
    
    targetCols - columns to be used in the scanner
    
    s - the base scanner, if not null, from previous RegionObserver in the chain
    
    Returns:
    
    a KeyValueScanner instance to use or null to use the default implementation
    
    Throws:
    
    IOException
  - preStoreScannerOpen
```
default KeyValueScanner preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                            Store store,
                                            Scan scan,
                                            NavigableSet<byte[]> targetCols,
                                            KeyValueScanner s,
                                            long readPt)
                                     throws IOException
```
    Called before a store opens a new scanner. This hook is called when a "user" scanner is opened.
    See preFlushScannerOpen(ObserverContext, Store, List, InternalScanner, long) and preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner, CompactionRequest, long) to override scanners created for flushes or compactions, resp.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors. Calling ObserverContext.bypass() has no effect in this hook.
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being scanned
    
    scan - the Scan specification
    
    targetCols - columns to be used in the scanner
    
    s - the base scanner, if not null, from previous RegionObserver in the chain
    
    readPt - the read point
    
    Returns:
    
    a KeyValueScanner instance to use or null to use the default implementation
    
    Throws:
    
    IOException
  - postScannerOpen
```
default RegionScanner postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                      Scan scan,
                                      RegionScanner s)
                               throws IOException
```
    Called after the client opens a new scanner.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    scan - the Scan specification
    
    s - if not null, the base scanner
    
    Returns:
    
    the scanner instance to use
    
    Throws:
    
    IOException
  - preScannerNext
```
default boolean preScannerNext(ObserverContext<RegionCoprocessorEnvironment> c,
                               InternalScanner s,
                               List<Result> result,
                               int limit,
                               boolean hasNext)
                        throws IOException
```
    Called before the client asks for the next row on a scanner.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    result - The result to return to the client if default processing is bypassed. Can be modified. Will not be returned if default processing is not bypassed.
    
    limit - the maximum number of results to return
    
    hasNext - the 'has more' indication
    
    Returns:
    
    'has more' indication that should be sent to client
    
    Throws:
    
    IOException
  - postScannerNext
```
default boolean postScannerNext(ObserverContext<RegionCoprocessorEnvironment> c,
                                InternalScanner s,
                                List<Result> result,
                                int limit,
                                boolean hasNext)
                         throws IOException
```
    Called after the client asks for the next row on a scanner.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Parameters:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    result - the result to return to the client, can be modified
    
    limit - the maximum number of results to return
    
    hasNext - the 'has more' indication
    
    Returns:
    
    'has more' indication that should be sent to client
    
    Throws:
    
    IOException
  - postScannerFilterRow
```
@Deprecated
default boolean postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> c,
                                                 InternalScanner s,
                                                 byte[] currentRow,
                                                 int offset,
                                                 short length,
                                                 boolean hasMore)
                                          throws IOException
```
    Deprecated. As of release 2.0.0, this will be removed in HBase 3.0.0. Instead use postScannerFilterRow(ObserverContext, InternalScanner, Cell, boolean)
    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
    Parameters:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    currentRow - The current rowkey which got filtered out
    
    offset - offset to rowkey
    
    length - length of rowkey
    
    hasMore - the 'has more' indication
    
    Returns:
    
    whether more rows are available for the scanner or not
    
    Throws:
    
    IOException
  - postScannerFilterRow
```
default boolean postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> c,
                                     InternalScanner s,
                                     Cell curRowCell,
                                     boolean hasMore)
                              throws IOException
```
    This will be called by the scan flow when the current scanned row is being filtered out by the filter. The filter may be filtering out the row via any of the below scenarios
    1. boolean filterRowKey(byte [] buffer, int offset, int length) returning true
    2. boolean filterRow() returning true
    3. default void filterRow(List<KeyValue> kvs) removing all the kvs from the passed List
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    Parameters:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    curRowCell - The cell in the current row which got filtered out
    
    hasMore - the 'has more' indication
    
    Returns:
    
    whether more rows are available for the scanner or not
    
    Throws:
    
    IOException
  - preScannerClose
```
default void preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c,
                             InternalScanner s)
                      throws IOException
```
    Called before the client closes a scanner.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Parameters:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    Throws:
    
    IOException
  - postScannerClose
```
default void postScannerClose(ObserverContext<RegionCoprocessorEnvironment> ctx,
                              InternalScanner s)
                       throws IOException
```
    Called after the client closes a scanner.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    s - the scanner
    
    Throws:
    
    IOException
  - preReplayWALs
```
default void preReplayWALs(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
                           HRegionInfo info,
                           org.apache.hadoop.fs.Path edits)
                    throws IOException
```
    Called before replaying WALs for this region. Calling ObserverContext.bypass() has no effect in this hook.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    info - the RegionInfo for this region
    
    edits - the file of recovered edits
    
    Throws:
    
    IOException
  - postReplayWALs
```
default void postReplayWALs(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
                            HRegionInfo info,
                            org.apache.hadoop.fs.Path edits)
                     throws IOException
```
    Called after replaying WALs for this region.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    info - the RegionInfo for this region
    
    edits - the file of recovered edits
    
    Throws:
    
    IOException
  - preWALRestore
```
default void preWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
                           HRegionInfo info,
                           WALKey logKey,
                           WALEdit logEdit)
                    throws IOException
```
    Called before a WALEdit replayed for this region.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    Throws:
    
    IOException
  - postWALRestore
```
default void postWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
                            HRegionInfo info,
                            WALKey logKey,
                            WALEdit logEdit)
                     throws IOException
```
    Called after a WALEdit replayed for this region.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    Throws:
    
    IOException
  - preBulkLoadHFile
```
default void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                              List<Pair<byte[],String>> familyPaths)
                       throws IOException
```
    Called before bulkLoadHFile. Users can create a StoreFile instance to access the contents of a HFile.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    familyPaths - pairs of { CF, HFile path } submitted for bulk load. Adding or removing from this list will add or remove HFiles to be bulk loaded.
    
    Throws:
    
    IOException
  - preCommitStoreFile
```
default void preCommitStoreFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                byte[] family,
                                List<Pair<org.apache.hadoop.fs.Path,org.apache.hadoop.fs.Path>> pairs)
                         throws IOException
```
    Called before moving bulk loaded hfile to region directory.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    family - column family
    
    pairs - List of pairs of { HFile location in staging dir, HFile path in region dir } Each pair are for the same hfile.
    
    Throws:
    
    IOException
  - postCommitStoreFile
```
default void postCommitStoreFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                 byte[] family,
                                 org.apache.hadoop.fs.Path srcPath,
                                 org.apache.hadoop.fs.Path dstPath)
                          throws IOException
```
    Called after moving bulk loaded hfile to region directory.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    family - column family
    
    srcPath - Path to file before the move
    
    dstPath - Path to file after the move
    
    Throws:
    
    IOException
  - postBulkLoadHFile
```
default boolean postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                  List<Pair<byte[],String>> stagingFamilyPaths,
                                  Map<byte[],List<org.apache.hadoop.fs.Path>> finalPaths,
                                  boolean hasLoaded)
                           throws IOException
```
    Called after bulkLoadHFile.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    stagingFamilyPaths - pairs of { CF, HFile path } submitted for bulk load
    
    finalPaths - Map of CF to List of file paths for the final loaded files
    
    hasLoaded - whether the bulkLoad was successful
    
    Returns:
    
    the new value of hasLoaded
    
    Throws:
    
    IOException
  - postBulkLoadHFile
```
default boolean postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                  List<Pair<byte[],String>> stagingFamilyPaths,
                                  boolean hasLoaded)
                           throws IOException
```
    Deprecated. Use postBulkLoadHFile(ObserverContext, List, Map, boolean)
    
    Called after bulkLoadHFile.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    stagingFamilyPaths - pairs of { CF, HFile path } submitted for bulk load
    
    hasLoaded - whether the bulkLoad was successful
    
    Returns:
    
    the new value of hasLoaded
    
    Throws:
    
    IOException
  - preStoreFileReaderOpen
```
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
```
    Called before creation of Reader for a store file. Calling ObserverContext.bypass() has no effect in this hook.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    fs - fileystem to read from
    
    p - path to the file
    
    in - FSDataInputStreamWrapper
    
    size - Full size of the file
    
    cacheConf -
    
    r - original reference file. This will be not null only when reading a split file.
    
    reader - the base reader, if not null, from previous RegionObserver in the chain
    
    Returns:
    
    a Reader instance to use instead of the base reader if overriding default behavior, null otherwise
    
    Throws:
    
    IOException
  - postStoreFileReaderOpen
```
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
```
    Called after the creation of Reader for a store file.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    fs - fileystem to read from
    
    p - path to the file
    
    in - FSDataInputStreamWrapper
    
    size - Full size of the file
    
    cacheConf -
    
    r - original reference file. This will be not null only when reading a split file.
    
    reader - the base reader instance
    
    Returns:
    
    The reader to use
    
    Throws:
    
    IOException
  - postMutationBeforeWAL
```
default Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                   RegionObserver.MutationType opType,
                                   Mutation mutation,
                                   Cell oldCell,
                                   Cell newCell)
                            throws IOException
```
    Called after a new cell has been created during an increment operation, but before it is committed to the WAL or memstore. Calling ObserverContext.bypass() has no effect in this hook.
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    opType - the operation type
    
    mutation - the current mutation
    
    oldCell - old cell containing previous value
    
    newCell - the new cell containing the computed value
    
    Returns:
    
    the new cell, possibly changed
    
    Throws:
    
    IOException
  - postInstantiateDeleteTracker
```
default DeleteTracker postInstantiateDeleteTracker(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                                   DeleteTracker delTracker)
                                            throws IOException
```
    Called after the ScanQueryMatcher creates ScanDeleteTracker. Implementing this hook would help in creating customised DeleteTracker and returning the newly created DeleteTracker
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    delTracker - the deleteTracker that is created by the QueryMatcher
    
    Returns:
    
    the Delete Tracker
    
    Throws:
    
    IOException

Interface RegionObserver

Exception Handling

Nested Class Summary

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

Field Summary

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

Method Summary

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

Method Detail

preOpen

postOpen

postLogReplay

preFlushScannerOpen

preFlushScannerOpen

preFlushScannerOpen

preFlush

preFlush

postFlush

postFlush

preCompactSelection

preCompactSelection

postCompactSelection

postCompactSelection

preCompact

preCompact

preCompactScannerOpen

preCompactScannerOpen

preCompactScannerOpen

postCompact

postCompact

preSplit

preSplit

postSplit

preSplitBeforePONR

preSplitAfterPONR

preRollBackSplit

postRollBackSplit

postCompleteSplit

preClose

postClose

preGetOp

postGetOp

preExists

postExists

prePut

postPut

preDelete

prePrepareTimeStampForDeleteVersion

postDelete

preBatchMutate

postBatchMutate

postStartRegionOperation

postCloseRegionOperation

postBatchMutateIndispensably

preCheckAndPut

preCheckAndPutAfterRowLock

postCheckAndPut

preCheckAndDelete

preCheckAndDeleteAfterRowLock

postCheckAndDelete

preIncrementColumnValue

postIncrementColumnValue

preAppend

preAppendAfterRowLock

postAppend

preIncrement

preIncrementAfterRowLock

postIncrement

preScannerOpen

preStoreScannerOpen

preStoreScannerOpen

postScannerOpen

preScannerNext

postScannerNext

postScannerFilterRow

postScannerFilterRow

preScannerClose

postScannerClose

preReplayWALs

postReplayWALs