HRegion (Apache HBase - Server 2.5.6-hadoop3 API)

java.lang.Object
- org.apache.hadoop.hbase.regionserver.HRegion

All Implemented Interfaces:

ConfigurationObserver, PropagatingConfigurationObserver, HeapSize, Region
```
@InterfaceAudience.Private
public class HRegion
extends Object
implements HeapSize, PropagatingConfigurationObserver, Region
```
Regions store data for a certain region of a table. It stores all columns for each row. A given table consists of one or more Regions.
An Region is defined by its table and its key extent.
Locking at the Region level serves only one purpose: preventing the region from being closed (and consequently split) while other operations are ongoing. Each row level operation obtains both a row lock and a region read lock for the duration of the operation. While a scanner is being constructed, getScanner holds a read lock. If the scanner is successfully constructed, it holds a read lock until it is closed. A close takes out a write lock and consequently will block for ongoing operations and will block new operations from starting while the close is in progress.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`HRegion.BulkLoadListener` Listener class to enable callers of bulkLoadHFile() to perform any necessary pre/post processing of a given bulkload call
`static interface`	`HRegion.FlushResult`
`static class`	`HRegion.FlushResultImpl` Objects from this class are created when flushing to describe all the different states that that method ends up in.
`static class`	`HRegion.RowLockImpl` Class used to represent a lock on a row.

Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.regionserver.Region
Region.Operation, Region.RowLock

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`CLOSE_WAIT_ABORT`
`static String`	`CLOSE_WAIT_INTERVAL`
`static String`	`CLOSE_WAIT_TIME`
`static String`	`COMPACTION_AFTER_BULKLOAD_ENABLE` Parameter name for compaction after bulkload
`protected org.apache.hadoop.conf.Configuration`	`conf`
`static long`	`DEEP_OVERHEAD`
`static int`	`DEFAULT_CACHE_FLUSH_INTERVAL` Default interval for the memstore flush
`static boolean`	`DEFAULT_CLOSE_WAIT_ABORT`
`static long`	`DEFAULT_CLOSE_WAIT_INTERVAL`
`static long`	`DEFAULT_CLOSE_WAIT_TIME`
`static boolean`	`DEFAULT_FAIR_REENTRANT_CLOSE_LOCK`
`static long`	`DEFAULT_FLUSH_PER_CHANGES`
`static int`	`DEFAULT_HBASE_REGIONSERVER_MINIBATCH_SIZE`
`static int`	`DEFAULT_MAX_CELL_SIZE`
`static String`	`DEFAULT_REGION_STORAGE_POLICY`
`static boolean`	`DEFAULT_USE_META_CELL_COMPARATOR`
`static boolean`	`DEFAULT_WAL_HSYNC`
`static String`	`FAIR_REENTRANT_CLOSE_LOCK` Conf key for fair locking policy
`static long`	`FIXED_OVERHEAD`
`static String`	`HBASE_MAX_CELL_SIZE_KEY`
`static String`	`HBASE_REGIONSERVER_MINIBATCH_SIZE`
`protected long`	`lastReplayedCompactionSeqId`
`protected long`	`lastReplayedOpenRegionSeqId` The sequence id of the last replayed open region event from the primary region.
`static String`	`LOAD_CFS_ON_DEMAND_CONFIG_KEY`
`static long`	`MAX_FLUSH_PER_CHANGES` The following MAX_FLUSH_PER_CHANGES is large enough because each KeyValue has 20+ bytes overhead.
`static String`	`MEMSTORE_FLUSH_PER_CHANGES` Conf key to force a flush if there are already enough changes for one region in memstore
`static String`	`MEMSTORE_PERIODIC_FLUSH_INTERVAL` Conf key for the periodic flush interval
`static String`	`REGION_STORAGE_POLICY_KEY`
`protected RegionServerServices`	`rsServices`
`static String`	`SPECIAL_RECOVERED_EDITS_DIR` This is for for using HRegion as a local storage, where we may put the recovered edits in a special place.
`static String`	`SPLIT_IGNORE_BLOCKING_ENABLED_KEY` Config for allow split when file count greater than the configured blocking file count
`protected Map<byte[],HStore>`	`stores`
`static int`	`SYSTEM_CACHE_FLUSH_INTERVAL` Default interval for System tables memstore flush
`static String`	`USE_META_CELL_COMPARATOR` Whether to use `MetaCellComparator` even if we are not meta region.
`static String`	`WAL_HSYNC_CONF_KEY`

Constructor Summary

Constructors
Constructor and Description
`HRegion(HRegionFileSystem fs, WAL wal, org.apache.hadoop.conf.Configuration confParam, TableDescriptor htd, RegionServerServices rsServices)` HRegion constructor.
`HRegion(org.apache.hadoop.fs.Path tableDir, WAL wal, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.conf.Configuration confParam, RegionInfo regionInfo, TableDescriptor htd, RegionServerServices rsServices)` Deprecated. Use other constructors.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addReadRequestsCount(long readRequestsCount)`
`void`	`addRegionToSnapshot(org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription desc, ForeignExceptionSnare exnSnare)` Complete taking the snapshot on the region.
`void`	`addWriteRequestsCount(long writeRequestsCount)`
`Result`	`append(Append append)` Perform one or more append operations on a row.
`Result`	`append(Append append, long nonceGroup, long nonce)`
`boolean`	`areWritesEnabled()`
`OperationStatus[]`	`batchMutate(Mutation[] mutations)` Perform a batch of mutations.
`OperationStatus[]`	`batchMutate(Mutation[] mutations, boolean atomic, long nonceGroup, long nonce)`
`OperationStatus[]`	`batchReplay(WALSplitUtil.MutationReplay[] mutations, long replaySeqId)`
`void`	`blockUpdates()`
`Map<byte[],List<org.apache.hadoop.fs.Path>>`	`bulkLoadHFiles(Collection<Pair<byte[],String>> familyPaths, boolean assignSeqId, HRegion.BulkLoadListener bulkLoadListener)` Attempts to atomically load a group of hfiles.
`Map<byte[],List<org.apache.hadoop.fs.Path>>`	`bulkLoadHFiles(Collection<Pair<byte[],String>> familyPaths, boolean assignSeqId, HRegion.BulkLoadListener bulkLoadListener, boolean copyFile, List<String> clusterIds, boolean replicate)` Attempts to atomically load a group of hfiles.
`boolean`	`checkAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, TimeRange timeRange, Mutation mutation)` Deprecated.
`boolean`	`checkAndMutate(byte[] row, Filter filter, TimeRange timeRange, Mutation mutation)` Deprecated.
`CheckAndMutateResult`	`checkAndMutate(CheckAndMutate checkAndMutate)` Atomically checks if a row matches the conditions and if it does, it performs the actions.
`CheckAndMutateResult`	`checkAndMutate(CheckAndMutate checkAndMutate, long nonceGroup, long nonce)`
`boolean`	`checkAndRowMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, TimeRange timeRange, RowMutations rm)` Deprecated.
`boolean`	`checkAndRowMutate(byte[] row, Filter filter, TimeRange timeRange, RowMutations rm)` Deprecated.
`void`	`checkFamilies(Collection<byte[]> families)` Check the collection of families for validity.
`Optional<byte[]>`	`checkSplit()`
`Optional<byte[]>`	`checkSplit(boolean force)` Return the split point.
`void`	`checkTimestamps(Map<byte[],List<Cell>> familyMap, long now)` Check the collection of families for valid timestamps
`Map<byte[],List<HStoreFile>>`	`close()` Close down this HRegion.
`Map<byte[],List<HStoreFile>>`	`close(boolean abort)` Close down this HRegion.
`void`	`closeRegionOperation()` Closes the region operation lock.
`void`	`closeRegionOperation(Region.Operation operation)` Closes the region operation lock.
`void`	`compact(boolean majorCompaction)` Synchronously compact all stores in the region.
`boolean`	`compact(CompactionContext compaction, HStore store, ThroughputController throughputController)` Called by compaction thread and after region is opened to compact the HStores if necessary.
`boolean`	`compact(CompactionContext compaction, HStore store, ThroughputController throughputController, User user)`
`void`	`compactStores()` This is a helper function that compact all the stores synchronously.
`static HDFSBlocksDistribution`	`computeHDFSBlocksDistribution(org.apache.hadoop.conf.Configuration conf, TableDescriptor tableDescriptor, RegionInfo regionInfo)` This is a helper function to compute HDFS block distribution on demand
`static HDFSBlocksDistribution`	`computeHDFSBlocksDistribution(org.apache.hadoop.conf.Configuration conf, TableDescriptor tableDescriptor, RegionInfo regionInfo, org.apache.hadoop.fs.Path tablePath)` This is a helper function to compute HDFS block distribution on demand
`static HRegion`	`createHRegion(org.apache.hadoop.conf.Configuration conf, RegionInfo regionInfo, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path tableDir, TableDescriptor tableDesc)` Create a region under the given table directory.
`static HRegion`	`createHRegion(RegionInfo info, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.conf.Configuration conf, TableDescriptor hTableDescriptor, WAL wal)`
`static HRegion`	`createHRegion(RegionInfo info, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.conf.Configuration conf, TableDescriptor hTableDescriptor, WAL wal, boolean initialize)` Convenience method creating new HRegions.
`static HRegion`	`createHRegion(RegionInfo info, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.conf.Configuration conf, TableDescriptor hTableDescriptor, WAL wal, boolean initialize, RegionServerServices rsRpcServices)` Convenience method creating new HRegions.
`static HRegionFileSystem`	`createRegionDir(org.apache.hadoop.conf.Configuration configuration, RegionInfo ri, org.apache.hadoop.fs.Path rootDir)` Create the region directory in the filesystem.
`void`	`decrementCompactionsQueuedCount()`
`protected void`	`decrementFlushesQueuedCount()`
`void`	`delete(Delete delete)` Deletes the specified cells/row.
`void`	`deregisterChildren(ConfigurationManager manager)`
`protected void`	`doRegionCompactionPrep()` Do preparation for pending compaction.
`boolean`	`equals(Object o)`
`com.google.protobuf.Message`	`execService(com.google.protobuf.RpcController controller, org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CoprocessorServiceCall call)` Executes a single protocol buffer coprocessor endpoint `Service` method using the registered protocol handlers.
`HRegion.FlushResult`	`flush(boolean flushAllStores)` Flush the cache.
`HRegion.FlushResultImpl`	`flushcache(List<byte[]> families, boolean writeFlushRequestWalMarker, FlushLifeCycleTracker tracker)` Flush the cache.
`Result`	`get(Get get)` Do a get based on the get parameter.
`List<Cell>`	`get(Get get, boolean withCoprocessor)` Do a get based on the get parameter.
`BlockCache`	`getBlockCache()`
`long`	`getBlockedRequestsCount()` Returns the number of blocked requests
`CellComparator`	`getCellComparator()` The comparator to be used with the region
`long`	`getCheckAndMutateChecksFailed()` Returns the number of failed checkAndMutate guards
`long`	`getCheckAndMutateChecksPassed()` Returns the number of checkAndMutate guards that passed
`CompactionState`	`getCompactionState()` Returns if a given region is in compaction now.
`int`	`getCompactPriority()` Returns The priority that this region should have in the compaction queue
`RegionCoprocessorHost`	`getCoprocessorHost()` Returns the coprocessor host
`long`	`getDataInMemoryWithoutWAL()` Returns the size of data processed bypassing the WAL, in bytes
`long`	`getEarliestFlushTimeForAllStores()`
`org.apache.hadoop.fs.FileSystem`	`getFilesystem()` Returns `FileSystem` being used by this region
`long`	`getFilteredReadRequestsCount()` Returns filtered read requests count for this region
`HDFSBlocksDistribution`	`getHDFSBlocksDistribution()`
`org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.RegionLoadStats`	`getLoadStatistics()` Returns statistics about the current load of the region
`ConcurrentHashMap<HashedBytes,org.apache.hadoop.hbase.regionserver.HRegion.RowLockContext>`	`getLockedRows()`
`long`	`getMaxFlushedSeqId()`
`Map<byte[],Long>`	`getMaxStoreSeqId()`
`long`	`getMemStoreDataSize()`
`long`	`getMemStoreFlushSize()`
`long`	`getMemStoreHeapSize()`
`long`	`getMemStoreOffHeapSize()`
`MetricsRegion`	`getMetrics()`
`MobFileCache`	`getMobFileCache()`
`MultiVersionConcurrencyControl`	`getMVCC()`
`protected long`	`getNextSequenceId(WAL wal)` Method to safely get the next sequence number.
`long`	`getNumMutationsWithoutWAL()` Returns the number of mutations processed bypassing the WAL
`long`	`getOldestHfileTs(boolean majorCompactionOnly)` This can be used to determine the last time all files of this region were major compacted.
`long`	`getOldestSeqIdOfStore(byte[] familyName)`
`long`	`getOpenSeqNum()` Returns the latest sequence number that was read from storage when this region was opened
`int`	`getReadLockCount()`
`org.apache.hadoop.conf.Configuration`	`getReadOnlyConfiguration()`
`long`	`getReadPoint(IsolationLevel isolationLevel)` Returns readpoint considering given IsolationLevel.
`long`	`getReadRequestsCount()` Returns read requests count for this region
`static org.apache.hadoop.fs.Path`	`getRegionDir(org.apache.hadoop.fs.Path tabledir, String name)` Deprecated. For tests only; to be removed.
`HRegionFileSystem`	`getRegionFileSystem()` Returns the `HRegionFileSystem` used by this region
`RegionInfo`	`getRegionInfo()` Returns region information for this region
`RegionServicesForStores`	`getRegionServicesForStores()` Returns store services for this region, to access services required by store level needs
`NavigableMap<byte[],Integer>`	`getReplicationScope()`
`Region.RowLock`	`getRowLock(byte[] row)` Get an exclusive ( write lock ) lock on a given row.
`Region.RowLock`	`getRowLock(byte[] row, boolean readLock)` Get a row lock for the specified row.
`protected Region.RowLock`	`getRowLockInternal(byte[] row, boolean readLock, Region.RowLock prevRowLock)`
`org.apache.hadoop.hbase.regionserver.RegionScannerImpl`	`getScanner(Scan scan)` Return an iterator that scans over the HRegion, returning the indicated columns and rows specified by the `Scan`.
`org.apache.hadoop.hbase.regionserver.RegionScannerImpl`	`getScanner(Scan scan, List<KeyValueScanner> additionalScanners)` Return an iterator that scans over the HRegion, returning the indicated columns and rows specified by the `Scan`.
`long`	`getSmallestReadPoint()`
`HStore`	`getStore(byte[] column)` Return the Store for the given family
`List<String>`	`getStoreFileList(byte[][] columns)` Returns list of store file names for the given families
`List<HStore>`	`getStores()` Return the list of Stores managed by this region
`TableDescriptor`	`getTableDescriptor()` Returns table descriptor for this region
`WAL`	`getWAL()` Returns WAL in use for this region
`org.apache.hadoop.fs.Path`	`getWALRegionDir()`
`long`	`getWriteRequestsCount()` Returns write request count for this region
`int`	`hashCode()`
`boolean`	`hasReferences()` Returns True if this region has references.
`long`	`heapSize()`
`Result`	`increment(Increment increment)` Perform one or more increment operations on a row.
`Result`	`increment(Increment increment, long nonceGroup, long nonce)`
`void`	`incrementCompactionsQueuedCount()`
`void`	`incrementFlushesQueuedCount()`
`long`	`initialize()` Deprecated. use HRegion.createHRegion() or HRegion.openHRegion()
`protected HStore`	`instantiateHStore(ColumnFamilyDescriptor family, boolean warmup)`
`protected org.apache.hadoop.hbase.regionserver.RegionScannerImpl`	`instantiateRegionScanner(Scan scan, List<KeyValueScanner> additionalScanners, long nonceGroup, long nonce)`
`protected HRegion.FlushResultImpl`	`internalFlushcache(WAL wal, long myseqid, Collection<HStore> storesToFlush, MonitoredTask status, boolean writeFlushWalMarker, FlushLifeCycleTracker tracker)` Flush the memstore.
`protected org.apache.hadoop.hbase.regionserver.HRegion.PrepareFlushResult`	`internalPrepareFlushCache(WAL wal, long myseqid, Collection<HStore> storesToFlush, MonitoredTask status, boolean writeFlushWalMarker, FlushLifeCycleTracker tracker)`
`boolean`	`isAvailable()` Returns true if region is available (not closed and not closing)
`boolean`	`isClosed()` Returns true if region is closed
`boolean`	`isClosing()` Returns True if closing process has started
`boolean`	`isLoadingCfsOnDemandDefault()`
`boolean`	`isMergeable()` Returns true if region is mergeable
`boolean`	`isReadOnly()` Returns True if region is read only
`boolean`	`isSplittable()` Returns true if region is splittable
`Result`	`mutateRow(RowMutations rm)` Performs multiple mutations atomically on a single row.
`Result`	`mutateRow(RowMutations rm, long nonceGroup, long nonce)`
`void`	`mutateRowsWithLocks(Collection<Mutation> mutations, Collection<byte[]> rowsToLock, long nonceGroup, long nonce)` Perform atomic (all or none) mutations within the region.
`static HRegion`	`newHRegion(org.apache.hadoop.fs.Path tableDir, WAL wal, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.conf.Configuration conf, RegionInfo regionInfo, TableDescriptor htd, RegionServerServices rsServices)` A utility method to create new instances of HRegion based on the `HConstants.REGION_IMPL` configuration property.
`void`	`onConfigurationChange(org.apache.hadoop.conf.Configuration conf)`
`static HRegion`	`openHRegion(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path rootDir, RegionInfo info, TableDescriptor htd, WAL wal)` Open a Region.
`static HRegion`	`openHRegion(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path rootDir, RegionInfo info, TableDescriptor htd, WAL wal, RegionServerServices rsServices, CancelableProgressable reporter)` Open a Region.
`static HRegion`	`openHRegion(HRegion other, CancelableProgressable reporter)` Useful when reopening a closed region (normally for unit tests)
`static HRegion`	`openHRegion(org.apache.hadoop.fs.Path rootDir, RegionInfo info, TableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf)` Open a Region.
`static HRegion`	`openHRegion(org.apache.hadoop.fs.Path rootDir, RegionInfo info, TableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf, RegionServerServices rsServices, CancelableProgressable reporter)` Open a Region.
`static Region`	`openHRegion(Region other, CancelableProgressable reporter)`
`static HRegion`	`openHRegion(RegionInfo info, TableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf)` Open a Region.
`static HRegion`	`openHRegion(RegionInfo info, TableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf, RegionServerServices rsServices, CancelableProgressable reporter)` Open a Region.
`static HRegion`	`openHRegionFromTableDir(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path tableDir, RegionInfo info, TableDescriptor htd, WAL wal, RegionServerServices rsServices, CancelableProgressable reporter)` Open a Region.
`static HRegion`	`openReadOnlyFileSystemHRegion(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path tableDir, RegionInfo info, TableDescriptor htd)` Open a Region on a read-only file-system (like hdfs snapshots)
`void`	`processRowsWithLocks(RowProcessor<?,?> processor)` Performs atomic multiple reads and writes on a given row.
`void`	`processRowsWithLocks(RowProcessor<?,?> processor, long nonceGroup, long nonce)` Performs atomic multiple reads and writes on a given row.
`void`	`processRowsWithLocks(RowProcessor<?,?> processor, long timeout, long nonceGroup, long nonce)` Performs atomic multiple reads and writes on a given row.
`void`	`put(Put put)` Puts some data in the table.
`boolean`	`refreshStoreFiles()` Check the region's underlying store files, open the files that have not been opened yet, and remove the store file readers for store files no longer available.
`protected boolean`	`refreshStoreFiles(boolean force)`
`void`	`registerChildren(ConfigurationManager manager)`
`boolean`	`registerService(com.google.protobuf.Service instance)` Registers a new protocol buffer `Service` subclass as a coprocessor endpoint to be available for handling Region#execService(com.google.protobuf.RpcController, org.apache.hadoop.hbase.protobuf.generated.ClientProtos.CoprocessorServiceCall) calls.
`void`	`reportCompactionRequestEnd(boolean isMajor, int numFiles, long filesSizeCompacted)`
`void`	`reportCompactionRequestFailure()`
`void`	`reportCompactionRequestStart(boolean isMajor)`
`void`	`requestCompaction(byte[] family, String why, int priority, boolean major, CompactionLifeCycleTracker tracker)` Request compaction for the given family
`void`	`requestCompaction(String why, int priority, boolean major, CompactionLifeCycleTracker tracker)` Request compaction on this region.
`void`	`requestFlush(FlushLifeCycleTracker tracker)` Request flush on this region.
`protected void`	`restoreEdit(HStore s, Cell cell, MemStoreSizing memstoreAccounting)` Used by tests
`static boolean`	`rowIsInRange(RegionInfo info, byte[] row)` Determines if the specified row is within the row range specified by the specified RegionInfo
`static boolean`	`rowIsInRange(RegionInfo info, byte[] row, int offset, short length)`
`void`	`setBlockCache(BlockCache blockCache)` Only used for unit test which doesn't start region server.
`void`	`setClosing(boolean closing)` Exposed for some very specific unit tests.
`void`	`setCoprocessorHost(RegionCoprocessorHost coprocessorHost)`
`void`	`setMobFileCache(MobFileCache mobFileCache)` Only used for unit test which doesn't start region server.
`void`	`setReadsEnabled(boolean readsEnabled)`
`void`	`setRestoredRegion(boolean restoredRegion)`
`void`	`setTableDescriptor(TableDescriptor desc)`
`void`	`setTimeoutForWriteLock(long timeoutForWriteLock)` The `doClose(boolean, org.apache.hadoop.hbase.monitoring.MonitoredTask)` will block forever if someone tries proving the dead lock via the unit test.
`void`	`startRegionOperation()` This method needs to be called before any public call that reads or modifies data.
`void`	`startRegionOperation(Region.Operation op)` This method needs to be called before any public call that reads or modifies data.
`String`	`toString()`
`void`	`unblockUpdates()`
`void`	`waitForFlushes()` Wait for all current flushes of the region to complete
`boolean`	`waitForFlushes(long timeout)` Wait for all current flushes of the region to complete
`void`	`waitForFlushesAndCompactions()` Wait for all current flushes and compactions of the region to complete
`static HRegion`	`warmupHRegion(RegionInfo info, TableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf, RegionServerServices rsServices, CancelableProgressable reporter)`
`protected void`	`writeRegionOpenMarker(WAL wal, long openSeqId)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.hadoop.hbase.regionserver.Region
checkAndMutate, checkAndMutate, checkAndRowMutate, checkAndRowMutate

- Field Detail
  - LOAD_CFS_ON_DEMAND_CONFIG_KEY
```
public static final String LOAD_CFS_ON_DEMAND_CONFIG_KEY
```
    See Also:
    
    Constant Field Values
  - HBASE_MAX_CELL_SIZE_KEY
```
public static final String HBASE_MAX_CELL_SIZE_KEY
```
    See Also:
    
    Constant Field Values
  - DEFAULT_MAX_CELL_SIZE
```
public static final int DEFAULT_MAX_CELL_SIZE
```
    See Also:
    
    Constant Field Values
  - HBASE_REGIONSERVER_MINIBATCH_SIZE
```
public static final String HBASE_REGIONSERVER_MINIBATCH_SIZE
```
    See Also:
    
    Constant Field Values
  - DEFAULT_HBASE_REGIONSERVER_MINIBATCH_SIZE
```
public static final int DEFAULT_HBASE_REGIONSERVER_MINIBATCH_SIZE
```
    See Also:
    
    Constant Field Values
  - WAL_HSYNC_CONF_KEY
```
public static final String WAL_HSYNC_CONF_KEY
```
    See Also:
    
    Constant Field Values
  - DEFAULT_WAL_HSYNC
```
public static final boolean DEFAULT_WAL_HSYNC
```
    See Also:
    
    Constant Field Values
  - COMPACTION_AFTER_BULKLOAD_ENABLE
```
public static final String COMPACTION_AFTER_BULKLOAD_ENABLE
```
    Parameter name for compaction after bulkload
    
    See Also:
    
    Constant Field Values
  - SPLIT_IGNORE_BLOCKING_ENABLED_KEY
```
public static final String SPLIT_IGNORE_BLOCKING_ENABLED_KEY
```
    Config for allow split when file count greater than the configured blocking file count
    
    See Also:
    
    Constant Field Values
  - REGION_STORAGE_POLICY_KEY
```
public static final String REGION_STORAGE_POLICY_KEY
```
    See Also:
    
    Constant Field Values
  - DEFAULT_REGION_STORAGE_POLICY
```
public static final String DEFAULT_REGION_STORAGE_POLICY
```
    See Also:
    
    Constant Field Values
  - SPECIAL_RECOVERED_EDITS_DIR
```
public static final String SPECIAL_RECOVERED_EDITS_DIR
```
    This is for for using HRegion as a local storage, where we may put the recovered edits in a special place. Once this is set, we will only replay the recovered edits under this directory and ignore the original replay directory configs.
    
    See Also:
    
    Constant Field Values
  - USE_META_CELL_COMPARATOR
```
public static final String USE_META_CELL_COMPARATOR
```
    Whether to use MetaCellComparator even if we are not meta region. Used when creating master local region.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_USE_META_CELL_COMPARATOR
```
public static final boolean DEFAULT_USE_META_CELL_COMPARATOR
```
    See Also:
    
    Constant Field Values
  - lastReplayedOpenRegionSeqId
```
protected volatile long lastReplayedOpenRegionSeqId
```
    The sequence id of the last replayed open region event from the primary region. This is used to skip entries before this due to the possibility of replay edits coming out of order from replication.
  - lastReplayedCompactionSeqId
```
protected volatile long lastReplayedCompactionSeqId
```
  - stores
```
protected final Map<byte[],HStore> stores
```
  - conf
```
protected final org.apache.hadoop.conf.Configuration conf
```
  - rsServices
```
protected RegionServerServices rsServices
```
  - FAIR_REENTRANT_CLOSE_LOCK
```
public static final String FAIR_REENTRANT_CLOSE_LOCK
```
    Conf key for fair locking policy
    
    See Also:
    
    Constant Field Values
  - DEFAULT_FAIR_REENTRANT_CLOSE_LOCK
```
public static final boolean DEFAULT_FAIR_REENTRANT_CLOSE_LOCK
```
    See Also:
    
    Constant Field Values
  - MEMSTORE_PERIODIC_FLUSH_INTERVAL
```
public static final String MEMSTORE_PERIODIC_FLUSH_INTERVAL
```
    Conf key for the periodic flush interval
    
    See Also:
    
    Constant Field Values
  - DEFAULT_CACHE_FLUSH_INTERVAL
```
public static final int DEFAULT_CACHE_FLUSH_INTERVAL
```
    Default interval for the memstore flush
    
    See Also:
    
    Constant Field Values
  - SYSTEM_CACHE_FLUSH_INTERVAL
```
public static final int SYSTEM_CACHE_FLUSH_INTERVAL
```
    Default interval for System tables memstore flush
    
    See Also:
    
    Constant Field Values
  - MEMSTORE_FLUSH_PER_CHANGES
```
public static final String MEMSTORE_FLUSH_PER_CHANGES
```
    Conf key to force a flush if there are already enough changes for one region in memstore
    
    See Also:
    
    Constant Field Values
  - DEFAULT_FLUSH_PER_CHANGES
```
public static final long DEFAULT_FLUSH_PER_CHANGES
```
    See Also:
    
    Constant Field Values
  - MAX_FLUSH_PER_CHANGES
```
public static final long MAX_FLUSH_PER_CHANGES
```
    The following MAX_FLUSH_PER_CHANGES is large enough because each KeyValue has 20+ bytes overhead. Therefore, even 1G empty KVs occupy at least 20GB memstore size for a single region
    
    See Also:
    
    Constant Field Values
  - CLOSE_WAIT_ABORT
```
public static final String CLOSE_WAIT_ABORT
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CLOSE_WAIT_ABORT
```
public static final boolean DEFAULT_CLOSE_WAIT_ABORT
```
    See Also:
    
    Constant Field Values
  - CLOSE_WAIT_TIME
```
public static final String CLOSE_WAIT_TIME
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CLOSE_WAIT_TIME
```
public static final long DEFAULT_CLOSE_WAIT_TIME
```
    See Also:
    
    Constant Field Values
  - CLOSE_WAIT_INTERVAL
```
public static final String CLOSE_WAIT_INTERVAL
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CLOSE_WAIT_INTERVAL
```
public static final long DEFAULT_CLOSE_WAIT_INTERVAL
```
    See Also:
    
    Constant Field Values
  - FIXED_OVERHEAD
```
public static final long FIXED_OVERHEAD
```
  - DEEP_OVERHEAD
```
public static final long DEEP_OVERHEAD
```
- Constructor Detail
  - HRegion
```
@Deprecated
public HRegion(org.apache.hadoop.fs.Path tableDir,
                           WAL wal,
                           org.apache.hadoop.fs.FileSystem fs,
                           org.apache.hadoop.conf.Configuration confParam,
                           RegionInfo regionInfo,
                           TableDescriptor htd,
                           RegionServerServices rsServices)
```
    Deprecated. Use other constructors.
    
    HRegion constructor. This constructor should only be used for testing and extensions. Instances of HRegion should be instantiated with the createHRegion(org.apache.hadoop.hbase.client.RegionInfo, org.apache.hadoop.fs.Path, org.apache.hadoop.conf.Configuration, org.apache.hadoop.hbase.client.TableDescriptor, org.apache.hadoop.hbase.wal.WAL, boolean) or openHRegion(org.apache.hadoop.hbase.client.RegionInfo, org.apache.hadoop.hbase.client.TableDescriptor, org.apache.hadoop.hbase.wal.WAL, org.apache.hadoop.conf.Configuration) method.
    
    Parameters:
    
    tableDir - qualified path of directory where region should be located, usually the table directory.
    
    wal - The WAL is the outbound log for any updates to the HRegion The wal file is a logfile from the previous execution that's custom-computed for this HRegion. The HRegionServer computes and sorts the appropriate wal info for this HRegion. If there is a previous wal file (implying that the HRegion has been written-to before), then read it from the supplied path.
    
    fs - is the filesystem.
    
    confParam - is global configuration settings.
    
    regionInfo - - RegionInfo that describes the region is new), then read them from the supplied path.
    
    htd - the table descriptor
    
    rsServices - reference to RegionServerServices or null
  - HRegion
```
public HRegion(HRegionFileSystem fs,
               WAL wal,
               org.apache.hadoop.conf.Configuration confParam,
               TableDescriptor htd,
               RegionServerServices rsServices)
```
    HRegion constructor. This constructor should only be used for testing and extensions. Instances of HRegion should be instantiated with the createHRegion(org.apache.hadoop.hbase.client.RegionInfo, org.apache.hadoop.fs.Path, org.apache.hadoop.conf.Configuration, org.apache.hadoop.hbase.client.TableDescriptor, org.apache.hadoop.hbase.wal.WAL, boolean) or openHRegion(org.apache.hadoop.hbase.client.RegionInfo, org.apache.hadoop.hbase.client.TableDescriptor, org.apache.hadoop.hbase.wal.WAL, org.apache.hadoop.conf.Configuration) method.
    
    Parameters:
    
    fs - is the filesystem.
    
    wal - The WAL is the outbound log for any updates to the HRegion The wal file is a logfile from the previous execution that's custom-computed for this HRegion. The HRegionServer computes and sorts the appropriate wal info for this HRegion. If there is a previous wal file (implying that the HRegion has been written-to before), then read it from the supplied path.
    
    confParam - is global configuration settings.
    
    htd - the table descriptor
    
    rsServices - reference to RegionServerServices or null
- Method Detail
  - setRestoredRegion
```
public void setRestoredRegion(boolean restoredRegion)
```
  - getSmallestReadPoint
```
public long getSmallestReadPoint()
```
    Returns:
    
    The smallest mvcc readPoint across all the scanners in this region. Writes older than this readPoint, are included in every read operation.
  - initialize
```
@Deprecated
public long initialize()
                            throws IOException
```
    Deprecated. use HRegion.createHRegion() or HRegion.openHRegion()
    
    Initialize this region. Used only by tests and SplitTransaction to reopen the region. You should use createHRegion() or openHRegion()
    
    Returns:
    
    What the next sequence (edit) id should be.
    
    Throws:
    
    IOException - e
  - writeRegionOpenMarker
```
protected void writeRegionOpenMarker(WAL wal,
                                     long openSeqId)
                              throws IOException
```
    Throws:
    
    IOException
  - hasReferences
```
public boolean hasReferences()
```
    Returns True if this region has references.
  - blockUpdates
```
public void blockUpdates()
```
  - unblockUpdates
```
public void unblockUpdates()
```
  - getHDFSBlocksDistribution
```
public HDFSBlocksDistribution getHDFSBlocksDistribution()
```
  - computeHDFSBlocksDistribution
```
public static HDFSBlocksDistribution computeHDFSBlocksDistribution(org.apache.hadoop.conf.Configuration conf,
                                                                   TableDescriptor tableDescriptor,
                                                                   RegionInfo regionInfo)
                                                            throws IOException
```
    This is a helper function to compute HDFS block distribution on demand
    
    Parameters:
    
    conf - configuration
    
    tableDescriptor - TableDescriptor of the table
    
    regionInfo - encoded name of the region
    
    Returns:
    
    The HDFS blocks distribution for the given region.
    
    Throws:
    
    IOException
  - computeHDFSBlocksDistribution
```
public static HDFSBlocksDistribution computeHDFSBlocksDistribution(org.apache.hadoop.conf.Configuration conf,
                                                                   TableDescriptor tableDescriptor,
                                                                   RegionInfo regionInfo,
                                                                   org.apache.hadoop.fs.Path tablePath)
                                                            throws IOException
```
    This is a helper function to compute HDFS block distribution on demand
    
    Parameters:
    
    conf - configuration
    
    tableDescriptor - TableDescriptor of the table
    
    regionInfo - encoded name of the region
    
    tablePath - the table directory
    
    Returns:
    
    The HDFS blocks distribution for the given region.
    
    Throws:
    
    IOException
  - getRegionInfo
```
public RegionInfo getRegionInfo()
```
    Description copied from interface: Region
    
    Returns region information for this region
    
    Specified by:
    
    getRegionInfo in interface Region
  - getReadRequestsCount
```
public long getReadRequestsCount()
```
    Description copied from interface: Region
    
    Returns read requests count for this region
    
    Specified by:
    
    getReadRequestsCount in interface Region
  - getFilteredReadRequestsCount
```
public long getFilteredReadRequestsCount()
```
    Description copied from interface: Region
    
    Returns filtered read requests count for this region
    
    Specified by:
    
    getFilteredReadRequestsCount in interface Region
  - getWriteRequestsCount
```
public long getWriteRequestsCount()
```
    Description copied from interface: Region
    
    Returns write request count for this region
    
    Specified by:
    
    getWriteRequestsCount in interface Region
  - getMemStoreDataSize
```
public long getMemStoreDataSize()
```
    Specified by:
    
    getMemStoreDataSize in interface Region
    
    Returns:
    
    memstore size for this region, in bytes. It just accounts data size of cells added to the memstores of this Region. Means size in bytes for key, value and tags within Cells. It wont consider any java heap overhead for the cell objects or any other.
  - getMemStoreHeapSize
```
public long getMemStoreHeapSize()
```
    Specified by:
    
    getMemStoreHeapSize in interface Region
    
    Returns:
    
    memstore heap size for this region, in bytes. It accounts data size of cells added to the memstores of this Region, as well as java heap overhead for the cell objects or any other.
  - getMemStoreOffHeapSize
```
public long getMemStoreOffHeapSize()
```
    Specified by:
    
    getMemStoreOffHeapSize in interface Region
    
    Returns:
    
    memstore off-heap size for this region, in bytes. It accounts data size of cells added to the memstores of this Region, as well as overhead for the cell objects or any other that is allocated off-heap.
  - getRegionServicesForStores
```
public RegionServicesForStores getRegionServicesForStores()
```
    Returns store services for this region, to access services required by store level needs
  - getNumMutationsWithoutWAL
```
public long getNumMutationsWithoutWAL()
```
    Description copied from interface: Region
    
    Returns the number of mutations processed bypassing the WAL
    
    Specified by:
    
    getNumMutationsWithoutWAL in interface Region
  - getDataInMemoryWithoutWAL
```
public long getDataInMemoryWithoutWAL()
```
    Description copied from interface: Region
    
    Returns the size of data processed bypassing the WAL, in bytes
    
    Specified by:
    
    getDataInMemoryWithoutWAL in interface Region
  - getBlockedRequestsCount
```
public long getBlockedRequestsCount()
```
    Description copied from interface: Region
    
    Returns the number of blocked requests
    
    Specified by:
    
    getBlockedRequestsCount in interface Region
  - getCheckAndMutateChecksPassed
```
public long getCheckAndMutateChecksPassed()
```
    Description copied from interface: Region
    
    Returns the number of checkAndMutate guards that passed
    
    Specified by:
    
    getCheckAndMutateChecksPassed in interface Region
  - getCheckAndMutateChecksFailed
```
public long getCheckAndMutateChecksFailed()
```
    Description copied from interface: Region
    
    Returns the number of failed checkAndMutate guards
    
    Specified by:
    
    getCheckAndMutateChecksFailed in interface Region
  - getMetrics
```
public MetricsRegion getMetrics()
```
  - isClosed
```
public boolean isClosed()
```
    Description copied from interface: Region
    
    Returns true if region is closed
    
    Specified by:
    
    isClosed in interface Region
  - isClosing
```
public boolean isClosing()
```
    Description copied from interface: Region
    
    Returns True if closing process has started
    
    Specified by:
    
    isClosing in interface Region
  - isReadOnly
```
public boolean isReadOnly()
```
    Description copied from interface: Region
    
    Returns True if region is read only
    
    Specified by:
    
    isReadOnly in interface Region
  - isAvailable
```
public boolean isAvailable()
```
    Description copied from interface: Region
    
    Returns true if region is available (not closed and not closing)
    
    Specified by:
    
    isAvailable in interface Region
  - isSplittable
```
public boolean isSplittable()
```
    Description copied from interface: Region
    
    Returns true if region is splittable
    
    Specified by:
    
    isSplittable in interface Region
  - isMergeable
```
public boolean isMergeable()
```
    Description copied from interface: Region
    
    Returns true if region is mergeable
    
    Specified by:
    
    isMergeable in interface Region
  - areWritesEnabled
```
public boolean areWritesEnabled()
```
  - getMVCC
```
public MultiVersionConcurrencyControl getMVCC()
```
  - getMaxFlushedSeqId
```
public long getMaxFlushedSeqId()
```
    Specified by:
    
    getMaxFlushedSeqId in interface Region
    
    Returns:
    
    the max sequence id of flushed data on this region; no edit in memory will have a sequence id that is less that what is returned here.
  - getReadPoint
```
public long getReadPoint(IsolationLevel isolationLevel)
```
    Returns readpoint considering given IsolationLevel. Pass null for default
  - isLoadingCfsOnDemandDefault
```
public boolean isLoadingCfsOnDemandDefault()
```
  - close
```
public Map<byte[],List<HStoreFile>> close()
                                   throws IOException
```
    Close down this HRegion. Flush the cache, shut down each HStore, don't service any more calls.
    This method could take some time to execute, so don't call it from a time-sensitive thread.
    
    Returns:
    
    Vector of all the storage files that the HRegion's component HStores make use of. It's a list of all StoreFile objects. Returns empty vector if already closed and null if judged that it should not close.
    
    Throws:
    
    IOException - e
    
    DroppedSnapshotException - Thrown when replay of wal is required because a Snapshot was not properly persisted. The region is put in closing mode, and the caller MUST abort after this.
  - close
```
public Map<byte[],List<HStoreFile>> close(boolean abort)
                                   throws IOException
```
    Close down this HRegion. Flush the cache unless abort parameter is true, Shut down each HStore, don't service any more calls. This method could take some time to execute, so don't call it from a time-sensitive thread.
    
    Parameters:
    
    abort - true if server is aborting (only during testing)
    
    Returns:
    
    Vector of all the storage files that the HRegion's component HStores make use of. It's a list of StoreFile objects. Can be null if we are not to close at this time or we are already closed.
    
    Throws:
    
    IOException - e
    
    DroppedSnapshotException - Thrown when replay of wal is required because a Snapshot was not properly persisted. The region is put in closing mode, and the caller MUST abort after this.
  - setClosing
```
public void setClosing(boolean closing)
```
    Exposed for some very specific unit tests.
  - setTimeoutForWriteLock
```
public void setTimeoutForWriteLock(long timeoutForWriteLock)
```
    The doClose(boolean, org.apache.hadoop.hbase.monitoring.MonitoredTask) will block forever if someone tries proving the dead lock via the unit test. Instead of blocking, the doClose(boolean, org.apache.hadoop.hbase.monitoring.MonitoredTask) will throw exception if you set the timeout.
    
    Parameters:
    
    timeoutForWriteLock - the second time to wait for the write lock in doClose(boolean, org.apache.hadoop.hbase.monitoring.MonitoredTask)
  - waitForFlushesAndCompactions
```
public void waitForFlushesAndCompactions()
```
    Wait for all current flushes and compactions of the region to complete
  - waitForFlushes
```
public void waitForFlushes()
```
    Wait for all current flushes of the region to complete
  - waitForFlushes
```
public boolean waitForFlushes(long timeout)
```
    Description copied from interface: Region
    
    Wait for all current flushes of the region to complete
    
    Specified by:
    
    waitForFlushes in interface Region
    
    Parameters:
    
    timeout - The maximum time to wait in milliseconds.
    
    Returns:
    
    False when timeout elapsed but flushes are not over. True when flushes are over within max wait time period.
  - getReadOnlyConfiguration
```
public org.apache.hadoop.conf.Configuration getReadOnlyConfiguration()
```
    Specified by:
    
    getReadOnlyConfiguration in interface Region
    
    Returns:
    
    a read only configuration of this region; throws UnsupportedOperationException if you try to set a configuration.
  - getTableDescriptor
```
public TableDescriptor getTableDescriptor()
```
    Description copied from interface: Region
    
    Returns table descriptor for this region
    
    Specified by:
    
    getTableDescriptor in interface Region
  - setTableDescriptor
```
public void setTableDescriptor(TableDescriptor desc)
```
  - getWAL
```
public WAL getWAL()
```
    Returns WAL in use for this region
  - getBlockCache
```
public BlockCache getBlockCache()
```
  - setBlockCache
```
public void setBlockCache(BlockCache blockCache)
```
    Only used for unit test which doesn't start region server.
  - getMobFileCache
```
public MobFileCache getMobFileCache()
```
  - setMobFileCache
```
public void setMobFileCache(MobFileCache mobFileCache)
```
    Only used for unit test which doesn't start region server.
  - getFilesystem
```
public org.apache.hadoop.fs.FileSystem getFilesystem()
```
    Returns FileSystem being used by this region
  - getRegionFileSystem
```
public HRegionFileSystem getRegionFileSystem()
```
    Returns the HRegionFileSystem used by this region
  - getWALRegionDir
```
public org.apache.hadoop.fs.Path getWALRegionDir()
                                          throws IOException
```
    Returns:
    
    the Region directory under WALRootDirectory
    
    Throws:
    
    IOException - if there is an error getting WALRootDir
  - getEarliestFlushTimeForAllStores
```
public long getEarliestFlushTimeForAllStores()
```
    Specified by:
    
    getEarliestFlushTimeForAllStores in interface Region
    
    Returns:
    
    The earliest time a store in the region was flushed. All other stores in the region would have been flushed either at, or after this time.
  - getOldestHfileTs
```
public long getOldestHfileTs(boolean majorCompactionOnly)
                      throws IOException
```
    Description copied from interface: Region
    
    This can be used to determine the last time all files of this region were major compacted.
    
    Specified by:
    
    getOldestHfileTs in interface Region
    
    Parameters:
    
    majorCompactionOnly - Only consider HFile that are the result of major compaction
    
    Returns:
    
    the timestamp of the oldest HFile for all stores of this region
    
    Throws:
    
    IOException
  - doRegionCompactionPrep
```
protected void doRegionCompactionPrep()
                               throws IOException
```
    Do preparation for pending compaction.
    
    Throws:
    
    IOException
  - compact
```
public void compact(boolean majorCompaction)
             throws IOException
```
    Synchronously compact all stores in the region.
    This operation could block for a long time, so don't call it from a time-sensitive thread.
    Note that no locks are taken to prevent possible conflicts between compaction and splitting activities. The regionserver does not normally compact and split in parallel. However by calling this method you may introduce unexpected and unhandled concurrency. Don't do this unless you know what you are doing.
    
    Parameters:
    
    majorCompaction - True to force a major compaction regardless of thresholds
    
    Throws:
    
    IOException
  - compactStores
```
public void compactStores()
                   throws IOException
```
    This is a helper function that compact all the stores synchronously.
    It is used by utilities and testing
    
    Throws:
    
    IOException
  - compact
```
public boolean compact(CompactionContext compaction,
                       HStore store,
                       ThroughputController throughputController)
                throws IOException
```
    Called by compaction thread and after region is opened to compact the HStores if necessary.
    This operation could block for a long time, so don't call it from a time-sensitive thread. Note that no locking is necessary at this level because compaction only conflicts with a region split, and that cannot happen because the region server does them sequentially and not in parallel.
    
    Parameters:
    
    compaction - Compaction details, obtained by requestCompaction()
    
    Returns:
    
    whether the compaction completed
    
    Throws:
    
    IOException
  - compact
```
public boolean compact(CompactionContext compaction,
                       HStore store,
                       ThroughputController throughputController,
                       User user)
                throws IOException
```
    Throws:
    
    IOException
  - flush
```
public HRegion.FlushResult flush(boolean flushAllStores)
                          throws IOException
```
    Flush the cache.
    When this method is called the cache will be flushed unless:
    1. the cache is empty
    2. the region is closed.
    3. a flush is already in progress
    4. writes are disabled
    This method may block for some time, so it should not be called from a time-sensitive thread.
    Parameters:
    
    flushAllStores - whether we want to force a flush of all stores
    
    Returns:
    
    FlushResult indicating whether the flush was successful or not and if the region needs compacting
    
    Throws:
    
    IOException - general io exceptions because a snapshot was not properly persisted.
  - flushcache
```
public HRegion.FlushResultImpl flushcache(List<byte[]> families,
                                          boolean writeFlushRequestWalMarker,
                                          FlushLifeCycleTracker tracker)
                                   throws IOException
```
    Flush the cache. When this method is called the cache will be flushed unless:
    1. the cache is empty
    2. the region is closed.
    3. a flush is already in progress
    4. writes are disabled
    This method may block for some time, so it should not be called from a time-sensitive thread.
    Parameters:
    
    families - stores of region to flush.
    
    writeFlushRequestWalMarker - whether to write the flush request marker to WAL
    
    tracker - used to track the life cycle of this flush
    
    Returns:
    
    whether the flush is success and whether the region needs compacting
    
    Throws:
    
    IOException - general io exceptions
    
    DroppedSnapshotException - Thrown when replay of wal is required because a Snapshot was not properly persisted. The region is put in closing mode, and the caller MUST abort after this.
  - internalFlushcache
```
protected HRegion.FlushResultImpl internalFlushcache(WAL wal,
                                                     long myseqid,
                                                     Collection<HStore> storesToFlush,
                                                     MonitoredTask status,
                                                     boolean writeFlushWalMarker,
                                                     FlushLifeCycleTracker tracker)
                                              throws IOException
```
    Flush the memstore. Flushing the memstore is a little tricky. We have a lot of updates in the memstore, all of which have also been written to the wal. We need to write those updates in the memstore out to disk, while being able to process reads/writes as much as possible during the flush operation.
    This method may block for some time. Every time you call it, we up the regions sequence id even if we don't flush; i.e. the returned region id will be at least one larger than the last edit applied to this region. The returned id does not refer to an actual edit. The returned id can be used for say installing a bulk loaded file just ahead of the last hfile that was the result of this flush, etc.
    
    Parameters:
    
    wal - Null if we're NOT to go via wal.
    
    myseqid - The seqid to use if wal is null writing out flush file.
    
    storesToFlush - The list of stores to flush.
    
    Returns:
    
    object describing the flush's state
    
    Throws:
    
    IOException - general io exceptions
    
    DroppedSnapshotException - Thrown when replay of WAL is required.
  - internalPrepareFlushCache
```
protected org.apache.hadoop.hbase.regionserver.HRegion.PrepareFlushResult internalPrepareFlushCache(WAL wal,
                                                                                                    long myseqid,
                                                                                                    Collection<HStore> storesToFlush,
                                                                                                    MonitoredTask status,
                                                                                                    boolean writeFlushWalMarker,
                                                                                                    FlushLifeCycleTracker tracker)
                                                                                             throws IOException
```
    Throws:
    
    IOException
  - getNextSequenceId
```
protected long getNextSequenceId(WAL wal)
                          throws IOException
```
    Method to safely get the next sequence number.
    
    Returns:
    
    Next sequence number unassociated with any actual edit.
    
    Throws:
    
    IOException
  - getScanner
```
public org.apache.hadoop.hbase.regionserver.RegionScannerImpl getScanner(Scan scan)
                                                                  throws IOException
```
    Description copied from interface: Region
    
    Return an iterator that scans over the HRegion, returning the indicated columns and rows specified by the Scan.
    This Iterator must be closed by the caller.
    
    Specified by:
    
    getScanner in interface Region
    
    Parameters:
    
    scan - configured Scan
    
    Throws:
    
    IOException - read exceptions
  - getScanner
```
public org.apache.hadoop.hbase.regionserver.RegionScannerImpl getScanner(Scan scan,
                                                                         List<KeyValueScanner> additionalScanners)
                                                                  throws IOException
```
    Description copied from interface: Region
    
    Return an iterator that scans over the HRegion, returning the indicated columns and rows specified by the Scan. The scanner will also include the additional scanners passed along with the scanners for the specified Scan instance. Should be careful with the usage to pass additional scanners only within this Region
    This Iterator must be closed by the caller.
    
    Specified by:
    
    getScanner in interface Region
    
    Parameters:
    
    scan - configured Scan
    
    additionalScanners - Any additional scanners to be used
    
    Throws:
    
    IOException - read exceptions
  - instantiateRegionScanner
```
protected org.apache.hadoop.hbase.regionserver.RegionScannerImpl instantiateRegionScanner(Scan scan,
                                                                                          List<KeyValueScanner> additionalScanners,
                                                                                          long nonceGroup,
                                                                                          long nonce)
                                                                                   throws IOException
```
    Throws:
    
    IOException
  - delete
```
public void delete(Delete delete)
            throws IOException
```
    Description copied from interface: Region
    
    Deletes the specified cells/row.
    
    Specified by:
    
    delete in interface Region
    
    Throws:
    
    IOException
  - put
```
public void put(Put put)
         throws IOException
```
    Description copied from interface: Region
    
    Puts some data in the table.
    
    Specified by:
    
    put in interface Region
    
    Throws:
    
    IOException
  - batchMutate
```
public OperationStatus[] batchMutate(Mutation[] mutations,
                                     boolean atomic,
                                     long nonceGroup,
                                     long nonce)
                              throws IOException
```
    Throws:
    
    IOException
  - batchMutate
```
public OperationStatus[] batchMutate(Mutation[] mutations)
                              throws IOException
```
    Description copied from interface: Region
    
    Perform a batch of mutations.
    Please do not operate on a same column of a single row in a batch, we will not consider the previous operation in the same batch when performing the operations in the batch.
    
    Specified by:
    
    batchMutate in interface Region
    
    Parameters:
    
    mutations - the list of mutations
    
    Returns:
    
    an array of OperationStatus which internally contains the OperationStatusCode and the exceptionMessage if any.
    
    Throws:
    
    IOException
  - batchReplay
```
public OperationStatus[] batchReplay(WALSplitUtil.MutationReplay[] mutations,
                                     long replaySeqId)
                              throws IOException
```
    Throws:
    
    IOException
  - checkAndMutate
```
@Deprecated
public boolean checkAndMutate(byte[] row,
                                          byte[] family,
                                          byte[] qualifier,
                                          CompareOperator op,
                                          ByteArrayComparable comparator,
                                          TimeRange timeRange,
                                          Mutation mutation)
                                   throws IOException
```
    Deprecated.
    
    Description copied from interface: Region
    
    Atomically checks if a row/family/qualifier value matches the expected value and if it does, it performs the mutation. If the passed value is null, the lack of column value (ie: non-existence) is used. See checkAndRowMutate to do many checkAndPuts at a time on a single row.
    
    Specified by:
    
    checkAndMutate in interface Region
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    op - the comparison operator
    
    comparator - the expected value
    
    timeRange - time range to check
    
    mutation - data to put if check succeeds
    
    Returns:
    
    true if mutation was applied, false otherwise
    
    Throws:
    
    IOException
  - checkAndMutate
```
@Deprecated
public boolean checkAndMutate(byte[] row,
                                          Filter filter,
                                          TimeRange timeRange,
                                          Mutation mutation)
                                   throws IOException
```
    Deprecated.
    
    Description copied from interface: Region
    
    Atomically checks if a row value matches the filter and if it does, it performs the mutation. See checkAndRowMutate to do many checkAndPuts at a time on a single row.
    
    Specified by:
    
    checkAndMutate in interface Region
    
    Parameters:
    
    row - to check
    
    filter - the filter
    
    timeRange - time range to check
    
    mutation - data to put if check succeeds
    
    Returns:
    
    true if mutation was applied, false otherwise
    
    Throws:
    
    IOException
  - checkAndRowMutate
```
@Deprecated
public boolean checkAndRowMutate(byte[] row,
                                             byte[] family,
                                             byte[] qualifier,
                                             CompareOperator op,
                                             ByteArrayComparable comparator,
                                             TimeRange timeRange,
                                             RowMutations rm)
                                      throws IOException
```
    Deprecated.
    
    Description copied from interface: Region
    
    Atomically checks if a row/family/qualifier value matches the expected values and if it does, it performs the row mutations. If the passed value is null, the lack of column value (ie: non-existence) is used. Use to do many mutations on a single row. Use checkAndMutate to do one checkAndMutate at a time.
    
    Specified by:
    
    checkAndRowMutate in interface Region
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    op - the comparison operator
    
    comparator - the expected value
    
    timeRange - time range to check
    
    rm - data to put if check succeeds
    
    Returns:
    
    true if mutations were applied, false otherwise
    
    Throws:
    
    IOException
  - checkAndRowMutate
```
@Deprecated
public boolean checkAndRowMutate(byte[] row,
                                             Filter filter,
                                             TimeRange timeRange,
                                             RowMutations rm)
                                      throws IOException
```
    Deprecated.
    
    Description copied from interface: Region
    
    Atomically checks if a row matches the filter and if it does, it performs the row mutations. Use to do many mutations on a single row. Use checkAndMutate to do one checkAndMutate at a time.
    
    Specified by:
    
    checkAndRowMutate in interface Region
    
    Parameters:
    
    row - to check
    
    filter - the filter
    
    timeRange - time range to check
    
    rm - data to put if check succeeds
    
    Returns:
    
    true if mutations were applied, false otherwise
    
    Throws:
    
    IOException
  - checkAndMutate
```
public CheckAndMutateResult checkAndMutate(CheckAndMutate checkAndMutate)
                                    throws IOException
```
    Description copied from interface: Region
    
    Atomically checks if a row matches the conditions and if it does, it performs the actions. Use to do many mutations on a single row. Use checkAndMutate to do one checkAndMutate at a time.
    
    Specified by:
    
    checkAndMutate in interface Region
    
    Parameters:
    
    checkAndMutate - the CheckAndMutate object
    
    Returns:
    
    true if mutations were applied, false otherwise
    
    Throws:
    
    IOException - if an error occurred in this method
  - checkAndMutate
```
public CheckAndMutateResult checkAndMutate(CheckAndMutate checkAndMutate,
                                           long nonceGroup,
                                           long nonce)
                                    throws IOException
```
    Throws:
    
    IOException
  - addRegionToSnapshot
```
public void addRegionToSnapshot(org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription desc,
                                ForeignExceptionSnare exnSnare)
                         throws IOException
```
    Complete taking the snapshot on the region. Writes the region info and adds references to the working snapshot directory. TODO for api consistency, consider adding another version with no ForeignExceptionSnare arg. (In the future other cancellable HRegion methods could eventually add a ForeignExceptionSnare, or we could do something fancier).
    
    Parameters:
    
    desc - snapshot description object
    
    exnSnare - ForeignExceptionSnare that captures external exceptions in case we need to bail out. This is allowed to be null and will just be ignored in that case.
    
    Throws:
    
    IOException - if there is an external or internal error causing the snapshot to fail
  - setReadsEnabled
```
public void setReadsEnabled(boolean readsEnabled)
```
  - checkFamilies
```
public void checkFamilies(Collection<byte[]> families)
                   throws NoSuchColumnFamilyException
```
    Check the collection of families for validity.
    
    Throws:
    
    NoSuchColumnFamilyException
  - checkTimestamps
```
public void checkTimestamps(Map<byte[],List<Cell>> familyMap,
                            long now)
                     throws FailedSanityCheckException
```
    Check the collection of families for valid timestamps
    
    Parameters:
    
    now - current timestamp
    
    Throws:
    
    FailedSanityCheckException
  - refreshStoreFiles
```
public boolean refreshStoreFiles()
                          throws IOException
```
    Description copied from interface: Region
    
    Check the region's underlying store files, open the files that have not been opened yet, and remove the store file readers for store files no longer available.
    
    Specified by:
    
    refreshStoreFiles in interface Region
    
    Throws:
    
    IOException
  - refreshStoreFiles
```
protected boolean refreshStoreFiles(boolean force)
                             throws IOException
```
    Throws:
    
    IOException
  - restoreEdit
```
protected void restoreEdit(HStore s,
                           Cell cell,
                           MemStoreSizing memstoreAccounting)
```
    Used by tests
    
    Parameters:
    
    s - Store to add edit too.
    
    cell - Cell to add.
  - instantiateHStore
```
protected HStore instantiateHStore(ColumnFamilyDescriptor family,
                                   boolean warmup)
                            throws IOException
```
    Throws:
    
    IOException
  - getStore
```
public HStore getStore(byte[] column)
```
    Description copied from interface: Region
    
    Return the Store for the given family
    Use with caution. Exposed for use of fixup utilities.
    
    Specified by:
    
    getStore in interface Region
    
    Returns:
    
    the Store for the given family
  - getStores
```
public List<HStore> getStores()
```
    Description copied from interface: Region
    
    Return the list of Stores managed by this region
    Use with caution. Exposed for use of fixup utilities.
    
    Specified by:
    
    getStores in interface Region
    
    Returns:
    
    a list of the Stores managed by this region
  - getStoreFileList
```
public List<String> getStoreFileList(byte[][] columns)
                              throws IllegalArgumentException
```
    Description copied from interface: Region
    
    Returns list of store file names for the given families
    
    Specified by:
    
    getStoreFileList in interface Region
    
    Throws:
    
    IllegalArgumentException
  - getRowLock
```
public Region.RowLock getRowLock(byte[] row)
                          throws IOException
```
    Get an exclusive ( write lock ) lock on a given row.
    
    Parameters:
    
    row - Which row to lock.
    
    Returns:
    
    A locked RowLock. The lock is exclusive and already aqquired.
    
    Throws:
    
    IOException
  - getRowLock
```
public Region.RowLock getRowLock(byte[] row,
                                 boolean readLock)
                          throws IOException
```
    Description copied from interface: Region
    
    Get a row lock for the specified row. All locks are reentrant. Before calling this function make sure that a region operation has already been started (the calling thread has already acquired the region-close-guard lock).
    The obtained locks should be released after use by Region.RowLock.release()
    NOTE: the boolean passed here has changed. It used to be a boolean that stated whether or not to wait on the lock. Now it is whether it an exclusive lock is requested.
    
    Specified by:
    
    getRowLock in interface Region
    
    Parameters:
    
    row - The row actions will be performed against
    
    readLock - is the lock reader or writer. True indicates that a non-exclusive lock is requested
    
    Throws:
    
    IOException
    
    See Also:
    
    Region.startRegionOperation(), Region.startRegionOperation(Operation)
  - getRowLockInternal
```
protected Region.RowLock getRowLockInternal(byte[] row,
                                            boolean readLock,
                                            Region.RowLock prevRowLock)
                                     throws IOException
```
    Throws:
    
    IOException
  - getReadLockCount
```
public int getReadLockCount()
```
  - getLockedRows
```
public ConcurrentHashMap<HashedBytes,org.apache.hadoop.hbase.regionserver.HRegion.RowLockContext> getLockedRows()
```
  - bulkLoadHFiles
```
public Map<byte[],List<org.apache.hadoop.fs.Path>> bulkLoadHFiles(Collection<Pair<byte[],String>> familyPaths,
                                                                  boolean assignSeqId,
                                                                  HRegion.BulkLoadListener bulkLoadListener)
                                                           throws IOException
```
    Attempts to atomically load a group of hfiles. This is critical for loading rows with multiple column families atomically.
    
    Parameters:
    
    familyPaths - List of Pair<byte[] column family, String hfilePath>
    
    bulkLoadListener - Internal hooks enabling massaging/preparation of a file about to be bulk loaded
    
    Returns:
    
    Map from family to List of store file paths if successful, null if failed recoverably
    
    Throws:
    
    IOException - if failed unrecoverably.
  - bulkLoadHFiles
```
public Map<byte[],List<org.apache.hadoop.fs.Path>> bulkLoadHFiles(Collection<Pair<byte[],String>> familyPaths,
                                                                  boolean assignSeqId,
                                                                  HRegion.BulkLoadListener bulkLoadListener,
                                                                  boolean copyFile,
                                                                  List<String> clusterIds,
                                                                  boolean replicate)
                                                           throws IOException
```
    Attempts to atomically load a group of hfiles. This is critical for loading rows with multiple column families atomically.
    
    Parameters:
    
    familyPaths - List of Pair<byte[] column family, String hfilePath>
    
    bulkLoadListener - Internal hooks enabling massaging/preparation of a file about to be bulk loaded
    
    copyFile - always copy hfiles if true
    
    clusterIds - ids from clusters that had already handled the given bulkload event.
    
    Returns:
    
    Map from family to List of store file paths if successful, null if failed recoverably
    
    Throws:
    
    IOException - if failed unrecoverably.
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - newHRegion
```
public static HRegion newHRegion(org.apache.hadoop.fs.Path tableDir,
                                 WAL wal,
                                 org.apache.hadoop.fs.FileSystem fs,
                                 org.apache.hadoop.conf.Configuration conf,
                                 RegionInfo regionInfo,
                                 TableDescriptor htd,
                                 RegionServerServices rsServices)
```
    A utility method to create new instances of HRegion based on the HConstants.REGION_IMPL configuration property.
    
    Parameters:
    
    tableDir - qualified path of directory where region should be located, usually the table directory.
    
    wal - The WAL is the outbound log for any updates to the HRegion The wal file is a logfile from the previous execution that's custom-computed for this HRegion. The HRegionServer computes and sorts the appropriate wal info for this HRegion. If there is a previous file (implying that the HRegion has been written-to before), then read it from the supplied path.
    
    fs - is the filesystem.
    
    conf - is global configuration settings.
    
    regionInfo - - RegionInfo that describes the region is new), then read them from the supplied path.
    
    htd - the table descriptor
    
    Returns:
    
    the new instance
  - createHRegion
```
public static HRegion createHRegion(RegionInfo info,
                                    org.apache.hadoop.fs.Path rootDir,
                                    org.apache.hadoop.conf.Configuration conf,
                                    TableDescriptor hTableDescriptor,
                                    WAL wal,
                                    boolean initialize)
                             throws IOException
```
    Convenience method creating new HRegions. Used by createTable.
    
    Parameters:
    
    info - Info for region to create.
    
    rootDir - Root directory for HBase instance
    
    wal - shared WAL
    
    initialize - - true to initialize the region
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - createHRegion
```
public static HRegion createHRegion(RegionInfo info,
                                    org.apache.hadoop.fs.Path rootDir,
                                    org.apache.hadoop.conf.Configuration conf,
                                    TableDescriptor hTableDescriptor,
                                    WAL wal,
                                    boolean initialize,
                                    RegionServerServices rsRpcServices)
                             throws IOException
```
    Convenience method creating new HRegions. Used by createTable.
    
    Parameters:
    
    info - Info for region to create.
    
    rootDir - Root directory for HBase instance
    
    wal - shared WAL
    
    initialize - - true to initialize the region
    
    rsRpcServices - An interface we can request flushes against.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - createHRegion
```
public static HRegion createHRegion(org.apache.hadoop.conf.Configuration conf,
                                    RegionInfo regionInfo,
                                    org.apache.hadoop.fs.FileSystem fs,
                                    org.apache.hadoop.fs.Path tableDir,
                                    TableDescriptor tableDesc)
                             throws IOException
```
    Create a region under the given table directory.
    
    Throws:
    
    IOException
  - createRegionDir
```
public static HRegionFileSystem createRegionDir(org.apache.hadoop.conf.Configuration configuration,
                                                RegionInfo ri,
                                                org.apache.hadoop.fs.Path rootDir)
                                         throws IOException
```
    Create the region directory in the filesystem.
    
    Throws:
    
    IOException
  - createHRegion
```
public static HRegion createHRegion(RegionInfo info,
                                    org.apache.hadoop.fs.Path rootDir,
                                    org.apache.hadoop.conf.Configuration conf,
                                    TableDescriptor hTableDescriptor,
                                    WAL wal)
                             throws IOException
```
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal,
                                  org.apache.hadoop.conf.Configuration conf)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    info - Info for region to be opened.
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal,
                                  org.apache.hadoop.conf.Configuration conf,
                                  RegionServerServices rsServices,
                                  CancelableProgressable reporter)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    info - Info for region to be opened
    
    htd - the table descriptor
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    conf - The Configuration object to use.
    
    rsServices - An interface we can request flushes against.
    
    reporter - An interface we can report progress against.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(org.apache.hadoop.fs.Path rootDir,
                                  RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal,
                                  org.apache.hadoop.conf.Configuration conf)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    rootDir - Root directory for HBase instance
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    conf - The Configuration object to use.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(org.apache.hadoop.fs.Path rootDir,
                                  RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal,
                                  org.apache.hadoop.conf.Configuration conf,
                                  RegionServerServices rsServices,
                                  CancelableProgressable reporter)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    rootDir - Root directory for HBase instance
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    conf - The Configuration object to use.
    
    rsServices - An interface we can request flushes against.
    
    reporter - An interface we can report progress against.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(org.apache.hadoop.conf.Configuration conf,
                                  org.apache.hadoop.fs.FileSystem fs,
                                  org.apache.hadoop.fs.Path rootDir,
                                  RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    conf - The Configuration object to use.
    
    fs - Filesystem to use
    
    rootDir - Root directory for HBase instance
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(org.apache.hadoop.conf.Configuration conf,
                                  org.apache.hadoop.fs.FileSystem fs,
                                  org.apache.hadoop.fs.Path rootDir,
                                  RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal,
                                  RegionServerServices rsServices,
                                  CancelableProgressable reporter)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    conf - The Configuration object to use.
    
    fs - Filesystem to use
    
    rootDir - Root directory for HBase instance
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    rsServices - An interface we can request flushes against.
    
    reporter - An interface we can report progress against.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegionFromTableDir
```
public static HRegion openHRegionFromTableDir(org.apache.hadoop.conf.Configuration conf,
                                              org.apache.hadoop.fs.FileSystem fs,
                                              org.apache.hadoop.fs.Path tableDir,
                                              RegionInfo info,
                                              TableDescriptor htd,
                                              WAL wal,
                                              RegionServerServices rsServices,
                                              CancelableProgressable reporter)
                                       throws IOException
```
    Open a Region.
    
    Parameters:
    
    conf - The Configuration object to use.
    
    fs - Filesystem to use
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    rsServices - An interface we can request flushes against.
    
    reporter - An interface we can report progress against.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - getReplicationScope
```
public NavigableMap<byte[],Integer> getReplicationScope()
```
  - openHRegion
```
public static HRegion openHRegion(HRegion other,
                                  CancelableProgressable reporter)
                           throws IOException
```
    Useful when reopening a closed region (normally for unit tests)
    
    Parameters:
    
    other - original object
    
    reporter - An interface we can report progress against.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegion
```
public static Region openHRegion(Region other,
                                 CancelableProgressable reporter)
                          throws IOException
```
    Throws:
    
    IOException
  - openReadOnlyFileSystemHRegion
```
public static HRegion openReadOnlyFileSystemHRegion(org.apache.hadoop.conf.Configuration conf,
                                                    org.apache.hadoop.fs.FileSystem fs,
                                                    org.apache.hadoop.fs.Path tableDir,
                                                    RegionInfo info,
                                                    TableDescriptor htd)
                                             throws IOException
```
    Open a Region on a read-only file-system (like hdfs snapshots)
    
    Parameters:
    
    conf - The Configuration object to use.
    
    fs - Filesystem to use
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - warmupHRegion
```
public static HRegion warmupHRegion(RegionInfo info,
                                    TableDescriptor htd,
                                    WAL wal,
                                    org.apache.hadoop.conf.Configuration conf,
                                    RegionServerServices rsServices,
                                    CancelableProgressable reporter)
                             throws IOException
```
    Throws:
    
    IOException
  - getRegionDir
```
@Deprecated
public static org.apache.hadoop.fs.Path getRegionDir(org.apache.hadoop.fs.Path tabledir,
                                                                 String name)
```
    Deprecated. For tests only; to be removed.
    
    Computes the Path of the HRegion
    
    Parameters:
    
    tabledir - qualified path for table
    
    name - ENCODED region name
    
    Returns:
    
    Path of HRegion directory
  - rowIsInRange
```
public static boolean rowIsInRange(RegionInfo info,
                                   byte[] row)
```
    Determines if the specified row is within the row range specified by the specified RegionInfo
    
    Parameters:
    
    info - RegionInfo that specifies the row range
    
    row - row to be checked
    
    Returns:
    
    true if the row is within the range specified by the RegionInfo
  - rowIsInRange
```
public static boolean rowIsInRange(RegionInfo info,
                                   byte[] row,
                                   int offset,
                                   short length)
```
  - get
```
public Result get(Get get)
           throws IOException
```
    Description copied from interface: Region
    
    Do a get based on the get parameter.
    
    Specified by:
    
    get in interface Region
    
    Parameters:
    
    get - query parameters
    
    Returns:
    
    result of the operation
    
    Throws:
    
    IOException
  - get
```
public List<Cell> get(Get get,
                      boolean withCoprocessor)
               throws IOException
```
    Description copied from interface: Region
    
    Do a get based on the get parameter.
    
    Specified by:
    
    get in interface Region
    
    Parameters:
    
    get - query parameters
    
    withCoprocessor - invoke coprocessor or not. We don't want to always invoke cp.
    
    Returns:
    
    list of cells resulting from the operation
    
    Throws:
    
    IOException
  - mutateRow
```
public Result mutateRow(RowMutations rm)
                 throws IOException
```
    Description copied from interface: Region
    
    Performs multiple mutations atomically on a single row.
    
    Specified by:
    
    mutateRow in interface Region
    
    Parameters:
    
    rm - object that specifies the set of mutations to perform atomically
    
    Returns:
    
    results of Increment/Append operations. If no Increment/Append operations, it returns null
    
    Throws:
    
    IOException
  - mutateRow
```
public Result mutateRow(RowMutations rm,
                        long nonceGroup,
                        long nonce)
                 throws IOException
```
    Throws:
    
    IOException
  - mutateRowsWithLocks
```
public void mutateRowsWithLocks(Collection<Mutation> mutations,
                                Collection<byte[]> rowsToLock,
                                long nonceGroup,
                                long nonce)
                         throws IOException
```
    Perform atomic (all or none) mutations within the region.
    
    Specified by:
    
    mutateRowsWithLocks in interface Region
    
    Parameters:
    
    mutations - The list of mutations to perform. mutations can contain operations for multiple rows. Caller has to ensure that all rows are contained in this region.
    
    rowsToLock - Rows to lock
    
    nonceGroup - Optional nonce group of the operation (client Id)
    
    nonce - Optional nonce of the operation (unique random id to ensure "more idempotence") If multiple rows are locked care should be taken that rowsToLock is sorted in order to avoid deadlocks.
    
    Throws:
    
    IOException
  - getLoadStatistics
```
public org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.RegionLoadStats getLoadStatistics()
```
    Returns statistics about the current load of the region
  - processRowsWithLocks
```
public void processRowsWithLocks(RowProcessor<?,?> processor)
                          throws IOException
```
    Description copied from interface: Region
    
    Performs atomic multiple reads and writes on a given row.
    
    Specified by:
    
    processRowsWithLocks in interface Region
    
    Parameters:
    
    processor - The object defines the reads and writes to a row.
    
    Throws:
    
    IOException
  - processRowsWithLocks
```
public void processRowsWithLocks(RowProcessor<?,?> processor,
                                 long nonceGroup,
                                 long nonce)
                          throws IOException
```
    Description copied from interface: Region
    
    Performs atomic multiple reads and writes on a given row.
    
    Specified by:
    
    processRowsWithLocks in interface Region
    
    Parameters:
    
    processor - The object defines the reads and writes to a row.
    
    nonceGroup - Optional nonce group of the operation (client Id)
    
    nonce - Optional nonce of the operation (unique random id to ensure "more idempotence")
    
    Throws:
    
    IOException
  - processRowsWithLocks
```
public void processRowsWithLocks(RowProcessor<?,?> processor,
                                 long timeout,
                                 long nonceGroup,
                                 long nonce)
                          throws IOException
```
    Description copied from interface: Region
    
    Performs atomic multiple reads and writes on a given row.
    
    Specified by:
    
    processRowsWithLocks in interface Region
    
    Parameters:
    
    processor - The object defines the reads and writes to a row.
    
    timeout - The timeout of the processor.process() execution Use a negative number to switch off the time bound
    
    nonceGroup - Optional nonce group of the operation (client Id)
    
    nonce - Optional nonce of the operation (unique random id to ensure "more idempotence")
    
    Throws:
    
    IOException
  - append
```
public Result append(Append append)
              throws IOException
```
    Description copied from interface: Region
    
    Perform one or more append operations on a row.
    
    Specified by:
    
    append in interface Region
    
    Returns:
    
    result of the operation
    
    Throws:
    
    IOException
  - append
```
public Result append(Append append,
                     long nonceGroup,
                     long nonce)
              throws IOException
```
    Throws:
    
    IOException
  - increment
```
public Result increment(Increment increment)
                 throws IOException
```
    Description copied from interface: Region
    
    Perform one or more increment operations on a row.
    
    Specified by:
    
    increment in interface Region
    
    Returns:
    
    result of the operation
    
    Throws:
    
    IOException
  - increment
```
public Result increment(Increment increment,
                        long nonceGroup,
                        long nonce)
                 throws IOException
```
    Throws:
    
    IOException
  - heapSize
```
public long heapSize()
```
    Specified by:
    
    heapSize in interface HeapSize
  - registerService
```
public boolean registerService(com.google.protobuf.Service instance)
```
    Registers a new protocol buffer Service subclass as a coprocessor endpoint to be available for handling Region#execService(com.google.protobuf.RpcController, org.apache.hadoop.hbase.protobuf.generated.ClientProtos.CoprocessorServiceCall) calls.
    Only a single instance may be registered per region for a given Service subclass (the instances are keyed on Descriptors.ServiceDescriptor.getFullName(). After the first registration, subsequent calls with the same service name will fail with a return value of false.
    
    Parameters:
    
    instance - the Service subclass instance to expose as a coprocessor endpoint
    
    Returns:
    
    true if the registration was successful, false otherwise
  - execService
```
public com.google.protobuf.Message execService(com.google.protobuf.RpcController controller,
                                               org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CoprocessorServiceCall call)
                                        throws IOException
```
    Executes a single protocol buffer coprocessor endpoint Service method using the registered protocol handlers. Service implementations must be registered via the registerService(com.google.protobuf.Service) method before they are available.
    
    Parameters:
    
    controller - an RpcContoller implementation to pass to the invoked service
    
    call - a CoprocessorServiceCall instance identifying the service, method, and parameters for the method invocation
    
    Returns:
    
    a protocol buffer Message instance containing the method's result
    
    Throws:
    
    IOException - if no registered service handler is found or an error occurs during the invocation
    
    See Also:
    
    registerService(com.google.protobuf.Service)
  - checkSplit
```
public Optional<byte[]> checkSplit()
```
  - checkSplit
```
public Optional<byte[]> checkSplit(boolean force)
```
    Return the split point. An empty result indicates the region isn't splittable.
  - getCompactPriority
```
public int getCompactPriority()
```
    Returns The priority that this region should have in the compaction queue
  - getCoprocessorHost
```
public RegionCoprocessorHost getCoprocessorHost()
```
    Returns the coprocessor host
  - setCoprocessorHost
```
public void setCoprocessorHost(RegionCoprocessorHost coprocessorHost)
```
    Parameters:
    
    coprocessorHost - the new coprocessor host
  - startRegionOperation
```
public void startRegionOperation()
                          throws IOException
```
    Description copied from interface: Region
    
    This method needs to be called before any public call that reads or modifies data. Acquires a read lock and checks if the region is closing or closed.
    Region.closeRegionOperation() MUST then always be called after the operation has completed, whether it succeeded or failed.
    
    Specified by:
    
    startRegionOperation in interface Region
    
    Throws:
    
    IOException
  - startRegionOperation
```
public void startRegionOperation(Region.Operation op)
                          throws IOException
```
    Description copied from interface: Region
    
    This method needs to be called before any public call that reads or modifies data. Acquires a read lock and checks if the region is closing or closed.
    Region.closeRegionOperation() MUST then always be called after the operation has completed, whether it succeeded or failed.
    
    Specified by:
    
    startRegionOperation in interface Region
    
    Parameters:
    
    op - The operation is about to be taken on the region
    
    Throws:
    
    IOException
  - closeRegionOperation
```
public void closeRegionOperation()
                          throws IOException
```
    Description copied from interface: Region
    
    Closes the region operation lock.
    
    Specified by:
    
    closeRegionOperation in interface Region
    
    Throws:
    
    IOException
  - closeRegionOperation
```
public void closeRegionOperation(Region.Operation operation)
                          throws IOException
```
    Description copied from interface: Region
    
    Closes the region operation lock. This needs to be called in the finally block corresponding to the try block of Region.startRegionOperation(Operation)
    
    Specified by:
    
    closeRegionOperation in interface Region
    
    Throws:
    
    IOException
  - getOpenSeqNum
```
public long getOpenSeqNum()
```
    Returns the latest sequence number that was read from storage when this region was opened
  - getMaxStoreSeqId
```
public Map<byte[],Long> getMaxStoreSeqId()
```
    Specified by:
    
    getMaxStoreSeqId in interface Region
    
    Returns:
    
    map of column family names to max sequence id that was read from storage when this region was opened
  - getOldestSeqIdOfStore
```
public long getOldestSeqIdOfStore(byte[] familyName)
```
  - getCompactionState
```
public CompactionState getCompactionState()
```
    Description copied from interface: Region
    
    Returns if a given region is in compaction now.
    
    Specified by:
    
    getCompactionState in interface Region
  - reportCompactionRequestStart
```
public void reportCompactionRequestStart(boolean isMajor)
```
  - reportCompactionRequestEnd
```
public void reportCompactionRequestEnd(boolean isMajor,
                                       int numFiles,
                                       long filesSizeCompacted)
```
  - reportCompactionRequestFailure
```
public void reportCompactionRequestFailure()
```
  - incrementCompactionsQueuedCount
```
public void incrementCompactionsQueuedCount()
```
  - decrementCompactionsQueuedCount
```
public void decrementCompactionsQueuedCount()
```
  - incrementFlushesQueuedCount
```
public void incrementFlushesQueuedCount()
```
  - decrementFlushesQueuedCount
```
protected void decrementFlushesQueuedCount()
```
  - onConfigurationChange
```
public void onConfigurationChange(org.apache.hadoop.conf.Configuration conf)
```
    Specified by:
    
    onConfigurationChange in interface ConfigurationObserver
  - registerChildren
```
public void registerChildren(ConfigurationManager manager)
```
    Specified by:
    
    registerChildren in interface PropagatingConfigurationObserver
  - deregisterChildren
```
public void deregisterChildren(ConfigurationManager manager)
```
    Specified by:
    
    deregisterChildren in interface PropagatingConfigurationObserver
  - getCellComparator
```
public CellComparator getCellComparator()
```
    Description copied from interface: Region
    
    The comparator to be used with the region
    
    Specified by:
    
    getCellComparator in interface Region
  - getMemStoreFlushSize
```
public long getMemStoreFlushSize()
```
  - requestCompaction
```
public void requestCompaction(String why,
                              int priority,
                              boolean major,
                              CompactionLifeCycleTracker tracker)
                       throws IOException
```
    Description copied from interface: Region
    
    Request compaction on this region.
    
    Specified by:
    
    requestCompaction in interface Region
    
    Throws:
    
    IOException
  - requestCompaction
```
public void requestCompaction(byte[] family,
                              String why,
                              int priority,
                              boolean major,
                              CompactionLifeCycleTracker tracker)
                       throws IOException
```
    Description copied from interface: Region
    
    Request compaction for the given family
    
    Specified by:
    
    requestCompaction in interface Region
    
    Throws:
    
    IOException
  - requestFlush
```
public void requestFlush(FlushLifeCycleTracker tracker)
                  throws IOException
```
    Description copied from interface: Region
    
    Request flush on this region.
    
    Specified by:
    
    requestFlush in interface Region
    
    Throws:
    
    IOException
  - addReadRequestsCount
```
public void addReadRequestsCount(long readRequestsCount)
```
  - addWriteRequestsCount
```
public void addWriteRequestsCount(long writeRequestsCount)
```

Class HRegion

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.hadoop.hbase.regionserver.Region

Field Detail

LOAD_CFS_ON_DEMAND_CONFIG_KEY

HBASE_MAX_CELL_SIZE_KEY

DEFAULT_MAX_CELL_SIZE

HBASE_REGIONSERVER_MINIBATCH_SIZE

DEFAULT_HBASE_REGIONSERVER_MINIBATCH_SIZE

WAL_HSYNC_CONF_KEY

DEFAULT_WAL_HSYNC

COMPACTION_AFTER_BULKLOAD_ENABLE

SPLIT_IGNORE_BLOCKING_ENABLED_KEY

REGION_STORAGE_POLICY_KEY

DEFAULT_REGION_STORAGE_POLICY

SPECIAL_RECOVERED_EDITS_DIR

USE_META_CELL_COMPARATOR

DEFAULT_USE_META_CELL_COMPARATOR

lastReplayedOpenRegionSeqId

lastReplayedCompactionSeqId

stores

conf

rsServices

FAIR_REENTRANT_CLOSE_LOCK

DEFAULT_FAIR_REENTRANT_CLOSE_LOCK

MEMSTORE_PERIODIC_FLUSH_INTERVAL

DEFAULT_CACHE_FLUSH_INTERVAL

SYSTEM_CACHE_FLUSH_INTERVAL

MEMSTORE_FLUSH_PER_CHANGES

DEFAULT_FLUSH_PER_CHANGES

MAX_FLUSH_PER_CHANGES

CLOSE_WAIT_ABORT

DEFAULT_CLOSE_WAIT_ABORT

CLOSE_WAIT_TIME

DEFAULT_CLOSE_WAIT_TIME

CLOSE_WAIT_INTERVAL

DEFAULT_CLOSE_WAIT_INTERVAL

FIXED_OVERHEAD

DEEP_OVERHEAD

Constructor Detail

HRegion

HRegion

Method Detail

setRestoredRegion

getSmallestReadPoint

initialize

writeRegionOpenMarker

hasReferences

blockUpdates

unblockUpdates

getHDFSBlocksDistribution

computeHDFSBlocksDistribution

computeHDFSBlocksDistribution

getRegionInfo

getReadRequestsCount

getFilteredReadRequestsCount

getWriteRequestsCount

getMemStoreDataSize

getMemStoreHeapSize

getMemStoreOffHeapSize

getRegionServicesForStores

getNumMutationsWithoutWAL

getDataInMemoryWithoutWAL

getBlockedRequestsCount

getCheckAndMutateChecksPassed

getCheckAndMutateChecksFailed

getMetrics

isClosed

isClosing

isReadOnly

isAvailable

isSplittable

isMergeable

areWritesEnabled

getMVCC