RegionObserver (Apache HBase 1.1.7 API)

All Superinterfaces:

Coprocessor

All Known Implementing Classes:

AccessController, BaseMasterAndRegionObserver, BaseRegionObserver, ConstraintProcessor, 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.

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

Methods
Modifier and Type	Method and Description
`Result`	`postAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append, Result result)` Called after Append
`void`	`postBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)` This will be called after applying a batch of Mutations on a region.
`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
`boolean`	`postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> familyPaths, boolean hasLoaded)` Called after bulkLoadHFile.
`boolean`	`postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)` Called after checkAndDelete
`boolean`	`postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)` Called after checkAndPut
`void`	`postClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested)` Called after the region is reported as closed to the master.
`void`	`postCloseRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx, Region.Operation operation)` Called after releasing read lock in `Region.closeRegionOperation()`.
`void`	`postCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile)` Deprecated. Use `postCompact(ObserverContext, Store, StoreFile, CompactionRequest)` instead
`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.
`void`	`postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, com.google.common.collect.ImmutableList<StoreFile> selected)` Deprecated. use `postCompactSelection(ObserverContext, Store, ImmutableList, CompactionRequest)` instead.
`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.
`void`	`postCompleteSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)` Called after any split request is processed.
`void`	`postDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)` Called after the client deletes a value.
`boolean`	`postExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists)` Called after the client tests for existence using a Get.
`void`	`postFlush(ObserverContext<RegionCoprocessorEnvironment> c)` Deprecated. use `preFlush(ObserverContext, Store, InternalScanner)` instead.
`void`	`postFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile)` Called after a Store's memstore is flushed to disk.
`void`	`postGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, Result result)` Called after a client makes a GetClosestRowBefore request.
`void`	`postGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result)` Called after the client performs a Get
`Result`	`postIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment, Result result)` Called after increment
`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
`DeleteTracker`	`postInstantiateDeleteTracker(ObserverContext<RegionCoprocessorEnvironment> ctx, DeleteTracker delTracker)` Called after the ScanQueryMatcher creates ScanDeleteTracker.
`void`	`postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c)` Called after the log replay on the region is over.
`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.
`void`	`postOpen(ObserverContext<RegionCoprocessorEnvironment> c)` Called after the region is reported as open to the master.
`void`	`postPut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)` Called after the client stores a value.
`void`	`postRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)` This will be called after the roll back of the split region is completed
`void`	`postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)` Called after the client closes a scanner.
`boolean`	`postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, byte[] currentRow, int offset, short length, boolean hasMore)` This will be called by the scan flow when the current scanned row is being filtered out by the filter.
`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.
`RegionScanner`	`postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s)` Called after the client opens a new scanner.
`void`	`postSplit(ObserverContext<RegionCoprocessorEnvironment> c, Region l, Region r)` Deprecated. Use postCompleteSplit() instead
`void`	`postStartRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx, Region.Operation operation)` This will be called for region operations where read lock is acquired in `Region.startRegionOperation()`.
`StoreFile.Reader`	`postStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path p, FSDataInputStreamWrapper in, long size, CacheConfig cacheConf, Reference r, StoreFile.Reader reader)` Called after the creation of Reader for a store file.
`void`	`postWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, HRegionInfo info, WALKey logKey, WALEdit logEdit)` Called after a `WALEdit` replayed for this region.
`void`	`postWALRestore(ObserverContext<RegionCoprocessorEnvironment> ctx, HRegionInfo info, HLogKey logKey, WALEdit logEdit)` Deprecated. use `postWALRestore(ObserverContext, HRegionInfo, WALKey, WALEdit)`
`Result`	`preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append)` Called before Append.
`Result`	`preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Append append)` Called before Append but after acquiring rowlock.
`void`	`preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)` This will be called for every batch mutation operation happening at the server.
`void`	`preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> familyPaths)` Called before bulkLoadHFile.
`boolean`	`preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)` Called before checkAndDelete.
`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.
`boolean`	`preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)` Called before checkAndPut.
`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.
`void`	`preClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested)` Called before the region is reported as closed to the master.
`InternalScanner`	`preCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner, ScanType scanType)` Deprecated. use `preCompact(ObserverContext, Store, InternalScanner, ScanType, CompactionRequest)` instead
`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`.
`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)` instead.
`InternalScanner`	`preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s, CompactionRequest request)` 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.
`void`	`preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<StoreFile> candidates)` Deprecated. Use `preCompactSelection(ObserverContext, Store, List, CompactionRequest)` instead
`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.
`void`	`preDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)` Called before the client deletes a value.
`boolean`	`preExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists)` Called before the client tests for existence using a Get.
`void`	`preFlush(ObserverContext<RegionCoprocessorEnvironment> c)` Deprecated. use `preFlush(ObserverContext, Store, InternalScanner)` instead
`InternalScanner`	`preFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner)` Called before a Store's memstore is flushed to disk.
`InternalScanner`	`preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, KeyValueScanner memstoreScanner, InternalScanner s)` Called before a memstore is flushed to disk and prior to creating the scanner to read from the memstore.
`void`	`preGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, Result result)` Called before a client makes a GetClosestRowBefore request.
`void`	`preGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result)` Called before the client performs a Get
`Result`	`preIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)` Called before Increment.
`Result`	`preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)` Called before Increment but after acquiring rowlock.
`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
`void`	`preOpen(ObserverContext<RegionCoprocessorEnvironment> c)` Called before the region is reported as open to the master.
`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.
`void`	`prePut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)` Called before the client stores a value.
`void`	`preRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)` This will be called before the roll back of the split region is completed
`void`	`preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)` Called before the client closes a scanner.
`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.
`RegionScanner`	`preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s)` Called before the client opens a new scanner.
`void`	`preSplit(ObserverContext<RegionCoprocessorEnvironment> c)` Deprecated. Use preSplit( final ObserverContext c, byte[] splitRow)
`void`	`preSplit(ObserverContext<RegionCoprocessorEnvironment> c, byte[] splitRow)` Called before the region is split.
`void`	`preSplitAfterPONR(ObserverContext<RegionCoprocessorEnvironment> ctx)` This will be called after PONR step as part of split transaction Calling `ObserverContext.bypass()` has no effect in this hook.
`void`	`preSplitBeforePONR(ObserverContext<RegionCoprocessorEnvironment> ctx, byte[] splitKey, List<Mutation> metaEntries)` This will be called before PONR step as part of split transaction.
`StoreFile.Reader`	`preStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path p, FSDataInputStreamWrapper in, long size, CacheConfig cacheConf, Reference r, StoreFile.Reader reader)` Called before creation of Reader for a store file.
`KeyValueScanner`	`preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, Scan scan, NavigableSet<byte[]> targetCols, KeyValueScanner s)` Called before a store opens a new scanner.
`void`	`preWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, HRegionInfo info, WALKey logKey, WALEdit logEdit)` Called before a `WALEdit` replayed for this region.
`void`	`preWALRestore(ObserverContext<RegionCoprocessorEnvironment> ctx, HRegionInfo info, HLogKey logKey, WALEdit logEdit)` Deprecated. use `preWALRestore(ObserverContext, HRegionInfo, WALKey, WALEdit)`

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

- Method Detail
  - preOpen
```
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 - if an error occurred on the coprocessor
  - postOpen
```
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
```
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
```
InternalScanner preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                  Store store,
                                  KeyValueScanner memstoreScanner,
                                  InternalScanner s)
                                    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
    memstoreScanner - the scanner 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 - if an error occurred on the coprocessor
  - preFlush
```
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 - if an error occurred on the coprocessor
  - preFlush
```
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 - if an error occurred on the coprocessor
  - postFlush
```
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 - if an error occurred on the coprocessor
  - postFlush
```
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 - if an error occurred on the coprocessor
  - preCompactSelection
```
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 - if an error occurred on the coprocessor
  - preCompactSelection
```
@Deprecated
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 - if an error occurred on the coprocessor
  - postCompactSelection
```
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
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
```
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 - if an error occurred on the coprocessor
  - preCompact
```
@Deprecated
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 - if an error occurred on the coprocessor
  - preCompactScannerOpen
```
InternalScanner preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                    Store store,
                                    List<? extends KeyValueScanner> scanners,
                                    ScanType scanType,
                                    long earliestPutTs,
                                    InternalScanner s,
                                    CompactionRequest request)
                                      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 - the requested compaction
    
    Returns:
    the scanner to use during compaction. null if the default implementation is to be used.
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - preCompactScannerOpen
```
@Deprecated
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) 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 - if an error occurred on the coprocessor
  - postCompact
```
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 - if an error occurred on the coprocessor
  - postCompact
```
@Deprecated
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 - if an error occurred on the coprocessor
  - preSplit
```
void preSplit(ObserverContext<RegionCoprocessorEnvironment> c)
              throws IOException
```
    Deprecated. Use preSplit( final ObserverContext c, byte[] splitRow)
    
    Called before the region is split.
    
    Parameters:
    c - the environment provided by the region server (e.getRegion() returns the parent region)
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - preSplit
```
void preSplit(ObserverContext<RegionCoprocessorEnvironment> c,
            byte[] splitRow)
              throws IOException
```
    Called before the region is split.
    
    Parameters:
    c - the environment provided by the region server (e.getRegion() returns the parent region)
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - postSplit
```
void postSplit(ObserverContext<RegionCoprocessorEnvironment> c,
             Region l,
             Region r)
               throws IOException
```
    Deprecated. Use postCompleteSplit() instead
    
    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 - if an error occurred on the coprocessor
  - preSplitBeforePONR
```
void preSplitBeforePONR(ObserverContext<RegionCoprocessorEnvironment> ctx,
                      byte[] splitKey,
                      List<Mutation> metaEntries)
                        throws IOException
```
    This will be called before PONR step as part of split transaction. Calling ObserverContext.bypass() rollback the split
    
    Parameters:
    ctx -
    splitKey -
    metaEntries -
    
    Throws:
    
    IOException
  - preSplitAfterPONR
```
void preSplitAfterPONR(ObserverContext<RegionCoprocessorEnvironment> ctx)
                       throws IOException
```
    This will be called after PONR step as part of split transaction Calling ObserverContext.bypass() has no effect in this hook.
    
    Parameters:
    ctx -
    
    Throws:
    
    IOException
  - preRollBackSplit
```
void preRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
                      throws IOException
```
    This will be called before the roll back of the split region is completed
    
    Parameters:
    ctx -
    
    Throws:
    
    IOException
  - postRollBackSplit
```
void postRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
                       throws IOException
```
    This will be called after the roll back of the split region is completed
    
    Parameters:
    ctx -
    
    Throws:
    
    IOException
  - postCompleteSplit
```
void postCompleteSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
                       throws IOException
```
    Called after any split request is processed. This will be called irrespective of success or failure of the split.
    
    Parameters:
    ctx -
    
    Throws:
    
    IOException
  - preClose
```
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
```
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
  - preGetClosestRowBefore
```
void preGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c,
                          byte[] row,
                          byte[] family,
                          Result result)
                            throws IOException
```
    Called before a client makes a GetClosestRowBefore request.
    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 - the row
    family - the family
    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 - if an error occurred on the coprocessor
  - postGetClosestRowBefore
```
void postGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c,
                           byte[] row,
                           byte[] family,
                           Result result)
                             throws IOException
```
    Called after a client makes a GetClosestRowBefore request.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Parameters:
    c - the environment provided by the region server
    row - the row
    family - the desired family
    result - the result to return to the client, modify as necessary
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - preGetOp
```
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 - if an error occurred on the coprocessor
  - postGetOp
```
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
    
    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 - if an error occurred on the coprocessor
  - preExists
```
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 - if an error occurred on the coprocessor
  - postExists
```
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 - if an error occurred on the coprocessor
  - prePut
```
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
    
    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 - if an error occurred on the coprocessor
  - postPut
```
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
    
    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 - if an error occurred on the coprocessor
  - preDelete
```
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
    
    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 - if an error occurred on the coprocessor
  - prePrepareTimeStampForDeleteVersion
```
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
```
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
    
    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 - if an error occurred on the coprocessor
  - preBatchMutate
```
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.
    
    Parameters:
    c - the environment provided by the region server
    miniBatchOp - batch of Mutations getting applied to region.
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - postBatchMutate
```
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.
    
    Parameters:
    c - the environment provided by the region server
    miniBatchOp - batch of Mutations applied to region.
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - postStartRegionOperation
```
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
```
void postCloseRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx,
                            Region.Operation operation)
                              throws IOException
```
    Called after releasing read lock in Region.closeRegionOperation().
    
    Parameters:
    ctx -
    operation -
    
    Throws:
    
    IOException
  - postBatchMutateIndispensably
```
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
    
    Parameters:
    ctx -
    miniBatchOp -
    success - true if batch operation is successful otherwise false.
    
    Throws:
    
    IOException
  - preCheckAndPut
```
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
    
    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 - if an error occurred on the coprocessor
  - preCheckAndPutAfterRowLock
```
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
    
    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 - if an error occurred on the coprocessor
  - postCheckAndPut
```
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
    
    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 - if an error occurred on the coprocessor
  - preCheckAndDelete
```
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
    
    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 - if an error occurred on the coprocessor
  - preCheckAndDeleteAfterRowLock
```
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
    
    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 - if an error occurred on the coprocessor
  - postCheckAndDelete
```
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
    
    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 - if an error occurred on the coprocessor
  - preIncrementColumnValue
```
@Deprecated
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 - if an error occurred on the coprocessor
  - postIncrementColumnValue
```
@Deprecated
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 - if an error occurred on the coprocessor
  - preAppend
```
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
    
    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 - if an error occurred on the coprocessor
  - preAppendAfterRowLock
```
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
    
    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 - if an error occurred on the coprocessor
  - postAppend
```
Result postAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                Append append,
                Result result)
                  throws IOException
```
    Called after Append
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    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 - if an error occurred on the coprocessor
  - preIncrement
```
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
    
    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 - if an error occurred on the coprocessor
  - preIncrementAfterRowLock
```
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
    
    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 - if an error occurred on the coprocessor
  - postIncrement
```
Result postIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                   Increment increment,
                   Result result)
                     throws IOException
```
    Called after increment
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    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 - if an error occurred on the coprocessor
  - preScannerOpen
```
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
    
    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 - if an error occurred on the coprocessor
  - preStoreScannerOpen
```
KeyValueScanner preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                  Store store,
                                  Scan scan,
                                  NavigableSet<byte[]> targetCols,
                                  KeyValueScanner s)
                                    throws IOException
```
    Called before a store opens a new scanner. This hook is called when a "user" scanner is opened.
    See preFlushScannerOpen(ObserverContext, Store, KeyValueScanner, InternalScanner) and preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner) 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.
    
    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 - if an error occurred on the coprocessor
  - postScannerOpen
```
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
    
    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 - if an error occurred on the coprocessor
  - preScannerNext
```
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
    
    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 - if an error occurred on the coprocessor
  - postScannerNext
```
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
    
    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 - if an error occurred on the coprocessor
  - postScannerFilterRow
```
boolean postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> c,
                           InternalScanner s,
                           byte[] currentRow,
                           int offset,
                           short length,
                           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. void filterRow(List 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
  - preScannerClose
```
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 - if an error occurred on the coprocessor
  - postScannerClose
```
void postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c,
                    InternalScanner s)
                      throws IOException
```
    Called after the client closes a scanner.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Parameters:
    c - the environment provided by the region server
    s - the scanner
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - preWALRestore
```
void preWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
                 HRegionInfo info,
                 WALKey logKey,
                 WALEdit logEdit)
                   throws IOException
```
    Called before a WALEdit replayed for this region.
    
    Throws:
    
    IOException
  - preWALRestore
```
@Deprecated
void preWALRestore(ObserverContext<RegionCoprocessorEnvironment> ctx,
                            HRegionInfo info,
                            HLogKey logKey,
                            WALEdit logEdit)
                   throws IOException
```
    Deprecated. use preWALRestore(ObserverContext, HRegionInfo, WALKey, WALEdit)
    
    Called before a WALEdit replayed for this region. This method is left in place to maintain binary compatibility with older RegionObservers. If an implementation directly overrides preWALRestore(ObserverContext, HRegionInfo, WALKey, WALEdit) then this version won't be called at all, barring problems with the Security Manager. To work correctly in the presence of a strict Security Manager, or in the case of an implementation that relies on a parent class to implement preWALRestore, you should implement this method as a call to the non-deprecated version. Users of this method will see all edits that can be treated as HLogKey. If there are edits that can't be treated as HLogKey they won't be offered to coprocessors that rely on this method. If a coprocessor gets skipped because of this mechanism, a log message at ERROR will be generated per coprocessor on the logger for CoprocessorHost once per classloader.
    
    Throws:
    
    IOException
  - postWALRestore
```
void postWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
                  HRegionInfo info,
                  WALKey logKey,
                  WALEdit logEdit)
                    throws IOException
```
    Called after a WALEdit replayed for this region.
    
    Throws:
    
    IOException
  - postWALRestore
```
@Deprecated
void postWALRestore(ObserverContext<RegionCoprocessorEnvironment> ctx,
                             HRegionInfo info,
                             HLogKey logKey,
                             WALEdit logEdit)
                    throws IOException
```
    Deprecated. use postWALRestore(ObserverContext, HRegionInfo, WALKey, WALEdit)
    
    Called after a WALEdit replayed for this region. This method is left in place to maintain binary compatibility with older RegionObservers. If an implementation directly overrides postWALRestore(ObserverContext, HRegionInfo, WALKey, WALEdit) then this version won't be called at all, barring problems with the Security Manager. To work correctly in the presence of a strict Security Manager, or in the case of an implementation that relies on a parent class to implement preWALRestore, you should implement this method as a call to the non-deprecated version. Users of this method will see all edits that can be treated as HLogKey. If there are edits that can't be treated as HLogKey they won't be offered to coprocessors that rely on this method. If a coprocessor gets skipped because of this mechanism, a log message at ERROR will be generated per coprocessor on the logger for CoprocessorHost once per classloader.
    
    Throws:
    
    IOException
  - preBulkLoadHFile
```
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 -
    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
  - postBulkLoadHFile
```
boolean postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                        List<Pair<byte[],String>> familyPaths,
                        boolean hasLoaded)
                          throws IOException
```
    Called after bulkLoadHFile.
    
    Parameters:
    ctx -
    familyPaths - pairs of { CF, HFile path } submitted for bulk load
    hasLoaded - whether the bulkLoad was successful
    
    Returns:
    the new value of hasLoaded
    
    Throws:
    
    IOException
  - preStoreFileReaderOpen
```
StoreFile.Reader preStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                      org.apache.hadoop.fs.FileSystem fs,
                                      org.apache.hadoop.fs.Path p,
                                      FSDataInputStreamWrapper in,
                                      long size,
                                      CacheConfig cacheConf,
                                      Reference r,
                                      StoreFile.Reader 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
```
StoreFile.Reader postStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                       org.apache.hadoop.fs.FileSystem fs,
                                       org.apache.hadoop.fs.Path p,
                                       FSDataInputStreamWrapper in,
                                       long size,
                                       CacheConfig cacheConf,
                                       Reference r,
                                       StoreFile.Reader 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
```
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
```
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

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

preFlush

preFlush

postFlush

postFlush

preCompactSelection

preCompactSelection

postCompactSelection

postCompactSelection

preCompact

preCompact

preCompactScannerOpen

preCompactScannerOpen

postCompact

postCompact

preSplit

preSplit

postSplit

preSplitBeforePONR

preSplitAfterPONR

preRollBackSplit

postRollBackSplit

postCompleteSplit

preClose

postClose

preGetClosestRowBefore

postGetClosestRowBefore

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

postScannerOpen

preScannerNext

postScannerNext

postScannerFilterRow

preScannerClose

postScannerClose

preWALRestore

preWALRestore

postWALRestore

postWALRestore

preBulkLoadHFile

postBulkLoadHFile