HRegion (Hortonworks Data Platform Apache HBase Java API Reference)

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

All Implemented Interfaces:

ConfigurationObserver, PropagatingConfigurationObserver, HeapSize, Region

Direct Known Subclasses:

TestAtomicOperation.MockHRegion, TestIOFencing.CompactionBlockerRegion, TestRegionObserverScannerOpenHook.CompactionCompletionNotifyingRegion
```
@InterfaceAudience.Private
public class HRegion
extends Object
implements HeapSize, PropagatingConfigurationObserver, Region
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`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`

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

Field Summary

Fields
Modifier and Type	Field and Description
`protected Configuration`	`conf`
`static long`	`DEEP_OVERHEAD`
`static int`	`DEFAULT_CACHE_FLUSH_INTERVAL` Default interval for the memstore flush
`static long`	`DEFAULT_FLUSH_PER_CHANGES`
`static long`	`FIXED_OVERHEAD`
`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 Log`	`LOG`
`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
`AtomicLong`	`memstoreSize`
`static int`	`META_CACHE_FLUSH_INTERVAL`
`protected Map<byte[],Store>`	`stores`

Constructor Summary

Constructors
Constructor and Description
`HRegion(HRegionFileSystem fs, WAL wal, Configuration confParam, HTableDescriptor htd, RegionServerServices rsServices)` HRegion constructor.
`HRegion(Path tableDir, WAL wal, FileSystem fs, Configuration confParam, HRegionInfo regionInfo, HTableDescriptor htd, RegionServerServices rsServices)` Deprecated.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`long`	`addAndGetGlobalMemstoreSize(long memStoreSize)` Increase the size of mem store in this region and the size of global mem store
`static void`	`addRegionToMETA(HRegion meta, HRegion r)` Inserts a new region's meta information into the passed `meta` region.
`void`	`addRegionToSnapshot(HBaseProtos.SnapshotDescription desc, ForeignExceptionSnare exnSnare)` Complete taking the snapshot on the region.
`Result`	`append(Append append)`
`Result`	`append(Append append, long nonceGroup, long nonce)` Perform one or more append operations on a row.
`boolean`	`areWritesEnabled()`
`OperationStatus[]`	`batchMutate(Mutation[] mutations)`
`OperationStatus[]`	`batchMutate(Mutation[] mutations, long nonceGroup, long nonce)` Perform a batch of mutations.
`OperationStatus[]`	`batchReplay(WALSplitter.MutationReplay[] mutations, long replaySeqId)` Replay a batch of mutations.
`boolean`	`bulkLoadHFiles(Collection<Pair<byte[],String>> familyPaths, boolean assignSeqId, Region.BulkLoadListener bulkLoadListener)` Attempts to atomically load a group of hfiles.
`boolean`	`checkAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Mutation w, boolean writeToWAL)` Atomically checks if a row/family/qualifier value matches the expected val If it does, it performs the row mutations.
`boolean`	`checkAndRowMutate(byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, RowMutations rm, boolean writeToWAL)` Atomically checks if a row/family/qualifier value matches the expected val If it does, it performs the row mutations.
`void`	`checkFamilies(Collection<byte[]> families)` Check the collection of families for validity.
`protected void`	`checkReadOnly()`
`protected void`	`checkReadsEnabled()`
`byte[]`	`checkSplit()` Return the splitpoint.
`void`	`checkTimestamps(Map<byte[],List<Cell>> familyMap, long now)` Check the collection of families for valid timestamps
`Map<byte[],List<StoreFile>>`	`close()` Close down this HRegion.
`Map<byte[],List<StoreFile>>`	`close(boolean abort)` Close down this HRegion.
`static void`	`closeHRegion(HRegion r)` This will do the necessary cleanup a call to `createHRegion(HRegionInfo, Path, Configuration, HTableDescriptor)` requires.
`void`	`closeRegionOperation()` Closes the region operation lock.
`void`	`closeRegionOperation(Region.Operation operation)` Closes the lock.
`void`	`compact(boolean majorCompaction)` Synchronously compact all stores in the region.
`boolean`	`compact(CompactionContext compaction, Store store, CompactionThroughputController throughputController)`
`void`	`compactStores()` This is a helper function that compact all the stores synchronously It is used by utilities and testing
`static HDFSBlocksDistribution`	`computeHDFSBlocksDistribution(Configuration conf, HTableDescriptor tableDescriptor, HRegionInfo regionInfo)` This is a helper function to compute HDFS block distribution on demand
`static HDFSBlocksDistribution`	`computeHDFSBlocksDistribution(Configuration conf, HTableDescriptor tableDescriptor, HRegionInfo regionInfo, Path tablePath)` This is a helper function to compute HDFS block distribution on demand
`static HRegion`	`createHRegion(HRegionInfo info, Path rootDir, Configuration conf, HTableDescriptor hTableDescriptor)` Convenience method creating new HRegions.
`static HRegion`	`createHRegion(HRegionInfo info, Path rootDir, Configuration conf, HTableDescriptor hTableDescriptor, WAL wal)`
`static HRegion`	`createHRegion(HRegionInfo info, Path rootDir, Configuration conf, HTableDescriptor hTableDescriptor, WAL wal, boolean initialize)` Convenience method creating new HRegions.
`static HRegion`	`createHRegion(HRegionInfo info, Path rootDir, Configuration conf, HTableDescriptor hTableDescriptor, WAL wal, boolean initialize, boolean ignoreWAL)` Convenience method creating new HRegions.
`static HRegion`	`createHRegion(HRegionInfo info, Path rootDir, Path tableDir, Configuration conf, HTableDescriptor hTableDescriptor, WAL wal, boolean initialize, boolean ignoreWAL)` Convenience method creating new HRegions.
`void`	`delete(Delete delete)` Deletes the specified cells/row.
`void`	`deregisterChildren(ConfigurationManager manager)` Needs to be called to deregister the children from the manager.
`protected void`	`doRegionCompactionPrep()`
`boolean`	`equals(Object o)`
`Message`	`execService(RpcController controller, ClientProtos.CoprocessorServiceCall call)` Executes a single protocol buffer coprocessor endpoint `Service` method using the registered protocol handlers.
`Region.FlushResult`	`flush(boolean force)` Flush the cache.
`Region.FlushResult`	`flushcache(boolean forceFlushAllStores, boolean writeFlushRequestWalMarker)` 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.
`long`	`getBlockedRequestsCount()`
`long`	`getCheckAndMutateChecksFailed()`
`long`	`getCheckAndMutateChecksPassed()`
`Result`	`getClosestRowBefore(byte[] row, byte[] family)` Return all the data for the row that matches row exactly, or the one that immediately preceeds it, at or immediately before ts.
`AdminProtos.GetRegionInfoResponse.CompactionState`	`getCompactionState()`
`int`	`getCompactPriority()`
`KeyValue.KVComparator`	`getComparator()`
`RegionCoprocessorHost`	`getCoprocessorHost()`
`long`	`getDataInMemoryWithoutWAL()`
`long`	`getEarliestFlushTimeForAllStores()`
`protected Durability`	`getEffectiveDurability(Durability d)` Returns effective durability from the passed durability and the table descriptor.
`FileSystem`	`getFilesystem()`
`HDFSBlocksDistribution`	`getHDFSBlocksDistribution()`
`long`	`getLargestHStoreSize()`
`long`	`getMaxFlushedSeqId()`
`Map<byte[],Long>`	`getMaxStoreSeqId()`
`long`	`getMemstoreSize()`
`MetricsRegion`	`getMetrics()`
`MultiVersionConsistencyControl`	`getMVCC()`
`protected long`	`getNextSequenceId(WAL wal)` Method to safely get the next sequence number.
`long`	`getNumMutationsWithoutWAL()`
`long`	`getOldestHfileTs(boolean majorCompactioOnly)` This can be used to determine the last time all files of this region were major compacted.
`long`	`getOldestSeqIdOfStore(byte[] familyName)`
`long`	`getOpenSeqNum()`
`long`	`getReadpoint(IsolationLevel isolationLevel)`
`long`	`getReadRequestsCount()`
`static Path`	`getRegionDir(Path rootdir, HRegionInfo info)` Deprecated.
`static Path`	`getRegionDir(Path tabledir, String name)` Deprecated.
`HRegionFileSystem`	`getRegionFileSystem()`
`HRegionInfo`	`getRegionInfo()`
`ClientProtos.RegionLoadStats`	`getRegionStats()`
`Region.RowLock`	`getRowLock(byte[] row)` Acquires a lock on the given row.
`Region.RowLock`	`getRowLock(byte[] row, boolean waitForLock)` Tries to acquire a lock on the given row.
`protected Region.RowLock`	`getRowLockInternal(byte[] row, boolean waitForLock)` A version of getRowLock(byte[], boolean) to use when a region operation has already been started (the calling thread has already acquired the region-close-guard lock).
`RegionScanner`	`getScanner(Scan scan)` Return an iterator that scans over the HRegion, returning the indicated columns and rows specified by the `Scan`.
`protected RegionScanner`	`getScanner(Scan scan, List<KeyValueScanner> additionalScanners)`
`AtomicLong`	`getSequenceId()` Do not change this sequence id.
`long`	`getSmallestReadPoint()`
`RegionSplitPolicy`	`getSplitPolicy()`
`Store`	`getStore(byte[] column)` Return the Store for the given family
`List<String>`	`getStoreFileList(byte[][] columns)`
`protected ThreadPoolExecutor`	`getStoreFileOpenAndCloseThreadPool(String threadNamePrefix)`
`protected ThreadPoolExecutor`	`getStoreOpenAndCloseThreadPool(String threadNamePrefix)`
`List<Store>`	`getStores()` Return the list of Stores managed by this region
`HTableDescriptor`	`getTableDesc()`
`WAL`	`getWAL()`
`long`	`getWriteRequestsCount()`
`int`	`hashCode()`
`boolean`	`hasReferences()`
`long`	`heapSize()`
`Result`	`increment(Increment increment)`
`Result`	`increment(Increment increment, long nonceGroup, long nonce)` Perform one or more increment operations on a row.
`long`	`initialize()` Deprecated. use HRegion.createHRegion() or HRegion.openHRegion()
`protected HStore`	`instantiateHStore(HColumnDescriptor family)`
`protected RegionScanner`	`instantiateRegionScanner(Scan scan, List<KeyValueScanner> additionalScanners)`
`protected Region.FlushResult`	`internalFlushcache(WAL wal, long myseqid, Collection<Store> storesToFlush, MonitoredTask status, boolean writeFlushWalMarker)` Flush the memstore.
`protected Region.FlushResult`	`internalFlushCacheAndCommit(WAL wal, MonitoredTask status, org.apache.hadoop.hbase.regionserver.HRegion.PrepareFlushResult prepareResult, Collection<Store> storesToFlush)`
`protected org.apache.hadoop.hbase.regionserver.HRegion.PrepareFlushResult`	`internalPrepareFlushCache(WAL wal, long myseqid, Collection<Store> storesToFlush, MonitoredTask status, boolean writeFlushWalMarker)`
`boolean`	`isAvailable()`
`boolean`	`isClosed()`
`boolean`	`isClosing()`
`boolean`	`isLoadingCfsOnDemandDefault()`
`boolean`	`isMergeable()`
`boolean`	`isReadOnly()`
`boolean`	`isRecovering()`
`boolean`	`isSplittable()`
`static void`	`main(String[] args)` Facility for dumping and compacting catalog tables.
`static HRegion`	`merge(HRegion a, HRegion b)` Merge two regions whether they are adjacent or not.
`static HRegion`	`mergeAdjacent(HRegion srcA, HRegion srcB)` Merge two HRegions.
`void`	`mutateRow(RowMutations rm)` Performs multiple mutations atomically on a single row.
`void`	`mutateRowsWithLocks(Collection<Mutation> mutations, Collection<byte[]> rowsToLock)` Perform atomic mutations within the region w/o nonces.
`void`	`mutateRowsWithLocks(Collection<Mutation> mutations, Collection<byte[]> rowsToLock, long nonceGroup, long nonce)` Perform atomic mutations within the region.
`void`	`onConfigurationChange(Configuration conf)` This method would be called by the `ConfigurationManager` object when the `Configuration` object is reloaded from disk.
`protected HRegion`	`openHRegion(CancelableProgressable reporter)` Open HRegion.
`static HRegion`	`openHRegion(Configuration conf, FileSystem fs, Path rootDir, HRegionInfo info, HTableDescriptor htd, WAL wal)` Open a Region.
`static HRegion`	`openHRegion(Configuration conf, FileSystem fs, Path rootDir, HRegionInfo info, HTableDescriptor htd, WAL wal, RegionServerServices rsServices, CancelableProgressable reporter)` Open a Region.
`static HRegion`	`openHRegion(Configuration conf, FileSystem fs, Path rootDir, Path tableDir, HRegionInfo info, HTableDescriptor 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(HRegionInfo info, HTableDescriptor htd, WAL wal, Configuration conf)` Open a Region.
`static HRegion`	`openHRegion(HRegionInfo info, HTableDescriptor htd, WAL wal, Configuration conf, RegionServerServices rsServices, CancelableProgressable reporter)` Open a Region.
`static HRegion`	`openHRegion(Path rootDir, HRegionInfo info, HTableDescriptor htd, WAL wal, Configuration conf)` Open a Region.
`static HRegion`	`openHRegion(Path rootDir, HRegionInfo info, HTableDescriptor htd, WAL wal, Configuration conf, RegionServerServices rsServices, CancelableProgressable reporter)` Open a Region.
`static Region`	`openHRegion(Region other, CancelableProgressable reporter)`
`void`	`prepareDelete(Delete delete)` Prepare a delete for a row mutation processor
`void`	`prepareDeleteTimestamps(Mutation mutation, Map<byte[],List<Cell>> familyMap, byte[] byteNow)` Set up correct timestamps in the KVs in Delete object.
`protected void`	`prepareToSplit()` Give the region a chance to prepare before it is split.
`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.
`void`	`registerChildren(ConfigurationManager manager)` Needs to be called to register the children to the manager.
`boolean`	`registerService(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`	`releaseRowLocks(List<Region.RowLock> rowLocks)` If the given list of row locks is not null, releases all locks.
`protected long`	`replayRecoveredEditsIfAny(Path regiondir, Map<byte[],Long> maxSeqIdInStores, CancelableProgressable reporter, MonitoredTask status)` Read the edits put under this region by wal splitting process.
`void`	`reportCompactionRequestEnd(boolean isMajor, int numFiles, long filesSizeCompacted)`
`void`	`reportCompactionRequestStart(boolean isMajor)`
`protected boolean`	`restoreEdit(Store s, Cell cell)` Used by tests
`static boolean`	`rowIsInRange(HRegionInfo info, byte[] row)` Determines if the specified row is within the row range specified by the specified HRegionInfo
`static boolean`	`rowIsInRange(HRegionInfo info, byte[] row, int offset, short length)`
`void`	`setClosing(boolean closing)` Exposed for some very specific unit tests.
`void`	`setCoprocessorHost(RegionCoprocessorHost coprocessorHost)`
`void`	`setReadsEnabled(boolean readsEnabled)`
`void`	`setRecovering(boolean newState)` Reset recovering state of current region
`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`	`triggerMajorCompaction()` Trigger major compaction on all stores in the region.
`void`	`updateCellTimestamps(Iterable<List<Cell>> cellItr, byte[] now)` Replace any cell timestamps set to HConstants#LATEST_TIMESTAMP with the provided current timestamp.
`void`	`updateReadRequestsCount(long i)` Update the read request count for this region
`void`	`updateWriteRequestsCount(long i)` Update the write request count for this region
`void`	`waitForFlushesAndCompactions()` Wait for all current flushes and compactions of the region to complete
`static void`	`warmupHRegion(HRegionInfo info, HTableDescriptor htd, WAL wal, Configuration conf, RegionServerServices rsServices, CancelableProgressable reporter)`

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

- Field Detail
  - LOG
```
public static final Log LOG
```
  - LOAD_CFS_ON_DEMAND_CONFIG_KEY
```
public static final String LOAD_CFS_ON_DEMAND_CONFIG_KEY
```
    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[],Store> stores
```
  - memstoreSize
```
public final AtomicLong memstoreSize
```
  - conf
```
protected final Configuration conf
```
  - 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
  - META_CACHE_FLUSH_INTERVAL
```
public static final int META_CACHE_FLUSH_INTERVAL
```
    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
  - FIXED_OVERHEAD
```
public static final long FIXED_OVERHEAD
```
  - DEEP_OVERHEAD
```
public static final long DEEP_OVERHEAD
```
- Constructor Detail
  - HRegion
```
@Deprecated
public HRegion(Path tableDir,
                           WAL wal,
                           FileSystem fs,
                           Configuration confParam,
                           HRegionInfo regionInfo,
                           HTableDescriptor htd,
                           RegionServerServices rsServices)
```
    Deprecated.
    
    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.HRegionInfo, Path, Configuration, org.apache.hadoop.hbase.HTableDescriptor) or openHRegion(org.apache.hadoop.hbase.HRegionInfo, org.apache.hadoop.hbase.HTableDescriptor, org.apache.hadoop.hbase.wal.WAL, 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 - - HRegionInfo 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,
               Configuration confParam,
               HTableDescriptor 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.HRegionInfo, Path, Configuration, org.apache.hadoop.hbase.HTableDescriptor) or openHRegion(org.apache.hadoop.hbase.HRegionInfo, org.apache.hadoop.hbase.HTableDescriptor, org.apache.hadoop.hbase.wal.WAL, 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
  - 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
  - hasReferences
```
public boolean hasReferences()
```
    Returns:
    
    True if this region has references.
  - getHDFSBlocksDistribution
```
public HDFSBlocksDistribution getHDFSBlocksDistribution()
```
    Specified by:
    
    getHDFSBlocksDistribution in interface Region
    
    Returns:
    
    the block distribution for all Stores managed by this region
  - computeHDFSBlocksDistribution
```
public static HDFSBlocksDistribution computeHDFSBlocksDistribution(Configuration conf,
                                                                   HTableDescriptor tableDescriptor,
                                                                   HRegionInfo regionInfo)
                                                            throws IOException
```
    This is a helper function to compute HDFS block distribution on demand
    
    Parameters:
    
    conf - configuration
    
    tableDescriptor - HTableDescriptor 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(Configuration conf,
                                                                   HTableDescriptor tableDescriptor,
                                                                   HRegionInfo regionInfo,
                                                                   Path tablePath)
                                                            throws IOException
```
    This is a helper function to compute HDFS block distribution on demand
    
    Parameters:
    
    conf - configuration
    
    tableDescriptor - HTableDescriptor of the table
    
    regionInfo - encoded name of the region
    
    tablePath - the table directory
    
    Returns:
    
    The HDFS blocks distribution for the given region.
    
    Throws:
    
    IOException
  - addAndGetGlobalMemstoreSize
```
public long addAndGetGlobalMemstoreSize(long memStoreSize)
```
    Increase the size of mem store in this region and the size of global mem store
    
    Returns:
    
    the size of memstore in this region
  - getRegionInfo
```
public HRegionInfo getRegionInfo()
```
    Specified by:
    
    getRegionInfo in interface Region
    
    Returns:
    
    region information for this region
  - getReadRequestsCount
```
public long getReadRequestsCount()
```
    Specified by:
    
    getReadRequestsCount in interface Region
    
    Returns:
    
    read requests count for this region
  - updateReadRequestsCount
```
public void updateReadRequestsCount(long i)
```
    Description copied from interface: Region
    
    Update the read request count for this region
    
    Specified by:
    
    updateReadRequestsCount in interface Region
    
    Parameters:
    
    i - increment
  - getWriteRequestsCount
```
public long getWriteRequestsCount()
```
    Specified by:
    
    getWriteRequestsCount in interface Region
    
    Returns:
    
    write request count for this region
  - updateWriteRequestsCount
```
public void updateWriteRequestsCount(long i)
```
    Description copied from interface: Region
    
    Update the write request count for this region
    
    Specified by:
    
    updateWriteRequestsCount in interface Region
    
    Parameters:
    
    i - increment
  - getMemstoreSize
```
public long getMemstoreSize()
```
    Specified by:
    
    getMemstoreSize in interface Region
    
    Returns:
    
    memstore size for this region, in bytes
  - getNumMutationsWithoutWAL
```
public long getNumMutationsWithoutWAL()
```
    Specified by:
    
    getNumMutationsWithoutWAL in interface Region
    
    Returns:
    
    the number of mutations processed bypassing the WAL
  - getDataInMemoryWithoutWAL
```
public long getDataInMemoryWithoutWAL()
```
    Specified by:
    
    getDataInMemoryWithoutWAL in interface Region
    
    Returns:
    
    the size of data processed bypassing the WAL, in bytes
  - getBlockedRequestsCount
```
public long getBlockedRequestsCount()
```
    Specified by:
    
    getBlockedRequestsCount in interface Region
    
    Returns:
    
    the number of blocked requests
  - getCheckAndMutateChecksPassed
```
public long getCheckAndMutateChecksPassed()
```
    Specified by:
    
    getCheckAndMutateChecksPassed in interface Region
    
    Returns:
    
    the number of checkAndMutate guards that passed
  - getCheckAndMutateChecksFailed
```
public long getCheckAndMutateChecksFailed()
```
    Specified by:
    
    getCheckAndMutateChecksFailed in interface Region
    
    Returns:
    
    the number of failed checkAndMutate guards
  - getMetrics
```
public MetricsRegion getMetrics()
```
    Specified by:
    
    getMetrics in interface Region
    
    Returns:
    
    the MetricsRegion for this region
  - isClosed
```
public boolean isClosed()
```
    Specified by:
    
    isClosed in interface Region
    
    Returns:
    
    true if region is closed
  - isClosing
```
public boolean isClosing()
```
    Specified by:
    
    isClosing in interface Region
    
    Returns:
    
    True if closing process has started
  - isReadOnly
```
public boolean isReadOnly()
```
    Specified by:
    
    isReadOnly in interface Region
    
    Returns:
    
    True if region is read only
  - setRecovering
```
public void setRecovering(boolean newState)
```
    Reset recovering state of current region
  - isRecovering
```
public boolean isRecovering()
```
    Specified by:
    
    isRecovering in interface Region
    
    Returns:
    
    True if region is in recovering state
  - isAvailable
```
public boolean isAvailable()
```
    Specified by:
    
    isAvailable in interface Region
    
    Returns:
    
    true if region is available (not closed and not closing)
  - isSplittable
```
public boolean isSplittable()
```
    Returns:
    
    true if region is splittable
  - isMergeable
```
public boolean isMergeable()
```
    Returns:
    
    true if region is mergeable
  - areWritesEnabled
```
public boolean areWritesEnabled()
```
  - getMVCC
```
public MultiVersionConsistencyControl getMVCC()
```
  - getMaxFlushedSeqId
```
public long getMaxFlushedSeqId()
```
    Specified by:
    
    getMaxFlushedSeqId in interface Region
    
    Returns:
    
    the max sequence id of flushed data on this region
  - getReadpoint
```
public long getReadpoint(IsolationLevel isolationLevel)
```
    Specified by:
    
    getReadpoint in interface Region
    
    Returns:
    
    readpoint considering given IsolationLevel
  - isLoadingCfsOnDemandDefault
```
public boolean isLoadingCfsOnDemandDefault()
```
    Specified by:
    
    isLoadingCfsOnDemandDefault in interface Region
    
    Returns:
    
    true if loading column families on demand by default
  - close
```
public Map<byte[],List<StoreFile>> 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 HStoreFile 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<StoreFile>> 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 HStoreFile 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.
  - waitForFlushesAndCompactions
```
public void waitForFlushesAndCompactions()
```
    Description copied from interface: Region
    
    Wait for all current flushes and compactions of the region to complete
    
    Specified by:
    
    waitForFlushesAndCompactions in interface Region
  - getStoreOpenAndCloseThreadPool
```
protected ThreadPoolExecutor getStoreOpenAndCloseThreadPool(String threadNamePrefix)
```
  - getStoreFileOpenAndCloseThreadPool
```
protected ThreadPoolExecutor getStoreFileOpenAndCloseThreadPool(String threadNamePrefix)
```
  - getTableDesc
```
public HTableDescriptor getTableDesc()
```
    Specified by:
    
    getTableDesc in interface Region
    
    Returns:
    
    table descriptor for this region
  - getWAL
```
public WAL getWAL()
```
    Returns:
    
    WAL in use for this region
  - getFilesystem
```
public FileSystem getFilesystem()
```
    Returns:
    
    FileSystem being used by this region
  - getRegionFileSystem
```
public HRegionFileSystem getRegionFileSystem()
```
    Returns:
    
    the HRegionFileSystem used by this region
  - 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 majorCompactioOnly)
                      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:
    
    majorCompactioOnly - 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
  - getLargestHStoreSize
```
public long getLargestHStoreSize()
```
    Returns:
    
    returns size of largest HStore.
  - getComparator
```
public KeyValue.KVComparator getComparator()
```
    Returns:
    
    KeyValue Comparator
  - doRegionCompactionPrep
```
protected void doRegionCompactionPrep()
                               throws IOException
```
    Throws:
    
    IOException
  - triggerMajorCompaction
```
public void triggerMajorCompaction()
                            throws IOException
```
    Description copied from interface: Region
    
    Trigger major compaction on all stores in the region.
    Compaction will be performed asynchronously to this call by the RegionServer's CompactSplitThread. See also Store.triggerMajorCompaction()
    
    Specified by:
    
    triggerMajorCompaction in interface Region
    
    Throws:
    
    IOException
  - compact
```
public void compact(boolean majorCompaction)
             throws IOException
```
    Description copied from interface: Region
    
    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.
    
    Specified by:
    
    compact in interface Region
    
    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 - e
  - compact
```
public boolean compact(CompactionContext compaction,
                       Store store,
                       CompactionThroughputController throughputController)
                throws IOException
```
    Throws:
    
    IOException
  - flush
```
public Region.FlushResult flush(boolean force)
                         throws IOException
```
    Description copied from interface: Region
    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.
    Specified by:
    
    flush in interface Region
    
    Parameters:
    
    force - 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
  - flushcache
```
public Region.FlushResult flushcache(boolean forceFlushAllStores,
                                     boolean writeFlushRequestWalMarker)
                              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:
    
    forceFlushAllStores - whether we want to flush all stores
    
    writeFlushRequestWalMarker - whether to write the flush request marker to WAL
    
    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 Region.FlushResult internalFlushcache(WAL wal,
                                                long myseqid,
                                                Collection<Store> storesToFlush,
                                                MonitoredTask status,
                                                boolean writeFlushWalMarker)
                                         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 because a Snapshot was not properly persisted.
  - internalPrepareFlushCache
```
protected org.apache.hadoop.hbase.regionserver.HRegion.PrepareFlushResult internalPrepareFlushCache(WAL wal,
                                                                                                    long myseqid,
                                                                                                    Collection<Store> storesToFlush,
                                                                                                    MonitoredTask status,
                                                                                                    boolean writeFlushWalMarker)
                                                                                             throws IOException
```
    Throws:
    
    IOException
  - internalFlushCacheAndCommit
```
protected Region.FlushResult internalFlushCacheAndCommit(WAL wal,
                                                         MonitoredTask status,
                                                         org.apache.hadoop.hbase.regionserver.HRegion.PrepareFlushResult prepareResult,
                                                         Collection<Store> storesToFlush)
                                                  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
  - getClosestRowBefore
```
public Result getClosestRowBefore(byte[] row,
                                  byte[] family)
                           throws IOException
```
    Description copied from interface: Region
    
    Return all the data for the row that matches row exactly, or the one that immediately preceeds it, at or immediately before ts.
    
    Specified by:
    
    getClosestRowBefore in interface Region
    
    Returns:
    
    result of the operation
    
    Throws:
    
    IOException
  - getScanner
```
public RegionScanner 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
    
    Returns:
    
    RegionScanner
    
    Throws:
    
    IOException - read exceptions
  - getScanner
```
protected RegionScanner getScanner(Scan scan,
                                   List<KeyValueScanner> additionalScanners)
                            throws IOException
```
    Throws:
    
    IOException
  - instantiateRegionScanner
```
protected RegionScanner instantiateRegionScanner(Scan scan,
                                                 List<KeyValueScanner> additionalScanners)
                                          throws IOException
```
    Throws:
    
    IOException
  - prepareDelete
```
public void prepareDelete(Delete delete)
                   throws IOException
```
    Description copied from interface: Region
    
    Prepare a delete for a row mutation processor
    
    Specified by:
    
    prepareDelete in interface Region
    
    Parameters:
    
    delete - The passed delete is modified by this method. WARNING!
    
    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
  - prepareDeleteTimestamps
```
public void prepareDeleteTimestamps(Mutation mutation,
                                    Map<byte[],List<Cell>> familyMap,
                                    byte[] byteNow)
                             throws IOException
```
    Description copied from interface: Region
    
    Set up correct timestamps in the KVs in Delete object.
    Caller should have the row and region locks.
    
    Specified by:
    
    prepareDeleteTimestamps 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,
                                     long nonceGroup,
                                     long nonce)
                              throws IOException
```
    Description copied from interface: Region
    
    Perform a batch of mutations.
    Note this supports only Put and Delete mutations and will ignore other types passed.
    
    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
  - batchMutate
```
public OperationStatus[] batchMutate(Mutation[] mutations)
                              throws IOException
```
    Throws:
    
    IOException
  - batchReplay
```
public OperationStatus[] batchReplay(WALSplitter.MutationReplay[] mutations,
                                     long replaySeqId)
                              throws IOException
```
    Description copied from interface: Region
    
    Replay a batch of mutations.
    
    Specified by:
    
    batchReplay in interface Region
    
    Parameters:
    
    mutations - mutations to replay.
    
    Returns:
    
    an array of OperationStatus which internally contains the OperationStatusCode and the exceptionMessage if any.
    
    Throws:
    
    IOException
  - getEffectiveDurability
```
protected Durability getEffectiveDurability(Durability d)
```
    Returns effective durability from the passed durability and the table descriptor.
  - checkAndMutate
```
public boolean checkAndMutate(byte[] row,
                              byte[] family,
                              byte[] qualifier,
                              CompareFilter.CompareOp compareOp,
                              ByteArrayComparable comparator,
                              Mutation w,
                              boolean writeToWAL)
                       throws IOException
```
    Description copied from interface: Region
    
    Atomically checks if a row/family/qualifier value matches the expected val If it does, it performs the row mutations. If the passed value is null, t is for the lack of column (ie: non-existence)
    
    Specified by:
    
    checkAndMutate in interface Region
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    compareOp - the comparison operator
    
    Returns:
    
    true if mutation was applied, false otherwise
    
    Throws:
    
    IOException
  - checkAndRowMutate
```
public boolean checkAndRowMutate(byte[] row,
                                 byte[] family,
                                 byte[] qualifier,
                                 CompareFilter.CompareOp compareOp,
                                 ByteArrayComparable comparator,
                                 RowMutations rm,
                                 boolean writeToWAL)
                          throws IOException
```
    Description copied from interface: Region
    
    Atomically checks if a row/family/qualifier value matches the expected val If it does, it performs the row mutations. If the passed value is null, t is for the lack of column (ie: non-existence)
    
    Specified by:
    
    checkAndRowMutate in interface Region
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    compareOp - the comparison operator
    
    Returns:
    
    true if mutation was applied, false otherwise
    
    Throws:
    
    IOException
  - addRegionToSnapshot
```
public void addRegionToSnapshot(HBaseProtos.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
  - updateCellTimestamps
```
public void updateCellTimestamps(Iterable<List<Cell>> cellItr,
                                 byte[] now)
                          throws IOException
```
    Description copied from interface: Region
    
    Replace any cell timestamps set to HConstants#LATEST_TIMESTAMP with the provided current timestamp.
    
    Specified by:
    
    updateCellTimestamps in interface Region
    
    Throws:
    
    IOException
  - checkReadOnly
```
protected void checkReadOnly()
                      throws IOException
```
    Throws:
    
    IOException - Throws exception if region is in read-only mode.
  - checkReadsEnabled
```
protected void checkReadsEnabled()
                          throws IOException
```
    Throws:
    
    IOException
  - setReadsEnabled
```
public void setReadsEnabled(boolean readsEnabled)
```
  - checkFamilies
```
public void checkFamilies(Collection<byte[]> families)
                   throws NoSuchColumnFamilyException
```
    Description copied from interface: Region
    
    Check the collection of families for validity.
    
    Specified by:
    
    checkFamilies in interface Region
    
    Throws:
    
    NoSuchColumnFamilyException
  - checkTimestamps
```
public void checkTimestamps(Map<byte[],List<Cell>> familyMap,
                            long now)
                     throws FailedSanityCheckException
```
    Description copied from interface: Region
    
    Check the collection of families for valid timestamps
    
    Specified by:
    
    checkTimestamps in interface Region
    
    now - current timestamp
    
    Throws:
    
    FailedSanityCheckException
  - replayRecoveredEditsIfAny
```
protected long replayRecoveredEditsIfAny(Path regiondir,
                                         Map<byte[],Long> maxSeqIdInStores,
                                         CancelableProgressable reporter,
                                         MonitoredTask status)
                                  throws IOException
```
    Read the edits put under this region by wal splitting process. Put the recovered edits back up into this region.
    We can ignore any wal message that has a sequence ID that's equal to or lower than minSeqId. (Because we know such messages are already reflected in the HFiles.)
    While this is running we are putting pressure on memory yet we are outside of our usual accounting because we are not yet an onlined region (this stuff is being run as part of Region initialization). This means that if we're up against global memory limits, we'll not be flagged to flush because we are not online. We can't be flushed by usual mechanisms anyways; we're not yet online so our relative sequenceids are not yet aligned with WAL sequenceids -- not till we come up online, post processing of split edits.
    But to help relieve memory pressure, at least manage our own heap size flushing if are in excess of per-region limits. Flushing, though, we have to be careful and avoid using the regionserver/wal sequenceid. Its running on a different line to whats going on in here in this region context so if we crashed replaying these edits, but in the midst had a flush that used the regionserver wal with a sequenceid in excess of whats going on in here in this region and with its split editlogs, then we could miss edits the next time we go to recover. So, we have to flush inline, using seqids that make sense in a this single region context only -- until we online.
    
    Parameters:
    
    maxSeqIdInStores - Any edit found in split editlogs needs to be in excess of the maxSeqId for the store to be applied, else its skipped.
    
    Returns:
    
    the sequence id of the last edit added to this region out of the recovered edits log or minSeqId if nothing added from editlogs.
    
    Throws:
    
    UnsupportedEncodingException
    
    IOException
  - 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
  - restoreEdit
```
protected boolean restoreEdit(Store s,
                              Cell cell)
```
    Used by tests
    
    Parameters:
    
    s - Store to add edit too.
    
    cell - Cell to add.
    
    Returns:
    
    True if we should flush.
  - instantiateHStore
```
protected HStore instantiateHStore(HColumnDescriptor family)
                            throws IOException
```
    Throws:
    
    IOException
  - getStore
```
public Store 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<Store> 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
```
    Specified by:
    
    getStoreFileList in interface Region
    
    Returns:
    
    list of store file names for the given families
    
    Throws:
    
    IllegalArgumentException
  - getRowLock
```
public Region.RowLock getRowLock(byte[] row,
                                 boolean waitForLock)
                          throws IOException
```
    Description copied from interface: Region
    
    Tries to acquire a lock on the given row.
    
    Specified by:
    
    getRowLock in interface Region
    
    waitForLock - if true, will block until the lock is available. Otherwise, just tries to obtain the lock and returns false if unavailable.
    
    Returns:
    
    the row lock if acquired, null if waitForLock was false and the lock was not acquired
    
    Throws:
    
    IOException - if waitForLock was true and the lock could not be acquired after waiting
  - getRowLockInternal
```
protected Region.RowLock getRowLockInternal(byte[] row,
                                            boolean waitForLock)
                                     throws IOException
```
    A version of getRowLock(byte[], boolean) to use when a region operation has already been started (the calling thread has already acquired the region-close-guard lock).
    
    Throws:
    
    IOException
  - getRowLock
```
public Region.RowLock getRowLock(byte[] row)
                          throws IOException
```
    Acquires a lock on the given row. The same thread may acquire multiple locks on the same row.
    
    Returns:
    
    the acquired row lock
    
    Throws:
    
    IOException - if the lock could not be acquired after waiting
  - releaseRowLocks
```
public void releaseRowLocks(List<Region.RowLock> rowLocks)
```
    Description copied from interface: Region
    
    If the given list of row locks is not null, releases all locks.
    
    Specified by:
    
    releaseRowLocks in interface Region
  - bulkLoadHFiles
```
public boolean bulkLoadHFiles(Collection<Pair<byte[],String>> familyPaths,
                              boolean assignSeqId,
                              Region.BulkLoadListener bulkLoadListener)
                       throws IOException
```
    Description copied from interface: Region
    
    Attempts to atomically load a group of hfiles. This is critical for loading rows with multiple column families atomically.
    
    Specified by:
    
    bulkLoadHFiles in interface Region
    
    Parameters:
    
    familyPaths - List of Pair
    
    bulkLoadListener - Internal hooks enabling massaging/preparation of a file about to be bulk loaded
    
    Returns:
    
    true if successful, false 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
  - createHRegion
```
public static HRegion createHRegion(HRegionInfo info,
                                    Path rootDir,
                                    Configuration conf,
                                    HTableDescriptor hTableDescriptor)
                             throws IOException
```
    Convenience method creating new HRegions. Used by createTable and by the bootstrap code in the HMaster constructor. Note, this method creates an WAL for the created region. It needs to be closed explicitly. Use getWAL() to get access. When done with a region created using this method, you will need to explicitly close the WAL it created too; it will not be done for you. Not closing the wal will leave at least a daemon thread running. Call closeHRegion(HRegion) and it will do necessary cleanup for you.
    
    Parameters:
    
    info - Info for region to create.
    
    rootDir - Root directory for HBase instance
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - closeHRegion
```
public static void closeHRegion(HRegion r)
                         throws IOException
```
    This will do the necessary cleanup a call to createHRegion(HRegionInfo, Path, Configuration, HTableDescriptor) requires. This method will close the region and then close its associated WAL file. You can still use it if you call the other createHRegion, the one that takes an WAL instance but don't be surprised by the call to the WAL.close() on the WAL the HRegion was carrying.
    
    Throws:
    
    IOException
  - createHRegion
```
public static HRegion createHRegion(HRegionInfo info,
                                    Path rootDir,
                                    Configuration conf,
                                    HTableDescriptor hTableDescriptor,
                                    WAL wal,
                                    boolean initialize)
                             throws IOException
```
    Convenience method creating new HRegions. Used by createTable. The WAL for the created region needs to be closed explicitly. Use getWAL() to get access.
    
    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(HRegionInfo info,
                                    Path rootDir,
                                    Configuration conf,
                                    HTableDescriptor hTableDescriptor,
                                    WAL wal,
                                    boolean initialize,
                                    boolean ignoreWAL)
                             throws IOException
```
    Convenience method creating new HRegions. Used by createTable. The WAL for the created region needs to be closed explicitly, if it is not null. Use getWAL() to get access.
    
    Parameters:
    
    info - Info for region to create.
    
    rootDir - Root directory for HBase instance
    
    wal - shared WAL
    
    initialize - - true to initialize the region
    
    ignoreWAL - - true to skip generate new wal if it is null, mostly for createTable
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - createHRegion
```
public static HRegion createHRegion(HRegionInfo info,
                                    Path rootDir,
                                    Path tableDir,
                                    Configuration conf,
                                    HTableDescriptor hTableDescriptor,
                                    WAL wal,
                                    boolean initialize,
                                    boolean ignoreWAL)
                             throws IOException
```
    Convenience method creating new HRegions. Used by createTable. The WAL for the created region needs to be closed explicitly, if it is not null. Use getWAL() to get access.
    
    Parameters:
    
    info - Info for region to create.
    
    rootDir - Root directory for HBase instance
    
    tableDir - table directory
    
    wal - shared WAL
    
    initialize - - true to initialize the region
    
    ignoreWAL - - true to skip generate new wal if it is null, mostly for createTable
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - createHRegion
```
public static HRegion createHRegion(HRegionInfo info,
                                    Path rootDir,
                                    Configuration conf,
                                    HTableDescriptor hTableDescriptor,
                                    WAL wal)
                             throws IOException
```
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(HRegionInfo info,
                                  HTableDescriptor htd,
                                  WAL wal,
                                  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(HRegionInfo info,
                                  HTableDescriptor htd,
                                  WAL wal,
                                  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(Path rootDir,
                                  HRegionInfo info,
                                  HTableDescriptor htd,
                                  WAL wal,
                                  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(Path rootDir,
                                  HRegionInfo info,
                                  HTableDescriptor htd,
                                  WAL wal,
                                  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(Configuration conf,
                                  FileSystem fs,
                                  Path rootDir,
                                  HRegionInfo info,
                                  HTableDescriptor 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(Configuration conf,
                                  FileSystem fs,
                                  Path rootDir,
                                  HRegionInfo info,
                                  HTableDescriptor 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
  - openHRegion
```
public static HRegion openHRegion(Configuration conf,
                                  FileSystem fs,
                                  Path rootDir,
                                  Path tableDir,
                                  HRegionInfo info,
                                  HTableDescriptor 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
  - 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
  - openHRegion
```
protected HRegion openHRegion(CancelableProgressable reporter)
                       throws IOException
```
    Open HRegion. Calls initialize and sets sequenceId.
    
    Returns:
    
    Returns this
    
    Throws:
    
    IOException
  - warmupHRegion
```
public static void warmupHRegion(HRegionInfo info,
                                 HTableDescriptor htd,
                                 WAL wal,
                                 Configuration conf,
                                 RegionServerServices rsServices,
                                 CancelableProgressable reporter)
                          throws IOException
```
    Throws:
    
    IOException
  - addRegionToMETA
```
public static void addRegionToMETA(HRegion meta,
                                   HRegion r)
                            throws IOException
```
    Inserts a new region's meta information into the passed meta region. Used by the HMaster bootstrap code adding new table to hbase:meta table.
    
    Parameters:
    
    meta - hbase:meta HRegion to be updated
    
    r - HRegion to add to meta
    
    Throws:
    
    IOException
  - getRegionDir
```
@Deprecated
public static Path getRegionDir(Path tabledir,
                                            String name)
```
    Deprecated.
    
    Computes the Path of the HRegion
    
    Parameters:
    
    tabledir - qualified path for table
    
    name - ENCODED region name
    
    Returns:
    
    Path of HRegion directory
  - getRegionDir
```
@Deprecated
public static Path getRegionDir(Path rootdir,
                                            HRegionInfo info)
```
    Deprecated.
    
    Computes the Path of the HRegion
    
    Parameters:
    
    rootdir - qualified path of HBase root directory
    
    info - HRegionInfo for the region
    
    Returns:
    
    qualified path of region directory
  - rowIsInRange
```
public static boolean rowIsInRange(HRegionInfo info,
                                   byte[] row)
```
    Determines if the specified row is within the row range specified by the specified HRegionInfo
    
    Parameters:
    
    info - HRegionInfo that specifies the row range
    
    row - row to be checked
    
    Returns:
    
    true if the row is within the range specified by the HRegionInfo
  - rowIsInRange
```
public static boolean rowIsInRange(HRegionInfo info,
                                   byte[] row,
                                   int offset,
                                   short length)
```
  - mergeAdjacent
```
public static HRegion mergeAdjacent(HRegion srcA,
                                    HRegion srcB)
                             throws IOException
```
    Merge two HRegions. The regions must be adjacent and must not overlap.
    
    Returns:
    
    new merged HRegion
    
    Throws:
    
    IOException
  - merge
```
public static HRegion merge(HRegion a,
                            HRegion b)
                     throws IOException
```
    Merge two regions whether they are adjacent or not.
    
    Parameters:
    
    a - region a
    
    b - region b
    
    Returns:
    
    new merged region
    
    Throws:
    
    IOException
  - 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 void mutateRow(RowMutations rm)
               throws IOException
```
    Description copied from interface: Region
    
    Performs multiple mutations atomically on a single row. Currently Put and Delete are supported.
    
    Specified by:
    
    mutateRow in interface Region
    
    Parameters:
    
    rm - object that specifies the set of mutations to perform atomically
    
    Throws:
    
    IOException
  - mutateRowsWithLocks
```
public void mutateRowsWithLocks(Collection<Mutation> mutations,
                                Collection<byte[]> rowsToLock)
                         throws IOException
```
    Perform atomic mutations within the region w/o nonces. See mutateRowsWithLocks(Collection, Collection, long, long)
    
    Throws:
    
    IOException
  - mutateRowsWithLocks
```
public void mutateRowsWithLocks(Collection<Mutation> mutations,
                                Collection<byte[]> rowsToLock,
                                long nonceGroup,
                                long nonce)
                         throws IOException
```
    Perform atomic 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
  - getRegionStats
```
public ClientProtos.RegionLoadStats getRegionStats()
```
    Returns:
    
    the current load statistics for the 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
```
    Throws:
    
    IOException
  - append
```
public Result append(Append append,
                     long nonceGroup,
                     long nonce)
              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
  - increment
```
public Result increment(Increment increment)
                 throws IOException
```
    Throws:
    
    IOException
  - increment
```
public Result increment(Increment increment,
                        long nonceGroup,
                        long nonce)
                 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
  - heapSize
```
public long heapSize()
```
    Specified by:
    
    heapSize in interface HeapSize
    
    Returns:
    
    Approximate 'exclusive deep size' of implementing object. Includes count of payload and hosting object sizings.
  - registerService
```
public boolean registerService(Service instance)
```
    Description copied from interface: Region
    
    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 com.google.protobuf.Descriptors.ServiceDescriptor#getFullName(). After the first registration, subsequent calls with the same service name will fail with a return value of false.
    
    Specified by:
    
    registerService in interface Region
    
    Parameters:
    
    instance - the Service subclass instance to expose as a coprocessor endpoint
    
    Returns:
    
    true if the registration was successful, false otherwise
  - execService
```
public Message execService(RpcController controller,
                           ClientProtos.CoprocessorServiceCall call)
                    throws IOException
```
    Description copied from interface: Region
    
    Executes a single protocol buffer coprocessor endpoint Service method using the registered protocol handlers. Service implementations must be registered via the Region#registerService(com.google.protobuf.Service) method before they are available.
    
    Specified by:
    
    execService in interface Region
    
    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:
    
    org.apache.hadoop.hbase.regionserver.Region#registerService(com.google.protobuf.Service)
  - prepareToSplit
```
protected void prepareToSplit()
```
    Give the region a chance to prepare before it is split.
  - checkSplit
```
public byte[] checkSplit()
```
    Return the splitpoint. null indicates the region isn't splittable If the splitpoint isn't explicitly specified, it will go over the stores to find the best splitpoint. Currently the criteria of best splitpoint is based on the size of the store.
  - getCompactPriority
```
public int getCompactPriority()
```
    Returns:
    
    The priority that this region should have in the compaction queue
  - getCoprocessorHost
```
public RegionCoprocessorHost getCoprocessorHost()
```
    Specified by:
    
    getCoprocessorHost in interface Region
    
    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
```
    Closes the lock. This needs to be called in the finally block corresponding to the try block of Region.startRegionOperation(Operation)
    
    Throws:
    
    IOException
  - main
```
public static void main(String[] args)
                 throws IOException
```
    Facility for dumping and compacting catalog tables. Only does catalog tables since these are only tables we for sure know schema on. For usage run:
```
   ./bin/hbase org.apache.hadoop.hbase.regionserver.HRegion
 
```
    Throws:
    
    IOException
  - getOpenSeqNum
```
public long getOpenSeqNum()
```
    Specified by:
    
    getOpenSeqNum in interface Region
    
    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)
```
    Specified by:
    
    getOldestSeqIdOfStore in interface Region
    
    Returns:
    
    the oldest sequence id found in the store for the given family
  - getCompactionState
```
public AdminProtos.GetRegionInfoResponse.CompactionState getCompactionState()
```
    Specified by:
    
    getCompactionState in interface Region
    
    Returns:
    
    if a given region is in compaction now.
  - reportCompactionRequestStart
```
public void reportCompactionRequestStart(boolean isMajor)
```
  - reportCompactionRequestEnd
```
public void reportCompactionRequestEnd(boolean isMajor,
                                       int numFiles,
                                       long filesSizeCompacted)
```
  - getSequenceId
```
public AtomicLong getSequenceId()
```
    Do not change this sequence id. See sequenceId comment.
    
    Returns:
    
    sequenceId
  - onConfigurationChange
```
public void onConfigurationChange(Configuration conf)
```
    This method would be called by the ConfigurationManager object when the Configuration object is reloaded from disk.
    
    Specified by:
    
    onConfigurationChange in interface ConfigurationObserver
  - registerChildren
```
public void registerChildren(ConfigurationManager manager)
```
    Needs to be called to register the children to the manager.
    
    Specified by:
    
    registerChildren in interface PropagatingConfigurationObserver
    
    Parameters:
    
    manager - : to register to
  - deregisterChildren
```
public void deregisterChildren(ConfigurationManager manager)
```
    Needs to be called to deregister the children from the manager.
    
    Specified by:
    
    deregisterChildren in interface PropagatingConfigurationObserver
    
    Parameters:
    
    manager - : to deregister from
  - getSplitPolicy
```
public RegionSplitPolicy getSplitPolicy()
```
    Returns:
    
    split policy for this region.

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

Field Detail

LOG

LOAD_CFS_ON_DEMAND_CONFIG_KEY

lastReplayedOpenRegionSeqId

lastReplayedCompactionSeqId

stores

memstoreSize

conf

MEMSTORE_PERIODIC_FLUSH_INTERVAL

DEFAULT_CACHE_FLUSH_INTERVAL

META_CACHE_FLUSH_INTERVAL

MEMSTORE_FLUSH_PER_CHANGES

DEFAULT_FLUSH_PER_CHANGES

MAX_FLUSH_PER_CHANGES

FIXED_OVERHEAD

DEEP_OVERHEAD

Constructor Detail

HRegion

HRegion

Method Detail

getSmallestReadPoint

initialize

hasReferences

getHDFSBlocksDistribution

computeHDFSBlocksDistribution

computeHDFSBlocksDistribution

addAndGetGlobalMemstoreSize

getRegionInfo

getReadRequestsCount

updateReadRequestsCount

getWriteRequestsCount

updateWriteRequestsCount

getMemstoreSize

getNumMutationsWithoutWAL

getDataInMemoryWithoutWAL

getBlockedRequestsCount

getCheckAndMutateChecksPassed

getCheckAndMutateChecksFailed

getMetrics

isClosed

isClosing

isReadOnly

setRecovering

isRecovering

isAvailable

isSplittable

isMergeable

areWritesEnabled

getMVCC

getMaxFlushedSeqId

getReadpoint

isLoadingCfsOnDemandDefault

close

close

setClosing

waitForFlushesAndCompactions

getStoreOpenAndCloseThreadPool

getStoreFileOpenAndCloseThreadPool

getTableDesc

getWAL

getFilesystem

getRegionFileSystem

getEarliestFlushTimeForAllStores

getOldestHfileTs

getLargestHStoreSize

getComparator

doRegionCompactionPrep

triggerMajorCompaction

compact

compactStores

compact

flush

flushcache